One Level Up Top Level

src/core/ngx_proxy_protocol.c - nginx-1.31.4 nginx/ @ 8d9666701

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Roman Arutyunyan
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>


  12. ‌#define NGX_PROXY_PROTOCOL_V2_MAX_HEADER    52

  14. ‌#define NGX_PROXY_PROTOCOL_CMD_LOCAL        0
  15. ‌#define NGX_PROXY_PROTOCOL_CMD_PROXY        1

  17. ‌#define NGX_PROXY_PROTOCOL_AF_UNSPEC        0
  18. ‌#define NGX_PROXY_PROTOCOL_AF_INET          1
  19. ‌#define NGX_PROXY_PROTOCOL_AF_INET6         2

  21. ‌#define NGX_PROXY_PROTOCOL_TYPE_UNSPEC      0
  22. ‌#define NGX_PROXY_PROTOCOL_TYPE_STREAM      1
  23. ‌#define NGX_PROXY_PROTOCOL_TYPE_DGRAM       2

  25. ‌#define NGX_PROXY_PROTOCOL_TLV_ALPN         0x01
  26. ‌#define NGX_PROXY_PROTOCOL_TLV_AUTHORITY    0x02
  27. ‌#define NGX_PROXY_PROTOCOL_TLV_CRC32C       0x03
  28. ‌#define NGX_PROXY_PROTOCOL_TLV_UNIQUE_ID    0x05
  29. ‌#define NGX_PROXY_PROTOCOL_TLV_SSL          0x20
  30. ‌#define NGX_PROXY_PROTOCOL_TLV_SSL_VERSION  0x21
  31. ‌#define NGX_PROXY_PROTOCOL_TLV_SSL_CN       0x22
  32. ‌#define NGX_PROXY_PROTOCOL_TLV_SSL_CIPHER   0x23
  33. ‌#define NGX_PROXY_PROTOCOL_TLV_SSL_SIG_ALG  0x24
  34. ‌#define NGX_PROXY_PROTOCOL_TLV_SSL_KEY_ALG  0x25
  35. ‌#define NGX_PROXY_PROTOCOL_TLV_NETNS        0x30

  37. ‌#define NGX_PROXY_PROTOCOL_V2_CLIENT_SSL          0x01
  38. ‌#define NGX_PROXY_PROTOCOL_V2_CLIENT_CERT_CONN    0x02
  39. ‌#define NGX_PROXY_PROTOCOL_V2_CLIENT_CERT_SESS    0x04


  42. ‌#define ngx_proxy_protocol_parse_uint16(p)                                    \
  43.     ( ((uint16_t) (p)[0] << 8)                                                \
  44.     + (           (p)[1]) )

  46. ‌#define ngx_proxy_protocol_parse_uint32(p)                                    \
  47.     ( ((uint32_t) (p)[0] << 24)                                               \
  48.     + (           (p)[1] << 16)                                               \
  49.     + (           (p)[2] << 8)                                                \
  50.     + (           (p)[3]) )


  53. ‌typedef struct {
  54.     u_char                                  signature[12];
  55.     u_char                                  version_command;
  56.     u_char                                  family_transport;
  57.     u_char                                  len[2];
  58. ‌} ngx_proxy_protocol_header_t;


  61. ‌typedef struct {
  62.     u_char                                  src_addr[4];
  63.     u_char                                  dst_addr[4];
  64.     u_char                                  src_port[2];
  65.     u_char                                  dst_port[2];
  66. ‌} ngx_proxy_protocol_inet_addrs_t;


  69. ‌typedef struct {
  70.     u_char                                  src_addr[16];
  71.     u_char                                  dst_addr[16];
  72.     u_char                                  src_port[2];
  73.     u_char                                  dst_port[2];
  74. ‌} ngx_proxy_protocol_inet6_addrs_t;


  77. ‌typedef struct {
  78.     u_char                                  type;
  79.     u_char                                  len[2];
  80. ‌} ngx_proxy_protocol_tlv_t;


  83. ‌typedef struct {
  84.     u_char                                  client;
  85.     u_char                                  verify[4];
  86. ‌} ngx_proxy_protocol_tlv_ssl_t;


  89. ‌typedef struct {
  90.     ngx_str_t                               name;
  91.     ngx_uint_t                              type;
  92. ‌} ngx_proxy_protocol_tlv_entry_t;


  95. ‌typedef struct {
  96.     ngx_uint_t                              type;
  97.     ngx_str_t                               value;
  98. ‌} ngx_proxy_protocol_tlv_value_t;


  101. static u_char *ngx_proxy_protocol_read_addr(ngx_connection_t *c, u_char *p,
  102.     u_char *last, ngx_str_t *addr);
  103. static u_char *ngx_proxy_protocol_read_port(u_char *p, u_char *last,
  104.     in_port_t *port, u_char sep);
  105. static u_char *ngx_proxy_protocol_v2_read(ngx_connection_t *c, u_char *buf,
  106.     u_char *last);
  107. static ngx_int_t ngx_proxy_protocol_lookup_tlv(ngx_connection_t *c,
  108.     ngx_str_t *tlvs, ngx_uint_t type, ngx_str_t *value);
  109. #if (NGX_OPENSSL)
  110. static ngx_int_t ngx_proxy_protocol_v2_eval_ssl(ngx_connection_t *c,
  111.     ngx_array_t *tlvs, ngx_array_t *ssl_tlvs, ngx_uint_t *client,
  112.     uint32_t *verify);
  113. static ngx_int_t ngx_proxy_protocol_v2_authority(ngx_connection_t *c,
  114.     ngx_str_t *out);
  115. static ngx_int_t ngx_proxy_protocol_v2_alpn(ngx_connection_t *c,
  116.     ngx_str_t *out);
  117. static ngx_int_t ngx_proxy_protocol_v2_ssl_sub(ngx_connection_t *c,
  118.     ngx_uint_t type, ngx_str_t *out);
  119. #endif
  120. static u_char *ngx_proxy_protocol_v2_write_header(ngx_connection_t *c,
  121.     u_char *buf, u_char *last);
  122. static u_char ngx_proxy_protocol_v2_family(ngx_uint_t family);
  123. static void ngx_proxy_protocol_v2_write_ipv4(struct sockaddr *sa, u_char *addr,
  124.     u_char *port);
  125. static void ngx_proxy_protocol_v2_write_ipv6(struct sockaddr *sa, u_char *addr,
  126.     u_char *port);
  127. static u_char *ngx_proxy_protocol_v2_write_tlv(ngx_connection_t *c, u_char *p,
  128.     u_char *last, ngx_uint_t type, ngx_str_t *value);
  129. static u_char *ngx_proxy_protocol_v2_write_ssl(ngx_connection_t *c, u_char *p,
  130.     u_char *last, ngx_array_t *ssl_tlvs, ngx_uint_t client, uint32_t verify);
  131. static void ngx_proxy_protocol_v2_set_len(u_char *buf, u_char *p);
  132. static u_char *ngx_proxy_protocol_v2_write_crc32c(ngx_connection_t *c,
  133.     u_char *buf, u_char *p, u_char *last);


  136. ‌static ngx_proxy_protocol_tlv_entry_t  ngx_proxy_protocol_tlv_entries[] = {
  137.     { ngx_string("alpn"),       NGX_PROXY_PROTOCOL_TLV_ALPN },
  138.     { ngx_string("authority"),  NGX_PROXY_PROTOCOL_TLV_AUTHORITY },
  139.     { ngx_string("unique_id"),  NGX_PROXY_PROTOCOL_TLV_UNIQUE_ID },
  140.     { ngx_string("ssl"),        NGX_PROXY_PROTOCOL_TLV_SSL },
  141.     { ngx_string("netns"),      NGX_PROXY_PROTOCOL_TLV_NETNS },
  142.     { ngx_null_string,          0x00 }
  143. };


  146. ‌static ngx_proxy_protocol_tlv_entry_t  ngx_proxy_protocol_tlv_ssl_entries[] = {
  147.     { ngx_string("version"),    NGX_PROXY_PROTOCOL_TLV_SSL_VERSION },
  148.     { ngx_string("cn"),         NGX_PROXY_PROTOCOL_TLV_SSL_CN },
  149.     { ngx_string("cipher"),     NGX_PROXY_PROTOCOL_TLV_SSL_CIPHER },
  150.     { ngx_string("sig_alg"),    NGX_PROXY_PROTOCOL_TLV_SSL_SIG_ALG },
  151.     { ngx_string("key_alg"),    NGX_PROXY_PROTOCOL_TLV_SSL_KEY_ALG },
  152.     { ngx_null_string,          0x00 }
  153. };


  156. ‌static const u_char  ngx_proxy_protocol_signature[] = "\r\n\r\n\0\r\nQUIT\n";


  159. u_char *
  160. ‌ngx_proxy_protocol_read(ngx_connection_t *c, u_char *buf, u_char *last)
  161. {
  162.     size_t                 len;
  163.     u_char                *p;
  164.     ngx_proxy_protocol_t  *pp;

  166.     p = buf;
  167.     len = last - buf;

  169.     if (len >= sizeof(ngx_proxy_protocol_header_t)
  170.         && ngx_memcmp(p, ngx_proxy_protocol_signature,
  171.                       sizeof(ngx_proxy_protocol_signature) - 1)
  172.            == 0)
  173.     {
  174.         return ngx_proxy_protocol_v2_read(c, buf, last);
  175.     }

  177.     if (len < 8 || ngx_strncmp(p, "PROXY ", 6) != 0) {
  178.         goto invalid;
  179.     }

  181.     p += 6;
  182.     len -= 6;

  184.     if (len >= 7 && ngx_strncmp(p, "UNKNOWN", 7) == 0) {
  185.         ngx_log_debug0(NGX_LOG_DEBUG_CORE, c->log, 0,
  186.                        "PROXY protocol unknown protocol");
  187.         p += 7;
  188.         goto skip;
  189.     }

  191.     if (len < 5 || ngx_strncmp(p, "TCP", 3) != 0
  192.         || (p[3] != '4' && p[3] != '6') || p[4] != ' ')
  193.     {
  194.         goto invalid;
  195.     }

  197.     p += 5;

  199.     pp = ngx_pcalloc(c->pool, sizeof(ngx_proxy_protocol_t));
  200.     if (pp == NULL) {
  201.         return NULL;
  202.     }

  204.     p = ngx_proxy_protocol_read_addr(c, p, last, &pp->src_addr);
  205.     if (p == NULL) {
  206.         goto invalid;
  207.     }

  209.     p = ngx_proxy_protocol_read_addr(c, p, last, &pp->dst_addr);
  210.     if (p == NULL) {
  211.         goto invalid;
  212.     }

  214.     p = ngx_proxy_protocol_read_port(p, last, &pp->src_port, ' ');
  215.     if (p == NULL) {
  216.         goto invalid;
  217.     }

  219.     p = ngx_proxy_protocol_read_port(p, last, &pp->dst_port, CR);
  220.     if (p == NULL) {
  221.         goto invalid;
  222.     }

  224.     if (p == last) {
  225.         goto invalid;
  226.     }

  228.     if (*p++ != LF) {
  229.         goto invalid;
  230.     }

  232.     ngx_log_debug4(NGX_LOG_DEBUG_CORE, c->log, 0,
  233.                    "PROXY protocol src: %V %d, dst: %V %d",
  234.                    &pp->src_addr, pp->src_port, &pp->dst_addr, pp->dst_port);

  236.     c->proxy_protocol = pp;

  238.     return p;

  240. skip:

  242.     for ( /* void */ ; p < last - 1; p++) {
  243.         if (p[0] == CR && p[1] == LF) {
  244.             return p + 2;
  245.         }
  246.     }

  248. invalid:

  250.     for (p = buf; p < last; p++) {
  251.         if (*p == CR || *p == LF) {
  252.             break;
  253.         }
  254.     }

  256.     ngx_log_error(NGX_LOG_ERR, c->log, 0,
  257.                   "broken header: \"%*s\"", (size_t) (p - buf), buf);

  259.     return NULL;
  260. }


  263. static u_char *
  264. ‌ngx_proxy_protocol_read_addr(ngx_connection_t *c, u_char *p, u_char *last,
  265.     ngx_str_t *addr)
  266. {
  267.     size_t  len;
  268.     u_char  ch, *pos;

  270.     pos = p;

  272.     for ( ;; ) {
  273.         if (p == last) {
  274.             return NULL;
  275.         }

  277.         ch = *p++;

  279.         if (ch == ' ') {
  280.             break;
  281.         }

  283.         if (ch != ':' && ch != '.'
  284.             && (ch < 'a' || ch > 'f')
  285.             && (ch < 'A' || ch > 'F')
  286.             && (ch < '0' || ch > '9'))
  287.         {
  288.             return NULL;
  289.         }
  290.     }

  292.     len = p - pos - 1;

  294.     addr->data = ngx_pnalloc(c->pool, len);
  295.     if (addr->data == NULL) {
  296.         return NULL;
  297.     }

  299.     ngx_memcpy(addr->data, pos, len);
  300.     addr->len = len;

  302.     return p;
  303. }


  306. static u_char *
  307. ‌ngx_proxy_protocol_read_port(u_char *p, u_char *last, in_port_t *port,
  308.     u_char sep)
  309. {
  310.     size_t      len;
  311.     u_char     *pos;
  312.     ngx_int_t   n;

  314.     pos = p;

  316.     for ( ;; ) {
  317.         if (p == last) {
  318.             return NULL;
  319.         }

  321.         if (*p++ == sep) {
  322.             break;
  323.         }
  324.     }

  326.     len = p - pos - 1;

  328.     n = ngx_atoi(pos, len);
  329.     if (n < 0 || n > 65535) {
  330.         return NULL;
  331.     }

  333.     *port = (in_port_t) n;

  335.     return p;
  336. }


  339. u_char *
  340. ‌ngx_proxy_protocol_write(ngx_connection_t *c, u_char *buf, u_char *last)
  341. {
  342.     ngx_uint_t  port, lport;

  344.     if (last - buf < NGX_PROXY_PROTOCOL_V1_MAX_HEADER) {
  345.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  346.                       "too small buffer for PROXY protocol");
  347.         return NULL;
  348.     }

  350.     if (ngx_connection_local_sockaddr(c, NULL, 0) != NGX_OK) {
  351.         return NULL;
  352.     }

  354.     switch (c->sockaddr->sa_family) {

  356.     case AF_INET:
  357.         buf = ngx_cpymem(buf, "PROXY TCP4 ", sizeof("PROXY TCP4 ") - 1);
  358.         break;

  360. #if (NGX_HAVE_INET6)
  361.     case AF_INET6:
  362.         buf = ngx_cpymem(buf, "PROXY TCP6 ", sizeof("PROXY TCP6 ") - 1);
  363.         break;
  364. #endif

  366.     default:
  367.         return ngx_cpymem(buf, "PROXY UNKNOWN" CRLF,
  368.                           sizeof("PROXY UNKNOWN" CRLF) - 1);
  369.     }

  371.     buf += ngx_sock_ntop(c->sockaddr, c->socklen, buf, last - buf, 0);

  373.     *buf++ = ' ';

  375.     buf += ngx_sock_ntop(c->local_sockaddr, c->local_socklen, buf, last - buf,
  376.                          0);

  378.     port = ngx_inet_get_port(c->sockaddr);
  379.     lport = ngx_inet_get_port(c->local_sockaddr);

  381.     return ngx_slprintf(buf, last, " %ui %ui" CRLF, port, lport);
  382. }


  385. static u_char *
  386. ‌ngx_proxy_protocol_v2_read(ngx_connection_t *c, u_char *buf, u_char *last)
  387. {
  388.     u_char                             *end;
  389.     size_t                              len;
  390.     socklen_t                           socklen;
  391.     ngx_uint_t                          version, command, family, transport;
  392.     ngx_sockaddr_t                      src_sockaddr, dst_sockaddr;
  393.     ngx_proxy_protocol_t               *pp;
  394.     ngx_proxy_protocol_header_t        *header;
  395.     ngx_proxy_protocol_inet_addrs_t    *in;
  396. #if (NGX_HAVE_INET6)
  397.     ngx_proxy_protocol_inet6_addrs_t   *in6;
  398. #endif

  400.     header = (ngx_proxy_protocol_header_t *) buf;

  402.     buf += sizeof(ngx_proxy_protocol_header_t);

  404.     version = header->version_command >> 4;

  406.     if (version != 2) {
  407.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  408.                       "unknown PROXY protocol version: %ui", version);
  409.         return NULL;
  410.     }

  412.     len = ngx_proxy_protocol_parse_uint16(header->len);

  414.     if ((size_t) (last - buf) < len) {
  415.         ngx_log_error(NGX_LOG_ERR, c->log, 0, "header is too large");
  416.         return NULL;
  417.     }

  419.     end = buf + len;

  421.     command = header->version_command & 0x0f;

  423.     /* only PROXY is supported */
  424.     if (command != NGX_PROXY_PROTOCOL_CMD_PROXY) {
  425.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, c->log, 0,
  426.                        "PROXY protocol v2 unsupported command %ui", command);
  427.         return end;
  428.     }

  430.     transport = header->family_transport & 0x0f;

  432.     /* only STREAM is supported */
  433.     if (transport != NGX_PROXY_PROTOCOL_TYPE_STREAM) {
  434.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, c->log, 0,
  435.                        "PROXY protocol v2 unsupported transport %ui",
  436.                        transport);
  437.         return end;
  438.     }

  440.     pp = ngx_pcalloc(c->pool, sizeof(ngx_proxy_protocol_t));
  441.     if (pp == NULL) {
  442.         return NULL;
  443.     }

  445.     family = header->family_transport >> 4;

  447.     switch (family) {

  449.     case NGX_PROXY_PROTOCOL_AF_INET:

  451.         if ((size_t) (end - buf) < sizeof(ngx_proxy_protocol_inet_addrs_t)) {
  452.             return NULL;
  453.         }

  455.         in = (ngx_proxy_protocol_inet_addrs_t *) buf;

  457.         src_sockaddr.sockaddr_in.sin_family = AF_INET;
  458.         src_sockaddr.sockaddr_in.sin_port = 0;
  459.         ngx_memcpy(&src_sockaddr.sockaddr_in.sin_addr, in->src_addr, 4);

  461.         dst_sockaddr.sockaddr_in.sin_family = AF_INET;
  462.         dst_sockaddr.sockaddr_in.sin_port = 0;
  463.         ngx_memcpy(&dst_sockaddr.sockaddr_in.sin_addr, in->dst_addr, 4);

  465.         pp->src_port = ngx_proxy_protocol_parse_uint16(in->src_port);
  466.         pp->dst_port = ngx_proxy_protocol_parse_uint16(in->dst_port);

  468.         socklen = sizeof(struct sockaddr_in);

  470.         buf += sizeof(ngx_proxy_protocol_inet_addrs_t);

  472.         break;

  474. #if (NGX_HAVE_INET6)

  476.     case NGX_PROXY_PROTOCOL_AF_INET6:

  478.         if ((size_t) (end - buf) < sizeof(ngx_proxy_protocol_inet6_addrs_t)) {
  479.             return NULL;
  480.         }

  482.         in6 = (ngx_proxy_protocol_inet6_addrs_t *) buf;

  484.         src_sockaddr.sockaddr_in6.sin6_family = AF_INET6;
  485.         src_sockaddr.sockaddr_in6.sin6_port = 0;
  486.         ngx_memcpy(&src_sockaddr.sockaddr_in6.sin6_addr, in6->src_addr, 16);

  488.         dst_sockaddr.sockaddr_in6.sin6_family = AF_INET6;
  489.         dst_sockaddr.sockaddr_in6.sin6_port = 0;
  490.         ngx_memcpy(&dst_sockaddr.sockaddr_in6.sin6_addr, in6->dst_addr, 16);

  492.         pp->src_port = ngx_proxy_protocol_parse_uint16(in6->src_port);
  493.         pp->dst_port = ngx_proxy_protocol_parse_uint16(in6->dst_port);

  495.         socklen = sizeof(struct sockaddr_in6);

  497.         buf += sizeof(ngx_proxy_protocol_inet6_addrs_t);

  499.         break;

  501. #endif

  503.     default:
  504.         ngx_log_debug1(NGX_LOG_DEBUG_CORE, c->log, 0,
  505.                        "PROXY protocol v2 unsupported address family %ui",
  506.                        family);
  507.         return end;
  508.     }

  510.     pp->src_addr.data = ngx_pnalloc(c->pool, NGX_SOCKADDR_STRLEN);
  511.     if (pp->src_addr.data == NULL) {
  512.         return NULL;
  513.     }

  515.     pp->src_addr.len = ngx_sock_ntop(&src_sockaddr.sockaddr, socklen,
  516.                                      pp->src_addr.data, NGX_SOCKADDR_STRLEN, 0);

  518.     pp->dst_addr.data = ngx_pnalloc(c->pool, NGX_SOCKADDR_STRLEN);
  519.     if (pp->dst_addr.data == NULL) {
  520.         return NULL;
  521.     }

  523.     pp->dst_addr.len = ngx_sock_ntop(&dst_sockaddr.sockaddr, socklen,
  524.                                      pp->dst_addr.data, NGX_SOCKADDR_STRLEN, 0);

  526.     ngx_log_debug4(NGX_LOG_DEBUG_CORE, c->log, 0,
  527.                    "PROXY protocol v2 src: %V %d, dst: %V %d",
  528.                    &pp->src_addr, pp->src_port, &pp->dst_addr, pp->dst_port);

  530.     if (buf < end) {
  531.         pp->tlvs.data = ngx_pnalloc(c->pool, end - buf);
  532.         if (pp->tlvs.data == NULL) {
  533.             return NULL;
  534.         }

  536.         ngx_memcpy(pp->tlvs.data, buf, end - buf);
  537.         pp->tlvs.len = end - buf;
  538.     }

  540.     c->proxy_protocol = pp;

  542.     return end;
  543. }


  546. ngx_int_t
  547. ‌ngx_proxy_protocol_get_tlv(ngx_connection_t *c, ngx_str_t *name,
  548.     ngx_str_t *value)
  549. {
  550.     u_char                          *p;
  551.     size_t                           n;
  552.     uint32_t                         verify;
  553.     ngx_str_t                        ssl, *tlvs;
  554.     ngx_int_t                        rc, type;
  555.     ngx_proxy_protocol_tlv_ssl_t    *tlv_ssl;
  556.     ngx_proxy_protocol_tlv_entry_t  *te;

  558.     if (c->proxy_protocol == NULL) {
  559.         return NGX_DECLINED;
  560.     }

  562.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, c->log, 0,
  563.                    "PROXY protocol v2 get tlv \"%V\"", name);

  565.     te = ngx_proxy_protocol_tlv_entries;
  566.     tlvs = &c->proxy_protocol->tlvs;

  568.     p = name->data;
  569.     n = name->len;

  571.     if (n >= 4 && p[0] == 's' && p[1] == 's' && p[2] == 'l' && p[3] == '_') {

  573.         rc = ngx_proxy_protocol_lookup_tlv(c, tlvs,
  574.                                            NGX_PROXY_PROTOCOL_TLV_SSL, &ssl);
  575.         if (rc != NGX_OK) {
  576.             return rc;
  577.         }

  579.         if (ssl.len < sizeof(ngx_proxy_protocol_tlv_ssl_t)) {
  580.             return NGX_ERROR;
  581.         }

  583.         p += 4;
  584.         n -= 4;

  586.         if (n == 6 && ngx_strncmp(p, "verify", 6) == 0) {

  588.             tlv_ssl = (ngx_proxy_protocol_tlv_ssl_t *) ssl.data;
  589.             verify = ngx_proxy_protocol_parse_uint32(tlv_ssl->verify);

  591.             value->data = ngx_pnalloc(c->pool, NGX_INT32_LEN);
  592.             if (value->data == NULL) {
  593.                 return NGX_ERROR;
  594.             }

  596.             value->len = ngx_sprintf(value->data, "%uD", verify)
  597.                          - value->data;
  598.             return NGX_OK;
  599.         }

  601.         ssl.data += sizeof(ngx_proxy_protocol_tlv_ssl_t);
  602.         ssl.len -= sizeof(ngx_proxy_protocol_tlv_ssl_t);

  604.         te = ngx_proxy_protocol_tlv_ssl_entries;
  605.         tlvs = &ssl;
  606.     }

  608.     if (n >= 2 && p[0] == '0' && p[1] == 'x') {

  610.         type = ngx_hextoi(p + 2, n - 2);
  611.         if (type == NGX_ERROR) {
  612.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  613.                           "invalid PROXY protocol TLV \"%V\"", name);
  614.             return NGX_ERROR;
  615.         }

  617.         return ngx_proxy_protocol_lookup_tlv(c, tlvs, type, value);
  618.     }

  620.     for ( /* void */ ; te->type; te++) {
  621.         if (te->name.len == n && ngx_strncmp(te->name.data, p, n) == 0) {
  622.             return ngx_proxy_protocol_lookup_tlv(c, tlvs, te->type, value);
  623.         }
  624.     }

  626.     ngx_log_error(NGX_LOG_ERR, c->log, 0,
  627.                   "unknown PROXY protocol TLV \"%V\"", name);

  629.     return NGX_DECLINED;
  630. }


  633. static ngx_int_t
  634. ‌ngx_proxy_protocol_lookup_tlv(ngx_connection_t *c, ngx_str_t *tlvs,
  635.     ngx_uint_t type, ngx_str_t *value)
  636. {
  637.     u_char                    *p;
  638.     size_t                     n, len;
  639.     ngx_proxy_protocol_tlv_t  *tlv;

  641.     ngx_log_debug1(NGX_LOG_DEBUG_CORE, c->log, 0,
  642.                    "PROXY protocol v2 lookup tlv:%02xi", type);

  644.     p = tlvs->data;
  645.     n = tlvs->len;

  647.     while (n) {
  648.         if (n < sizeof(ngx_proxy_protocol_tlv_t)) {
  649.             ngx_log_error(NGX_LOG_ERR, c->log, 0, "broken PROXY protocol TLV");
  650.             return NGX_ERROR;
  651.         }

  653.         tlv = (ngx_proxy_protocol_tlv_t *) p;
  654.         len = ngx_proxy_protocol_parse_uint16(tlv->len);

  656.         p += sizeof(ngx_proxy_protocol_tlv_t);
  657.         n -= sizeof(ngx_proxy_protocol_tlv_t);

  659.         if (n < len) {
  660.             ngx_log_error(NGX_LOG_ERR, c->log, 0, "broken PROXY protocol TLV");
  661.             return NGX_ERROR;
  662.         }

  664.         if (tlv->type == type) {
  665.             value->data = p;
  666.             value->len = len;
  667.             return NGX_OK;
  668.         }

  670.         p += len;
  671.         n -= len;
  672.     }

  674.     return NGX_DECLINED;
  675. }


  678. u_char *
  679. ‌ngx_proxy_protocol_v2_write(ngx_connection_t *c, u_char *buf, u_char *last,
  680.     ngx_array_t *tlvs /* reserved */ )
  681. {
  682.     u_char                          *p;
  683.     uint32_t                         verify;
  684.     ngx_uint_t                       i, client;
  685.     ngx_array_t                      base_tlvs, ssl_tlvs;
  686.     ngx_proxy_protocol_tlv_value_t  *tlv;

  688.     client = 0;
  689.     verify = 0;

  691.     ngx_memzero(&base_tlvs, sizeof(ngx_array_t));
  692.     ngx_memzero(&ssl_tlvs, sizeof(ngx_array_t));

  694. #if (NGX_OPENSSL)

  696.     if (c->ssl != NULL) {
  697.         if (ngx_array_init(&base_tlvs, c->pool, 2,
  698.                            sizeof(ngx_proxy_protocol_tlv_value_t))
  699.             != NGX_OK)
  700.         {
  701.             return NULL;
  702.         }

  704.         if (ngx_array_init(&ssl_tlvs, c->pool, 5,
  705.                            sizeof(ngx_proxy_protocol_tlv_value_t))
  706.             != NGX_OK)
  707.         {
  708.             return NULL;
  709.         }

  711.         if (ngx_proxy_protocol_v2_eval_ssl(c, &base_tlvs, &ssl_tlvs, &client,
  712.                                            &verify)
  713.             != NGX_OK)
  714.         {
  715.             return NULL;
  716.         }
  717.     }

  719. #endif

  721.     p = ngx_proxy_protocol_v2_write_header(c, buf, last);
  722.     if (p == NULL) {
  723.         return NULL;
  724.     }

  726.     tlv = base_tlvs.elts;

  728.     for (i = 0; i < base_tlvs.nelts; i++) {
  729.         p = ngx_proxy_protocol_v2_write_tlv(c, p, last, tlv[i].type,
  730.                                            &tlv[i].value);
  731.         if (p == NULL) {
  732.             return NULL;
  733.         }
  734.     }

  736.     if (client) {
  737.         p = ngx_proxy_protocol_v2_write_ssl(c, p, last, &ssl_tlvs, client,
  738.                                             verify);
  739.         if (p == NULL) {
  740.             return NULL;
  741.         }
  742.     }

  744.     ngx_proxy_protocol_v2_set_len(buf,
  745.                                   p + sizeof(ngx_proxy_protocol_tlv_t) + 4);

  747.     return ngx_proxy_protocol_v2_write_crc32c(c, buf, p, last);
  748. }


  751. #if (NGX_OPENSSL)

  753. static ngx_int_t
  754. ‌ngx_proxy_protocol_v2_eval_ssl(ngx_connection_t *c, ngx_array_t *tlvs,
  755.     ngx_array_t *ssl_tlvs, ngx_uint_t *client, uint32_t *verify)
  756. {
  757.     X509                            *cert;
  758.     long                             n;
  759.     ngx_int_t                        rc;
  760.     ngx_str_t                        value;
  761.     ngx_uint_t                       type;
  762.     const char                      *s;
  763.     ngx_proxy_protocol_tlv_value_t  *tlv;

  765.     if (ngx_proxy_protocol_v2_authority(c, &value) == NGX_OK) {
  766.         tlv = ngx_array_push(tlvs);
  767.         if (tlv == NULL) {
  768.             return NGX_ERROR;
  769.         }

  771.         tlv->type = NGX_PROXY_PROTOCOL_TLV_AUTHORITY;
  772.         tlv->value = value;
  773.     }

  775.     if (ngx_proxy_protocol_v2_alpn(c, &value) == NGX_OK) {
  776.         tlv = ngx_array_push(tlvs);
  777.         if (tlv == NULL) {
  778.             return NGX_ERROR;
  779.         }

  781.         tlv->type = NGX_PROXY_PROTOCOL_TLV_ALPN;
  782.         tlv->value = value;
  783.     }

  785.     for (type = NGX_PROXY_PROTOCOL_TLV_SSL_VERSION;
  786.          type <= NGX_PROXY_PROTOCOL_TLV_SSL_KEY_ALG;
  787.          type++)
  788.     {
  789.         rc = ngx_proxy_protocol_v2_ssl_sub(c, type, &value);

  791.         if (rc == NGX_ERROR) {
  792.             return NGX_ERROR;
  793.         }

  795.         if (rc != NGX_OK) {
  796.             continue;
  797.         }

  799.         tlv = ngx_array_push(ssl_tlvs);
  800.         if (tlv == NULL) {
  801.             return NGX_ERROR;
  802.         }

  804.         tlv->type = type;
  805.         tlv->value = value;
  806.     }

  808.     *client = NGX_PROXY_PROTOCOL_V2_CLIENT_SSL;
  809.     *verify = 1;  /* X509_V_ERR_UNSPECIFIED */

  811.     cert = SSL_get_peer_certificate(c->ssl->connection);

  813.     if (cert != NULL) {
  814.         X509_free(cert);

  816.         *client |= NGX_PROXY_PROTOCOL_V2_CLIENT_CERT_SESS;

  818.         if (!SSL_session_reused(c->ssl->connection)) {
  819.             *client |= NGX_PROXY_PROTOCOL_V2_CLIENT_CERT_CONN;
  820.         }

  822.         n = SSL_get_verify_result(c->ssl->connection);

  824.         if (n == X509_V_OK) {

  826.             if (ngx_ssl_ocsp_get_status(c, &s) != NGX_OK) {
  827.                 n = X509_V_ERR_CERT_REVOKED;
  828.             }
  829.         }

  831.         *verify = (uint32_t) n;
  832.     }

  834.     return NGX_OK;
  835. }


  838. static ngx_int_t
  839. ‌ngx_proxy_protocol_v2_authority(ngx_connection_t *c, ngx_str_t *out)
  840. {
  841. #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

  843.     const char  *sni;

  845.     sni = SSL_get_servername(c->ssl->connection, TLSEXT_NAMETYPE_host_name);
  846.     if (sni == NULL) {
  847.         return NGX_DECLINED;
  848.     }

  850.     out->data = (u_char *) sni;
  851.     out->len = ngx_strlen(sni);
  852.     return NGX_OK;

  854. #else
  855.     return NGX_DECLINED;
  856. #endif
  857. }


  860. static ngx_int_t
  861. ‌ngx_proxy_protocol_v2_alpn(ngx_connection_t *c, ngx_str_t *out)
  862. {
  863. #ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

  865.     unsigned int          alpnlen;
  866.     const unsigned char  *alpn;

  868.     SSL_get0_alpn_selected(c->ssl->connection, &alpn, &alpnlen);
  869.     if (alpn == NULL || alpnlen == 0) {
  870.         return NGX_DECLINED;
  871.     }

  873.     out->data = (u_char *) alpn;
  874.     out->len = alpnlen;
  875.     return NGX_OK;

  877. #else
  878.     return NGX_DECLINED;
  879. #endif
  880. }


  883. static ngx_int_t
  884. ‌ngx_proxy_protocol_v2_ssl_sub(ngx_connection_t *c, ngx_uint_t type,
  885.     ngx_str_t *out)
  886. {
  887.     int               i, len;
  888.     X509             *cert;
  889.     u_char           *alg, *s;
  890.     EVP_PKEY         *pkey;
  891. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  892.     const
  893. #endif
  894.     X509_NAME        *subject;
  895. #if (OPENSSL_VERSION_NUMBER >= 0x40000000L)
  896.     const
  897. #endif
  898.     X509_NAME_ENTRY  *entry;

  900.     switch (type) {

  902.     case NGX_PROXY_PROTOCOL_TLV_SSL_VERSION:
  903.         out->data = (u_char *) SSL_get_version(c->ssl->connection);
  904.         out->len = ngx_strlen(out->data);
  905.         return NGX_OK;

  907.     case NGX_PROXY_PROTOCOL_TLV_SSL_CIPHER:
  908.         out->data = (u_char *) SSL_get_cipher_name(c->ssl->connection);
  909.         out->len = ngx_strlen(out->data);
  910.         return NGX_OK;

  912.     case NGX_PROXY_PROTOCOL_TLV_SSL_CN:
  913.         cert = SSL_get_peer_certificate(c->ssl->connection);
  914.         if (cert == NULL) {
  915.             return NGX_DECLINED;
  916.         }

  918.         subject = X509_get_subject_name(cert);
  919.         if (subject == NULL) {
  920.             X509_free(cert);
  921.             return NGX_ERROR;
  922.         }

  924.         i = X509_NAME_get_index_by_NID(subject, NID_commonName, -1);
  925.         if (i < 0) {
  926.             X509_free(cert);
  927.             return NGX_DECLINED;
  928.         }

  930.         entry = X509_NAME_get_entry(subject, i);

  932.         len = ASN1_STRING_to_UTF8(&s, X509_NAME_ENTRY_get_data(entry));
  933.         if (len < 0) {
  934.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0,
  935.                           "ASN1_STRING_to_UTF8() failed");
  936.             X509_free(cert);
  937.             return NGX_ERROR;
  938.         }

  940.         out->len = len;
  941.         out->data = ngx_pnalloc(c->pool, len);
  942.         if (out->data == NULL) {
  943.             OPENSSL_free(s);
  944.             X509_free(cert);
  945.             return NGX_ERROR;
  946.         }

  948.         ngx_memcpy(out->data, s, len);

  950.         OPENSSL_free(s);
  951.         X509_free(cert);
  952.         return NGX_OK;

  954.     case NGX_PROXY_PROTOCOL_TLV_SSL_SIG_ALG:
  955.         cert = SSL_get_certificate(c->ssl->connection);

  957.         out->data = (u_char *) OBJ_nid2sn(X509_get_signature_nid(cert));
  958.         out->len = ngx_strlen(out->data);
  959.         return NGX_OK;

  961.     case NGX_PROXY_PROTOCOL_TLV_SSL_KEY_ALG:
  962.         cert = SSL_get_certificate(c->ssl->connection);

  964.         pkey = X509_get_pubkey(cert);
  965.         if (pkey == NULL) {
  966.             return NGX_ERROR;
  967.         }

  969.         switch (EVP_PKEY_base_id(pkey)) {

  971.         case EVP_PKEY_RSA:
  972. #ifdef EVP_PKEY_RSA_PSS
  973.         case EVP_PKEY_RSA_PSS:
  974. #endif
  975.             alg = (u_char *) "RSA";
  976.             break;

  978.         case EVP_PKEY_EC:
  979.             alg = (u_char *) "EC";
  980.             break;

  982.         case EVP_PKEY_DSA:
  983.             alg = (u_char *) "DSA";
  984.             break;

  986.         default:
  987.             EVP_PKEY_free(pkey);
  988.             return NGX_DECLINED;
  989.         }

  991.         out->len = sizeof("RSA16384") - 1;
  992.         out->data = ngx_pnalloc(c->pool, out->len);
  993.         if (out->data == NULL) {
  994.             EVP_PKEY_free(pkey);
  995.             return NGX_ERROR;
  996.         }

  998.         out->len = ngx_snprintf(out->data, out->len, "%s%d",
  999.                                 alg, EVP_PKEY_bits(pkey))
  1000.                    - out->data;

  1002.         EVP_PKEY_free(pkey);

  1004.         return NGX_OK;
  1005.     }

  1007.     return NGX_DECLINED;
  1008. }

  1010. #endif


  1013. static u_char *
  1014. ‌ngx_proxy_protocol_v2_write_header(ngx_connection_t *c, u_char *buf,
  1015.     u_char *last)
  1016. {
  1017.     u_char                            *p, src_af, dst_af,
  1018.                                        family, command, transport;
  1019.     ngx_uint_t                         src_fam, dst_fam;
  1020.     ngx_proxy_protocol_header_t       *header;
  1021.     ngx_proxy_protocol_inet_addrs_t   *in;
  1022. #if (NGX_HAVE_INET6)
  1023.     ngx_uint_t                         port, lport;
  1024.     struct in6_addr                   *src6, *dst6;
  1025.     ngx_proxy_protocol_inet6_addrs_t  *in6;
  1026. #endif

  1028.     if (last - buf < NGX_PROXY_PROTOCOL_V2_MAX_HEADER) {
  1029.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  1030.                       "too small buffer for PROXY protocol v2");
  1031.         return NULL;
  1032.     }

  1034.     if (ngx_connection_local_sockaddr(c, NULL, 0) != NGX_OK) {
  1035.         return NULL;
  1036.     }

  1038.     /* the length field is set by the caller once all TLVs are written */

  1040.     header = (ngx_proxy_protocol_header_t *) buf;

  1042.     ngx_memcpy(header->signature, ngx_proxy_protocol_signature,
  1043.                sizeof(ngx_proxy_protocol_signature) - 1);

  1045.     p = buf + sizeof(ngx_proxy_protocol_header_t);

  1047.     src_fam = c->sockaddr->sa_family;
  1048.     dst_fam = c->local_sockaddr->sa_family;

  1050.     src_af = ngx_proxy_protocol_v2_family(src_fam);
  1051.     dst_af = ngx_proxy_protocol_v2_family(dst_fam);

  1053.     /* promote to the highest address family present on either side */

  1055.     if (src_af == NGX_PROXY_PROTOCOL_AF_UNSPEC
  1056.         || dst_af == NGX_PROXY_PROTOCOL_AF_UNSPEC)
  1057.     {
  1058.         command = NGX_PROXY_PROTOCOL_CMD_LOCAL;
  1059.         family = NGX_PROXY_PROTOCOL_AF_UNSPEC;
  1060.         transport = NGX_PROXY_PROTOCOL_TYPE_UNSPEC;

  1062.     } else {
  1063.         command = NGX_PROXY_PROTOCOL_CMD_PROXY;
  1064.         family = ngx_max(src_af, dst_af);

  1066.         switch (c->type) {
  1067.         case SOCK_STREAM:
  1068.             transport = NGX_PROXY_PROTOCOL_TYPE_STREAM;
  1069.             break;
  1070.         case SOCK_DGRAM:
  1071.             transport = NGX_PROXY_PROTOCOL_TYPE_DGRAM;
  1072.             break;
  1073.         default:
  1074.             transport = NGX_PROXY_PROTOCOL_TYPE_UNSPEC;
  1075.             break;
  1076.         }
  1077.     }

  1079.     header->version_command = 0x20 | command;
  1080.     header->family_transport = (family << 4) | transport;

  1082.     switch (family) {

  1084.     case NGX_PROXY_PROTOCOL_AF_INET:

  1086.         in = (ngx_proxy_protocol_inet_addrs_t *) p;

  1088.         ngx_proxy_protocol_v2_write_ipv4(c->sockaddr,
  1089.                                          in->src_addr, in->src_port);
  1090.         ngx_proxy_protocol_v2_write_ipv4(c->local_sockaddr,
  1091.                                          in->dst_addr, in->dst_port);

  1093.         p += sizeof(ngx_proxy_protocol_inet_addrs_t);

  1095.         break;

  1097. #if (NGX_HAVE_INET6)

  1099.     case NGX_PROXY_PROTOCOL_AF_INET6:

  1101.         if (src_fam == AF_INET6 && dst_fam == AF_INET6) {
  1102.             src6 = &((struct sockaddr_in6 *) c->sockaddr)->sin6_addr;
  1103.             dst6 = &((struct sockaddr_in6 *) c->local_sockaddr)->sin6_addr;

  1105.             if (IN6_IS_ADDR_V4MAPPED(src6) && IN6_IS_ADDR_V4MAPPED(dst6)) {

  1107.                 /* both v4-mapped: demote to AF_INET */

  1109.                 header->family_transport = (NGX_PROXY_PROTOCOL_AF_INET << 4)
  1110.                                            | transport;

  1112.                 in = (ngx_proxy_protocol_inet_addrs_t *) p;

  1114.                 ngx_memcpy(in->src_addr, src6->s6_addr + 12, 4);
  1115.                 ngx_memcpy(in->dst_addr, dst6->s6_addr + 12, 4);

  1117.                 port  = ngx_inet_get_port(c->sockaddr);
  1118.                 lport = ngx_inet_get_port(c->local_sockaddr);

  1120.                 in->src_port[0] = (u_char) (port >> 8);
  1121.                 in->src_port[1] = (u_char)  port;
  1122.                 in->dst_port[0] = (u_char) (lport >> 8);
  1123.                 in->dst_port[1] = (u_char)  lport;

  1125.                 p += sizeof(ngx_proxy_protocol_inet_addrs_t);
  1126.                 break;
  1127.             }
  1128.         }

  1130.         in6 = (ngx_proxy_protocol_inet6_addrs_t *) p;

  1132.         ngx_proxy_protocol_v2_write_ipv6(c->sockaddr,
  1133.                                          in6->src_addr, in6->src_port);
  1134.         ngx_proxy_protocol_v2_write_ipv6(c->local_sockaddr,
  1135.                                          in6->dst_addr, in6->dst_port);

  1137.         p += sizeof(ngx_proxy_protocol_inet6_addrs_t);

  1139.         break;

  1141. #endif

  1143.     default:  /* NGX_PROXY_PROTOCOL_AF_UNSPEC */
  1144.         break;
  1145.     }

  1147.     return p;
  1148. }


  1151. static u_char
  1152. ‌ngx_proxy_protocol_v2_family(ngx_uint_t family)
  1153. {
  1154.     switch (family) {

  1156.     case AF_INET:
  1157.         return NGX_PROXY_PROTOCOL_AF_INET;

  1159. #if (NGX_HAVE_INET6)
  1160.     case AF_INET6:
  1161.         return NGX_PROXY_PROTOCOL_AF_INET6;
  1162. #endif

  1164.     default:
  1165.         return NGX_PROXY_PROTOCOL_AF_UNSPEC;
  1166.     }
  1167. }


  1170. static void
  1171. ‌ngx_proxy_protocol_v2_write_ipv4(struct sockaddr *sa, u_char *addr,
  1172.     u_char *port)
  1173. {
  1174.     struct sockaddr_in  *sin;

  1176.     sin = (struct sockaddr_in *) sa;
  1177.     ngx_memcpy(addr, &sin->sin_addr, 4);
  1178.     ngx_memcpy(port, &sin->sin_port, 2);
  1179. }


  1182. #if (NGX_HAVE_INET6)

  1184. static void
  1185. ‌ngx_proxy_protocol_v2_write_ipv6(struct sockaddr *sa, u_char *addr,
  1186.     u_char *port)
  1187. {
  1188.     struct sockaddr_in   *sin;
  1189.     struct sockaddr_in6  *sin6;

  1191.     /* IPv4-mapped prefix: 80 zero bits + 16 one bits */
  1192.     static const u_char  mapped[]   = { 0x00, 0x00, 0x00, 0x00,
  1193.                                         0x00, 0x00, 0x00, 0x00,
  1194.                                         0x00, 0x00, 0xff, 0xff };

  1196.     if (sa->sa_family == AF_INET6) {
  1197.         sin6 = (struct sockaddr_in6 *) sa;
  1198.         ngx_memcpy(addr, &sin6->sin6_addr, 16);
  1199.         ngx_memcpy(port, &sin6->sin6_port, 2);

  1201.     } else {
  1202.         /* promote AF_INET to ::ffff:a.b.c.d */
  1203.         sin = (struct sockaddr_in *) sa;
  1204.         ngx_memcpy(addr, mapped, sizeof(mapped));
  1205.         ngx_memcpy(addr + sizeof(mapped), &sin->sin_addr, 4);
  1206.         ngx_memcpy(port, &sin->sin_port, 2);
  1207.     }
  1208. }

  1210. #endif


  1213. static u_char *
  1214. ‌ngx_proxy_protocol_v2_write_tlv(ngx_connection_t *c, u_char *p, u_char *last,
  1215.     ngx_uint_t type, ngx_str_t *value)
  1216. {
  1217.     ngx_proxy_protocol_tlv_t  *tlv;

  1219.     if ((size_t) (last - p) < sizeof(ngx_proxy_protocol_tlv_t) + value->len) {
  1220.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  1221.                       "too small buffer for PROXY protocol v2 TLV");
  1222.         return NULL;
  1223.     }

  1225.     tlv = (ngx_proxy_protocol_tlv_t *) p;
  1226.     tlv->type = (u_char) type;
  1227.     tlv->len[0] = (u_char) (value->len >> 8);
  1228.     tlv->len[1] = (u_char)  value->len;

  1230.     p += sizeof(ngx_proxy_protocol_tlv_t);

  1232.     return ngx_cpymem(p, value->data, value->len);
  1233. }


  1236. static u_char *
  1237. ‌ngx_proxy_protocol_v2_write_ssl(ngx_connection_t *c, u_char *p, u_char *last,
  1238.     ngx_array_t *ssl_tlvs, ngx_uint_t client, uint32_t verify)
  1239. {
  1240.     u_char                          *start;
  1241.     uint16_t                         len;
  1242.     ngx_uint_t                       i;
  1243.     ngx_proxy_protocol_tlv_t        *tlv;
  1244.     ngx_proxy_protocol_tlv_ssl_t    *tlv_ssl;
  1245.     ngx_proxy_protocol_tlv_value_t  *sub;

  1247.     if ((size_t) (last - p) < sizeof(ngx_proxy_protocol_tlv_t)
  1248.                               + sizeof(ngx_proxy_protocol_tlv_ssl_t))
  1249.     {
  1250.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  1251.                       "too small buffer for PROXY protocol v2 SSL TLV");
  1252.         return NULL;
  1253.     }

  1255.     start = p;
  1256.     p += sizeof(ngx_proxy_protocol_tlv_t);

  1258.     tlv_ssl = (ngx_proxy_protocol_tlv_ssl_t *) p;
  1259.     tlv_ssl->client = (u_char) client;
  1260.     tlv_ssl->verify[0] = (u_char) (verify >> 24);
  1261.     tlv_ssl->verify[1] = (u_char) (verify >> 16);
  1262.     tlv_ssl->verify[2] = (u_char) (verify >> 8);
  1263.     tlv_ssl->verify[3] = (u_char)  verify;

  1265.     p += sizeof(ngx_proxy_protocol_tlv_ssl_t);

  1267.     sub = ssl_tlvs->elts;

  1269.     for (i = 0; i < ssl_tlvs->nelts; i++) {
  1270.         p = ngx_proxy_protocol_v2_write_tlv(c, p, last, sub[i].type,
  1271.                                             &sub[i].value);
  1272.         if (p == NULL) {
  1273.             return NULL;
  1274.         }
  1275.     }

  1277.     len = (uint16_t) (p - start - sizeof(ngx_proxy_protocol_tlv_t));

  1279.     tlv = (ngx_proxy_protocol_tlv_t *) start;
  1280.     tlv->type = NGX_PROXY_PROTOCOL_TLV_SSL;
  1281.     tlv->len[0] = (u_char) (len >> 8);
  1282.     tlv->len[1] = (u_char)  len;

  1284.     return p;
  1285. }


  1288. static void
  1289. ‌ngx_proxy_protocol_v2_set_len(u_char *buf, u_char *p)
  1290. {
  1291.     uint16_t                      len;
  1292.     ngx_proxy_protocol_header_t  *header;

  1294.     len = (uint16_t) (p - buf - sizeof(ngx_proxy_protocol_header_t));

  1296.     header = (ngx_proxy_protocol_header_t *) buf;
  1297.     header->len[0] = (u_char) (len >> 8);
  1298.     header->len[1] = (u_char) len;
  1299. }


  1302. static u_char *
  1303. ‌ngx_proxy_protocol_v2_write_crc32c(ngx_connection_t *c, u_char *buf,
  1304.     u_char *p, u_char *last)
  1305. {
  1306.     u_char                    *value;
  1307.     uint32_t                   crc;
  1308.     ngx_proxy_protocol_tlv_t  *tlv;

  1310.     if ((size_t) (last - p) < sizeof(ngx_proxy_protocol_tlv_t) + 4) {
  1311.         ngx_log_error(NGX_LOG_ALERT, c->log, 0,
  1312.                       "too small buffer for PROXY protocol v2 CRC32c TLV");
  1313.         return NULL;
  1314.     }

  1316.     /* append the CRC32c TLV with a zeroed value field */

  1318.     tlv = (ngx_proxy_protocol_tlv_t *) p;
  1319.     tlv->type = NGX_PROXY_PROTOCOL_TLV_CRC32C;
  1320.     tlv->len[0] = 0;
  1321.     tlv->len[1] = 4;

  1323.     value = p + sizeof(ngx_proxy_protocol_tlv_t);

  1325.     ngx_memzero(value, 4);

  1327.     p = value + 4;

  1329.     /* the checksum covers the entire header with the zeroed value */

  1331.     crc = ngx_crc32c_long(buf, p - buf);

  1333.     value[0] = (u_char) (crc >> 24);
  1334.     value[1] = (u_char) (crc >> 16);
  1335.     value[2] = (u_char) (crc >> 8);
  1336.     value[3] = (u_char) crc;

  1338.     return p;
  1339. }

One Level Up Top Level