One Level Up Top Level

src/event/ngx_event_openssl_stapling.c - nginx source code

Data types defined

Functions defined

Source code


  2. /*
  3. * Copyright (C) Maxim Dounin
  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>


  14. #if (!defined OPENSSL_NO_OCSP && defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB)


  17. ‌typedef struct {
  18.     ngx_rbtree_node_t            node;

  20.     ngx_str_t                    staple;
  21.     ngx_msec_t                   timeout;

  23.     ngx_resolver_t              *resolver;
  24.     ngx_msec_t                   resolver_timeout;

  26.     ngx_addr_t                  *addrs;
  27.     ngx_uint_t                   naddrs;
  28.     ngx_str_t                    host;
  29.     ngx_str_t                    uri;
  30.     in_port_t                    port;

  32.     SSL_CTX                     *ssl_ctx;

  34.     X509                        *cert;
  35.     X509                        *issuer;
  36.     STACK_OF(X509)              *chain;

  38.     u_char                      *name;

  40.     time_t                       valid;
  41.     time_t                       refresh;

  43.     unsigned                     verify:1;
  44.     unsigned                     loading:1;
  45. ‌} ngx_ssl_stapling_t;


  48. ‌typedef struct {
  49.     ngx_addr_t                  *addrs;
  50.     ngx_uint_t                   naddrs;

  52.     ngx_str_t                    host;
  53.     ngx_str_t                    uri;
  54.     in_port_t                    port;
  55.     ngx_uint_t                   depth;

  57.     ngx_shm_zone_t              *shm_zone;

  59.     ngx_resolver_t              *resolver;
  60.     ngx_msec_t                   resolver_timeout;
  61. ‌} ngx_ssl_ocsp_conf_t;


  64. ‌typedef struct {
  65.     ngx_rbtree_t                 rbtree;
  66.     ngx_rbtree_node_t            sentinel;
  67.     ngx_queue_t                  expire_queue;
  68. ‌} ngx_ssl_ocsp_cache_t;


  71. ‌typedef struct {
  72.     ngx_str_node_t               node;
  73.     ngx_queue_t                  queue;
  74.     int                          status;
  75.     time_t                       valid;
  76. ‌} ngx_ssl_ocsp_cache_node_t;


  79. ‌typedef struct ngx_ssl_ocsp_ctx_s  ngx_ssl_ocsp_ctx_t;


  82. ‌struct ngx_ssl_ocsp_s {
  83.     STACK_OF(X509)              *certs;
  84.     ngx_uint_t                   ncert;

  86.     int                          cert_status;
  87.     ngx_int_t                    status;

  89.     ngx_ssl_ocsp_conf_t         *conf;
  90.     ngx_ssl_ocsp_ctx_t          *ctx;
  91. };


  94. ‌struct ngx_ssl_ocsp_ctx_s {
  95.     SSL_CTX                     *ssl_ctx;

  97.     X509                        *cert;
  98.     X509                        *issuer;
  99.     STACK_OF(X509)              *chain;

  101.     int                          status;
  102.     time_t                       valid;

  104.     u_char                      *name;

  106.     ngx_uint_t                   naddrs;
  107.     ngx_uint_t                   naddr;

  109.     ngx_addr_t                  *addrs;
  110.     ngx_str_t                    host;
  111.     ngx_str_t                    uri;
  112.     in_port_t                    port;

  114.     ngx_resolver_t              *resolver;
  115.     ngx_msec_t                   resolver_timeout;

  117.     ngx_msec_t                   timeout;

  119.     void                       (*handler)(ngx_ssl_ocsp_ctx_t *ctx);
  120.     void                        *data;

  122.     ngx_str_t                    key;
  123.     ngx_buf_t                   *request;
  124.     ngx_buf_t                   *response;
  125.     ngx_peer_connection_t        peer;

  127.     ngx_shm_zone_t              *shm_zone;

  129.     ngx_int_t                  (*process)(ngx_ssl_ocsp_ctx_t *ctx);

  131.     ngx_uint_t                   state;

  133.     ngx_uint_t                   code;
  134.     ngx_uint_t                   count;
  135.     ngx_uint_t                   flags;
  136.     ngx_uint_t                   done;

  138.     u_char                      *header_name_start;
  139.     u_char                      *header_name_end;
  140.     u_char                      *header_start;
  141.     u_char                      *header_end;

  143.     ngx_pool_t                  *pool;
  144.     ngx_log_t                   *log;
  145. };


  148. static ngx_int_t ngx_ssl_stapling_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl,
  149.     X509 *cert, ngx_str_t *file, ngx_str_t *responder, ngx_uint_t verify);
  150. static ngx_int_t ngx_ssl_stapling_file(ngx_conf_t *cf, ngx_ssl_t *ssl,
  151.     ngx_ssl_stapling_t *staple, ngx_str_t *file);
  152. static ngx_int_t ngx_ssl_stapling_issuer(ngx_conf_t *cf, ngx_ssl_t *ssl,
  153.     ngx_ssl_stapling_t *staple);
  154. static ngx_int_t ngx_ssl_stapling_responder(ngx_conf_t *cf, ngx_ssl_t *ssl,
  155.     ngx_ssl_stapling_t *staple, ngx_str_t *responder);

  157. static int ngx_ssl_certificate_status_callback(ngx_ssl_conn_t *ssl_conn,
  158.     void *data);
  159. static ngx_ssl_stapling_t *ngx_ssl_stapling_lookup(ngx_ssl_t *ssl, X509 *cert);
  160. static void ngx_ssl_stapling_update(ngx_ssl_stapling_t *staple);
  161. static void ngx_ssl_stapling_ocsp_handler(ngx_ssl_ocsp_ctx_t *ctx);

  163. static time_t ngx_ssl_stapling_time(ASN1_GENERALIZEDTIME *asn1time);

  165. static void ngx_ssl_stapling_cleanup(void *data);

  167. static void ngx_ssl_ocsp_validate_next(ngx_connection_t *c);
  168. static void ngx_ssl_ocsp_handler(ngx_ssl_ocsp_ctx_t *ctx);
  169. static ngx_int_t ngx_ssl_ocsp_responder(ngx_connection_t *c,
  170.     ngx_ssl_ocsp_ctx_t *ctx);

  172. static ngx_ssl_ocsp_ctx_t *ngx_ssl_ocsp_start(ngx_log_t *log);
  173. static void ngx_ssl_ocsp_done(ngx_ssl_ocsp_ctx_t *ctx);
  174. static void ngx_ssl_ocsp_next(ngx_ssl_ocsp_ctx_t *ctx);
  175. static void ngx_ssl_ocsp_request(ngx_ssl_ocsp_ctx_t *ctx);
  176. static void ngx_ssl_ocsp_resolve_handler(ngx_resolver_ctx_t *resolve);
  177. static void ngx_ssl_ocsp_connect(ngx_ssl_ocsp_ctx_t *ctx);
  178. static void ngx_ssl_ocsp_write_handler(ngx_event_t *wev);
  179. static void ngx_ssl_ocsp_read_handler(ngx_event_t *rev);
  180. static void ngx_ssl_ocsp_dummy_handler(ngx_event_t *ev);

  182. static ngx_int_t ngx_ssl_ocsp_create_request(ngx_ssl_ocsp_ctx_t *ctx);
  183. static ngx_int_t ngx_ssl_ocsp_process_status_line(ngx_ssl_ocsp_ctx_t *ctx);
  184. static ngx_int_t ngx_ssl_ocsp_parse_status_line(ngx_ssl_ocsp_ctx_t *ctx);
  185. static ngx_int_t ngx_ssl_ocsp_process_headers(ngx_ssl_ocsp_ctx_t *ctx);
  186. static ngx_int_t ngx_ssl_ocsp_parse_header_line(ngx_ssl_ocsp_ctx_t *ctx);
  187. static ngx_int_t ngx_ssl_ocsp_process_body(ngx_ssl_ocsp_ctx_t *ctx);
  188. static ngx_int_t ngx_ssl_ocsp_verify(ngx_ssl_ocsp_ctx_t *ctx);

  190. static ngx_int_t ngx_ssl_ocsp_cache_lookup(ngx_ssl_ocsp_ctx_t *ctx);
  191. static ngx_int_t ngx_ssl_ocsp_cache_store(ngx_ssl_ocsp_ctx_t *ctx);
  192. static ngx_int_t ngx_ssl_ocsp_create_key(ngx_ssl_ocsp_ctx_t *ctx);

  194. static u_char *ngx_ssl_ocsp_log_error(ngx_log_t *log, u_char *buf, size_t len);


  197. ngx_int_t
  198. ‌ngx_ssl_stapling(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *file,
  199.     ngx_str_t *responder, ngx_uint_t verify)
  200. {
  201.     X509        *cert;
  202.     ngx_uint_t   k;

  204.     for (k = 0; k < ssl->certs.nelts; k++) {
  205.         cert = ((X509 **) ssl->certs.elts)[k];

  207.         if (ngx_ssl_stapling_certificate(cf, ssl, cert, file, responder, verify)
  208.             != NGX_OK)
  209.         {
  210.             return NGX_ERROR;
  211.         }
  212.     }

  214.     SSL_CTX_set_tlsext_status_cb(ssl->ctx, ngx_ssl_certificate_status_callback);

  216.     return NGX_OK;
  217. }


  220. static ngx_int_t
  221. ‌ngx_ssl_stapling_certificate(ngx_conf_t *cf, ngx_ssl_t *ssl, X509 *cert,
  222.     ngx_str_t *file, ngx_str_t *responder, ngx_uint_t verify)
  223. {
  224.     ngx_int_t            rc;
  225.     ngx_pool_cleanup_t  *cln;
  226.     ngx_ssl_stapling_t  *staple;

  228.     staple = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_stapling_t));
  229.     if (staple == NULL) {
  230.         return NGX_ERROR;
  231.     }

  233.     cln = ngx_pool_cleanup_add(cf->pool, 0);
  234.     if (cln == NULL) {
  235.         return NGX_ERROR;
  236.     }

  238.     cln->handler = ngx_ssl_stapling_cleanup;
  239.     cln->data = staple;

  241.     staple->node.key = (ngx_rbtree_key_t) cert;

  243.     ngx_rbtree_insert(&ssl->staple_rbtree, &staple->node);

  245. #ifdef SSL_CTRL_SELECT_CURRENT_CERT
  246.     /* OpenSSL 1.0.2+ */
  247.     SSL_CTX_select_current_cert(ssl->ctx, cert);
  248. #endif

  250. #ifdef SSL_CTRL_GET_EXTRA_CHAIN_CERTS
  251.     /* OpenSSL 1.0.1+ */
  252.     SSL_CTX_get_extra_chain_certs(ssl->ctx, &staple->chain);
  253. #else
  254.     staple->chain = ssl->ctx->extra_certs;
  255. #endif

  257.     staple->ssl_ctx = ssl->ctx;
  258.     staple->timeout = 60000;
  259.     staple->verify = verify;
  260.     staple->cert = cert;
  261.     staple->name = X509_get_ex_data(staple->cert,
  262.                                     ngx_ssl_certificate_name_index);

  264.     if (file->len) {
  265.         /* use OCSP response from the file */

  267.         if (ngx_ssl_stapling_file(cf, ssl, staple, file) != NGX_OK) {
  268.             return NGX_ERROR;
  269.         }

  271.         return NGX_OK;
  272.     }

  274.     rc = ngx_ssl_stapling_issuer(cf, ssl, staple);

  276.     if (rc == NGX_DECLINED) {
  277.         return NGX_OK;
  278.     }

  280.     if (rc != NGX_OK) {
  281.         return NGX_ERROR;
  282.     }

  284.     rc = ngx_ssl_stapling_responder(cf, ssl, staple, responder);

  286.     if (rc == NGX_DECLINED) {
  287.         return NGX_OK;
  288.     }

  290.     if (rc != NGX_OK) {
  291.         return NGX_ERROR;
  292.     }

  294.     return NGX_OK;
  295. }


  298. static ngx_int_t
  299. ‌ngx_ssl_stapling_file(ngx_conf_t *cf, ngx_ssl_t *ssl,
  300.     ngx_ssl_stapling_t *staple, ngx_str_t *file)
  301. {
  302.     BIO            *bio;
  303.     int             len;
  304.     u_char         *p, *buf;
  305.     OCSP_RESPONSE  *response;

  307.     if (ngx_conf_full_name(cf->cycle, file, 1) != NGX_OK) {
  308.         return NGX_ERROR;
  309.     }

  311.     bio = BIO_new_file((char *) file->data, "rb");
  312.     if (bio == NULL) {
  313.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  314.                       "BIO_new_file(\"%s\") failed", file->data);
  315.         return NGX_ERROR;
  316.     }

  318.     response = d2i_OCSP_RESPONSE_bio(bio, NULL);
  319.     if (response == NULL) {
  320.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  321.                       "d2i_OCSP_RESPONSE_bio(\"%s\") failed", file->data);
  322.         BIO_free(bio);
  323.         return NGX_ERROR;
  324.     }

  326.     len = i2d_OCSP_RESPONSE(response, NULL);
  327.     if (len <= 0) {
  328.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  329.                       "i2d_OCSP_RESPONSE(\"%s\") failed", file->data);
  330.         goto failed;
  331.     }

  333.     buf = ngx_alloc(len, ssl->log);
  334.     if (buf == NULL) {
  335.         goto failed;
  336.     }

  338.     p = buf;
  339.     len = i2d_OCSP_RESPONSE(response, &p);
  340.     if (len <= 0) {
  341.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  342.                       "i2d_OCSP_RESPONSE(\"%s\") failed", file->data);
  343.         ngx_free(buf);
  344.         goto failed;
  345.     }

  347.     OCSP_RESPONSE_free(response);
  348.     BIO_free(bio);

  350.     staple->staple.data = buf;
  351.     staple->staple.len = len;
  352.     staple->valid = NGX_MAX_TIME_T_VALUE;

  354.     return NGX_OK;

  356. failed:

  358.     OCSP_RESPONSE_free(response);
  359.     BIO_free(bio);

  361.     return NGX_ERROR;
  362. }


  365. static ngx_int_t
  366. ‌ngx_ssl_stapling_issuer(ngx_conf_t *cf, ngx_ssl_t *ssl,
  367.     ngx_ssl_stapling_t *staple)
  368. {
  369.     int              i, n, rc;
  370.     X509            *cert, *issuer;
  371.     X509_STORE      *store;
  372.     X509_STORE_CTX  *store_ctx;

  374.     cert = staple->cert;

  376.     n = sk_X509_num(staple->chain);

  378.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ssl->log, 0,
  379.                    "SSL get issuer: %d extra certs", n);

  381.     for (i = 0; i < n; i++) {
  382.         issuer = sk_X509_value(staple->chain, i);
  383.         if (X509_check_issued(issuer, cert) == X509_V_OK) {
  384. #if OPENSSL_VERSION_NUMBER >= 0x10100001L
  385.             X509_up_ref(issuer);
  386. #else
  387.             CRYPTO_add(&issuer->references, 1, CRYPTO_LOCK_X509);
  388. #endif

  390.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ssl->log, 0,
  391.                            "SSL get issuer: found %p in extra certs", issuer);

  393.             staple->issuer = issuer;

  395.             return NGX_OK;
  396.         }
  397.     }

  399.     store = SSL_CTX_get_cert_store(ssl->ctx);
  400.     if (store == NULL) {
  401.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  402.                       "SSL_CTX_get_cert_store() failed");
  403.         return NGX_ERROR;
  404.     }

  406.     store_ctx = X509_STORE_CTX_new();
  407.     if (store_ctx == NULL) {
  408.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  409.                       "X509_STORE_CTX_new() failed");
  410.         return NGX_ERROR;
  411.     }

  413.     if (X509_STORE_CTX_init(store_ctx, store, NULL, NULL) == 0) {
  414.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  415.                       "X509_STORE_CTX_init() failed");
  416.         X509_STORE_CTX_free(store_ctx);
  417.         return NGX_ERROR;
  418.     }

  420.     rc = X509_STORE_CTX_get1_issuer(&issuer, store_ctx, cert);

  422.     if (rc == -1) {
  423.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  424.                       "X509_STORE_CTX_get1_issuer() failed");
  425.         X509_STORE_CTX_free(store_ctx);
  426.         return NGX_ERROR;
  427.     }

  429.     if (rc == 0) {
  430.         ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  431.                       "\"ssl_stapling\" ignored, "
  432.                       "issuer certificate not found for certificate \"%s\"",
  433.                       staple->name);
  434.         X509_STORE_CTX_free(store_ctx);
  435.         return NGX_DECLINED;
  436.     }

  438.     X509_STORE_CTX_free(store_ctx);

  440.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ssl->log, 0,
  441.                    "SSL get issuer: found %p in cert store", issuer);

  443.     staple->issuer = issuer;

  445.     return NGX_OK;
  446. }


  449. static ngx_int_t
  450. ‌ngx_ssl_stapling_responder(ngx_conf_t *cf, ngx_ssl_t *ssl,
  451.     ngx_ssl_stapling_t *staple, ngx_str_t *responder)
  452. {
  453.     char                      *s;
  454.     ngx_str_t                  rsp;
  455.     ngx_url_t                  u;
  456.     STACK_OF(OPENSSL_STRING)  *aia;

  458.     if (responder->len == 0) {

  460.         /* extract OCSP responder URL from certificate */

  462.         aia = X509_get1_ocsp(staple->cert);
  463.         if (aia == NULL) {
  464.             ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  465.                           "\"ssl_stapling\" ignored, "
  466.                           "no OCSP responder URL in the certificate \"%s\"",
  467.                           staple->name);
  468.             return NGX_DECLINED;
  469.         }

  471. #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  472.         s = sk_OPENSSL_STRING_value(aia, 0);
  473. #else
  474.         s = sk_value(aia, 0);
  475. #endif
  476.         if (s == NULL) {
  477.             ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  478.                           "\"ssl_stapling\" ignored, "
  479.                           "no OCSP responder URL in the certificate \"%s\"",
  480.                           staple->name);
  481.             X509_email_free(aia);
  482.             return NGX_DECLINED;
  483.         }

  485.         responder = &rsp;

  487.         responder->len = ngx_strlen(s);
  488.         responder->data = ngx_palloc(cf->pool, responder->len);
  489.         if (responder->data == NULL) {
  490.             X509_email_free(aia);
  491.             return NGX_ERROR;
  492.         }

  494.         ngx_memcpy(responder->data, s, responder->len);
  495.         X509_email_free(aia);
  496.     }

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

  500.     u.url = *responder;
  501.     u.default_port = 80;
  502.     u.uri_part = 1;

  504.     if (u.url.len > 7
  505.         && ngx_strncasecmp(u.url.data, (u_char *) "http://", 7) == 0)
  506.     {
  507.         u.url.len -= 7;
  508.         u.url.data += 7;

  510.     } else {
  511.         ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  512.                       "\"ssl_stapling\" ignored, "
  513.                       "invalid URL prefix in OCSP responder \"%V\" "
  514.                       "in the certificate \"%s\"",
  515.                       &u.url, staple->name);
  516.         return NGX_DECLINED;
  517.     }

  519.     if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  520.         if (u.err) {
  521.             ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  522.                           "\"ssl_stapling\" ignored, "
  523.                           "%s in OCSP responder \"%V\" "
  524.                           "in the certificate \"%s\"",
  525.                           u.err, &u.url, staple->name);
  526.             return NGX_DECLINED;
  527.         }

  529.         return NGX_ERROR;
  530.     }

  532.     staple->addrs = u.addrs;
  533.     staple->naddrs = u.naddrs;
  534.     staple->host = u.host;
  535.     staple->uri = u.uri;
  536.     staple->port = u.port;

  538.     if (staple->uri.len == 0) {
  539.         ngx_str_set(&staple->uri, "/");
  540.     }

  542.     return NGX_OK;
  543. }


  546. ngx_int_t
  547. ‌ngx_ssl_stapling_resolver(ngx_conf_t *cf, ngx_ssl_t *ssl,
  548.     ngx_resolver_t *resolver, ngx_msec_t resolver_timeout)
  549. {
  550.     ngx_rbtree_t        *tree;
  551.     ngx_rbtree_node_t   *node;
  552.     ngx_ssl_stapling_t  *staple;

  554.     tree = &ssl->staple_rbtree;

  556.     if (tree->root == tree->sentinel) {
  557.         return NGX_OK;
  558.     }

  560.     for (node = ngx_rbtree_min(tree->root, tree->sentinel);
  561.          node;
  562.          node = ngx_rbtree_next(tree, node))
  563.     {
  564.         staple = ngx_rbtree_data(node, ngx_ssl_stapling_t, node);
  565.         staple->resolver = resolver;
  566.         staple->resolver_timeout = resolver_timeout;
  567.     }

  569.     return NGX_OK;
  570. }


  573. static int
  574. ‌ngx_ssl_certificate_status_callback(ngx_ssl_conn_t *ssl_conn, void *data)
  575. {
  576.     int                  rc;
  577.     X509                *cert;
  578.     u_char              *p;
  579.     SSL_CTX             *ssl_ctx;
  580.     ngx_ssl_t           *ssl;
  581.     ngx_connection_t    *c;
  582.     ngx_ssl_stapling_t  *staple;

  584.     c = ngx_ssl_get_connection(ssl_conn);

  586.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, c->log, 0,
  587.                    "SSL certificate status callback");

  589.     rc = SSL_TLSEXT_ERR_NOACK;

  591.     cert = SSL_get_certificate(ssl_conn);

  593.     if (cert == NULL) {
  594.         return rc;
  595.     }

  597.     ssl_ctx = SSL_get_SSL_CTX(ssl_conn);
  598.     ssl = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_index);

  600.     staple = ngx_ssl_stapling_lookup(ssl, cert);

  602.     if (staple == NULL) {
  603.         return rc;
  604.     }

  606.     if (staple->staple.len
  607.         && staple->valid >= ngx_time())
  608.     {
  609.         /* we have to copy ocsp response as OpenSSL will free it by itself */

  611.         p = OPENSSL_malloc(staple->staple.len);
  612.         if (p == NULL) {
  613.             ngx_ssl_error(NGX_LOG_ALERT, c->log, 0, "OPENSSL_malloc() failed");
  614.             return SSL_TLSEXT_ERR_NOACK;
  615.         }

  617.         ngx_memcpy(p, staple->staple.data, staple->staple.len);

  619.         SSL_set_tlsext_status_ocsp_resp(ssl_conn, p, staple->staple.len);

  621.         rc = SSL_TLSEXT_ERR_OK;
  622.     }

  624.     ngx_ssl_stapling_update(staple);

  626.     return rc;
  627. }


  630. static ngx_ssl_stapling_t *
  631. ‌ngx_ssl_stapling_lookup(ngx_ssl_t *ssl, X509 *cert)
  632. {
  633.     ngx_rbtree_key_t    key;
  634.     ngx_rbtree_node_t  *node, *sentinel;

  636.     node = ssl->staple_rbtree.root;
  637.     sentinel = ssl->staple_rbtree.sentinel;
  638.     key = (ngx_rbtree_key_t) cert;

  640.     while (node != sentinel) {

  642.         if (key != node->key) {
  643.             node = (key < node->key) ? node->left : node->right;
  644.             continue;
  645.         }

  647.         return ngx_rbtree_data(node, ngx_ssl_stapling_t, node);
  648.     }

  650.     return NULL;
  651. }


  654. static void
  655. ‌ngx_ssl_stapling_update(ngx_ssl_stapling_t *staple)
  656. {
  657.     ngx_ssl_ocsp_ctx_t  *ctx;

  659.     if (staple->host.len == 0
  660.         || staple->loading || staple->refresh >= ngx_time())
  661.     {
  662.         return;
  663.     }

  665.     staple->loading = 1;

  667.     ctx = ngx_ssl_ocsp_start(ngx_cycle->log);
  668.     if (ctx == NULL) {
  669.         return;
  670.     }

  672.     ctx->ssl_ctx = staple->ssl_ctx;
  673.     ctx->cert = staple->cert;
  674.     ctx->issuer = staple->issuer;
  675.     ctx->chain = staple->chain;
  676.     ctx->name = staple->name;
  677.     ctx->flags = (staple->verify ? OCSP_TRUSTOTHER : OCSP_NOVERIFY);

  679.     ctx->addrs = staple->addrs;
  680.     ctx->naddrs = staple->naddrs;
  681.     ctx->host = staple->host;
  682.     ctx->uri = staple->uri;
  683.     ctx->port = staple->port;
  684.     ctx->timeout = staple->timeout;

  686.     ctx->resolver = staple->resolver;
  687.     ctx->resolver_timeout = staple->resolver_timeout;

  689.     ctx->handler = ngx_ssl_stapling_ocsp_handler;
  690.     ctx->data = staple;

  692.     ngx_ssl_ocsp_request(ctx);

  694.     return;
  695. }


  698. static void
  699. ‌ngx_ssl_stapling_ocsp_handler(ngx_ssl_ocsp_ctx_t *ctx)
  700. {
  701.     time_t               now;
  702.     ngx_str_t            response;
  703.     ngx_ssl_stapling_t  *staple;

  705.     staple = ctx->data;
  706.     now = ngx_time();

  708.     if (ngx_ssl_ocsp_verify(ctx) != NGX_OK) {
  709.         goto error;
  710.     }

  712.     if (ctx->status != V_OCSP_CERTSTATUS_GOOD) {
  713.         ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  714.                       "certificate status \"%s\" in the OCSP response",
  715.                       OCSP_cert_status_str(ctx->status));
  716.         goto error;
  717.     }

  719.     /* copy the response to memory not in ctx->pool */

  721.     response.len = ctx->response->last - ctx->response->pos;
  722.     response.data = ngx_alloc(response.len, ctx->log);

  724.     if (response.data == NULL) {
  725.         goto error;
  726.     }

  728.     ngx_memcpy(response.data, ctx->response->pos, response.len);

  730.     if (staple->staple.data) {
  731.         ngx_free(staple->staple.data);
  732.     }

  734.     staple->staple = response;
  735.     staple->valid = ctx->valid;

  737.     /*
  738.      * refresh before the response expires,
  739.      * but not earlier than in 5 minutes, and at least in an hour
  740.      */

  742.     staple->loading = 0;
  743.     staple->refresh = ngx_max(ngx_min(ctx->valid - 300, now + 3600), now + 300);

  745.     ngx_ssl_ocsp_done(ctx);
  746.     return;

  748. error:

  750.     staple->loading = 0;
  751.     staple->refresh = now + 300;

  753.     ngx_ssl_ocsp_done(ctx);
  754. }


  757. static time_t
  758. ‌ngx_ssl_stapling_time(ASN1_GENERALIZEDTIME *asn1time)
  759. {
  760.     BIO     *bio;
  761.     char    *value;
  762.     size_t   len;
  763.     time_t   time;

  765.     /*
  766.      * OpenSSL doesn't provide a way to convert ASN1_GENERALIZEDTIME
  767.      * into time_t.  To do this, we use ASN1_GENERALIZEDTIME_print(),
  768.      * which uses the "MMM DD HH:MM:SS YYYY [GMT]" format (e.g.,
  769.      * "Feb  3 00:55:52 2015 GMT"), and parse the result.
  770.      */

  772.     bio = BIO_new(BIO_s_mem());
  773.     if (bio == NULL) {
  774.         return NGX_ERROR;
  775.     }

  777.     /* fake weekday prepended to match C asctime() format */

  779.     BIO_write(bio, "Tue ", sizeof("Tue ") - 1);
  780.     ASN1_GENERALIZEDTIME_print(bio, asn1time);
  781.     len = BIO_get_mem_data(bio, &value);

  783.     time = ngx_parse_http_time((u_char *) value, len);

  785.     BIO_free(bio);

  787.     return time;
  788. }


  791. static void
  792. ‌ngx_ssl_stapling_cleanup(void *data)
  793. {
  794.     ngx_ssl_stapling_t  *staple = data;

  796.     if (staple->issuer) {
  797.         X509_free(staple->issuer);
  798.     }

  800.     if (staple->staple.data) {
  801.         ngx_free(staple->staple.data);
  802.     }
  803. }


  806. ngx_int_t
  807. ‌ngx_ssl_ocsp(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *responder,
  808.     ngx_uint_t depth, ngx_shm_zone_t *shm_zone)
  809. {
  810.     ngx_url_t             u;
  811.     ngx_ssl_ocsp_conf_t  *ocf;

  813.     ocf = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_ocsp_conf_t));
  814.     if (ocf == NULL) {
  815.         return NGX_ERROR;
  816.     }

  818.     ocf->depth = depth;
  819.     ocf->shm_zone = shm_zone;

  821.     if (responder->len) {
  822.         ngx_memzero(&u, sizeof(ngx_url_t));

  824.         u.url = *responder;
  825.         u.default_port = 80;
  826.         u.uri_part = 1;

  828.         if (u.url.len > 7
  829.             && ngx_strncasecmp(u.url.data, (u_char *) "http://", 7) == 0)
  830.         {
  831.             u.url.len -= 7;
  832.             u.url.data += 7;

  834.         } else {
  835.             ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  836.                           "invalid URL prefix in OCSP responder \"%V\" "
  837.                           "in \"ssl_ocsp_responder\"", &u.url);
  838.             return NGX_ERROR;
  839.         }

  841.         if (ngx_parse_url(cf->pool, &u) != NGX_OK) {
  842.             if (u.err) {
  843.                 ngx_log_error(NGX_LOG_EMERG, cf->log, 0,
  844.                               "%s in OCSP responder \"%V\" "
  845.                               "in \"ssl_ocsp_responder\"", u.err, &u.url);
  846.             }

  848.             return NGX_ERROR;
  849.         }

  851.         ocf->addrs = u.addrs;
  852.         ocf->naddrs = u.naddrs;
  853.         ocf->host = u.host;
  854.         ocf->uri = u.uri;
  855.         ocf->port = u.port;
  856.     }

  858.     if (SSL_CTX_set_ex_data(ssl->ctx, ngx_ssl_ocsp_index, ocf) == 0) {
  859.         ngx_ssl_error(NGX_LOG_EMERG, ssl->log, 0,
  860.                       "SSL_CTX_set_ex_data() failed");
  861.         return NGX_ERROR;
  862.     }

  864.     return NGX_OK;
  865. }


  868. ngx_int_t
  869. ‌ngx_ssl_ocsp_resolver(ngx_conf_t *cf, ngx_ssl_t *ssl,
  870.     ngx_resolver_t *resolver, ngx_msec_t resolver_timeout)
  871. {
  872.     ngx_ssl_ocsp_conf_t  *ocf;

  874.     ocf = SSL_CTX_get_ex_data(ssl->ctx, ngx_ssl_ocsp_index);
  875.     ocf->resolver = resolver;
  876.     ocf->resolver_timeout = resolver_timeout;

  878.     return NGX_OK;
  879. }


  882. ngx_int_t
  883. ‌ngx_ssl_ocsp_validate(ngx_connection_t *c)
  884. {
  885.     X509                 *cert;
  886.     SSL_CTX              *ssl_ctx;
  887.     ngx_int_t             rc;
  888.     X509_STORE           *store;
  889.     X509_STORE_CTX       *store_ctx;
  890.     STACK_OF(X509)       *chain;
  891.     ngx_ssl_ocsp_t       *ocsp;
  892.     ngx_ssl_ocsp_conf_t  *ocf;

  894.     if (c->ssl->in_ocsp) {
  895.         if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
  896.             return NGX_ERROR;
  897.         }

  899.         if (ngx_handle_write_event(c->write, 0) != NGX_OK) {
  900.             return NGX_ERROR;
  901.         }

  903.         return NGX_AGAIN;
  904.     }

  906.     ssl_ctx = SSL_get_SSL_CTX(c->ssl->connection);

  908.     ocf = SSL_CTX_get_ex_data(ssl_ctx, ngx_ssl_ocsp_index);
  909.     if (ocf == NULL) {
  910.         return NGX_OK;
  911.     }

  913.     if (SSL_get_verify_result(c->ssl->connection) != X509_V_OK) {
  914.         return NGX_OK;
  915.     }

  917.     cert = SSL_get_peer_certificate(c->ssl->connection);
  918.     if (cert == NULL) {
  919.         return NGX_OK;
  920.     }

  922.     ocsp = ngx_pcalloc(c->pool, sizeof(ngx_ssl_ocsp_t));
  923.     if (ocsp == NULL) {
  924.         X509_free(cert);
  925.         return NGX_ERROR;
  926.     }

  928.     c->ssl->ocsp = ocsp;

  930.     ocsp->status = NGX_AGAIN;
  931.     ocsp->cert_status = V_OCSP_CERTSTATUS_GOOD;
  932.     ocsp->conf = ocf;

  934. #if OPENSSL_VERSION_NUMBER >= 0x10100000L

  936.     ocsp->certs = SSL_get0_verified_chain(c->ssl->connection);

  938.     if (ocsp->certs) {
  939.         ocsp->certs = X509_chain_up_ref(ocsp->certs);
  940.         if (ocsp->certs == NULL) {
  941.             X509_free(cert);
  942.             return NGX_ERROR;
  943.         }
  944.     }

  946. #endif

  948.     if (ocsp->certs == NULL) {
  949.         store = SSL_CTX_get_cert_store(ssl_ctx);
  950.         if (store == NULL) {
  951.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  952.                           "SSL_CTX_get_cert_store() failed");
  953.             X509_free(cert);
  954.             return NGX_ERROR;
  955.         }

  957.         store_ctx = X509_STORE_CTX_new();
  958.         if (store_ctx == NULL) {
  959.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  960.                           "X509_STORE_CTX_new() failed");
  961.             X509_free(cert);
  962.             return NGX_ERROR;
  963.         }

  965.         chain = SSL_get_peer_cert_chain(c->ssl->connection);

  967.         if (X509_STORE_CTX_init(store_ctx, store, cert, chain) == 0) {
  968.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  969.                           "X509_STORE_CTX_init() failed");
  970.             X509_STORE_CTX_free(store_ctx);
  971.             X509_free(cert);
  972.             return NGX_ERROR;
  973.         }

  975.         rc = X509_verify_cert(store_ctx);
  976.         if (rc <= 0) {
  977.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0, "X509_verify_cert() failed");
  978.             X509_STORE_CTX_free(store_ctx);
  979.             X509_free(cert);
  980.             return NGX_ERROR;
  981.         }

  983.         ocsp->certs = X509_STORE_CTX_get1_chain(store_ctx);
  984.         if (ocsp->certs == NULL) {
  985.             ngx_ssl_error(NGX_LOG_ERR, c->log, 0,
  986.                           "X509_STORE_CTX_get1_chain() failed");
  987.             X509_STORE_CTX_free(store_ctx);
  988.             X509_free(cert);
  989.             return NGX_ERROR;
  990.         }

  992.         X509_STORE_CTX_free(store_ctx);
  993.     }

  995.     X509_free(cert);

  997.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  998.                    "ssl ocsp validate, certs:%d", sk_X509_num(ocsp->certs));

  1000.     ngx_ssl_ocsp_validate_next(c);

  1002.     if (ocsp->status == NGX_AGAIN) {
  1003.         c->ssl->in_ocsp = 1;
  1004.         return NGX_AGAIN;
  1005.     }

  1007.     return NGX_OK;
  1008. }


  1011. static void
  1012. ‌ngx_ssl_ocsp_validate_next(ngx_connection_t *c)
  1013. {
  1014.     ngx_int_t             rc;
  1015.     ngx_uint_t            n;
  1016.     ngx_ssl_ocsp_t       *ocsp;
  1017.     ngx_ssl_ocsp_ctx_t   *ctx;
  1018.     ngx_ssl_ocsp_conf_t  *ocf;

  1020.     ocsp = c->ssl->ocsp;
  1021.     ocf = ocsp->conf;

  1023.     n = sk_X509_num(ocsp->certs);

  1025.     for ( ;; ) {

  1027.         if (ocsp->ncert == n - 1 || (ocf->depth == 2 && ocsp->ncert == 1)) {
  1028.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  1029.                            "ssl ocsp validated, certs:%ui", ocsp->ncert);
  1030.             rc = NGX_OK;
  1031.             goto done;
  1032.         }

  1034.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
  1035.                        "ssl ocsp validate cert:%ui", ocsp->ncert);

  1037.         ctx = ngx_ssl_ocsp_start(c->log);
  1038.         if (ctx == NULL) {
  1039.             rc = NGX_ERROR;
  1040.             goto done;
  1041.         }

  1043.         ocsp->ctx = ctx;

  1045.         ctx->ssl_ctx = SSL_get_SSL_CTX(c->ssl->connection);
  1046.         ctx->cert = sk_X509_value(ocsp->certs, ocsp->ncert);
  1047.         ctx->issuer = sk_X509_value(ocsp->certs, ocsp->ncert + 1);
  1048.         ctx->chain = ocsp->certs;

  1050.         ctx->resolver = ocf->resolver;
  1051.         ctx->resolver_timeout = ocf->resolver_timeout;

  1053.         ctx->handler = ngx_ssl_ocsp_handler;
  1054.         ctx->data = c;

  1056.         ctx->shm_zone = ocf->shm_zone;

  1058.         ctx->addrs = ocf->addrs;
  1059.         ctx->naddrs = ocf->naddrs;
  1060.         ctx->host = ocf->host;
  1061.         ctx->uri = ocf->uri;
  1062.         ctx->port = ocf->port;

  1064.         rc = ngx_ssl_ocsp_responder(c, ctx);
  1065.         if (rc != NGX_OK) {
  1066.             goto done;
  1067.         }

  1069.         if (ctx->uri.len == 0) {
  1070.             ngx_str_set(&ctx->uri, "/");
  1071.         }

  1073.         ocsp->ncert++;

  1075.         rc = ngx_ssl_ocsp_cache_lookup(ctx);

  1077.         if (rc == NGX_ERROR) {
  1078.             goto done;
  1079.         }

  1081.         if (rc == NGX_DECLINED) {
  1082.             break;
  1083.         }

  1085.         /* rc == NGX_OK */

  1087.         if (ctx->status != V_OCSP_CERTSTATUS_GOOD) {
  1088.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1089.                            "ssl ocsp cached status \"%s\"",
  1090.                            OCSP_cert_status_str(ctx->status));
  1091.             ocsp->cert_status = ctx->status;
  1092.             goto done;
  1093.         }

  1095.         ocsp->ctx = NULL;
  1096.         ngx_ssl_ocsp_done(ctx);
  1097.     }

  1099.     ngx_ssl_ocsp_request(ctx);
  1100.     return;

  1102. done:

  1104.     ocsp->status = rc;

  1106.     if (c->ssl->in_ocsp) {
  1107.         c->ssl->handshaked = 1;
  1108.         c->ssl->handler(c);
  1109.     }
  1110. }


  1113. static void
  1114. ‌ngx_ssl_ocsp_handler(ngx_ssl_ocsp_ctx_t *ctx)
  1115. {
  1116.     ngx_int_t          rc;
  1117.     ngx_ssl_ocsp_t    *ocsp;
  1118.     ngx_connection_t  *c;

  1120.     c = ctx->data;
  1121.     ocsp = c->ssl->ocsp;
  1122.     ocsp->ctx = NULL;

  1124.     rc = ngx_ssl_ocsp_verify(ctx);
  1125.     if (rc != NGX_OK) {
  1126.         goto done;
  1127.     }

  1129.     rc = ngx_ssl_ocsp_cache_store(ctx);
  1130.     if (rc != NGX_OK) {
  1131.         goto done;
  1132.     }

  1134.     if (ctx->status != V_OCSP_CERTSTATUS_GOOD) {
  1135.         ocsp->cert_status = ctx->status;
  1136.         goto done;
  1137.     }

  1139.     ngx_ssl_ocsp_done(ctx);

  1141.     ngx_ssl_ocsp_validate_next(c);

  1143.     return;

  1145. done:

  1147.     ocsp->status = rc;
  1148.     ngx_ssl_ocsp_done(ctx);

  1150.     if (c->ssl->in_ocsp) {
  1151.         c->ssl->handshaked = 1;
  1152.         c->ssl->handler(c);
  1153.     }
  1154. }


  1157. static ngx_int_t
  1158. ‌ngx_ssl_ocsp_responder(ngx_connection_t *c, ngx_ssl_ocsp_ctx_t *ctx)
  1159. {
  1160.     char                      *s;
  1161.     ngx_str_t                  responder;
  1162.     ngx_url_t                  u;
  1163.     STACK_OF(OPENSSL_STRING)  *aia;

  1165.     if (ctx->host.len) {
  1166.         return NGX_OK;
  1167.     }

  1169.     /* extract OCSP responder URL from certificate */

  1171.     aia = X509_get1_ocsp(ctx->cert);
  1172.     if (aia == NULL) {
  1173.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1174.                       "no OCSP responder URL in certificate");
  1175.         return NGX_ERROR;
  1176.     }

  1178. #if OPENSSL_VERSION_NUMBER >= 0x10000000L
  1179.     s = sk_OPENSSL_STRING_value(aia, 0);
  1180. #else
  1181.     s = sk_value(aia, 0);
  1182. #endif
  1183.     if (s == NULL) {
  1184.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1185.                       "no OCSP responder URL in certificate");
  1186.         X509_email_free(aia);
  1187.         return NGX_ERROR;
  1188.     }

  1190.     responder.len = ngx_strlen(s);
  1191.     responder.data = ngx_palloc(ctx->pool, responder.len);
  1192.     if (responder.data == NULL) {
  1193.         X509_email_free(aia);
  1194.         return NGX_ERROR;
  1195.     }

  1197.     ngx_memcpy(responder.data, s, responder.len);
  1198.     X509_email_free(aia);

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

  1202.     u.url = responder;
  1203.     u.default_port = 80;
  1204.     u.uri_part = 1;
  1205.     u.no_resolve = 1;

  1207.     if (u.url.len > 7
  1208.         && ngx_strncasecmp(u.url.data, (u_char *) "http://", 7) == 0)
  1209.     {
  1210.         u.url.len -= 7;
  1211.         u.url.data += 7;

  1213.     } else {
  1214.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1215.                       "invalid URL prefix in OCSP responder \"%V\" "
  1216.                       "in certificate", &u.url);
  1217.         return NGX_ERROR;
  1218.     }

  1220.     if (ngx_parse_url(ctx->pool, &u) != NGX_OK) {
  1221.         if (u.err) {
  1222.             ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1223.                           "%s in OCSP responder \"%V\" in certificate",
  1224.                           u.err, &u.url);
  1225.         }

  1227.         return NGX_ERROR;
  1228.     }

  1230.     if (u.host.len == 0) {
  1231.         ngx_log_error(NGX_LOG_ERR, c->log, 0,
  1232.                       "empty host in OCSP responder in certificate");
  1233.         return NGX_ERROR;
  1234.     }

  1236.     ctx->addrs = u.addrs;
  1237.     ctx->naddrs = u.naddrs;
  1238.     ctx->host = u.host;
  1239.     ctx->uri = u.uri;
  1240.     ctx->port = u.port;

  1242.     return NGX_OK;
  1243. }


  1246. ngx_int_t
  1247. ‌ngx_ssl_ocsp_get_status(ngx_connection_t *c, const char **s)
  1248. {
  1249.     ngx_ssl_ocsp_t  *ocsp;

  1251.     ocsp = c->ssl->ocsp;
  1252.     if (ocsp == NULL) {
  1253.         return NGX_OK;
  1254.     }

  1256.     if (ocsp->status == NGX_ERROR) {
  1257.         *s = "certificate status request failed";
  1258.         return NGX_DECLINED;
  1259.     }

  1261.     switch (ocsp->cert_status) {

  1263.     case V_OCSP_CERTSTATUS_GOOD:
  1264.         return NGX_OK;

  1266.     case V_OCSP_CERTSTATUS_REVOKED:
  1267.         *s = "certificate revoked";
  1268.         break;

  1270.     default: /* V_OCSP_CERTSTATUS_UNKNOWN */
  1271.         *s = "certificate status unknown";
  1272.     }

  1274.     return NGX_DECLINED;
  1275. }


  1278. void
  1279. ‌ngx_ssl_ocsp_cleanup(ngx_connection_t *c)
  1280. {
  1281.     ngx_ssl_ocsp_t  *ocsp;

  1283.     ocsp = c->ssl->ocsp;
  1284.     if (ocsp == NULL) {
  1285.         return;
  1286.     }

  1288.     if (ocsp->ctx) {
  1289.         ngx_ssl_ocsp_done(ocsp->ctx);
  1290.         ocsp->ctx = NULL;
  1291.     }

  1293.     if (ocsp->certs) {
  1294.         sk_X509_pop_free(ocsp->certs, X509_free);
  1295.         ocsp->certs = NULL;
  1296.     }
  1297. }


  1300. static ngx_ssl_ocsp_ctx_t *
  1301. ‌ngx_ssl_ocsp_start(ngx_log_t *log)
  1302. {
  1303.     ngx_pool_t          *pool;
  1304.     ngx_ssl_ocsp_ctx_t  *ctx;

  1306.     pool = ngx_create_pool(2048, log);
  1307.     if (pool == NULL) {
  1308.         return NULL;
  1309.     }

  1311.     ctx = ngx_pcalloc(pool, sizeof(ngx_ssl_ocsp_ctx_t));
  1312.     if (ctx == NULL) {
  1313.         ngx_destroy_pool(pool);
  1314.         return NULL;
  1315.     }

  1317.     log = ngx_palloc(pool, sizeof(ngx_log_t));
  1318.     if (log == NULL) {
  1319.         ngx_destroy_pool(pool);
  1320.         return NULL;
  1321.     }

  1323.     ctx->pool = pool;

  1325.     *log = *ctx->pool->log;

  1327.     ctx->pool->log = log;
  1328.     ctx->log = log;

  1330.     log->handler = ngx_ssl_ocsp_log_error;
  1331.     log->data = ctx;
  1332.     log->action = "requesting certificate status";

  1334.     return ctx;
  1335. }


  1338. static void
  1339. ‌ngx_ssl_ocsp_done(ngx_ssl_ocsp_ctx_t *ctx)
  1340. {
  1341.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1342.                    "ssl ocsp done");

  1344.     if (ctx->peer.connection) {
  1345.         ngx_close_connection(ctx->peer.connection);
  1346.     }

  1348.     ngx_destroy_pool(ctx->pool);
  1349. }


  1352. static void
  1353. ‌ngx_ssl_ocsp_error(ngx_ssl_ocsp_ctx_t *ctx)
  1354. {
  1355.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1356.                    "ssl ocsp error");

  1358.     ctx->code = 0;
  1359.     ctx->handler(ctx);
  1360. }


  1363. static void
  1364. ‌ngx_ssl_ocsp_next(ngx_ssl_ocsp_ctx_t *ctx)
  1365. {
  1366.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1367.                    "ssl ocsp next");

  1369.     if (++ctx->naddr >= ctx->naddrs) {
  1370.         ngx_ssl_ocsp_error(ctx);
  1371.         return;
  1372.     }

  1374.     ctx->request->pos = ctx->request->start;

  1376.     if (ctx->response) {
  1377.         ctx->response->last = ctx->response->pos;
  1378.     }

  1380.     if (ctx->peer.connection) {
  1381.         ngx_close_connection(ctx->peer.connection);
  1382.         ctx->peer.connection = NULL;
  1383.     }

  1385.     ctx->state = 0;
  1386.     ctx->count = 0;
  1387.     ctx->done = 0;

  1389.     ngx_ssl_ocsp_connect(ctx);
  1390. }


  1393. static void
  1394. ‌ngx_ssl_ocsp_request(ngx_ssl_ocsp_ctx_t *ctx)
  1395. {
  1396.     ngx_resolver_ctx_t  *resolve, temp;

  1398.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1399.                    "ssl ocsp request");

  1401.     if (ngx_ssl_ocsp_create_request(ctx) != NGX_OK) {
  1402.         ngx_ssl_ocsp_error(ctx);
  1403.         return;
  1404.     }

  1406.     if (ctx->resolver) {
  1407.         /* resolve OCSP responder hostname */

  1409.         temp.name = ctx->host;

  1411.         resolve = ngx_resolve_start(ctx->resolver, &temp);
  1412.         if (resolve == NULL) {
  1413.             ngx_ssl_ocsp_error(ctx);
  1414.             return;
  1415.         }

  1417.         if (resolve == NGX_NO_RESOLVER) {
  1418.             if (ctx->naddrs == 0) {
  1419.                 ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  1420.                               "no resolver defined to resolve %V", &ctx->host);

  1422.                 ngx_ssl_ocsp_error(ctx);
  1423.                 return;
  1424.             }

  1426.             ngx_log_error(NGX_LOG_WARN, ctx->log, 0,
  1427.                           "no resolver defined to resolve %V", &ctx->host);
  1428.             goto connect;
  1429.         }

  1431.         resolve->name = ctx->host;
  1432.         resolve->handler = ngx_ssl_ocsp_resolve_handler;
  1433.         resolve->data = ctx;
  1434.         resolve->timeout = ctx->resolver_timeout;

  1436.         if (ngx_resolve_name(resolve) != NGX_OK) {
  1437.             ngx_ssl_ocsp_error(ctx);
  1438.             return;
  1439.         }

  1441.         return;
  1442.     }

  1444. connect:

  1446.     ngx_ssl_ocsp_connect(ctx);
  1447. }


  1450. static void
  1451. ‌ngx_ssl_ocsp_resolve_handler(ngx_resolver_ctx_t *resolve)
  1452. {
  1453.     ngx_ssl_ocsp_ctx_t *ctx = resolve->data;

  1455.     u_char           *p;
  1456.     size_t            len;
  1457.     socklen_t         socklen;
  1458.     ngx_uint_t        i;
  1459.     struct sockaddr  *sockaddr;

  1461.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1462.                    "ssl ocsp resolve handler");

  1464.     if (resolve->state) {
  1465.         ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  1466.                       "%V could not be resolved (%i: %s)",
  1467.                       &resolve->name, resolve->state,
  1468.                       ngx_resolver_strerror(resolve->state));
  1469.         goto failed;
  1470.     }

  1472. #if (NGX_DEBUG)
  1473.     {
  1474.     u_char     text[NGX_SOCKADDR_STRLEN];
  1475.     ngx_str_t  addr;

  1477.     addr.data = text;

  1479.     for (i = 0; i < resolve->naddrs; i++) {
  1480.         addr.len = ngx_sock_ntop(resolve->addrs[i].sockaddr,
  1481.                                  resolve->addrs[i].socklen,
  1482.                                  text, NGX_SOCKADDR_STRLEN, 0);

  1484.         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1485.                        "name was resolved to %V", &addr);

  1487.     }
  1488.     }
  1489. #endif

  1491.     ctx->naddrs = resolve->naddrs;
  1492.     ctx->addrs = ngx_pcalloc(ctx->pool, ctx->naddrs * sizeof(ngx_addr_t));

  1494.     if (ctx->addrs == NULL) {
  1495.         goto failed;
  1496.     }

  1498.     for (i = 0; i < resolve->naddrs; i++) {

  1500.         socklen = resolve->addrs[i].socklen;

  1502.         sockaddr = ngx_palloc(ctx->pool, socklen);
  1503.         if (sockaddr == NULL) {
  1504.             goto failed;
  1505.         }

  1507.         ngx_memcpy(sockaddr, resolve->addrs[i].sockaddr, socklen);
  1508.         ngx_inet_set_port(sockaddr, ctx->port);

  1510.         ctx->addrs[i].sockaddr = sockaddr;
  1511.         ctx->addrs[i].socklen = socklen;

  1513.         p = ngx_pnalloc(ctx->pool, NGX_SOCKADDR_STRLEN);
  1514.         if (p == NULL) {
  1515.             goto failed;
  1516.         }

  1518.         len = ngx_sock_ntop(sockaddr, socklen, p, NGX_SOCKADDR_STRLEN, 1);

  1520.         ctx->addrs[i].name.len = len;
  1521.         ctx->addrs[i].name.data = p;
  1522.     }

  1524.     ngx_resolve_name_done(resolve);

  1526.     ngx_ssl_ocsp_connect(ctx);
  1527.     return;

  1529. failed:

  1531.     ngx_resolve_name_done(resolve);
  1532.     ngx_ssl_ocsp_error(ctx);
  1533. }


  1536. static void
  1537. ‌ngx_ssl_ocsp_connect(ngx_ssl_ocsp_ctx_t *ctx)
  1538. {
  1539.     ngx_int_t    rc;
  1540.     ngx_addr_t  *addr;

  1542.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1543.                    "ssl ocsp connect %ui/%ui", ctx->naddr, ctx->naddrs);

  1545.     addr = &ctx->addrs[ctx->naddr];

  1547.     ctx->peer.sockaddr = addr->sockaddr;
  1548.     ctx->peer.socklen = addr->socklen;
  1549.     ctx->peer.name = &addr->name;
  1550.     ctx->peer.get = ngx_event_get_peer;
  1551.     ctx->peer.log = ctx->log;
  1552.     ctx->peer.log_error = NGX_ERROR_ERR;

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

  1556.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1557.                    "ssl ocsp connect peer done");

  1559.     if (rc == NGX_ERROR) {
  1560.         ngx_ssl_ocsp_error(ctx);
  1561.         return;
  1562.     }

  1564.     if (rc == NGX_BUSY || rc == NGX_DECLINED) {
  1565.         ngx_ssl_ocsp_next(ctx);
  1566.         return;
  1567.     }

  1569.     ctx->peer.connection->data = ctx;
  1570.     ctx->peer.connection->pool = ctx->pool;

  1572.     ctx->peer.connection->read->handler = ngx_ssl_ocsp_read_handler;
  1573.     ctx->peer.connection->write->handler = ngx_ssl_ocsp_write_handler;

  1575.     ctx->process = ngx_ssl_ocsp_process_status_line;

  1577.     if (ctx->timeout) {
  1578.         ngx_add_timer(ctx->peer.connection->read, ctx->timeout);
  1579.         ngx_add_timer(ctx->peer.connection->write, ctx->timeout);
  1580.     }

  1582.     if (rc == NGX_OK) {
  1583.         ngx_ssl_ocsp_write_handler(ctx->peer.connection->write);
  1584.         return;
  1585.     }
  1586. }


  1589. static void
  1590. ‌ngx_ssl_ocsp_write_handler(ngx_event_t *wev)
  1591. {
  1592.     ssize_t              n, size;
  1593.     ngx_connection_t    *c;
  1594.     ngx_ssl_ocsp_ctx_t  *ctx;

  1596.     c = wev->data;
  1597.     ctx = c->data;

  1599.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, wev->log, 0,
  1600.                    "ssl ocsp write handler");

  1602.     if (wev->timedout) {
  1603.         ngx_log_error(NGX_LOG_ERR, wev->log, NGX_ETIMEDOUT,
  1604.                       "OCSP responder timed out");
  1605.         ngx_ssl_ocsp_next(ctx);
  1606.         return;
  1607.     }

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

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

  1613.     if (n == NGX_ERROR) {
  1614.         ngx_ssl_ocsp_next(ctx);
  1615.         return;
  1616.     }

  1618.     if (n > 0) {
  1619.         ctx->request->pos += n;

  1621.         if (n == size) {
  1622.             wev->handler = ngx_ssl_ocsp_dummy_handler;

  1624.             if (wev->timer_set) {
  1625.                 ngx_del_timer(wev);
  1626.             }

  1628.             if (ngx_handle_write_event(wev, 0) != NGX_OK) {
  1629.                 ngx_ssl_ocsp_error(ctx);
  1630.             }

  1632.             return;
  1633.         }
  1634.     }

  1636.     if (!wev->timer_set && ctx->timeout) {
  1637.         ngx_add_timer(wev, ctx->timeout);
  1638.     }
  1639. }


  1642. static void
  1643. ‌ngx_ssl_ocsp_read_handler(ngx_event_t *rev)
  1644. {
  1645.     ssize_t              n, size;
  1646.     ngx_int_t            rc;
  1647.     ngx_connection_t    *c;
  1648.     ngx_ssl_ocsp_ctx_t  *ctx;

  1650.     c = rev->data;
  1651.     ctx = c->data;

  1653.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, rev->log, 0,
  1654.                    "ssl ocsp read handler");

  1656.     if (rev->timedout) {
  1657.         ngx_log_error(NGX_LOG_ERR, rev->log, NGX_ETIMEDOUT,
  1658.                       "OCSP responder timed out");
  1659.         ngx_ssl_ocsp_next(ctx);
  1660.         return;
  1661.     }

  1663.     if (ctx->response == NULL) {
  1664.         ctx->response = ngx_create_temp_buf(ctx->pool, 16384);
  1665.         if (ctx->response == NULL) {
  1666.             ngx_ssl_ocsp_error(ctx);
  1667.             return;
  1668.         }
  1669.     }

  1671.     for ( ;; ) {

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

  1675.         n = ngx_recv(c, ctx->response->last, size);

  1677.         if (n > 0) {
  1678.             ctx->response->last += n;

  1680.             rc = ctx->process(ctx);

  1682.             if (rc == NGX_ERROR) {
  1683.                 ngx_ssl_ocsp_next(ctx);
  1684.                 return;
  1685.             }

  1687.             continue;
  1688.         }

  1690.         if (n == NGX_AGAIN) {

  1692.             if (ngx_handle_read_event(rev, 0) != NGX_OK) {
  1693.                 ngx_ssl_ocsp_error(ctx);
  1694.             }

  1696.             return;
  1697.         }

  1699.         break;
  1700.     }

  1702.     ctx->done = 1;

  1704.     rc = ctx->process(ctx);

  1706.     if (rc == NGX_DONE) {
  1707.         /* ctx->handler() was called */
  1708.         return;
  1709.     }

  1711.     ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  1712.                   "OCSP responder prematurely closed connection");

  1714.     ngx_ssl_ocsp_next(ctx);
  1715. }


  1718. static void
  1719. ‌ngx_ssl_ocsp_dummy_handler(ngx_event_t *ev)
  1720. {
  1721.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  1722.                    "ssl ocsp dummy handler");
  1723. }


  1726. static ngx_int_t
  1727. ‌ngx_ssl_ocsp_create_request(ngx_ssl_ocsp_ctx_t *ctx)
  1728. {
  1729.     int            len;
  1730.     u_char        *p;
  1731.     uintptr_t      escape;
  1732.     ngx_str_t      binary, base64;
  1733.     ngx_buf_t     *b;
  1734.     OCSP_CERTID   *id;
  1735.     OCSP_REQUEST  *ocsp;

  1737.     ocsp = OCSP_REQUEST_new();
  1738.     if (ocsp == NULL) {
  1739.         ngx_ssl_error(NGX_LOG_CRIT, ctx->log, 0,
  1740.                       "OCSP_REQUEST_new() failed");
  1741.         return NGX_ERROR;
  1742.     }

  1744.     id = OCSP_cert_to_id(NULL, ctx->cert, ctx->issuer);
  1745.     if (id == NULL) {
  1746.         ngx_ssl_error(NGX_LOG_CRIT, ctx->log, 0,
  1747.                       "OCSP_cert_to_id() failed");
  1748.         goto failed;
  1749.     }

  1751.     if (OCSP_request_add0_id(ocsp, id) == NULL) {
  1752.         ngx_ssl_error(NGX_LOG_CRIT, ctx->log, 0,
  1753.                       "OCSP_request_add0_id() failed");
  1754.         OCSP_CERTID_free(id);
  1755.         goto failed;
  1756.     }

  1758.     len = i2d_OCSP_REQUEST(ocsp, NULL);
  1759.     if (len <= 0) {
  1760.         ngx_ssl_error(NGX_LOG_CRIT, ctx->log, 0,
  1761.                       "i2d_OCSP_REQUEST() failed");
  1762.         goto failed;
  1763.     }

  1765.     binary.len = len;
  1766.     binary.data = ngx_palloc(ctx->pool, len);
  1767.     if (binary.data == NULL) {
  1768.         goto failed;
  1769.     }

  1771.     p = binary.data;
  1772.     len = i2d_OCSP_REQUEST(ocsp, &p);
  1773.     if (len <= 0) {
  1774.         ngx_ssl_error(NGX_LOG_EMERG, ctx->log, 0,
  1775.                       "i2d_OCSP_REQUEST() failed");
  1776.         goto failed;
  1777.     }

  1779.     base64.len = ngx_base64_encoded_length(binary.len);
  1780.     base64.data = ngx_palloc(ctx->pool, base64.len);
  1781.     if (base64.data == NULL) {
  1782.         goto failed;
  1783.     }

  1785.     ngx_encode_base64(&base64, &binary);

  1787.     escape = ngx_escape_uri(NULL, base64.data, base64.len,
  1788.                             NGX_ESCAPE_URI_COMPONENT);

  1790.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1791.                    "ssl ocsp request length %z, escape %d",
  1792.                    base64.len, (int) escape);

  1794.     len = sizeof("GET ") - 1 + ctx->uri.len + sizeof("/") - 1
  1795.           + base64.len + 2 * escape + sizeof(" HTTP/1.0" CRLF) - 1
  1796.           + sizeof("Host: ") - 1 + ctx->host.len + sizeof(CRLF) - 1
  1797.           + sizeof(CRLF) - 1;

  1799.     b = ngx_create_temp_buf(ctx->pool, len);
  1800.     if (b == NULL) {
  1801.         goto failed;
  1802.     }

  1804.     p = b->last;

  1806.     p = ngx_cpymem(p, "GET ", sizeof("GET ") - 1);
  1807.     p = ngx_cpymem(p, ctx->uri.data, ctx->uri.len);

  1809.     if (ctx->uri.data[ctx->uri.len - 1] != '/') {
  1810.         *p++ = '/';
  1811.     }

  1813.     if (escape == 0) {
  1814.         p = ngx_cpymem(p, base64.data, base64.len);

  1816.     } else {
  1817.         p = (u_char *) ngx_escape_uri(p, base64.data, base64.len,
  1818.                                       NGX_ESCAPE_URI_COMPONENT);
  1819.     }

  1821.     p = ngx_cpymem(p, " HTTP/1.0" CRLF, sizeof(" HTTP/1.0" CRLF) - 1);
  1822.     p = ngx_cpymem(p, "Host: ", sizeof("Host: ") - 1);
  1823.     p = ngx_cpymem(p, ctx->host.data, ctx->host.len);
  1824.     *p++ = CR; *p++ = LF;

  1826.     /* add "\r\n" at the header end */
  1827.     *p++ = CR; *p++ = LF;

  1829.     b->last = p;
  1830.     ctx->request = b;

  1832.     OCSP_REQUEST_free(ocsp);

  1834.     return NGX_OK;

  1836. failed:

  1838.     OCSP_REQUEST_free(ocsp);

  1840.     return NGX_ERROR;
  1841. }


  1844. static ngx_int_t
  1845. ‌ngx_ssl_ocsp_process_status_line(ngx_ssl_ocsp_ctx_t *ctx)
  1846. {
  1847.     ngx_int_t  rc;

  1849.     rc = ngx_ssl_ocsp_parse_status_line(ctx);

  1851.     if (rc == NGX_OK) {
  1852.         ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1853.                        "ssl ocsp status %ui \"%*s\"",
  1854.                        ctx->code,
  1855.                        ctx->header_end - ctx->header_start,
  1856.                        ctx->header_start);

  1858.         ctx->process = ngx_ssl_ocsp_process_headers;
  1859.         return ctx->process(ctx);
  1860.     }

  1862.     if (rc == NGX_AGAIN) {
  1863.         return NGX_AGAIN;
  1864.     }

  1866.     /* rc == NGX_ERROR */

  1868.     ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  1869.                   "OCSP responder sent invalid response");

  1871.     return NGX_ERROR;
  1872. }


  1875. static ngx_int_t
  1876. ‌ngx_ssl_ocsp_parse_status_line(ngx_ssl_ocsp_ctx_t *ctx)
  1877. {
  1878.     u_char      ch;
  1879.     u_char     *p;
  1880.     ngx_buf_t  *b;
  1881. ‌    enum {
  1882.         sw_start = 0,
  1883.         sw_H,
  1884.         sw_HT,
  1885.         sw_HTT,
  1886.         sw_HTTP,
  1887.         sw_first_major_digit,
  1888.         sw_major_digit,
  1889.         sw_first_minor_digit,
  1890.         sw_minor_digit,
  1891.         sw_status,
  1892.         sw_space_after_status,
  1893.         sw_status_text,
  1894.         sw_almost_done
  1895.     } state;

  1897.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  1898.                    "ssl ocsp process status line");

  1900.     state = ctx->state;
  1901.     b = ctx->response;

  1903.     for (p = b->pos; p < b->last; p++) {
  1904.         ch = *p;

  1906.         switch (state) {

  1908.         /* "HTTP/" */
  1909.         case sw_start:
  1910.             switch (ch) {
  1911.             case 'H':
  1912.                 state = sw_H;
  1913.                 break;
  1914.             default:
  1915.                 return NGX_ERROR;
  1916.             }
  1917.             break;

  1919.         case sw_H:
  1920.             switch (ch) {
  1921.             case 'T':
  1922.                 state = sw_HT;
  1923.                 break;
  1924.             default:
  1925.                 return NGX_ERROR;
  1926.             }
  1927.             break;

  1929.         case sw_HT:
  1930.             switch (ch) {
  1931.             case 'T':
  1932.                 state = sw_HTT;
  1933.                 break;
  1934.             default:
  1935.                 return NGX_ERROR;
  1936.             }
  1937.             break;

  1939.         case sw_HTT:
  1940.             switch (ch) {
  1941.             case 'P':
  1942.                 state = sw_HTTP;
  1943.                 break;
  1944.             default:
  1945.                 return NGX_ERROR;
  1946.             }
  1947.             break;

  1949.         case sw_HTTP:
  1950.             switch (ch) {
  1951.             case '/':
  1952.                 state = sw_first_major_digit;
  1953.                 break;
  1954.             default:
  1955.                 return NGX_ERROR;
  1956.             }
  1957.             break;

  1959.         /* the first digit of major HTTP version */
  1960.         case sw_first_major_digit:
  1961.             if (ch < '1' || ch > '9') {
  1962.                 return NGX_ERROR;
  1963.             }

  1965.             state = sw_major_digit;
  1966.             break;

  1968.         /* the major HTTP version or dot */
  1969.         case sw_major_digit:
  1970.             if (ch == '.') {
  1971.                 state = sw_first_minor_digit;
  1972.                 break;
  1973.             }

  1975.             if (ch < '0' || ch > '9') {
  1976.                 return NGX_ERROR;
  1977.             }

  1979.             break;

  1981.         /* the first digit of minor HTTP version */
  1982.         case sw_first_minor_digit:
  1983.             if (ch < '0' || ch > '9') {
  1984.                 return NGX_ERROR;
  1985.             }

  1987.             state = sw_minor_digit;
  1988.             break;

  1990.         /* the minor HTTP version or the end of the request line */
  1991.         case sw_minor_digit:
  1992.             if (ch == ' ') {
  1993.                 state = sw_status;
  1994.                 break;
  1995.             }

  1997.             if (ch < '0' || ch > '9') {
  1998.                 return NGX_ERROR;
  1999.             }

  2001.             break;

  2003.         /* HTTP status code */
  2004.         case sw_status:
  2005.             if (ch == ' ') {
  2006.                 break;
  2007.             }

  2009.             if (ch < '0' || ch > '9') {
  2010.                 return NGX_ERROR;
  2011.             }

  2013.             ctx->code = ctx->code * 10 + (ch - '0');

  2015.             if (++ctx->count == 3) {
  2016.                 state = sw_space_after_status;
  2017.                 ctx->header_start = p - 2;
  2018.             }

  2020.             break;

  2022.         /* space or end of line */
  2023.         case sw_space_after_status:
  2024.             switch (ch) {
  2025.             case ' ':
  2026.                 state = sw_status_text;
  2027.                 break;
  2028.             case '.':                    /* IIS may send 403.1, 403.2, etc */
  2029.                 state = sw_status_text;
  2030.                 break;
  2031.             case CR:
  2032.                 state = sw_almost_done;
  2033.                 break;
  2034.             case LF:
  2035.                 ctx->header_end = p;
  2036.                 goto done;
  2037.             default:
  2038.                 return NGX_ERROR;
  2039.             }
  2040.             break;

  2042.         /* any text until end of line */
  2043.         case sw_status_text:
  2044.             switch (ch) {
  2045.             case CR:
  2046.                 state = sw_almost_done;
  2047.                 break;
  2048.             case LF:
  2049.                 ctx->header_end = p;
  2050.                 goto done;
  2051.             }
  2052.             break;

  2054.         /* end of status line */
  2055.         case sw_almost_done:
  2056.             switch (ch) {
  2057.             case LF:
  2058.                 ctx->header_end = p - 1;
  2059.                 goto done;
  2060.             default:
  2061.                 return NGX_ERROR;
  2062.             }
  2063.         }
  2064.     }

  2066.     b->pos = p;
  2067.     ctx->state = state;

  2069.     return NGX_AGAIN;

  2071. done:

  2073.     b->pos = p + 1;
  2074.     ctx->state = sw_start;

  2076.     return NGX_OK;
  2077. }


  2080. static ngx_int_t
  2081. ‌ngx_ssl_ocsp_process_headers(ngx_ssl_ocsp_ctx_t *ctx)
  2082. {
  2083.     size_t     len;
  2084.     ngx_int_t  rc;

  2086.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2087.                    "ssl ocsp process headers");

  2089.     for ( ;; ) {
  2090.         rc = ngx_ssl_ocsp_parse_header_line(ctx);

  2092.         if (rc == NGX_OK) {

  2094.             ngx_log_debug4(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2095.                            "ssl ocsp header \"%*s: %*s\"",
  2096.                            ctx->header_name_end - ctx->header_name_start,
  2097.                            ctx->header_name_start,
  2098.                            ctx->header_end - ctx->header_start,
  2099.                            ctx->header_start);

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

  2103.             if (len == sizeof("Content-Type") - 1
  2104.                 && ngx_strncasecmp(ctx->header_name_start,
  2105.                                    (u_char *) "Content-Type",
  2106.                                    sizeof("Content-Type") - 1)
  2107.                    == 0)
  2108.             {
  2109.                 len = ctx->header_end - ctx->header_start;

  2111.                 if (len != sizeof("application/ocsp-response") - 1
  2112.                     || ngx_strncasecmp(ctx->header_start,
  2113.                                        (u_char *) "application/ocsp-response",
  2114.                                        sizeof("application/ocsp-response") - 1)
  2115.                        != 0)
  2116.                 {
  2117.                     ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  2118.                                   "OCSP responder sent invalid "
  2119.                                   "\"Content-Type\" header: \"%*s\"",
  2120.                                   ctx->header_end - ctx->header_start,
  2121.                                   ctx->header_start);
  2122.                     return NGX_ERROR;
  2123.                 }

  2125.                 continue;
  2126.             }

  2128.             /* TODO: honor Content-Length */

  2130.             continue;
  2131.         }

  2133.         if (rc == NGX_DONE) {
  2134.             break;
  2135.         }

  2137.         if (rc == NGX_AGAIN) {
  2138.             return NGX_AGAIN;
  2139.         }

  2141.         /* rc == NGX_ERROR */

  2143.         ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  2144.                       "OCSP responder sent invalid response");

  2146.         return NGX_ERROR;
  2147.     }

  2149.     ctx->process = ngx_ssl_ocsp_process_body;
  2150.     return ctx->process(ctx);
  2151. }


  2154. static ngx_int_t
  2155. ‌ngx_ssl_ocsp_parse_header_line(ngx_ssl_ocsp_ctx_t *ctx)
  2156. {
  2157.     u_char  c, ch, *p;
  2158. ‌    enum {
  2159.         sw_start = 0,
  2160.         sw_name,
  2161.         sw_space_before_value,
  2162.         sw_value,
  2163.         sw_space_after_value,
  2164.         sw_almost_done,
  2165.         sw_header_almost_done
  2166.     } state;

  2168.     state = ctx->state;

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

  2173. #if 0
  2174.         ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2175.                        "s:%d in:'%02Xd:%c'", state, ch, ch);
  2176. #endif

  2178.         switch (state) {

  2180.         /* first char */
  2181.         case sw_start:

  2183.             switch (ch) {
  2184.             case CR:
  2185.                 ctx->header_end = p;
  2186.                 state = sw_header_almost_done;
  2187.                 break;
  2188.             case LF:
  2189.                 ctx->header_end = p;
  2190.                 goto header_done;
  2191.             default:
  2192.                 state = sw_name;
  2193.                 ctx->header_name_start = p;

  2195.                 c = (u_char) (ch | 0x20);
  2196.                 if (c >= 'a' && c <= 'z') {
  2197.                     break;
  2198.                 }

  2200.                 if (ch >= '0' && ch <= '9') {
  2201.                     break;
  2202.                 }

  2204.                 return NGX_ERROR;
  2205.             }
  2206.             break;

  2208.         /* header name */
  2209.         case sw_name:
  2210.             c = (u_char) (ch | 0x20);
  2211.             if (c >= 'a' && c <= 'z') {
  2212.                 break;
  2213.             }

  2215.             if (ch == ':') {
  2216.                 ctx->header_name_end = p;
  2217.                 state = sw_space_before_value;
  2218.                 break;
  2219.             }

  2221.             if (ch == '-') {
  2222.                 break;
  2223.             }

  2225.             if (ch >= '0' && ch <= '9') {
  2226.                 break;
  2227.             }

  2229.             if (ch == CR) {
  2230.                 ctx->header_name_end = p;
  2231.                 ctx->header_start = p;
  2232.                 ctx->header_end = p;
  2233.                 state = sw_almost_done;
  2234.                 break;
  2235.             }

  2237.             if (ch == LF) {
  2238.                 ctx->header_name_end = p;
  2239.                 ctx->header_start = p;
  2240.                 ctx->header_end = p;
  2241.                 goto done;
  2242.             }

  2244.             return NGX_ERROR;

  2246.         /* space* before header value */
  2247.         case sw_space_before_value:
  2248.             switch (ch) {
  2249.             case ' ':
  2250.                 break;
  2251.             case CR:
  2252.                 ctx->header_start = p;
  2253.                 ctx->header_end = p;
  2254.                 state = sw_almost_done;
  2255.                 break;
  2256.             case LF:
  2257.                 ctx->header_start = p;
  2258.                 ctx->header_end = p;
  2259.                 goto done;
  2260.             default:
  2261.                 ctx->header_start = p;
  2262.                 state = sw_value;
  2263.                 break;
  2264.             }
  2265.             break;

  2267.         /* header value */
  2268.         case sw_value:
  2269.             switch (ch) {
  2270.             case ' ':
  2271.                 ctx->header_end = p;
  2272.                 state = sw_space_after_value;
  2273.                 break;
  2274.             case CR:
  2275.                 ctx->header_end = p;
  2276.                 state = sw_almost_done;
  2277.                 break;
  2278.             case LF:
  2279.                 ctx->header_end = p;
  2280.                 goto done;
  2281.             }
  2282.             break;

  2284.         /* space* before end of header line */
  2285.         case sw_space_after_value:
  2286.             switch (ch) {
  2287.             case ' ':
  2288.                 break;
  2289.             case CR:
  2290.                 state = sw_almost_done;
  2291.                 break;
  2292.             case LF:
  2293.                 goto done;
  2294.             default:
  2295.                 state = sw_value;
  2296.                 break;
  2297.             }
  2298.             break;

  2300.         /* end of header line */
  2301.         case sw_almost_done:
  2302.             switch (ch) {
  2303.             case LF:
  2304.                 goto done;
  2305.             default:
  2306.                 return NGX_ERROR;
  2307.             }

  2309.         /* end of header */
  2310.         case sw_header_almost_done:
  2311.             switch (ch) {
  2312.             case LF:
  2313.                 goto header_done;
  2314.             default:
  2315.                 return NGX_ERROR;
  2316.             }
  2317.         }
  2318.     }

  2320.     ctx->response->pos = p;
  2321.     ctx->state = state;

  2323.     return NGX_AGAIN;

  2325. done:

  2327.     ctx->response->pos = p + 1;
  2328.     ctx->state = sw_start;

  2330.     return NGX_OK;

  2332. header_done:

  2334.     ctx->response->pos = p + 1;
  2335.     ctx->state = sw_start;

  2337.     return NGX_DONE;
  2338. }


  2341. static ngx_int_t
  2342. ‌ngx_ssl_ocsp_process_body(ngx_ssl_ocsp_ctx_t *ctx)
  2343. {
  2344.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2345.                    "ssl ocsp process body");

  2347.     if (ctx->done) {
  2348.         ctx->handler(ctx);
  2349.         return NGX_DONE;
  2350.     }

  2352.     return NGX_AGAIN;
  2353. }


  2356. static ngx_int_t
  2357. ‌ngx_ssl_ocsp_verify(ngx_ssl_ocsp_ctx_t *ctx)
  2358. {
  2359.     int                    n;
  2360.     size_t                 len;
  2361.     X509_STORE            *store;
  2362.     const u_char          *p;
  2363.     OCSP_CERTID           *id;
  2364.     OCSP_RESPONSE         *ocsp;
  2365.     OCSP_BASICRESP        *basic;
  2366.     ASN1_GENERALIZEDTIME  *thisupdate, *nextupdate;

  2368.     ocsp = NULL;
  2369.     basic = NULL;
  2370.     id = NULL;

  2372.     if (ctx->code != 200) {
  2373.         goto error;
  2374.     }

  2376.     /* check the response */

  2378.     len = ctx->response->last - ctx->response->pos;
  2379.     p = ctx->response->pos;

  2381.     ocsp = d2i_OCSP_RESPONSE(NULL, &p, len);
  2382.     if (ocsp == NULL) {
  2383.         ngx_ssl_error(NGX_LOG_ERR, ctx->log, 0,
  2384.                       "d2i_OCSP_RESPONSE() failed");
  2385.         goto error;
  2386.     }

  2388.     n = OCSP_response_status(ocsp);

  2390.     if (n != OCSP_RESPONSE_STATUS_SUCCESSFUL) {
  2391.         ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  2392.                       "OCSP response not successful (%d: %s)",
  2393.                       n, OCSP_response_status_str(n));
  2394.         goto error;
  2395.     }

  2397.     basic = OCSP_response_get1_basic(ocsp);
  2398.     if (basic == NULL) {
  2399.         ngx_ssl_error(NGX_LOG_ERR, ctx->log, 0,
  2400.                       "OCSP_response_get1_basic() failed");
  2401.         goto error;
  2402.     }

  2404.     store = SSL_CTX_get_cert_store(ctx->ssl_ctx);
  2405.     if (store == NULL) {
  2406.         ngx_ssl_error(NGX_LOG_CRIT, ctx->log, 0,
  2407.                       "SSL_CTX_get_cert_store() failed");
  2408.         goto error;
  2409.     }

  2411.     if (OCSP_basic_verify(basic, ctx->chain, store, ctx->flags) != 1) {
  2412.         ngx_ssl_error(NGX_LOG_ERR, ctx->log, 0,
  2413.                       "OCSP_basic_verify() failed");
  2414.         goto error;
  2415.     }

  2417.     id = OCSP_cert_to_id(NULL, ctx->cert, ctx->issuer);
  2418.     if (id == NULL) {
  2419.         ngx_ssl_error(NGX_LOG_CRIT, ctx->log, 0,
  2420.                       "OCSP_cert_to_id() failed");
  2421.         goto error;
  2422.     }

  2424.     if (OCSP_resp_find_status(basic, id, &ctx->status, NULL, NULL,
  2425.                               &thisupdate, &nextupdate)
  2426.         != 1)
  2427.     {
  2428.         ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  2429.                       "certificate status not found in the OCSP response");
  2430.         goto error;
  2431.     }

  2433.     if (OCSP_check_validity(thisupdate, nextupdate, 300, -1) != 1) {
  2434.         ngx_ssl_error(NGX_LOG_ERR, ctx->log, 0,
  2435.                       "OCSP_check_validity() failed");
  2436.         goto error;
  2437.     }

  2439.     if (nextupdate) {
  2440.         ctx->valid = ngx_ssl_stapling_time(nextupdate);
  2441.         if (ctx->valid == (time_t) NGX_ERROR) {
  2442.             ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
  2443.                           "invalid nextUpdate time in certificate status");
  2444.             goto error;
  2445.         }

  2447.     } else {
  2448.         ctx->valid = NGX_MAX_TIME_T_VALUE;
  2449.     }

  2451.     OCSP_CERTID_free(id);
  2452.     OCSP_BASICRESP_free(basic);
  2453.     OCSP_RESPONSE_free(ocsp);

  2455.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2456.                    "ssl ocsp response, %s, %uz",
  2457.                    OCSP_cert_status_str(ctx->status), len);

  2459.     return NGX_OK;

  2461. error:

  2463.     if (id) {
  2464.         OCSP_CERTID_free(id);
  2465.     }

  2467.     if (basic) {
  2468.         OCSP_BASICRESP_free(basic);
  2469.     }

  2471.     if (ocsp) {
  2472.         OCSP_RESPONSE_free(ocsp);
  2473.     }

  2475.     return NGX_ERROR;
  2476. }


  2479. ngx_int_t
  2480. ‌ngx_ssl_ocsp_cache_init(ngx_shm_zone_t *shm_zone, void *data)
  2481. {
  2482.     size_t                 len;
  2483.     ngx_slab_pool_t       *shpool;
  2484.     ngx_ssl_ocsp_cache_t  *cache;

  2486.     if (data) {
  2487.         shm_zone->data = data;
  2488.         return NGX_OK;
  2489.     }

  2491.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;

  2493.     if (shm_zone->shm.exists) {
  2494.         shm_zone->data = shpool->data;
  2495.         return NGX_OK;
  2496.     }

  2498.     cache = ngx_slab_alloc(shpool, sizeof(ngx_ssl_ocsp_cache_t));
  2499.     if (cache == NULL) {
  2500.         return NGX_ERROR;
  2501.     }

  2503.     shpool->data = cache;
  2504.     shm_zone->data = cache;

  2506.     ngx_rbtree_init(&cache->rbtree, &cache->sentinel,
  2507.                     ngx_str_rbtree_insert_value);

  2509.     ngx_queue_init(&cache->expire_queue);

  2511.     len = sizeof(" in OCSP cache \"\"") + shm_zone->shm.name.len;

  2513.     shpool->log_ctx = ngx_slab_alloc(shpool, len);
  2514.     if (shpool->log_ctx == NULL) {
  2515.         return NGX_ERROR;
  2516.     }

  2518.     ngx_sprintf(shpool->log_ctx, " in OCSP cache \"%V\"%Z",
  2519.                 &shm_zone->shm.name);

  2521.     shpool->log_nomem = 0;

  2523.     return NGX_OK;
  2524. }


  2527. static ngx_int_t
  2528. ‌ngx_ssl_ocsp_cache_lookup(ngx_ssl_ocsp_ctx_t *ctx)
  2529. {
  2530.     uint32_t                    hash;
  2531.     ngx_shm_zone_t             *shm_zone;
  2532.     ngx_slab_pool_t            *shpool;
  2533.     ngx_ssl_ocsp_cache_t       *cache;
  2534.     ngx_ssl_ocsp_cache_node_t  *node;

  2536.     shm_zone = ctx->shm_zone;

  2538.     if (shm_zone == NULL) {
  2539.         return NGX_DECLINED;
  2540.     }

  2542.     if (ngx_ssl_ocsp_create_key(ctx) != NGX_OK) {
  2543.         return NGX_ERROR;
  2544.     }

  2546.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0, "ssl ocsp cache lookup");

  2548.     cache = shm_zone->data;
  2549.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;
  2550.     hash = ngx_hash_key(ctx->key.data, ctx->key.len);

  2552.     ngx_shmtx_lock(&shpool->mutex);

  2554.     node = (ngx_ssl_ocsp_cache_node_t *)
  2555.                ngx_str_rbtree_lookup(&cache->rbtree, &ctx->key, hash);

  2557.     if (node) {
  2558.         if (node->valid > ngx_time()) {
  2559.             ctx->status = node->status;
  2560.             ngx_shmtx_unlock(&shpool->mutex);

  2562.             ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2563.                            "ssl ocsp cache hit, %s",
  2564.                            OCSP_cert_status_str(ctx->status));

  2566.             return NGX_OK;
  2567.         }

  2569.         ngx_queue_remove(&node->queue);
  2570.         ngx_rbtree_delete(&cache->rbtree, &node->node.node);
  2571.         ngx_slab_free_locked(shpool, node);

  2573.         ngx_shmtx_unlock(&shpool->mutex);

  2575.         ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2576.                        "ssl ocsp cache expired");

  2578.         return NGX_DECLINED;
  2579.     }

  2581.     ngx_shmtx_unlock(&shpool->mutex);

  2583.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ctx->log, 0, "ssl ocsp cache miss");

  2585.     return NGX_DECLINED;
  2586. }


  2589. static ngx_int_t
  2590. ‌ngx_ssl_ocsp_cache_store(ngx_ssl_ocsp_ctx_t *ctx)
  2591. {
  2592.     time_t                      now, valid;
  2593.     uint32_t                    hash;
  2594.     ngx_queue_t                *q;
  2595.     ngx_shm_zone_t             *shm_zone;
  2596.     ngx_slab_pool_t            *shpool;
  2597.     ngx_ssl_ocsp_cache_t       *cache;
  2598.     ngx_ssl_ocsp_cache_node_t  *node;

  2600.     shm_zone = ctx->shm_zone;

  2602.     if (shm_zone == NULL) {
  2603.         return NGX_OK;
  2604.     }

  2606.     valid = ctx->valid;

  2608.     now = ngx_time();

  2610.     if (valid < now) {
  2611.         return NGX_OK;
  2612.     }

  2614.     if (valid == NGX_MAX_TIME_T_VALUE) {
  2615.         valid = now + 3600;
  2616.     }

  2618.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2619.                    "ssl ocsp cache store, valid:%T", valid - now);

  2621.     cache = shm_zone->data;
  2622.     shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;
  2623.     hash = ngx_hash_key(ctx->key.data, ctx->key.len);

  2625.     ngx_shmtx_lock(&shpool->mutex);

  2627.     node = ngx_slab_calloc_locked(shpool,
  2628.                              sizeof(ngx_ssl_ocsp_cache_node_t) + ctx->key.len);
  2629.     if (node == NULL) {

  2631.         if (!ngx_queue_empty(&cache->expire_queue)) {
  2632.             q = ngx_queue_last(&cache->expire_queue);
  2633.             node = ngx_queue_data(q, ngx_ssl_ocsp_cache_node_t, queue);

  2635.             ngx_rbtree_delete(&cache->rbtree, &node->node.node);
  2636.             ngx_queue_remove(q);
  2637.             ngx_slab_free_locked(shpool, node);

  2639.             node = ngx_slab_alloc_locked(shpool,
  2640.                              sizeof(ngx_ssl_ocsp_cache_node_t) + ctx->key.len);
  2641.         }

  2643.         if (node == NULL) {
  2644.             ngx_shmtx_unlock(&shpool->mutex);
  2645.             ngx_log_error(NGX_LOG_ALERT, ctx->log, 0,
  2646.                           "could not allocate new entry%s", shpool->log_ctx);
  2647.             return NGX_ERROR;
  2648.         }
  2649.     }

  2651.     node->node.str.len = ctx->key.len;
  2652.     node->node.str.data = (u_char *) node + sizeof(ngx_ssl_ocsp_cache_node_t);
  2653.     ngx_memcpy(node->node.str.data, ctx->key.data, ctx->key.len);
  2654.     node->node.node.key = hash;
  2655.     node->status = ctx->status;
  2656.     node->valid = valid;

  2658.     ngx_rbtree_insert(&cache->rbtree, &node->node.node);
  2659.     ngx_queue_insert_head(&cache->expire_queue, &node->queue);

  2661.     ngx_shmtx_unlock(&shpool->mutex);

  2663.     return NGX_OK;
  2664. }


  2667. static ngx_int_t
  2668. ‌ngx_ssl_ocsp_create_key(ngx_ssl_ocsp_ctx_t *ctx)
  2669. {
  2670.     u_char        *p;
  2671.     X509_NAME     *name;
  2672.     ASN1_INTEGER  *serial;

  2674.     p = ngx_pnalloc(ctx->pool, 60);
  2675.     if (p == NULL) {
  2676.         return NGX_ERROR;
  2677.     }

  2679.     ctx->key.data = p;
  2680.     ctx->key.len = 60;

  2682.     name = X509_get_subject_name(ctx->issuer);
  2683.     if (X509_NAME_digest(name, EVP_sha1(), p, NULL) == 0) {
  2684.         return NGX_ERROR;
  2685.     }

  2687.     p += 20;

  2689.     if (X509_pubkey_digest(ctx->issuer, EVP_sha1(), p, NULL) == 0) {
  2690.         return NGX_ERROR;
  2691.     }

  2693.     p += 20;

  2695.     serial = X509_get_serialNumber(ctx->cert);
  2696.     if (serial->length > 20) {
  2697.         return NGX_ERROR;
  2698.     }

  2700.     p = ngx_cpymem(p, serial->data, serial->length);
  2701.     ngx_memzero(p, 20 - serial->length);

  2703.     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ctx->log, 0,
  2704.                    "ssl ocsp key %xV", &ctx->key);

  2706.     return NGX_OK;
  2707. }


  2710. static u_char *
  2711. ‌ngx_ssl_ocsp_log_error(ngx_log_t *log, u_char *buf, size_t len)
  2712. {
  2713.     u_char              *p;
  2714.     ngx_ssl_ocsp_ctx_t  *ctx;

  2716.     p = buf;

  2718.     if (log->action) {
  2719.         p = ngx_snprintf(buf, len, " while %s", log->action);
  2720.         len -= p - buf;
  2721.         buf = p;
  2722.     }

  2724.     ctx = log->data;

  2726.     if (ctx) {
  2727.         p = ngx_snprintf(buf, len, ", responder: %V", &ctx->host);
  2728.         len -= p - buf;
  2729.         buf = p;
  2730.     }

  2732.     if (ctx && ctx->peer.name) {
  2733.         p = ngx_snprintf(buf, len, ", peer: %V", ctx->peer.name);
  2734.         len -= p - buf;
  2735.         buf = p;
  2736.     }

  2738.     if (ctx && ctx->name) {
  2739.         p = ngx_snprintf(buf, len, ", certificate: \"%s\"", ctx->name);
  2740.         len -= p - buf;
  2741.         buf = p;
  2742.     }

  2744.     return p;
  2745. }


  2748. #else


  2751. ngx_int_t
  2752. ‌ngx_ssl_stapling(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *file,
  2753.     ngx_str_t *responder, ngx_uint_t verify)
  2754. {
  2755.     ngx_log_error(NGX_LOG_WARN, ssl->log, 0,
  2756.                   "\"ssl_stapling\" ignored, not supported");

  2758.     return NGX_OK;
  2759. }


  2762. ngx_int_t
  2763. ‌ngx_ssl_stapling_resolver(ngx_conf_t *cf, ngx_ssl_t *ssl,
  2764.     ngx_resolver_t *resolver, ngx_msec_t resolver_timeout)
  2765. {
  2766.     return NGX_OK;
  2767. }


  2770. ngx_int_t
  2771. ‌ngx_ssl_ocsp(ngx_conf_t *cf, ngx_ssl_t *ssl, ngx_str_t *responder,
  2772.     ngx_uint_t depth, ngx_shm_zone_t *shm_zone)
  2773. {
  2774.     ngx_log_error(NGX_LOG_EMERG, ssl->log, 0,
  2775.                   "\"ssl_ocsp\" is not supported on this platform");

  2777.     return NGX_ERROR;
  2778. }


  2781. ngx_int_t
  2782. ‌ngx_ssl_ocsp_resolver(ngx_conf_t *cf, ngx_ssl_t *ssl,
  2783.     ngx_resolver_t *resolver, ngx_msec_t resolver_timeout)
  2784. {
  2785.     return NGX_OK;
  2786. }


  2789. ngx_int_t
  2790. ‌ngx_ssl_ocsp_validate(ngx_connection_t *c)
  2791. {
  2792.     return NGX_OK;
  2793. }


  2796. ngx_int_t
  2797. ‌ngx_ssl_ocsp_get_status(ngx_connection_t *c, const char **s)
  2798. {
  2799.     return NGX_OK;
  2800. }


  2803. void
  2804. ‌ngx_ssl_ocsp_cleanup(ngx_connection_t *c)
  2805. {
  2806. }


  2809. ngx_int_t
  2810. ‌ngx_ssl_ocsp_cache_init(ngx_shm_zone_t *shm_zone, void *data)
  2811. {
  2812.     return NGX_OK;
  2813. }


  2816. #endif

One Level Up Top Level