One Level Up Top Level

src/http/modules/ngx_http_upstream_sticky_module.c - nginx

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_http.h>
  10. #include <ngx_md5.h>


  13. ‌#define NGX_HTTP_STICKY_COOKIE_MAX_EXPIRES  2145916555

  15. ‌#define ngx_http_upstream_sticky_sess_node(rbn, mb)                           \
  16.     (ngx_http_upstream_sticky_sess_node_t *)                                  \
  17.         ((char *) (rbn) - offsetof(ngx_http_upstream_sticky_sess_node_t, mb))


  20. ‌typedef union {
  21.     u_char                                      md5[16];
  22.     ngx_uint_t                                  hash;
  23. ‌} ngx_http_upstream_sticky_sess_key_t;


  26. ‌typedef struct {
  27.     ngx_rbtree_t                                rbtree;
  28.     ngx_rbtree_node_t                           sentinel;

  30.     ngx_rbtree_t                                exp_rbtree;
  31.     ngx_rbtree_node_t                           exp_sentinel;
  32. ‌} ngx_http_upstream_sticky_sess_shared_t;


  35. ‌typedef struct {
  36.     ngx_http_upstream_sticky_sess_shared_t     *sh;
  37.     ngx_slab_pool_t                            *shpool;
  38.     ngx_str_t                                  *host;

  40.     ngx_msec_t                                  timeout;
  41.     ngx_event_t                                 event;
  42. ‌} ngx_http_upstream_sticky_sess_t;


  45. /* session data: mapping of session ID hash to server ID */
  46. ‌typedef struct {
  47.     ngx_rbtree_node_t                           rbnode;
  48.     ngx_rbtree_node_t                           enode;

  50. ‌    union {
  51.         u_char                                  md5[16];
  52.         ngx_uint_t                              hash;
  53.     } u;

  55.     ngx_msec_t                                  last;

  57.     u_char                                      sid_len;
  58.     u_char                                      sid[NGX_HTTP_UPSTREAM_SID_LEN];
  59. ‌} ngx_http_upstream_sticky_sess_node_t;


  62. /* per-upstream sticky configuration */
  63. ‌typedef struct {
  64.     ngx_http_upstream_init_pt                   original_init_upstream;
  65.     ngx_http_upstream_init_peer_pt              original_init_peer;

  67.     ngx_array_t                                *lookup_vars; /* of ngx_int_t */
  68.     ngx_array_t                                *create_vars; /* of ngx_int_t */
  69.     ngx_shm_zone_t                             *shm_zone;    /* sessions */

  71.     ngx_str_t                                   cookie_name;
  72.     ngx_http_complex_value_t                   *cookie_domain;
  73.     ngx_str_t                                   cookie_path;
  74.     time_t                                      cookie_expires;
  75.     ngx_http_complex_value_t                   *cookie_samesite;
  76.     unsigned                                    cookie_httponly:1;
  77.     unsigned                                    cookie_secure:1;
  78.     unsigned                                    learn_after_headers:1;
  79. ‌} ngx_http_upstream_sticky_srv_conf_t;


  82. ‌typedef struct {
  83.     void                                       *original_data;
  84.     ngx_http_request_t                         *request;

  86.     ngx_http_upstream_sticky_srv_conf_t        *conf;

  88.     ngx_str_t                                   id;
  89.     ngx_table_elt_t                            *cookie;

  91.     ngx_event_get_peer_pt                       original_get_peer;
  92.     ngx_event_free_peer_pt                      original_free_peer;

  94. #if (NGX_HTTP_SSL)
  95.     ngx_event_set_peer_session_pt               original_set_session;
  96.     ngx_event_save_peer_session_pt              original_save_session;
  97. #endif

  99.     ngx_event_notify_peer_pt                    original_notify;

  101. ‌} ngx_http_upstream_sticky_peer_data_t;


  104. static ngx_int_t ngx_http_upstream_sticky_init_upstream(ngx_conf_t *cf,
  105.     ngx_http_upstream_srv_conf_t *us);
  106. static ngx_int_t ngx_http_upstream_sticky_init_peer(ngx_http_request_t *r,
  107.     ngx_http_upstream_srv_conf_t *us);
  108. static ngx_int_t ngx_http_upstream_sticky_get_id(
  109.     ngx_http_upstream_sticky_srv_conf_t *stcf, ngx_http_request_t *r,
  110.     ngx_array_t *vars, ngx_str_t *id);
  111. static void ngx_http_upstream_sticky_sess_init_key(ngx_str_t *sess_id,
  112.     ngx_http_upstream_sticky_sess_key_t *key);
  113. static ngx_int_t ngx_http_upstream_sticky_get_peer(ngx_peer_connection_t *pc,
  114.     void *data);
  115. static void ngx_http_upstream_sticky_free_peer(ngx_peer_connection_t *pc,
  116.     void *data, ngx_uint_t state);
  117. static void ngx_http_upstream_sticky_learn_peer(
  118.     ngx_http_upstream_sticky_peer_data_t *stp, ngx_peer_connection_t *pc);


  121. #if (NGX_HTTP_SSL)
  122. static ngx_int_t ngx_http_upstream_sticky_set_session(
  123.     ngx_peer_connection_t *pc, void *data);
  124. static void ngx_http_upstream_sticky_save_session(ngx_peer_connection_t *pc,
  125.     void *data);
  126. #endif


  129. static void ngx_http_upstream_sticky_notify_peer(
  130.     ngx_peer_connection_t *pc, void *data, ngx_uint_t type);
  131. static ngx_int_t ngx_http_upstream_sticky_cookie_insert(
  132.     ngx_peer_connection_t *pc, ngx_http_upstream_sticky_peer_data_t *stp);
  133. static ngx_int_t ngx_http_upstream_sticky_samesite(ngx_str_t *value);


  136. static ngx_http_upstream_sticky_sess_node_t *
  137.     ngx_http_upstream_sticky_sess_lookup(ngx_http_upstream_sticky_sess_t *sess,
  138.     ngx_http_upstream_sticky_sess_key_t *key);
  139. static ngx_http_upstream_sticky_sess_node_t *
  140.     ngx_http_upstream_sticky_sess_create(ngx_http_upstream_sticky_sess_t *sess,
  141.     ngx_http_upstream_sticky_sess_key_t *key, ngx_str_t *sid);
  142. static void ngx_http_upstream_sticky_sess_rbtree_insert_value(
  143.     ngx_rbtree_node_t *temp, ngx_rbtree_node_t *node,
  144.     ngx_rbtree_node_t *sentinel);
  145. static void ngx_http_upstream_sticky_sess_timer_handler(ngx_event_t *ev);
  146. static ngx_msec_t ngx_http_upstream_sticky_sess_expire(
  147.     ngx_http_upstream_sticky_sess_t *sess, ngx_uint_t force);
  148. static ngx_int_t ngx_http_upstream_sticky_sess_init_zone(
  149.     ngx_shm_zone_t *shm_zone, void *data);

  151. static void *ngx_http_upstream_sticky_create_conf(ngx_conf_t *cf);
  152. static char *ngx_http_upstream_sticky(ngx_conf_t *cf, ngx_command_t *cmd,
  153.     void *conf);
  154. static char *ngx_http_upstream_sticky_cookie(ngx_conf_t *cf,
  155.     ngx_http_upstream_sticky_srv_conf_t *stcf);
  156. static char *ngx_http_upstream_sticky_learn(ngx_conf_t *cf,
  157.     ngx_http_upstream_sticky_srv_conf_t *stcf,
  158.     ngx_http_upstream_srv_conf_t *us);

  160. static ngx_int_t ngx_http_upstream_sticky_init_worker(ngx_cycle_t *cycle);


  163. ‌static u_char expires[] =
  164.     "; expires=Thu, 31-Dec-37 23:55:55 GMT; max-age=315360000";
  165. ‌static u_char httponly[] = "; httponly";
  166. ‌static u_char secure[] = "; secure";


  169. ‌static ngx_command_t  ngx_http_upstream_sticky_commands[] = {

  171.     { ngx_string("sticky"),
  172.       NGX_HTTP_UPS_CONF|NGX_CONF_2MORE,
  173.       ngx_http_upstream_sticky,
  174.       0,
  175.       0,
  176.       NULL },

  178.       ngx_null_command
  179. };


  182. static ngx_http_module_t
  183. ‌ngx_http_upstream_sticky_module_ctx = {
  184.     NULL,                                 /* preconfiguration */
  185.     NULL,                                 /* postconfiguration */

  187.     NULL,                                 /* create main configuration */
  188.     NULL,                                 /* init main configuration */

  190.     ngx_http_upstream_sticky_create_conf, /* create server configuration */
  191.     NULL,                                 /* merge server configuration */

  193.     NULL,                                 /* create location configuration */
  194.     NULL                                  /* merge location configuration */
  195. };


  198. ngx_module_t
  199. ‌ngx_http_upstream_sticky_module =
  200. {
  201.     NGX_MODULE_V1,

  203.     &ngx_http_upstream_sticky_module_ctx, /* module context */
  204.     ngx_http_upstream_sticky_commands,    /* module directives */

  206.     NGX_HTTP_MODULE,                      /* module type */
  207.     NULL,                                 /* init master */

  209.     NULL,                                 /* init module */
  210.     ngx_http_upstream_sticky_init_worker, /* init process */

  212.     NULL,                                 /* init thread */
  213.     NULL,                                 /* exit thread */

  215.     NULL,                                 /* exit process */
  216.     NULL,                                 /* exit master */

  218.     NGX_MODULE_V1_PADDING
  219. };


  222. static ngx_int_t
  223. ‌ngx_http_upstream_sticky_init_upstream(ngx_conf_t *cf,
  224.     ngx_http_upstream_srv_conf_t *us)
  225. {
  226.     ngx_http_upstream_sticky_srv_conf_t  *stcf;

  228.     stcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_sticky_module);

  230.     if (stcf->original_init_upstream(cf, us) != NGX_OK) {
  231.         return NGX_ERROR;
  232.     }

  234.     stcf->original_init_peer = us->peer.init;
  235.     us->peer.init = ngx_http_upstream_sticky_init_peer;

  237.     return NGX_OK;
  238. }


  241. static ngx_int_t
  242. ‌ngx_http_upstream_sticky_init_peer(ngx_http_request_t *r,
  243.     ngx_http_upstream_srv_conf_t *us)
  244. {
  245.     ngx_int_t                              rc;
  246.     ngx_http_upstream_t                   *u;
  247.     ngx_http_upstream_sticky_srv_conf_t   *stcf;
  248.     ngx_http_upstream_sticky_peer_data_t  *stp;

  250.     stcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_sticky_module);

  252.     stp = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_sticky_peer_data_t));
  253.     if (stp == NULL) {
  254.         return NGX_ERROR;
  255.     }

  257.     rc = stcf->original_init_peer(r, us);

  259.     if (rc != NGX_OK) {
  260.         return rc;
  261.     }

  263.     u = r->upstream;

  265.     stp->original_data = u->peer.data;
  266.     stp->original_get_peer = u->peer.get;
  267.     stp->original_free_peer = u->peer.free;

  269.     stp->request = r;
  270.     stp->conf = stcf;

  272.     u->peer.get = ngx_http_upstream_sticky_get_peer;
  273.     u->peer.free = ngx_http_upstream_sticky_free_peer;
  274.     u->peer.data = stp;

  276. #if (NGX_HTTP_SSL)
  277.     stp->original_set_session = u->peer.set_session;
  278.     stp->original_save_session = u->peer.save_session;
  279.     u->peer.set_session = ngx_http_upstream_sticky_set_session;
  280.     u->peer.save_session = ngx_http_upstream_sticky_save_session;
  281. #endif

  283.     if (u->peer.notify || stcf->learn_after_headers) {
  284.         stp->original_notify = u->peer.notify;
  285.         u->peer.notify = ngx_http_upstream_sticky_notify_peer;
  286.     }

  288.     ngx_http_upstream_sticky_get_id(stcf, r, stcf->lookup_vars, &stp->id);

  290.     return NGX_OK;
  291. }


  294. static ngx_int_t
  295. ‌ngx_http_upstream_sticky_get_id(ngx_http_upstream_sticky_srv_conf_t *stcf,
  296.     ngx_http_request_t *r, ngx_array_t *vars, ngx_str_t *id)
  297. {
  298.     ngx_int_t                  *index;
  299.     ngx_uint_t                  i;
  300.     ngx_http_variable_value_t  *v;

  302.     index = vars->elts;

  304.     for (i = 0; i < vars->nelts; i++) {

  306.         v = ngx_http_get_flushed_variable(r, index[i]);

  308.         if (v == NULL || v->not_found || v->len == 0) {
  309.             continue;
  310.         }

  312.         id->data = v->data;
  313.         id->len = v->len;

  315.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  316.                        "sticky: using \"%v\" found in variable #%i", v, i + 1);

  318.         return NGX_OK;
  319.     }

  321.     ngx_str_null(id);

  323.     return NGX_DONE;
  324. }


  327. static ngx_inline void
  328. ‌ngx_http_upstream_sticky_sess_init_key(ngx_str_t *sess_id,
  329.     ngx_http_upstream_sticky_sess_key_t *key)
  330. {
  331.     ngx_md5_t  md5;

  333.     ngx_md5_init(&md5);
  334.     ngx_md5_update(&md5, sess_id->data, sess_id->len);
  335.     ngx_md5_final(key->md5, &md5);
  336. }


  339. static ngx_int_t
  340. ‌ngx_http_upstream_sticky_get_peer(ngx_peer_connection_t *pc, void *data)
  341. {
  342.     ngx_http_upstream_sticky_peer_data_t  *stp = data;

  344.     ngx_int_t                              rc;
  345.     ngx_str_t                              sid;
  346.     ngx_http_upstream_sticky_sess_t       *sess;
  347.     ngx_http_upstream_sticky_sess_key_t    key;
  348.     ngx_http_upstream_sticky_sess_node_t  *sn;
  349.     u_char                                 sid_data[NGX_HTTP_UPSTREAM_SID_LEN];

  351.     if (pc->hint == NULL && stp->conf->shm_zone && stp->id.len) {

  353.         /* request holds session ID, extract server ID from session */

  355.         sess = stp->conf->shm_zone->data;

  357.         ngx_http_upstream_sticky_sess_init_key(&stp->id, &key);

  359.         ngx_shmtx_lock(&sess->shpool->mutex);

  361.         sn = ngx_http_upstream_sticky_sess_lookup(sess, &key);
  362.         if (sn == NULL) {
  363.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  364.                            "sticky: session \"%V\" not found", &stp->id);

  366.         } else {
  367.             ngx_memcpy(sid_data, sn->sid, sn->sid_len);
  368.             sid.len = sn->sid_len;
  369.             sid.data = sid_data;
  370.             pc->hint = &sid;

  372.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  373.                            "sticky: session \"%V\", SID \"%V\"",
  374.                            &stp->id, &sid);
  375.         }

  377.         ngx_shmtx_unlock(&sess->shpool->mutex);

  379.     } else if (pc->hint == NULL && stp->id.len) {

  381.         /* request holds server ID */

  383.         pc->hint = &stp->id;
  384.     }

  386.     rc = stp->original_get_peer(pc, stp->original_data);

  388.     pc->hint = NULL;

  390.     if (rc != NGX_OK && rc != NGX_DONE) {
  391.         return rc;
  392.     }

  394.     if (stp->conf->cookie_name.len == 0) {
  395.         return rc;
  396.     }

  398.     if (ngx_http_upstream_sticky_cookie_insert(pc, stp) != NGX_OK) {
  399.         return NGX_ERROR;
  400.     }

  402.     return rc;
  403. }


  406. static void
  407. ‌ngx_http_upstream_sticky_free_peer(ngx_peer_connection_t *pc, void *data,
  408.     ngx_uint_t state)
  409. {
  410.     ngx_http_upstream_sticky_peer_data_t  *stp = data;

  412.     if (state & (NGX_PEER_FAILED|NGX_PEER_NEXT)) {
  413.         goto done;
  414.     }

  416.     if (stp->conf->shm_zone && !stp->conf->learn_after_headers) {
  417.         ngx_http_upstream_sticky_learn_peer(stp, pc);
  418.     }

  420. done:

  422.     stp->original_free_peer(pc, stp->original_data, state);
  423. }


  426. static void
  427. ‌ngx_http_upstream_sticky_learn_peer(ngx_http_upstream_sticky_peer_data_t *stp,
  428.     ngx_peer_connection_t *pc)
  429. {
  430.     ngx_str_t                              sess_id;
  431.     ngx_msec_t                             now;
  432.     ngx_time_t                            *tp;
  433.     ngx_uint_t                             create;
  434.     ngx_http_request_t                    *r;
  435.     ngx_http_upstream_sticky_sess_t       *sess;
  436.     ngx_http_upstream_sticky_sess_key_t    key;
  437.     ngx_http_upstream_sticky_srv_conf_t   *stcf;
  438.     ngx_http_upstream_sticky_sess_node_t  *sn;

  440.     if (pc->sid == NULL) {
  441.         ngx_log_error(NGX_LOG_WARN, pc->log, 0,
  442.                       "balancer does not support sticky");
  443.         return;
  444.     }

  446.     stcf = stp->conf;

  448.     r = stp->request;

  450.     sess = stcf->shm_zone->data;

  452.     if (ngx_http_upstream_sticky_get_id(stcf, r, stcf->create_vars, &sess_id)
  453.         == NGX_OK)
  454.     {
  455.         create = 1;

  457.     } else if (stp->id.len) {
  458.         sess_id = stp->id;
  459.         create = 0;

  461.     } else {
  462.         return;
  463.     }

  465.     tp = ngx_timeofday();
  466.     now = tp->sec * 1000 + tp->msec;

  468.     ngx_http_upstream_sticky_sess_init_key(&sess_id, &key);

  470.     ngx_shmtx_lock(&sess->shpool->mutex);

  472.     sn = ngx_http_upstream_sticky_sess_lookup(sess, &key);

  474.     if (sn) {
  475.         if (pc->sid->len != sn->sid_len
  476.             || ngx_memcmp(pc->sid->data, sn->sid, sn->sid_len) != 0)
  477.         {
  478.             ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  479.                            "sticky: session \"%V\" reused for SID \"%V\"",
  480.                            &sess_id, pc->sid);

  482.             sn->sid_len = pc->sid->len;
  483.             ngx_memcpy(sn->sid, pc->sid->data, pc->sid->len);
  484.         }

  486.         ngx_rbtree_delete(&sess->sh->exp_rbtree, &sn->enode);
  487.         sn->last = now;
  488.         sn->enode.key = sn->last;
  489.         ngx_rbtree_insert(&sess->sh->exp_rbtree, &sn->enode);

  491.         ngx_shmtx_unlock(&sess->shpool->mutex);
  492.         return;
  493.     }

  495.     if (create) {
  496.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  497.                        "sticky: creating session \"%V\", SID \"%V\"",
  498.                        &sess_id, pc->sid);

  500.         sn = ngx_http_upstream_sticky_sess_create(sess, &key, pc->sid);

  502.         if (sn) {
  503.             sn->last = now;
  504.             sn->enode.key = sn->last;
  505.             ngx_rbtree_insert(&sess->sh->exp_rbtree, &sn->enode);

  507.             if (!sess->event.timer_set) {
  508.                 ngx_add_timer(&sess->event, sess->timeout);
  509.             }
  510.         }
  511.     }

  513.     ngx_shmtx_unlock(&sess->shpool->mutex);
  514. }


  517. #if (NGX_HTTP_SSL)

  519. static ngx_int_t
  520. ‌ngx_http_upstream_sticky_set_session(ngx_peer_connection_t *pc, void *data)
  521. {
  522.     ngx_http_upstream_sticky_peer_data_t  *stp = data;

  524.     return stp->original_set_session(pc, stp->original_data);
  525. }


  528. static void
  529. ‌ngx_http_upstream_sticky_save_session(ngx_peer_connection_t *pc, void *data)
  530. {
  531.     ngx_http_upstream_sticky_peer_data_t  *stp = data;

  533.     stp->original_save_session(pc, stp->original_data);
  534. }

  536. #endif


  539. static void
  540. ‌ngx_http_upstream_sticky_notify_peer(ngx_peer_connection_t *pc, void *data,
  541.     ngx_uint_t type)
  542. {
  543.     ngx_http_upstream_sticky_peer_data_t  *stp = data;

  545.     if (type == NGX_HTTP_UPSTREAM_NOTIFY_HEADER
  546.         && stp->conf->learn_after_headers)
  547.     {
  548.         ngx_http_upstream_sticky_learn_peer(stp, pc);
  549.     }

  551.     if (stp->original_notify) {
  552.         stp->original_notify(pc, stp->original_data, type);
  553.     }
  554. }


  557. static ngx_int_t
  558. ‌ngx_http_upstream_sticky_cookie_insert(ngx_peer_connection_t *pc,
  559.     ngx_http_upstream_sticky_peer_data_t *stp)
  560. {
  561.     size_t                                len;
  562.     u_char                               *data, *p;
  563.     ngx_str_t                             domain, samesite;
  564.     ngx_table_elt_t                      *cookie;
  565.     ngx_http_request_t                   *r;
  566.     ngx_http_upstream_sticky_srv_conf_t  *stcf;

  568.     stcf = stp->conf;
  569.     r = stp->request;

  571.     if (pc->sid == NULL) {
  572.         ngx_log_error(NGX_LOG_WARN, pc->log, 0,
  573.                       "balancer does not support sticky");
  574.         return NGX_OK;
  575.     }

  577. #if (NGX_DEBUG)

  579.     if (stp->id.len) {

  581.         /* check that the selected peer matches SID from request */

  583.         if (pc->sid->len != stp->id.len
  584.             || ngx_memcmp(pc->sid->data, stp->id.data, stp->id.len) != 0)
  585.         {
  586.             ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  587.                            "sticky: server with requested SID is unavailable");
  588.         }
  589.     }

  591. #endif

  593.     len = stcf->cookie_name.len + 1 + pc->sid->len + stcf->cookie_path.len;

  595.     ngx_str_set(&domain, "");

  597.     if (stcf->cookie_domain) {
  598.         if (ngx_http_complex_value(r, stcf->cookie_domain, &domain)
  599.             != NGX_OK)
  600.         {
  601.             return NGX_ERROR;
  602.         }
  603.     }

  605.     if (domain.len) {
  606.         len += sizeof("; domain=") - 1 + domain.len;
  607.     }

  609.     if (stcf->cookie_expires != (time_t) NGX_CONF_UNSET) {
  610.         len += sizeof(expires) - 1 + NGX_TIME_T_LEN;
  611.     }

  613.     if (stcf->cookie_httponly) {
  614.         len += sizeof(httponly) - 1;
  615.     }

  617.     if (stcf->cookie_secure) {
  618.         len += sizeof(secure) - 1;
  619.     }

  621.     ngx_str_set(&samesite, "");

  623.     if (stcf->cookie_samesite) {

  625.         if (ngx_http_complex_value(r, stcf->cookie_samesite, &samesite)
  626.             != NGX_OK)
  627.         {
  628.             return NGX_ERROR;
  629.         }

  631.         if (stcf->cookie_samesite->lengths && samesite.len
  632.             && ngx_http_upstream_sticky_samesite(&samesite) != NGX_OK)
  633.         {
  634.             ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  635.                            "sticky: invalid cookie samesite value \"%V\"",
  636.                            &samesite);
  637.             ngx_str_set(&samesite, "strict");
  638.         }
  639.     }

  641.     if (samesite.len) {
  642.         len += sizeof("; samesite=") - 1 + samesite.len;
  643.     }

  645.     data = ngx_pnalloc(r->pool, len);
  646.     if (data == NULL) {
  647.         return NGX_ERROR;
  648.     }

  650.     p = ngx_copy(data, stcf->cookie_name.data, stcf->cookie_name.len);
  651.     *p++ = '=';
  652.     p = ngx_copy(p, pc->sid->data, pc->sid->len);

  654.     if (stcf->cookie_expires != (time_t) NGX_CONF_UNSET) {

  656.         if (stcf->cookie_expires == NGX_HTTP_STICKY_COOKIE_MAX_EXPIRES) {
  657.             p = ngx_cpymem(p, expires, sizeof(expires) - 1);

  659.         } else {
  660.             p = ngx_cpymem(p, "; expires=", 10);
  661.             p = ngx_http_cookie_time(p, ngx_time() + stcf->cookie_expires);
  662.             p = ngx_sprintf(p, "; max-age=%T", stcf->cookie_expires);
  663.         }
  664.     }

  666.     if (domain.len) {
  667.         p = ngx_cpymem(p, "; domain=", 9);
  668.         p = ngx_copy(p, domain.data, domain.len);
  669.     }

  671.     if (stcf->cookie_httponly) {
  672.         p = ngx_copy(p, httponly, sizeof(httponly) - 1);
  673.     }

  675.     if (stcf->cookie_secure) {
  676.         p = ngx_copy(p, secure, sizeof(secure) - 1);
  677.     }

  679.     if (samesite.len) {
  680.         p = ngx_cpymem(p, "; samesite=", 11);
  681.         p = ngx_copy(p, samesite.data, samesite.len);
  682.     }

  684.     p = ngx_cpymem(p, stcf->cookie_path.data, stcf->cookie_path.len);

  686.     cookie = stp->cookie;

  688.     if (cookie == NULL) {

  690.         cookie = ngx_list_push(&r->headers_out.headers);
  691.         if (cookie == NULL) {
  692.             return NGX_ERROR;
  693.         }

  695.         cookie->hash = 1;
  696.         cookie->next = NULL;
  697.         ngx_str_set(&cookie->key, "Set-Cookie");

  699.         stp->cookie = cookie;
  700.     }

  702.     cookie->value.len = p - data;
  703.     cookie->value.data = data;

  705.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  706.                    "sticky: set cookie: \"%V\"", &cookie->value);

  708.     return NGX_OK;
  709. }


  712. static ngx_int_t
  713. ‌ngx_http_upstream_sticky_samesite(ngx_str_t *value)
  714. {
  715.     ngx_uint_t  i;

  717.     static ngx_str_t samesite[] = {
  718.         ngx_string("strict"),
  719.         ngx_string("lax"),
  720.         ngx_string("none"),
  721.         ngx_null_string
  722.     };

  724.     for (i = 0; samesite[i].len != 0; i++) {

  726.         if (samesite[i].len == value->len
  727.             && ngx_strncasecmp(samesite[i].data, value->data, value->len) == 0)
  728.         {
  729.             return NGX_OK;
  730.         }
  731.     }

  733.     return NGX_ERROR;
  734. }


  737. static ngx_http_upstream_sticky_sess_node_t *
  738. ‌ngx_http_upstream_sticky_sess_lookup(ngx_http_upstream_sticky_sess_t *sess,
  739.     ngx_http_upstream_sticky_sess_key_t *key)
  740. {
  741.     ngx_int_t                              rc;
  742.     ngx_uint_t                             hash;
  743.     ngx_rbtree_node_t                     *node, *sentinel;
  744.     ngx_http_upstream_sticky_sess_node_t  *sn;

  746.     hash = key->hash;
  747.     node = sess->sh->rbtree.root;
  748.     sentinel = sess->sh->rbtree.sentinel;

  750.     while (node != sentinel) {

  752.         if (hash < node->key) {
  753.             node = node->left;
  754.             continue;
  755.         }

  757.         if (hash > node->key) {
  758.             node = node->right;
  759.             continue;
  760.         }

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

  764.         do {

  766.             sn = (ngx_http_upstream_sticky_sess_node_t *) node;

  768.             rc = ngx_memcmp(key->md5, sn->u.md5, 16);

  770.             if (rc == 0) {
  771.                 return sn;
  772.             }

  774.             node = (rc < 0) ? node->left : node->right;

  776.         } while (node != sentinel && hash == node->key);

  778.         break;
  779.     }

  781.     return NULL;
  782. }


  785. static ngx_http_upstream_sticky_sess_node_t *
  786. ‌ngx_http_upstream_sticky_sess_create(ngx_http_upstream_sticky_sess_t *sess,
  787.     ngx_http_upstream_sticky_sess_key_t *key, ngx_str_t *sid)
  788. {
  789.     size_t                                 n;
  790.     ngx_rbtree_node_t                     *node;
  791.     ngx_http_upstream_sticky_sess_node_t  *sn;

  793.     n = sizeof(ngx_http_upstream_sticky_sess_node_t);

  795.     sn = ngx_slab_alloc_locked(sess->shpool, n);
  796.     if (sn == NULL) {

  798.         ngx_log_error(NGX_LOG_WARN, ngx_cycle->log, 0,
  799.                       "could not allocate node%s, expiring least "
  800.                       "recently used session", sess->shpool->log_ctx);

  802.         (void) ngx_http_upstream_sticky_sess_expire(sess, 1);

  804.         sn = ngx_slab_alloc_locked(sess->shpool, n);
  805.         if (sn == NULL) {
  806.             ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  807.                           "could not allocate node%s", sess->shpool->log_ctx);
  808.             return NULL;
  809.         }
  810.     }

  812.     ngx_memcpy(sn->u.md5, key->md5, 16);

  814.     sn->sid_len = sid->len;
  815.     ngx_memcpy(sn->sid, sid->data, sid->len);

  817.     node = &sn->rbnode;
  818.     node->key = sn->u.hash;

  820.     ngx_rbtree_insert(&sess->sh->rbtree, node);

  822.     return sn;
  823. }


  826. static void
  827. ‌ngx_http_upstream_sticky_sess_rbtree_insert_value(ngx_rbtree_node_t *temp,
  828.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
  829. {
  830.     ngx_rbtree_node_t                     **p;
  831.     ngx_http_upstream_sticky_sess_node_t  *sn, *snt;

  833.     for ( ;; ) {

  835.         if (node->key < temp->key) {

  837.             p = &temp->left;

  839.         } else if (node->key > temp->key) {

  841.             p = &temp->right;

  843.         } else { /* node->key == temp->key */

  845.             sn = (ngx_http_upstream_sticky_sess_node_t *) node;
  846.             snt = (ngx_http_upstream_sticky_sess_node_t *) temp;

  848.             p = (ngx_memcmp(sn->u.md5, snt->u.md5, 16) < 0)
  849.                 ? &temp->left : &temp->right;
  850.         }

  852.         if (*p == sentinel) {
  853.             break;
  854.         }

  856.         temp = *p;
  857.     }

  859.     *p = node;
  860.     node->parent = temp;
  861.     node->left = sentinel;
  862.     node->right = sentinel;
  863.     ngx_rbt_red(node);
  864. }


  867. static void
  868. ‌ngx_http_upstream_sticky_sess_timer_handler(ngx_event_t *ev)
  869. {
  870.     ngx_msec_t                        wait;
  871.     ngx_http_upstream_sticky_sess_t  *sess;

  873.     sess = ev->data;

  875.     ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, 0,
  876.                    "sticky: session timer");

  878.     ngx_shmtx_lock(&sess->shpool->mutex);

  880.     wait = ngx_http_upstream_sticky_sess_expire(sess, 0);

  882.     ngx_shmtx_unlock(&sess->shpool->mutex);

  884.     if (wait > 0) {
  885.         ngx_add_timer(&sess->event, wait);
  886.     }
  887. }


  890. static ngx_msec_t
  891. ‌ngx_http_upstream_sticky_sess_expire(ngx_http_upstream_sticky_sess_t *sess,
  892.     ngx_uint_t force)
  893. {
  894.     ngx_msec_t                             now, wait;
  895.     ngx_time_t                            *tp;
  896.     ngx_rbtree_node_t                     *node, *next;
  897.     ngx_http_upstream_sticky_sess_node_t  *sn;

  899.     wait = 0;

  901.     tp = ngx_timeofday();
  902.     now = tp->sec * 1000 + tp->msec;

  904.     if (sess->sh->exp_rbtree.root == sess->sh->exp_rbtree.sentinel) {
  905.         return 0;
  906.     }

  908. #if (NGX_SUPPRESS_WARN)
  909.     next = NULL;
  910. #endif

  912.     for (node = ngx_rbtree_min(sess->sh->exp_rbtree.root,
  913.                                sess->sh->exp_rbtree.sentinel);
  914.          node;
  915.          node = next)
  916.     {

  918.         sn = ngx_http_upstream_sticky_sess_node(node, enode);
  919.         wait = sn->last + sess->timeout - now;

  921.         if (!force && (ngx_msec_int_t) wait > 0) {
  922.             break;
  923.         }

  925.         force = 0;

  927.         next = ngx_rbtree_next(&sess->sh->exp_rbtree, node);

  929.         /* remove node */
  930.         node = &sn->enode;
  931.         ngx_rbtree_delete(&sess->sh->exp_rbtree, node);

  933.         node = &sn->rbnode;
  934.         ngx_rbtree_delete(&sess->sh->rbtree, node);
  935.         ngx_slab_free_locked(sess->shpool, node);
  936.     }

  938.     return wait;
  939. }


  942. static ngx_int_t
  943. ‌ngx_http_upstream_sticky_sess_init_zone(ngx_shm_zone_t *shm_zone, void *data)
  944. {
  945.     ngx_http_upstream_sticky_sess_t  *old_sess = data;

  947.     size_t                            len;
  948.     ngx_http_upstream_sticky_sess_t  *sess;

  950.     sess = shm_zone->data;

  952.     if (old_sess) {

  954.         if (ngx_strcmp(sess->host->data, old_sess->host->data) != 0) {

  956.             ngx_log_error(NGX_LOG_EMERG, shm_zone->shm.log, 0,
  957.                           "sticky zone \"%V\" is used in upstream \"%V\" "
  958.                           "while previously it was used in upstream \"%V\"",
  959.                           &shm_zone->shm.name, sess->host, old_sess->host);

  961.             return NGX_ERROR;
  962.         }

  964.         sess->sh = old_sess->sh;
  965.         sess->shpool = old_sess->shpool;
  966.         return NGX_OK;
  967.     }

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

  971.     if (shm_zone->shm.exists) {
  972.         sess->sh = sess->shpool->data;
  973.         return NGX_OK;
  974.     }

  976.     sess->sh = ngx_slab_alloc(sess->shpool,
  977.                               sizeof(ngx_http_upstream_sticky_sess_shared_t));
  978.     if (sess->sh == NULL) {
  979.         return NGX_ERROR;
  980.     }

  982.     sess->shpool->data = sess->sh;

  984.     ngx_rbtree_init(&sess->sh->rbtree, &sess->sh->sentinel,
  985.                     ngx_http_upstream_sticky_sess_rbtree_insert_value);

  987.     ngx_rbtree_init(&sess->sh->exp_rbtree, &sess->sh->exp_sentinel,
  988.                     ngx_rbtree_insert_timer_value);

  990.     len = sizeof(" in sticky session zone \"\"") + shm_zone->shm.name.len;

  992.     sess->shpool->log_ctx = ngx_slab_alloc(sess->shpool, len);
  993.     if (sess->shpool->log_ctx == NULL) {
  994.         return NGX_ERROR;
  995.     }

  997.     ngx_sprintf(sess->shpool->log_ctx, " in sticky session zone \"%V\"%Z",
  998.                 &shm_zone->shm.name);

  1000.     sess->shpool->log_nomem = 0;

  1002.     return NGX_OK;
  1003. }


  1006. static void *
  1007. ‌ngx_http_upstream_sticky_create_conf(ngx_conf_t *cf)
  1008. {
  1009.     ngx_http_upstream_sticky_srv_conf_t  *stcf;

  1011.     stcf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_sticky_srv_conf_t));
  1012.     if (stcf == NULL) {
  1013.         return NULL;
  1014.     }

  1016.     /*
  1017.      * set by ngx_pcalloc():
  1018.      *
  1019.      *     stcf->original_init_upstream = NULL;
  1020.      *     stcf->original_init_peer = NULL;
  1021.      *
  1022.      *     stcf->lookup_vars = NULL;
  1023.      *     stcf->create_vars = NULL;
  1024.      *     stcf->shm_zone = NULL;
  1025.      *
  1026.      *     stcf->cookie_name = { 0, NULL };
  1027.      *     stcf->cookie_domain = NULL;
  1028.      *     stcf->cookie_path = { 0, NULL };
  1029.      *     stcf->cookie_httponly = 0;
  1030.      *     stcf->cookie_secure = 0;
  1031.      *     stcf->cookie_samesite = NULL;
  1032.      *
  1033.      *     stcf->learn_after_headers = 0;
  1034.      */

  1036.     stcf->cookie_expires = NGX_CONF_UNSET;

  1038.     return stcf;
  1039. }


  1042. static char *
  1043. ‌ngx_http_upstream_sticky(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  1044. {
  1045.     ngx_str_t                            *value;
  1046.     ngx_int_t                            *indexp, index;
  1047.     ngx_uint_t                            i;
  1048.     ngx_http_upstream_srv_conf_t         *us;
  1049.     ngx_http_upstream_sticky_srv_conf_t  *stcf;

  1051.     us = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);
  1052.     stcf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_sticky_module);

  1054.     if (stcf->lookup_vars != NULL) {
  1055.         return "is duplicate";
  1056.     }

  1058.     stcf->lookup_vars = ngx_array_create(cf->pool, 1, sizeof(ngx_int_t));
  1059.     if (stcf->lookup_vars == NULL) {
  1060.         return NGX_CONF_ERROR;
  1061.     }

  1063.     stcf->original_init_upstream = us->peer.init_upstream
  1064.                                    ? us->peer.init_upstream
  1065.                                    : ngx_http_upstream_init_round_robin;

  1067.     us->peer.init_upstream = ngx_http_upstream_sticky_init_upstream;

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

  1071.     if (ngx_strcmp(value[1].data, "cookie") == 0) {
  1072.         return ngx_http_upstream_sticky_cookie(cf, stcf);

  1074.     } else if (ngx_strcmp(value[1].data, "route") == 0) {

  1076.         for (i = 2; i < cf->args->nelts; i++) {

  1078.             if (value[i].data[0] != '$') {
  1079.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1080.                                    "invalid variable name \"%V\"", &value[i]);
  1081.                 return NGX_CONF_ERROR;
  1082.             }

  1084.             value[i].len--;
  1085.             value[i].data++;

  1087.             index = ngx_http_get_variable_index(cf, &value[i]);
  1088.             if (index == NGX_ERROR) {
  1089.                 return NGX_CONF_ERROR;
  1090.             }

  1092.             indexp = ngx_array_push(stcf->lookup_vars);
  1093.             if (indexp == NULL) {
  1094.                 return NGX_CONF_ERROR;
  1095.             }

  1097.             *indexp = index;
  1098.         }

  1100.         return NGX_CONF_OK;

  1102.     } else if (ngx_strcmp(value[1].data, "learn") == 0) {
  1103.         return ngx_http_upstream_sticky_learn(cf, stcf, us);
  1104.     }

  1106.     ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, "unknown parameter \"%V\"",
  1107.                        &value[1]);
  1108.     return NGX_CONF_ERROR;
  1109. }


  1112. static char *
  1113. ‌ngx_http_upstream_sticky_cookie(ngx_conf_t *cf,
  1114.     ngx_http_upstream_sticky_srv_conf_t *stcf)
  1115. {
  1116.     u_char                            *p;
  1117.     ngx_str_t                          name, *value;
  1118.     ngx_int_t                          index, *indexp;
  1119.     ngx_uint_t                         i;
  1120.     ngx_http_compile_complex_value_t   ccv;

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

  1124.     if (value[2].len == 0) {
  1125.         return "empty cookie name";
  1126.     }

  1128.     stcf->cookie_name = value[2];

  1130.     for (i = 3; i < cf->args->nelts; i++) {

  1132.         if (ngx_strncmp(value[i].data, "domain=", 7) == 0) {

  1134.             if (stcf->cookie_domain != NULL) {
  1135.                 return "parameter \"domain\" is duplicate";
  1136.             }

  1138.             value[i].data += 7;
  1139.             value[i].len -= 7;

  1141.             if (value[i].len == 0) {
  1142.                 return "no value for \"domain\"";
  1143.             }

  1145.             ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  1147.             stcf->cookie_domain = ngx_palloc(cf->pool,
  1148.                                              sizeof(ngx_http_complex_value_t));
  1149.             if (stcf->cookie_domain == NULL) {
  1150.                 return NGX_CONF_ERROR;
  1151.             }

  1153.             ccv.cf = cf;
  1154.             ccv.value = &value[i];
  1155.             ccv.complex_value = stcf->cookie_domain;

  1157.             if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  1158.                 return NGX_CONF_ERROR;
  1159.             }

  1161.         } else if (ngx_strncmp(value[i].data, "path=", 5) == 0) {

  1163.             if (stcf->cookie_path.data != NULL) {
  1164.                 return "parameter \"path\" is duplicate";
  1165.             }

  1167.             value[i].data += 5;
  1168.             value[i].len -= 5;

  1170.             if (value[i].len == 0) {
  1171.                 return "no value for \"path\"";
  1172.             }

  1174.             stcf->cookie_path.len = sizeof("; path=") - 1 + value[i].len;

  1176.             stcf->cookie_path.data = ngx_pnalloc(cf->pool,
  1177.                                                  stcf->cookie_path.len);
  1178.             if (stcf->cookie_path.data == NULL) {
  1179.                 return NGX_CONF_ERROR;
  1180.             }

  1182.             p = ngx_cpymem(stcf->cookie_path.data,
  1183.                            "; path=", sizeof("; path=") - 1);
  1184.             ngx_memcpy(p, value[i].data, value[i].len);


  1187.         } else if (ngx_strncmp(value[i].data, "expires=", 8) == 0) {

  1189.             if (stcf->cookie_expires != (time_t) NGX_CONF_UNSET) {
  1190.                 return "parameter \"expires\" is duplicate";
  1191.             }

  1193.             value[i].data += 8;
  1194.             value[i].len -= 8;

  1196.             if (ngx_strcmp(value[i].data, "max") == 0) {
  1197.                 stcf->cookie_expires = NGX_HTTP_STICKY_COOKIE_MAX_EXPIRES;

  1199.             } else {
  1200.                 stcf->cookie_expires = ngx_parse_time(&value[i], 1);
  1201.                 if (stcf->cookie_expires == (time_t) NGX_ERROR) {
  1202.                     return "invalid \"expires\" parameter value";
  1203.                 }
  1204.             }

  1206.         } else if (ngx_strcmp(value[i].data, "httponly") == 0) {

  1208.             if (stcf->cookie_httponly) {
  1209.                 return "parameter \"httponly\" is duplicate";
  1210.             }

  1212.             stcf->cookie_httponly = 1;

  1214.         } else if (ngx_strcmp(value[i].data, "secure") == 0) {

  1216.             if (stcf->cookie_secure) {
  1217.                 return "parameter \"secure\" is duplicate";
  1218.             }

  1220.             stcf->cookie_secure = 1;

  1222.         } else if (ngx_strncmp(value[i].data, "samesite=", 9) == 0) {

  1224.             if (stcf->cookie_samesite) {
  1225.                 return "parameter \"samesite\" is duplicate";
  1226.             }

  1228.             value[i].data += 9;
  1229.             value[i].len -= 9;

  1231.             ngx_memzero(&ccv, sizeof(ngx_http_compile_complex_value_t));

  1233.             stcf->cookie_samesite = ngx_palloc(cf->pool,
  1234.                                              sizeof(ngx_http_complex_value_t));
  1235.             if (stcf->cookie_samesite == NULL) {
  1236.                 return NGX_CONF_ERROR;
  1237.             }

  1239.             ccv.cf = cf;
  1240.             ccv.value = &value[i];
  1241.             ccv.complex_value = stcf->cookie_samesite;

  1243.             if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  1244.                 return NGX_CONF_ERROR;
  1245.             }

  1247.             if (stcf->cookie_samesite->lengths == NULL
  1248.                 && ngx_http_upstream_sticky_samesite(&value[i]) != NGX_OK)
  1249.             {
  1250.                 return "invalid \"samesite\" parameter value";
  1251.             }

  1253.         } else {
  1254.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1255.                                "unknown parameter \"%V\"", &value[i]);
  1256.             return NGX_CONF_ERROR;
  1257.         }
  1258.     }

  1260.     name.len = sizeof("cookie_") - 1  + stcf->cookie_name.len;
  1261.     name.data = ngx_pnalloc(cf->pool, name.len);
  1262.     if (name.data == NULL) {
  1263.          return NGX_CONF_ERROR;
  1264.     }

  1266.     ngx_sprintf(name.data, "cookie_%V", &stcf->cookie_name);

  1268.     index = ngx_http_get_variable_index(cf, &name);
  1269.     if (index == NGX_ERROR) {
  1270.         return NGX_CONF_ERROR;
  1271.     }

  1273.     indexp = ngx_array_push(stcf->lookup_vars);
  1274.     if (indexp == NULL) {
  1275.         return NGX_CONF_ERROR;
  1276.     }

  1278.     *indexp = index;

  1280.     return NGX_CONF_OK;
  1281. }


  1284. static char *
  1285. ‌ngx_http_upstream_sticky_learn(ngx_conf_t *cf,
  1286.     ngx_http_upstream_sticky_srv_conf_t *stcf, ngx_http_upstream_srv_conf_t *us)
  1287. {
  1288.     u_char                           *p;
  1289.     ssize_t                           zone_size;
  1290.     ngx_str_t                        *value, name, size;
  1291.     ngx_int_t                         index, *indexp;
  1292.     ngx_uint_t                        i;
  1293.     ngx_msec_t                        timeout;
  1294.     ngx_shm_zone_t                   *shm_zone;
  1295.     ngx_http_upstream_sticky_sess_t  *sess;

  1297.     zone_size = 0;
  1298.     timeout = NGX_CONF_UNSET_MSEC;

  1300.     stcf->create_vars = ngx_array_create(cf->pool, 1, sizeof(ngx_int_t));
  1301.     if (stcf->create_vars == NULL) {
  1302.         return NGX_CONF_ERROR;
  1303.     }

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

  1307.     for (i = 2; i < cf->args->nelts; i++) {

  1309.         if (ngx_strncmp(value[i].data, "zone=", 5) == 0) {

  1311.             if (zone_size != 0) {
  1312.                 return "duplicate zone";
  1313.             }

  1315.             name.data = value[i].data + 5;

  1317.             p = (u_char *) ngx_strchr(name.data, ':');

  1319.             if (p == NULL) {
  1320.                 return "zone size is not specified";
  1321.             }

  1323.             name.len = p - name.data;

  1325.             if (name.len == 0) {
  1326.                 return "zone name is not specified";
  1327.             }

  1329.             size.data = ++p;
  1330.             size.len = value[i].data + value[i].len - p;

  1332.             zone_size = ngx_parse_size(&size);
  1333.             if (zone_size == NGX_ERROR) {
  1334.                 return "invalid zone size";
  1335.             }

  1337.             /* 32k ~ 200 sessions, 1m ~ 8000 sessions */
  1338.             if (zone_size < (ssize_t) (8 * ngx_pagesize)) {
  1339.                 return "zone is too small";
  1340.             }

  1342.         } else if (ngx_strncmp(value[i].data, "timeout=", 8) == 0) {

  1344.             if (timeout != NGX_CONF_UNSET_MSEC) {
  1345.                 return "duplicate timeout";
  1346.             }

  1348.             value[i].data += 8;
  1349.             value[i].len -= 8;

  1351.             timeout = ngx_parse_time(&value[i], 0);
  1352.             if (timeout == (ngx_msec_t) NGX_ERROR || timeout == 0) {
  1353.                 return "invalid timeout";
  1354.             }

  1356.         } else if (ngx_strncmp(value[i].data, "create=", 7) == 0) {

  1358.             if (value[i].data[7] != '$') {
  1359.                 return "missing variable in the \"create\" parameter";
  1360.             }

  1362.             value[i].data += 8;
  1363.             value[i].len -= 8;

  1365.             index = ngx_http_get_variable_index(cf, &value[i]);
  1366.             if (index == NGX_ERROR) {
  1367.                 return NGX_CONF_ERROR;
  1368.             }

  1370.             indexp = ngx_array_push(stcf->create_vars);
  1371.             if (indexp == NULL) {
  1372.                 return NGX_CONF_ERROR;
  1373.             }

  1375.             *indexp = index;

  1377.         } else if (ngx_strncmp(value[i].data, "lookup=", 7) == 0) {

  1379.             if (value[i].data[7] != '$') {
  1380.                 return "missing variable in the \"lookup\" parameter";
  1381.             }

  1383.             value[i].data += 8;
  1384.             value[i].len -= 8;

  1386.             index = ngx_http_get_variable_index(cf, &value[i]);
  1387.             if (index == NGX_ERROR) {
  1388.                 return NGX_CONF_ERROR;
  1389.             }

  1391.             indexp = ngx_array_push(stcf->lookup_vars);
  1392.             if (indexp == NULL) {
  1393.                 return NGX_CONF_ERROR;
  1394.             }

  1396.             *indexp = index;

  1398.         } else if (ngx_strcmp(value[i].data, "header") == 0) {
  1399.             stcf->learn_after_headers = 1;

  1401.         } else {
  1402.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1403.                                "unknown parameter \"%V\"", &value[i]);
  1404.             return NGX_CONF_ERROR;
  1405.         }
  1406.     }

  1408.     if (stcf->lookup_vars->nelts == 0) {
  1409.         return "\"lookup\" parameter is not specified";
  1410.     }

  1412.     if (stcf->create_vars->nelts == 0) {
  1413.         return "\"create\" parameter is not specified";
  1414.     }

  1416.     if (zone_size == 0) {
  1417.         return "\"zone\" parameter is not specified";
  1418.     }

  1420.     if (timeout == NGX_CONF_UNSET_MSEC) {
  1421.         timeout = 600000; /* 10m */
  1422.     }

  1424.     shm_zone = ngx_shared_memory_add(cf, &name, zone_size,
  1425.                                      &ngx_http_upstream_sticky_module);
  1426.     if (shm_zone == NULL) {
  1427.         return NGX_CONF_ERROR;
  1428.     }

  1430.     if (shm_zone->data) {
  1431.         sess = shm_zone->data;

  1433.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  1434.                            "sticky zone \"%V\" is already used in "
  1435.                            "upstream \"%V\"", &name, sess->host);

  1437.         return NGX_CONF_ERROR;
  1438.     }

  1440.     sess = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_sticky_sess_t));
  1441.     if (sess == NULL) {
  1442.         return NGX_CONF_ERROR;
  1443.     }

  1445.     sess->timeout = timeout;
  1446.     sess->host = &us->host;

  1448.     sess->event.data = sess;
  1449.     sess->event.log = &cf->cycle->new_log;
  1450.     sess->event.handler = ngx_http_upstream_sticky_sess_timer_handler;
  1451.     sess->event.cancelable = 1;

  1453.     shm_zone->init = ngx_http_upstream_sticky_sess_init_zone;
  1454.     shm_zone->data = sess;

  1456.     stcf->shm_zone = shm_zone;

  1458.     return NGX_CONF_OK;
  1459. }


  1462. static ngx_int_t
  1463. ‌ngx_http_upstream_sticky_init_worker(ngx_cycle_t *cycle)
  1464. {
  1465.     ngx_msec_t                             wait;
  1466.     ngx_uint_t                             i;
  1467.     ngx_http_upstream_srv_conf_t         **uscfp;
  1468.     ngx_http_upstream_main_conf_t         *umcf;
  1469.     ngx_http_upstream_sticky_sess_t       *sess;
  1470.     ngx_http_upstream_sticky_srv_conf_t   *stcf;

  1472.     if ((ngx_process != NGX_PROCESS_WORKER || ngx_worker != 0)
  1473.         && ngx_process != NGX_PROCESS_SINGLE)
  1474.     {
  1475.         return NGX_OK;
  1476.     }

  1478.     umcf = ngx_http_cycle_get_module_main_conf(cycle, ngx_http_upstream_module);

  1480.     if (umcf == NULL) {
  1481.         return NGX_OK;
  1482.     }

  1484.     uscfp = umcf->upstreams.elts;

  1486.     for (i = 0; i < umcf->upstreams.nelts; i++) {

  1488.         if (uscfp[i]->srv_conf == NULL) {
  1489.             continue;
  1490.         }

  1492.         stcf = ngx_http_conf_upstream_srv_conf(uscfp[i],
  1493.                                                ngx_http_upstream_sticky_module);

  1495.         if (stcf == NULL || stcf->shm_zone == NULL) {
  1496.             continue;
  1497.         }

  1499.         sess = stcf->shm_zone->data;

  1501.         ngx_shmtx_lock(&sess->shpool->mutex);

  1503.         wait = ngx_http_upstream_sticky_sess_expire(sess, 0);

  1505.         ngx_shmtx_unlock(&sess->shpool->mutex);

  1507.         if (wait > 0) {
  1508.             ngx_add_timer(&sess->event, wait);
  1509.         }
  1510.     }

  1512.     return NGX_OK;
  1513. }

One Level Up Top Level