One Level Up Top Level

src/event/ngx_event_openssl_cache.c - nginx source code

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


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


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


  12. ‌#define NGX_SSL_CACHE_PATH    0
  13. ‌#define NGX_SSL_CACHE_DATA    1
  14. ‌#define NGX_SSL_CACHE_ENGINE  2


  17. ‌typedef struct {
  18.     unsigned                    type:2;
  19.     unsigned                    len:30;
  20.     u_char                     *data;
  21. ‌} ngx_ssl_cache_key_t;


  24. ‌typedef void *(*ngx_ssl_cache_create_pt)(ngx_ssl_cache_key_t *id, char **err,
  25.     void *data);
  26. ‌typedef void (*ngx_ssl_cache_free_pt)(void *data);
  27. ‌typedef void *(*ngx_ssl_cache_ref_pt)(char **err, void *data);


  30. ‌typedef struct {
  31.     ngx_ssl_cache_create_pt     create;
  32.     ngx_ssl_cache_free_pt       free;
  33.     ngx_ssl_cache_ref_pt        ref;
  34. ‌} ngx_ssl_cache_type_t;


  37. ‌typedef struct {
  38.     ngx_rbtree_node_t           node;
  39.     ngx_ssl_cache_key_t         id;
  40.     ngx_ssl_cache_type_t       *type;
  41.     void                       *value;
  42. ‌} ngx_ssl_cache_node_t;


  45. ‌typedef struct {
  46.     ngx_rbtree_t                rbtree;
  47.     ngx_rbtree_node_t           sentinel;
  48. ‌} ngx_ssl_cache_t;


  51. static ngx_int_t ngx_ssl_cache_init_key(ngx_pool_t *pool, ngx_uint_t index,
  52.     ngx_str_t *path, ngx_ssl_cache_key_t *id);
  53. static ngx_ssl_cache_node_t *ngx_ssl_cache_lookup(ngx_ssl_cache_t *cache,
  54.     ngx_ssl_cache_type_t *type, ngx_ssl_cache_key_t *id, uint32_t hash);

  56. static void *ngx_ssl_cache_cert_create(ngx_ssl_cache_key_t *id, char **err,
  57.     void *data);
  58. static void ngx_ssl_cache_cert_free(void *data);
  59. static void *ngx_ssl_cache_cert_ref(char **err, void *data);

  61. static void *ngx_ssl_cache_pkey_create(ngx_ssl_cache_key_t *id, char **err,
  62.     void *data);
  63. static int ngx_ssl_cache_pkey_password_callback(char *buf, int size, int rwflag,
  64.     void *userdata);
  65. static void ngx_ssl_cache_pkey_free(void *data);
  66. static void *ngx_ssl_cache_pkey_ref(char **err, void *data);

  68. static void *ngx_ssl_cache_crl_create(ngx_ssl_cache_key_t *id, char **err,
  69.     void *data);
  70. static void ngx_ssl_cache_crl_free(void *data);
  71. static void *ngx_ssl_cache_crl_ref(char **err, void *data);

  73. static void *ngx_ssl_cache_ca_create(ngx_ssl_cache_key_t *id, char **err,
  74.     void *data);

  76. static BIO *ngx_ssl_cache_create_bio(ngx_ssl_cache_key_t *id, char **err);

  78. static void *ngx_openssl_cache_create_conf(ngx_cycle_t *cycle);
  79. static void ngx_ssl_cache_cleanup(void *data);
  80. static void ngx_ssl_cache_node_insert(ngx_rbtree_node_t *temp,
  81.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel);


  84. ‌static ngx_core_module_t  ngx_openssl_cache_module_ctx = {
  85.     ngx_string("openssl_cache"),
  86.     ngx_openssl_cache_create_conf,
  87.     NULL
  88. };


  91. ‌ngx_module_t  ngx_openssl_cache_module = {
  92.     NGX_MODULE_V1,
  93.     &ngx_openssl_cache_module_ctx,         /* module context */
  94.     NULL,                                  /* module directives */
  95.     NGX_CORE_MODULE,                       /* module type */
  96.     NULL,                                  /* init master */
  97.     NULL,                                  /* init module */
  98.     NULL,                                  /* init process */
  99.     NULL,                                  /* init thread */
  100.     NULL,                                  /* exit thread */
  101.     NULL,                                  /* exit process */
  102.     NULL,                                  /* exit master */
  103.     NGX_MODULE_V1_PADDING
  104. };


  107. ‌static ngx_ssl_cache_type_t  ngx_ssl_cache_types[] = {

  109.     /* NGX_SSL_CACHE_CERT */
  110.     { ngx_ssl_cache_cert_create,
  111.       ngx_ssl_cache_cert_free,
  112.       ngx_ssl_cache_cert_ref },

  114.     /* NGX_SSL_CACHE_PKEY */
  115.     { ngx_ssl_cache_pkey_create,
  116.       ngx_ssl_cache_pkey_free,
  117.       ngx_ssl_cache_pkey_ref },

  119.     /* NGX_SSL_CACHE_CRL */
  120.     { ngx_ssl_cache_crl_create,
  121.       ngx_ssl_cache_crl_free,
  122.       ngx_ssl_cache_crl_ref },

  124.     /* NGX_SSL_CACHE_CA */
  125.     { ngx_ssl_cache_ca_create,
  126.       ngx_ssl_cache_cert_free,
  127.       ngx_ssl_cache_cert_ref }
  128. };


  131. void *
  132. ‌ngx_ssl_cache_fetch(ngx_conf_t *cf, ngx_uint_t index, char **err,
  133.     ngx_str_t *path, void *data)
  134. {
  135.     uint32_t               hash;
  136.     ngx_ssl_cache_t       *cache;
  137.     ngx_ssl_cache_key_t    id;
  138.     ngx_ssl_cache_type_t  *type;
  139.     ngx_ssl_cache_node_t  *cn;

  141.     *err = NULL;

  143.     if (ngx_ssl_cache_init_key(cf->pool, index, path, &id) != NGX_OK) {
  144.         return NULL;
  145.     }

  147.     cache = (ngx_ssl_cache_t *) ngx_get_conf(cf->cycle->conf_ctx,
  148.                                              ngx_openssl_cache_module);

  150.     type = &ngx_ssl_cache_types[index];
  151.     hash = ngx_murmur_hash2(id.data, id.len);

  153.     cn = ngx_ssl_cache_lookup(cache, type, &id, hash);
  154.     if (cn != NULL) {
  155.         return type->ref(err, cn->value);
  156.     }

  158.     cn = ngx_palloc(cf->pool, sizeof(ngx_ssl_cache_node_t) + id.len + 1);
  159.     if (cn == NULL) {
  160.         return NULL;
  161.     }

  163.     cn->node.key = hash;
  164.     cn->id.data = (u_char *)(cn + 1);
  165.     cn->id.len = id.len;
  166.     cn->id.type = id.type;
  167.     cn->type = type;

  169.     ngx_cpystrn(cn->id.data, id.data, id.len + 1);

  171.     cn->value = type->create(&id, err, data);
  172.     if (cn->value == NULL) {
  173.         return NULL;
  174.     }

  176.     ngx_rbtree_insert(&cache->rbtree, &cn->node);

  178.     return type->ref(err, cn->value);
  179. }


  182. void *
  183. ‌ngx_ssl_cache_connection_fetch(ngx_pool_t *pool, ngx_uint_t index, char **err,
  184.     ngx_str_t *path, void *data)
  185. {
  186.     ngx_ssl_cache_key_t  id;

  188.     *err = NULL;

  190.     if (ngx_ssl_cache_init_key(pool, index, path, &id) != NGX_OK) {
  191.         return NULL;
  192.     }

  194.     return ngx_ssl_cache_types[index].create(&id, err, data);
  195. }


  198. static ngx_int_t
  199. ‌ngx_ssl_cache_init_key(ngx_pool_t *pool, ngx_uint_t index, ngx_str_t *path,
  200.     ngx_ssl_cache_key_t *id)
  201. {
  202.     if (index <= NGX_SSL_CACHE_PKEY
  203.         && ngx_strncmp(path->data, "data:", sizeof("data:") - 1) == 0)
  204.     {
  205.         id->type = NGX_SSL_CACHE_DATA;

  207.     } else if (index == NGX_SSL_CACHE_PKEY
  208.         && ngx_strncmp(path->data, "engine:", sizeof("engine:") - 1) == 0)
  209.     {
  210.         id->type = NGX_SSL_CACHE_ENGINE;

  212.     } else {
  213.         if (ngx_get_full_name(pool, (ngx_str_t *) &ngx_cycle->conf_prefix, path)
  214.             != NGX_OK)
  215.         {
  216.             return NGX_ERROR;
  217.         }

  219.         id->type = NGX_SSL_CACHE_PATH;
  220.     }

  222.     id->len = path->len;
  223.     id->data = path->data;

  225.     return NGX_OK;
  226. }


  229. static ngx_ssl_cache_node_t *
  230. ‌ngx_ssl_cache_lookup(ngx_ssl_cache_t *cache, ngx_ssl_cache_type_t *type,
  231.     ngx_ssl_cache_key_t *id, uint32_t hash)
  232. {
  233.     ngx_int_t              rc;
  234.     ngx_rbtree_node_t     *node, *sentinel;
  235.     ngx_ssl_cache_node_t  *cn;

  237.     node = cache->rbtree.root;
  238.     sentinel = cache->rbtree.sentinel;

  240.     while (node != sentinel) {

  242.         if (hash < node->key) {
  243.             node = node->left;
  244.             continue;
  245.         }

  247.         if (hash > node->key) {
  248.             node = node->right;
  249.             continue;
  250.         }

  252.         /* hash == node->key */

  254.         cn = (ngx_ssl_cache_node_t *) node;

  256.         if (type < cn->type) {
  257.             node = node->left;
  258.             continue;
  259.         }

  261.         if (type > cn->type) {
  262.             node = node->right;
  263.             continue;
  264.         }

  266.         /* type == cn->type */

  268.         rc = ngx_memn2cmp(id->data, cn->id.data, id->len, cn->id.len);

  270.         if (rc == 0) {
  271.             return cn;
  272.         }

  274.         node = (rc < 0) ? node->left : node->right;
  275.     }

  277.     return NULL;
  278. }


  281. static void *
  282. ‌ngx_ssl_cache_cert_create(ngx_ssl_cache_key_t *id, char **err, void *data)
  283. {
  284.     BIO             *bio;
  285.     X509            *x509;
  286.     u_long           n;
  287.     STACK_OF(X509)  *chain;

  289.     chain = sk_X509_new_null();
  290.     if (chain == NULL) {
  291.         *err = "sk_X509_new_null() failed";
  292.         return NULL;
  293.     }

  295.     bio = ngx_ssl_cache_create_bio(id, err);
  296.     if (bio == NULL) {
  297.         sk_X509_pop_free(chain, X509_free);
  298.         return NULL;
  299.     }

  301.     /* certificate itself */

  303.     x509 = PEM_read_bio_X509_AUX(bio, NULL, NULL, NULL);
  304.     if (x509 == NULL) {
  305.         *err = "PEM_read_bio_X509_AUX() failed";
  306.         BIO_free(bio);
  307.         sk_X509_pop_free(chain, X509_free);
  308.         return NULL;
  309.     }

  311.     if (sk_X509_push(chain, x509) == 0) {
  312.         *err = "sk_X509_push() failed";
  313.         BIO_free(bio);
  314.         X509_free(x509);
  315.         sk_X509_pop_free(chain, X509_free);
  316.         return NULL;
  317.     }

  319.     /* rest of the chain */

  321.     for ( ;; ) {

  323.         x509 = PEM_read_bio_X509(bio, NULL, NULL, NULL);
  324.         if (x509 == NULL) {
  325.             n = ERR_peek_last_error();

  327.             if (ERR_GET_LIB(n) == ERR_LIB_PEM
  328.                 && ERR_GET_REASON(n) == PEM_R_NO_START_LINE)
  329.             {
  330.                 /* end of file */
  331.                 ERR_clear_error();
  332.                 break;
  333.             }

  335.             /* some real error */

  337.             *err = "PEM_read_bio_X509() failed";
  338.             BIO_free(bio);
  339.             sk_X509_pop_free(chain, X509_free);
  340.             return NULL;
  341.         }

  343.         if (sk_X509_push(chain, x509) == 0) {
  344.             *err = "sk_X509_push() failed";
  345.             BIO_free(bio);
  346.             X509_free(x509);
  347.             sk_X509_pop_free(chain, X509_free);
  348.             return NULL;
  349.         }
  350.     }

  352.     BIO_free(bio);

  354.     return chain;
  355. }


  358. static void
  359. ‌ngx_ssl_cache_cert_free(void *data)
  360. {
  361.     sk_X509_pop_free(data, X509_free);
  362. }


  365. static void *
  366. ‌ngx_ssl_cache_cert_ref(char **err, void *data)
  367. {
  368.     int              n, i;
  369.     X509            *x509;
  370.     STACK_OF(X509)  *chain;

  372.     chain = sk_X509_dup(data);
  373.     if (chain == NULL) {
  374.         *err = "sk_X509_dup() failed";
  375.         return NULL;
  376.     }

  378.     n = sk_X509_num(chain);

  380.     for (i = 0; i < n; i++) {
  381.         x509 = sk_X509_value(chain, i);

  383. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L)
  384.         X509_up_ref(x509);
  385. #else
  386.         CRYPTO_add(&x509->references, 1, CRYPTO_LOCK_X509);
  387. #endif
  388.     }

  390.     return chain;
  391. }


  394. static void *
  395. ‌ngx_ssl_cache_pkey_create(ngx_ssl_cache_key_t *id, char **err, void *data)
  396. {
  397.     ngx_array_t  *passwords = data;

  399.     BIO              *bio;
  400.     EVP_PKEY         *pkey;
  401.     ngx_str_t        *pwd;
  402.     ngx_uint_t        tries;
  403.     pem_password_cb  *cb;

  405.     if (id->type == NGX_SSL_CACHE_ENGINE) {

  407. #ifndef OPENSSL_NO_ENGINE

  409.         u_char  *p, *last;
  410.         ENGINE  *engine;

  412.         p = id->data + sizeof("engine:") - 1;
  413.         last = (u_char *) ngx_strchr(p, ':');

  415.         if (last == NULL) {
  416.             *err = "invalid syntax";
  417.             return NULL;
  418.         }

  420.         *last = '\0';

  422.         engine = ENGINE_by_id((char *) p);

  424.         *last++ = ':';

  426.         if (engine == NULL) {
  427.             *err = "ENGINE_by_id() failed";
  428.             return NULL;
  429.         }

  431.         pkey = ENGINE_load_private_key(engine, (char *) last, 0, 0);

  433.         if (pkey == NULL) {
  434.             *err = "ENGINE_load_private_key() failed";
  435.             ENGINE_free(engine);
  436.             return NULL;
  437.         }

  439.         ENGINE_free(engine);

  441.         return pkey;

  443. #else

  445.         *err = "loading \"engine:...\" certificate keys is not supported";
  446.         return NULL;

  448. #endif
  449.     }

  451.     bio = ngx_ssl_cache_create_bio(id, err);
  452.     if (bio == NULL) {
  453.         return NULL;
  454.     }

  456.     if (passwords) {
  457.         tries = passwords->nelts;
  458.         pwd = passwords->elts;
  459.         cb = ngx_ssl_cache_pkey_password_callback;

  461.     } else {
  462.         tries = 1;
  463.         pwd = NULL;
  464.         cb = NULL;
  465.     }

  467.     for ( ;; ) {

  469.         pkey = PEM_read_bio_PrivateKey(bio, NULL, cb, pwd);
  470.         if (pkey != NULL) {
  471.             break;
  472.         }

  474.         if (tries-- > 1) {
  475.             ERR_clear_error();
  476.             (void) BIO_reset(bio);
  477.             pwd++;
  478.             continue;
  479.         }

  481.         *err = "PEM_read_bio_PrivateKey() failed";
  482.         BIO_free(bio);
  483.         return NULL;
  484.     }

  486.     BIO_free(bio);

  488.     return pkey;
  489. }


  492. static int
  493. ‌ngx_ssl_cache_pkey_password_callback(char *buf, int size, int rwflag,
  494.     void *userdata)
  495. {
  496.     ngx_str_t  *pwd = userdata;

  498.     if (rwflag) {
  499.         ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  500.                       "ngx_ssl_cache_pkey_password_callback() is called "
  501.                       "for encryption");
  502.         return 0;
  503.     }

  505.     if (pwd == NULL) {
  506.         return 0;
  507.     }

  509.     if (pwd->len > (size_t) size) {
  510.         ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0,
  511.                       "password is truncated to %d bytes", size);
  512.     } else {
  513.         size = pwd->len;
  514.     }

  516.     ngx_memcpy(buf, pwd->data, size);

  518.     return size;
  519. }


  522. static void
  523. ‌ngx_ssl_cache_pkey_free(void *data)
  524. {
  525.     EVP_PKEY_free(data);
  526. }


  529. static void *
  530. ‌ngx_ssl_cache_pkey_ref(char **err, void *data)
  531. {
  532.     EVP_PKEY  *pkey = data;

  534. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L)
  535.     EVP_PKEY_up_ref(pkey);
  536. #else
  537.     CRYPTO_add(&pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
  538. #endif

  540.     return data;
  541. }


  544. static void *
  545. ‌ngx_ssl_cache_crl_create(ngx_ssl_cache_key_t *id, char **err, void *data)
  546. {
  547.     BIO                 *bio;
  548.     u_long               n;
  549.     X509_CRL            *x509;
  550.     STACK_OF(X509_CRL)  *chain;

  552.     chain = sk_X509_CRL_new_null();
  553.     if (chain == NULL) {
  554.         *err = "sk_X509_CRL_new_null() failed";
  555.         return NULL;
  556.     }

  558.     bio = ngx_ssl_cache_create_bio(id, err);
  559.     if (bio == NULL) {
  560.         sk_X509_CRL_pop_free(chain, X509_CRL_free);
  561.         return NULL;
  562.     }

  564.     for ( ;; ) {

  566.         x509 = PEM_read_bio_X509_CRL(bio, NULL, NULL, NULL);
  567.         if (x509 == NULL) {
  568.             n = ERR_peek_last_error();

  570.             if (ERR_GET_LIB(n) == ERR_LIB_PEM
  571.                 && ERR_GET_REASON(n) == PEM_R_NO_START_LINE
  572.                 && sk_X509_CRL_num(chain) > 0)
  573.             {
  574.                 /* end of file */
  575.                 ERR_clear_error();
  576.                 break;
  577.             }

  579.             /* some real error */

  581.             *err = "PEM_read_bio_X509_CRL() failed";
  582.             BIO_free(bio);
  583.             sk_X509_CRL_pop_free(chain, X509_CRL_free);
  584.             return NULL;
  585.         }

  587.         if (sk_X509_CRL_push(chain, x509) == 0) {
  588.             *err = "sk_X509_CRL_push() failed";
  589.             BIO_free(bio);
  590.             X509_CRL_free(x509);
  591.             sk_X509_CRL_pop_free(chain, X509_CRL_free);
  592.             return NULL;
  593.         }
  594.     }

  596.     BIO_free(bio);

  598.     return chain;
  599. }


  602. static void
  603. ‌ngx_ssl_cache_crl_free(void *data)
  604. {
  605.     sk_X509_CRL_pop_free(data, X509_CRL_free);
  606. }


  609. static void *
  610. ‌ngx_ssl_cache_crl_ref(char **err, void *data)
  611. {
  612.     int                  n, i;
  613.     X509_CRL            *x509;
  614.     STACK_OF(X509_CRL)  *chain;

  616.     chain = sk_X509_CRL_dup(data);
  617.     if (chain == NULL) {
  618.         *err = "sk_X509_CRL_dup() failed";
  619.         return NULL;
  620.     }

  622.     n = sk_X509_CRL_num(chain);

  624.     for (i = 0; i < n; i++) {
  625.         x509 = sk_X509_CRL_value(chain, i);

  627. #if (OPENSSL_VERSION_NUMBER >= 0x10100000L)
  628.         X509_CRL_up_ref(x509);
  629. #else
  630.         CRYPTO_add(&x509->references, 1, CRYPTO_LOCK_X509_CRL);
  631. #endif
  632.     }

  634.     return chain;
  635. }


  638. static void *
  639. ‌ngx_ssl_cache_ca_create(ngx_ssl_cache_key_t *id, char **err, void *data)
  640. {
  641.     BIO             *bio;
  642.     X509            *x509;
  643.     u_long           n;
  644.     STACK_OF(X509)  *chain;

  646.     chain = sk_X509_new_null();
  647.     if (chain == NULL) {
  648.         *err = "sk_X509_new_null() failed";
  649.         return NULL;
  650.     }

  652.     bio = ngx_ssl_cache_create_bio(id, err);
  653.     if (bio == NULL) {
  654.         sk_X509_pop_free(chain, X509_free);
  655.         return NULL;
  656.     }

  658.     for ( ;; ) {

  660.         x509 = PEM_read_bio_X509_AUX(bio, NULL, NULL, NULL);
  661.         if (x509 == NULL) {
  662.             n = ERR_peek_last_error();

  664.             if (ERR_GET_LIB(n) == ERR_LIB_PEM
  665.                 && ERR_GET_REASON(n) == PEM_R_NO_START_LINE
  666.                 && sk_X509_num(chain) > 0)
  667.             {
  668.                 /* end of file */
  669.                 ERR_clear_error();
  670.                 break;
  671.             }

  673.             /* some real error */

  675.             *err = "PEM_read_bio_X509_AUX() failed";
  676.             BIO_free(bio);
  677.             sk_X509_pop_free(chain, X509_free);
  678.             return NULL;
  679.         }

  681.         if (sk_X509_push(chain, x509) == 0) {
  682.             *err = "sk_X509_push() failed";
  683.             BIO_free(bio);
  684.             X509_free(x509);
  685.             sk_X509_pop_free(chain, X509_free);
  686.             return NULL;
  687.         }
  688.     }

  690.     BIO_free(bio);

  692.     return chain;
  693. }


  696. static BIO *
  697. ‌ngx_ssl_cache_create_bio(ngx_ssl_cache_key_t *id, char **err)
  698. {
  699.     BIO  *bio;

  701.     if (id->type == NGX_SSL_CACHE_DATA) {

  703.         bio = BIO_new_mem_buf(id->data + sizeof("data:") - 1,
  704.                               id->len - (sizeof("data:") - 1));
  705.         if (bio == NULL) {
  706.             *err = "BIO_new_mem_buf() failed";
  707.         }

  709.         return bio;
  710.     }

  712.     bio = BIO_new_file((char *) id->data, "r");
  713.     if (bio == NULL) {
  714.         *err = "BIO_new_file() failed";
  715.     }

  717.     return bio;
  718. }


  721. static void *
  722. ‌ngx_openssl_cache_create_conf(ngx_cycle_t *cycle)
  723. {
  724.     ngx_ssl_cache_t     *cache;
  725.     ngx_pool_cleanup_t  *cln;

  727.     cache = ngx_pcalloc(cycle->pool, sizeof(ngx_ssl_cache_t));
  728.     if (cache == NULL) {
  729.         return NULL;
  730.     }

  732.     cln = ngx_pool_cleanup_add(cycle->pool, 0);
  733.     if (cln == NULL) {
  734.         return NULL;
  735.     }

  737.     cln->handler = ngx_ssl_cache_cleanup;
  738.     cln->data = cache;

  740.     ngx_rbtree_init(&cache->rbtree, &cache->sentinel,
  741.                     ngx_ssl_cache_node_insert);

  743.     return cache;
  744. }


  747. static void
  748. ‌ngx_ssl_cache_cleanup(void *data)
  749. {
  750.     ngx_ssl_cache_t  *cache = data;

  752.     ngx_rbtree_t          *tree;
  753.     ngx_rbtree_node_t     *node;
  754.     ngx_ssl_cache_node_t  *cn;

  756.     tree = &cache->rbtree;

  758.     if (tree->root == tree->sentinel) {
  759.         return;
  760.     }

  762.     for (node = ngx_rbtree_min(tree->root, tree->sentinel);
  763.          node;
  764.          node = ngx_rbtree_next(tree, node))
  765.     {
  766.         cn = ngx_rbtree_data(node, ngx_ssl_cache_node_t, node);
  767.         cn->type->free(cn->value);
  768.     }
  769. }


  772. static void
  773. ‌ngx_ssl_cache_node_insert(ngx_rbtree_node_t *temp,
  774.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
  775. {
  776.     ngx_rbtree_node_t     **p;
  777.     ngx_ssl_cache_node_t   *n, *t;

  779.     for ( ;; ) {

  781.         n = ngx_rbtree_data(node, ngx_ssl_cache_node_t, node);
  782.         t = ngx_rbtree_data(temp, ngx_ssl_cache_node_t, node);

  784.         if (node->key != temp->key) {

  786.             p = (node->key < temp->key) ? &temp->left : &temp->right;

  788.         } else if (n->type != t->type) {

  790.             p = (n->type < t->type) ? &temp->left : &temp->right;

  792.         } else {

  794.             p = (ngx_memn2cmp(n->id.data, t->id.data, n->id.len, t->id.len)
  795.                  < 0) ? &temp->left : &temp->right;
  796.         }

  798.         if (*p == sentinel) {
  799.             break;
  800.         }

  802.         temp = *p;
  803.     }

  805.     *p = node;
  806.     node->parent = temp;
  807.     node->left = sentinel;
  808.     node->right = sentinel;
  809.     ngx_rbt_red(node);
  810. }

One Level Up Top Level