One Level Up Top Level

src/stream/ngx_stream_limit_conn_module.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


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


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


  13. ‌#define NGX_STREAM_LIMIT_CONN_PASSED            1
  14. ‌#define NGX_STREAM_LIMIT_CONN_REJECTED          2
  15. ‌#define NGX_STREAM_LIMIT_CONN_REJECTED_DRY_RUN  3


  18. ‌typedef struct {
  19.     u_char                          color;
  20.     u_char                          len;
  21.     u_short                         conn;
  22.     u_char                          data[1];
  23. ‌} ngx_stream_limit_conn_node_t;


  26. ‌typedef struct {
  27.     ngx_shm_zone_t                 *shm_zone;
  28.     ngx_rbtree_node_t              *node;
  29. ‌} ngx_stream_limit_conn_cleanup_t;


  32. ‌typedef struct {
  33.     ngx_rbtree_t                    rbtree;
  34.     ngx_rbtree_node_t               sentinel;
  35. ‌} ngx_stream_limit_conn_shctx_t;


  38. ‌typedef struct {
  39.     ngx_stream_limit_conn_shctx_t  *sh;
  40.     ngx_slab_pool_t                *shpool;
  41.     ngx_stream_complex_value_t      key;
  42. ‌} ngx_stream_limit_conn_ctx_t;


  45. ‌typedef struct {
  46.     ngx_shm_zone_t                 *shm_zone;
  47.     ngx_uint_t                      conn;
  48. ‌} ngx_stream_limit_conn_limit_t;


  51. ‌typedef struct {
  52.     ngx_array_t                     limits;
  53.     ngx_uint_t                      log_level;
  54.     ngx_flag_t                      dry_run;
  55. ‌} ngx_stream_limit_conn_conf_t;


  58. static ngx_rbtree_node_t *ngx_stream_limit_conn_lookup(ngx_rbtree_t *rbtree,
  59.     ngx_str_t *key, uint32_t hash);
  60. static void ngx_stream_limit_conn_cleanup(void *data);
  61. static ngx_inline void ngx_stream_limit_conn_cleanup_all(ngx_pool_t *pool);
  62. static void ngx_stream_limit_conn_cleanup_node(ngx_shm_zone_t *shm_zone,
  63.     ngx_rbtree_node_t *node);

  65. static ngx_int_t ngx_stream_limit_conn_status_variable(ngx_stream_session_t *s,
  66.     ngx_stream_variable_value_t *v, uintptr_t data);
  67. static void *ngx_stream_limit_conn_create_conf(ngx_conf_t *cf);
  68. static char *ngx_stream_limit_conn_merge_conf(ngx_conf_t *cf, void *parent,
  69.     void *child);
  70. static char *ngx_stream_limit_conn_zone(ngx_conf_t *cf, ngx_command_t *cmd,
  71.     void *conf);
  72. static char *ngx_stream_limit_conn(ngx_conf_t *cf, ngx_command_t *cmd,
  73.     void *conf);
  74. static ngx_int_t ngx_stream_limit_conn_add_variables(ngx_conf_t *cf);
  75. static ngx_int_t ngx_stream_limit_conn_init(ngx_conf_t *cf);


  78. ‌static ngx_conf_enum_t  ngx_stream_limit_conn_log_levels[] = {
  79.     { ngx_string("info"), NGX_LOG_INFO },
  80.     { ngx_string("notice"), NGX_LOG_NOTICE },
  81.     { ngx_string("warn"), NGX_LOG_WARN },
  82.     { ngx_string("error"), NGX_LOG_ERR },
  83.     { ngx_null_string, 0 }
  84. };


  87. ‌static ngx_command_t  ngx_stream_limit_conn_commands[] = {

  89.     { ngx_string("limit_conn_zone"),
  90.       NGX_STREAM_MAIN_CONF|NGX_CONF_TAKE2,
  91.       ngx_stream_limit_conn_zone,
  92.       0,
  93.       0,
  94.       NULL },

  96.     { ngx_string("limit_conn"),
  97.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE2,
  98.       ngx_stream_limit_conn,
  99.       NGX_STREAM_SRV_CONF_OFFSET,
  100.       0,
  101.       NULL },

  103.     { ngx_string("limit_conn_log_level"),
  104.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_TAKE1,
  105.       ngx_conf_set_enum_slot,
  106.       NGX_STREAM_SRV_CONF_OFFSET,
  107.       offsetof(ngx_stream_limit_conn_conf_t, log_level),
  108.       &ngx_stream_limit_conn_log_levels },

  110.     { ngx_string("limit_conn_dry_run"),
  111.       NGX_STREAM_MAIN_CONF|NGX_STREAM_SRV_CONF|NGX_CONF_FLAG,
  112.       ngx_conf_set_flag_slot,
  113.       NGX_STREAM_SRV_CONF_OFFSET,
  114.       offsetof(ngx_stream_limit_conn_conf_t, dry_run),
  115.       NULL },

  117.       ngx_null_command
  118. };


  121. ‌static ngx_stream_module_t  ngx_stream_limit_conn_module_ctx = {
  122.     ngx_stream_limit_conn_add_variables,   /* preconfiguration */
  123.     ngx_stream_limit_conn_init,            /* postconfiguration */

  125.     NULL,                                  /* create main configuration */
  126.     NULL,                                  /* init main configuration */

  128.     ngx_stream_limit_conn_create_conf,     /* create server configuration */
  129.     ngx_stream_limit_conn_merge_conf       /* merge server configuration */
  130. };


  133. ‌ngx_module_t  ngx_stream_limit_conn_module = {
  134.     NGX_MODULE_V1,
  135.     &ngx_stream_limit_conn_module_ctx,     /* module context */
  136.     ngx_stream_limit_conn_commands,        /* module directives */
  137.     NGX_STREAM_MODULE,                     /* module type */
  138.     NULL,                                  /* init master */
  139.     NULL,                                  /* init module */
  140.     NULL,                                  /* init process */
  141.     NULL,                                  /* init thread */
  142.     NULL,                                  /* exit thread */
  143.     NULL,                                  /* exit process */
  144.     NULL,                                  /* exit master */
  145.     NGX_MODULE_V1_PADDING
  146. };


  149. ‌static ngx_stream_variable_t  ngx_stream_limit_conn_vars[] = {

  151.     { ngx_string("limit_conn_status"), NULL,
  152.       ngx_stream_limit_conn_status_variable, 0, NGX_STREAM_VAR_NOCACHEABLE, 0 },

  154.       ngx_stream_null_variable
  155. };


  158. ‌static ngx_str_t  ngx_stream_limit_conn_status[] = {
  159.     ngx_string("PASSED"),
  160.     ngx_string("REJECTED"),
  161.     ngx_string("REJECTED_DRY_RUN")
  162. };


  165. static ngx_int_t
  166. ‌ngx_stream_limit_conn_handler(ngx_stream_session_t *s)
  167. {
  168.     size_t                            n;
  169.     uint32_t                          hash;
  170.     ngx_str_t                         key;
  171.     ngx_uint_t                        i;
  172.     ngx_rbtree_node_t                *node;
  173.     ngx_pool_cleanup_t               *cln;
  174.     ngx_stream_limit_conn_ctx_t      *ctx;
  175.     ngx_stream_limit_conn_node_t     *lc;
  176.     ngx_stream_limit_conn_conf_t     *lccf;
  177.     ngx_stream_limit_conn_limit_t    *limits;
  178.     ngx_stream_limit_conn_cleanup_t  *lccln;

  180.     lccf = ngx_stream_get_module_srv_conf(s, ngx_stream_limit_conn_module);
  181.     limits = lccf->limits.elts;

  183.     for (i = 0; i < lccf->limits.nelts; i++) {
  184.         ctx = limits[i].shm_zone->data;

  186.         if (ngx_stream_complex_value(s, &ctx->key, &key) != NGX_OK) {
  187.             return NGX_ERROR;
  188.         }

  190.         if (key.len == 0) {
  191.             continue;
  192.         }

  194.         if (key.len > 255) {
  195.             ngx_log_error(NGX_LOG_ERR, s->connection->log, 0,
  196.                           "the value of the \"%V\" key "
  197.                           "is more than 255 bytes: \"%V\"",
  198.                           &ctx->key.value, &key);
  199.             continue;
  200.         }

  202.         s->limit_conn_status = NGX_STREAM_LIMIT_CONN_PASSED;

  204.         hash = ngx_crc32_short(key.data, key.len);

  206.         ngx_shmtx_lock(&ctx->shpool->mutex);

  208.         node = ngx_stream_limit_conn_lookup(&ctx->sh->rbtree, &key, hash);

  210.         if (node == NULL) {

  212.             n = offsetof(ngx_rbtree_node_t, color)
  213.                 + offsetof(ngx_stream_limit_conn_node_t, data)
  214.                 + key.len;

  216.             node = ngx_slab_alloc_locked(ctx->shpool, n);

  218.             if (node == NULL) {
  219.                 ngx_shmtx_unlock(&ctx->shpool->mutex);
  220.                 ngx_stream_limit_conn_cleanup_all(s->connection->pool);

  222.                 if (lccf->dry_run) {
  223.                     s->limit_conn_status =
  224.                                         NGX_STREAM_LIMIT_CONN_REJECTED_DRY_RUN;
  225.                     return NGX_DECLINED;
  226.                 }

  228.                 s->limit_conn_status = NGX_STREAM_LIMIT_CONN_REJECTED;

  230.                 return NGX_STREAM_SERVICE_UNAVAILABLE;
  231.             }

  233.             lc = (ngx_stream_limit_conn_node_t *) &node->color;

  235.             node->key = hash;
  236.             lc->len = (u_char) key.len;
  237.             lc->conn = 1;
  238.             ngx_memcpy(lc->data, key.data, key.len);

  240.             ngx_rbtree_insert(&ctx->sh->rbtree, node);

  242.         } else {

  244.             lc = (ngx_stream_limit_conn_node_t *) &node->color;

  246.             if ((ngx_uint_t) lc->conn >= limits[i].conn) {

  248.                 ngx_shmtx_unlock(&ctx->shpool->mutex);

  250.                 ngx_log_error(lccf->log_level, s->connection->log, 0,
  251.                               "limiting connections%s by zone \"%V\"",
  252.                               lccf->dry_run ? ", dry run," : "",
  253.                               &limits[i].shm_zone->shm.name);

  255.                 ngx_stream_limit_conn_cleanup_all(s->connection->pool);

  257.                 if (lccf->dry_run) {
  258.                     s->limit_conn_status =
  259.                                         NGX_STREAM_LIMIT_CONN_REJECTED_DRY_RUN;
  260.                     return NGX_DECLINED;
  261.                 }

  263.                 s->limit_conn_status = NGX_STREAM_LIMIT_CONN_REJECTED;

  265.                 return NGX_STREAM_SERVICE_UNAVAILABLE;
  266.             }

  268.             lc->conn++;
  269.         }

  271.         ngx_log_debug2(NGX_LOG_DEBUG_STREAM, s->connection->log, 0,
  272.                        "limit conn: %08Xi %d", node->key, lc->conn);

  274.         ngx_shmtx_unlock(&ctx->shpool->mutex);

  276.         cln = ngx_pool_cleanup_add(s->connection->pool,
  277.                                    sizeof(ngx_stream_limit_conn_cleanup_t));
  278.         if (cln == NULL) {
  279.             ngx_stream_limit_conn_cleanup_node(limits[i].shm_zone, node);
  280.             return NGX_ERROR;
  281.         }

  283.         cln->handler = ngx_stream_limit_conn_cleanup;
  284.         lccln = cln->data;

  286.         lccln->shm_zone = limits[i].shm_zone;
  287.         lccln->node = node;
  288.     }

  290.     return NGX_DECLINED;
  291. }


  294. static void
  295. ‌ngx_stream_limit_conn_rbtree_insert_value(ngx_rbtree_node_t *temp,
  296.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
  297. {
  298.     ngx_rbtree_node_t             **p;
  299.     ngx_stream_limit_conn_node_t   *lcn, *lcnt;

  301.     for ( ;; ) {

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

  305.             p = &temp->left;

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

  309.             p = &temp->right;

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

  313.             lcn = (ngx_stream_limit_conn_node_t *) &node->color;
  314.             lcnt = (ngx_stream_limit_conn_node_t *) &temp->color;

  316.             p = (ngx_memn2cmp(lcn->data, lcnt->data, lcn->len, lcnt->len) < 0)
  317.                 ? &temp->left : &temp->right;
  318.         }

  320.         if (*p == sentinel) {
  321.             break;
  322.         }

  324.         temp = *p;
  325.     }

  327.     *p = node;
  328.     node->parent = temp;
  329.     node->left = sentinel;
  330.     node->right = sentinel;
  331.     ngx_rbt_red(node);
  332. }


  335. static ngx_rbtree_node_t *
  336. ‌ngx_stream_limit_conn_lookup(ngx_rbtree_t *rbtree, ngx_str_t *key,
  337.     uint32_t hash)
  338. {
  339.     ngx_int_t                      rc;
  340.     ngx_rbtree_node_t             *node, *sentinel;
  341.     ngx_stream_limit_conn_node_t  *lcn;

  343.     node = rbtree->root;
  344.     sentinel = rbtree->sentinel;

  346.     while (node != sentinel) {

  348.         if (hash < node->key) {
  349.             node = node->left;
  350.             continue;
  351.         }

  353.         if (hash > node->key) {
  354.             node = node->right;
  355.             continue;
  356.         }

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

  360.         lcn = (ngx_stream_limit_conn_node_t *) &node->color;

  362.         rc = ngx_memn2cmp(key->data, lcn->data, key->len, (size_t) lcn->len);

  364.         if (rc == 0) {
  365.             return node;
  366.         }

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

  371.     return NULL;
  372. }


  375. static void
  376. ‌ngx_stream_limit_conn_cleanup(void *data)
  377. {
  378.     ngx_stream_limit_conn_cleanup_t  *lccln = data;

  380.     ngx_rbtree_node_t             *node;
  381.     ngx_stream_limit_conn_ctx_t   *ctx;
  382.     ngx_stream_limit_conn_node_t  *lc;

  384.     ctx = lccln->shm_zone->data;
  385.     node = lccln->node;
  386.     lc = (ngx_stream_limit_conn_node_t *) &node->color;

  388.     ngx_shmtx_lock(&ctx->shpool->mutex);

  390.     ngx_log_debug2(NGX_LOG_DEBUG_STREAM, lccln->shm_zone->shm.log, 0,
  391.                    "limit conn cleanup: %08Xi %d", node->key, lc->conn);

  393.     lc->conn--;

  395.     if (lc->conn == 0) {
  396.         ngx_rbtree_delete(&ctx->sh->rbtree, node);
  397.         ngx_slab_free_locked(ctx->shpool, node);
  398.     }

  400.     ngx_shmtx_unlock(&ctx->shpool->mutex);
  401. }


  404. static ngx_inline void
  405. ‌ngx_stream_limit_conn_cleanup_all(ngx_pool_t *pool)
  406. {
  407.     ngx_pool_cleanup_t  *cln;

  409.     cln = pool->cleanup;

  411.     while (cln && cln->handler == ngx_stream_limit_conn_cleanup) {
  412.         ngx_stream_limit_conn_cleanup(cln->data);
  413.         cln = cln->next;
  414.     }

  416.     pool->cleanup = cln;
  417. }


  420. static void
  421. ‌ngx_stream_limit_conn_cleanup_node(ngx_shm_zone_t *shm_zone,
  422.     ngx_rbtree_node_t *node)
  423. {
  424.     ngx_stream_limit_conn_cleanup_t  lccln;

  426.     lccln.shm_zone = shm_zone;
  427.     lccln.node = node;

  429.     ngx_stream_limit_conn_cleanup(&lccln);
  430. }


  433. static ngx_int_t
  434. ‌ngx_stream_limit_conn_init_zone(ngx_shm_zone_t *shm_zone, void *data)
  435. {
  436.     ngx_stream_limit_conn_ctx_t  *octx = data;

  438.     size_t                        len;
  439.     ngx_stream_limit_conn_ctx_t  *ctx;

  441.     ctx = shm_zone->data;

  443.     if (octx) {
  444.         if (ctx->key.value.len != octx->key.value.len
  445.             || ngx_strncmp(ctx->key.value.data, octx->key.value.data,
  446.                            ctx->key.value.len)
  447.                != 0)
  448.         {
  449.             ngx_log_error(NGX_LOG_EMERG, shm_zone->shm.log, 0,
  450.                           "limit_conn_zone \"%V\" uses the \"%V\" key "
  451.                           "while previously it used the \"%V\" key",
  452.                           &shm_zone->shm.name, &ctx->key.value,
  453.                           &octx->key.value);
  454.             return NGX_ERROR;
  455.         }

  457.         ctx->sh = octx->sh;
  458.         ctx->shpool = octx->shpool;

  460.         return NGX_OK;
  461.     }

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

  465.     if (shm_zone->shm.exists) {
  466.         ctx->sh = ctx->shpool->data;

  468.         return NGX_OK;
  469.     }

  471.     ctx->sh = ngx_slab_alloc(ctx->shpool,
  472.                              sizeof(ngx_stream_limit_conn_shctx_t));
  473.     if (ctx->sh == NULL) {
  474.         return NGX_ERROR;
  475.     }

  477.     ctx->shpool->data = ctx->sh;

  479.     ngx_rbtree_init(&ctx->sh->rbtree, &ctx->sh->sentinel,
  480.                     ngx_stream_limit_conn_rbtree_insert_value);

  482.     len = sizeof(" in limit_conn_zone \"\"") + shm_zone->shm.name.len;

  484.     ctx->shpool->log_ctx = ngx_slab_alloc(ctx->shpool, len);
  485.     if (ctx->shpool->log_ctx == NULL) {
  486.         return NGX_ERROR;
  487.     }

  489.     ngx_sprintf(ctx->shpool->log_ctx, " in limit_conn_zone \"%V\"%Z",
  490.                 &shm_zone->shm.name);

  492.     return NGX_OK;
  493. }


  496. static ngx_int_t
  497. ‌ngx_stream_limit_conn_status_variable(ngx_stream_session_t *s,
  498.     ngx_stream_variable_value_t *v, uintptr_t data)
  499. {
  500.     if (s->limit_conn_status == 0) {
  501.         v->not_found = 1;
  502.         return NGX_OK;
  503.     }

  505.     v->valid = 1;
  506.     v->no_cacheable = 0;
  507.     v->not_found = 0;
  508.     v->len = ngx_stream_limit_conn_status[s->limit_conn_status - 1].len;
  509.     v->data = ngx_stream_limit_conn_status[s->limit_conn_status - 1].data;

  511.     return NGX_OK;
  512. }


  515. static void *
  516. ‌ngx_stream_limit_conn_create_conf(ngx_conf_t *cf)
  517. {
  518.     ngx_stream_limit_conn_conf_t  *conf;

  520.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_limit_conn_conf_t));
  521.     if (conf == NULL) {
  522.         return NULL;
  523.     }

  525.     /*
  526.      * set by ngx_pcalloc():
  527.      *
  528.      *     conf->limits.elts = NULL;
  529.      */

  531.     conf->log_level = NGX_CONF_UNSET_UINT;
  532.     conf->dry_run = NGX_CONF_UNSET;

  534.     return conf;
  535. }


  538. static char *
  539. ‌ngx_stream_limit_conn_merge_conf(ngx_conf_t *cf, void *parent, void *child)
  540. {
  541.     ngx_stream_limit_conn_conf_t *prev = parent;
  542.     ngx_stream_limit_conn_conf_t *conf = child;

  544.     if (conf->limits.elts == NULL) {
  545.         conf->limits = prev->limits;
  546.     }

  548.     ngx_conf_merge_uint_value(conf->log_level, prev->log_level, NGX_LOG_ERR);

  550.     ngx_conf_merge_value(conf->dry_run, prev->dry_run, 0);

  552.     return NGX_CONF_OK;
  553. }


  556. static char *
  557. ‌ngx_stream_limit_conn_zone(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  558. {
  559.     u_char                              *p;
  560.     ssize_t                              size;
  561.     ngx_str_t                           *value, name, s;
  562.     ngx_uint_t                           i;
  563.     ngx_shm_zone_t                      *shm_zone;
  564.     ngx_stream_limit_conn_ctx_t         *ctx;
  565.     ngx_stream_compile_complex_value_t   ccv;

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

  569.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_stream_limit_conn_ctx_t));
  570.     if (ctx == NULL) {
  571.         return NGX_CONF_ERROR;
  572.     }

  574.     ngx_memzero(&ccv, sizeof(ngx_stream_compile_complex_value_t));

  576.     ccv.cf = cf;
  577.     ccv.value = &value[1];
  578.     ccv.complex_value = &ctx->key;

  580.     if (ngx_stream_compile_complex_value(&ccv) != NGX_OK) {
  581.         return NGX_CONF_ERROR;
  582.     }

  584.     size = 0;
  585.     name.len = 0;

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

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

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

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

  595.             if (p == NULL) {
  596.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  597.                                    "invalid zone size \"%V\"", &value[i]);
  598.                 return NGX_CONF_ERROR;
  599.             }

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

  603.             s.data = p + 1;
  604.             s.len = value[i].data + value[i].len - s.data;

  606.             size = ngx_parse_size(&s);

  608.             if (size == NGX_ERROR) {
  609.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  610.                                    "invalid zone size \"%V\"", &value[i]);
  611.                 return NGX_CONF_ERROR;
  612.             }

  614.             if (size < (ssize_t) (8 * ngx_pagesize)) {
  615.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  616.                                    "zone \"%V\" is too small", &value[i]);
  617.                 return NGX_CONF_ERROR;
  618.             }

  620.             continue;
  621.         }

  623.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  624.                            "invalid parameter \"%V\"", &value[i]);
  625.         return NGX_CONF_ERROR;
  626.     }

  628.     if (name.len == 0) {
  629.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  630.                            "\"%V\" must have \"zone\" parameter",
  631.                            &cmd->name);
  632.         return NGX_CONF_ERROR;
  633.     }

  635.     shm_zone = ngx_shared_memory_add(cf, &name, size,
  636.                                      &ngx_stream_limit_conn_module);
  637.     if (shm_zone == NULL) {
  638.         return NGX_CONF_ERROR;
  639.     }

  641.     if (shm_zone->data) {
  642.         ctx = shm_zone->data;

  644.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  645.                            "%V \"%V\" is already bound to key \"%V\"",
  646.                            &cmd->name, &name, &ctx->key.value);
  647.         return NGX_CONF_ERROR;
  648.     }

  650.     shm_zone->init = ngx_stream_limit_conn_init_zone;
  651.     shm_zone->data = ctx;

  653.     return NGX_CONF_OK;
  654. }


  657. static char *
  658. ‌ngx_stream_limit_conn(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  659. {
  660.     ngx_shm_zone_t                 *shm_zone;
  661.     ngx_stream_limit_conn_conf_t   *lccf = conf;
  662.     ngx_stream_limit_conn_limit_t  *limit, *limits;

  664.     ngx_str_t   *value;
  665.     ngx_int_t    n;
  666.     ngx_uint_t   i;

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

  670.     shm_zone = ngx_shared_memory_add(cf, &value[1], 0,
  671.                                      &ngx_stream_limit_conn_module);
  672.     if (shm_zone == NULL) {
  673.         return NGX_CONF_ERROR;
  674.     }

  676.     limits = lccf->limits.elts;

  678.     if (limits == NULL) {
  679.         if (ngx_array_init(&lccf->limits, cf->pool, 1,
  680.                            sizeof(ngx_stream_limit_conn_limit_t))
  681.             != NGX_OK)
  682.         {
  683.             return NGX_CONF_ERROR;
  684.         }
  685.     }

  687.     for (i = 0; i < lccf->limits.nelts; i++) {
  688.         if (shm_zone == limits[i].shm_zone) {
  689.             return "is duplicate";
  690.         }
  691.     }

  693.     n = ngx_atoi(value[2].data, value[2].len);
  694.     if (n <= 0) {
  695.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  696.                            "invalid number of connections \"%V\"", &value[2]);
  697.         return NGX_CONF_ERROR;
  698.     }

  700.     if (n > 65535) {
  701.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  702.                            "connection limit must be less 65536");
  703.         return NGX_CONF_ERROR;
  704.     }

  706.     limit = ngx_array_push(&lccf->limits);
  707.     if (limit == NULL) {
  708.         return NGX_CONF_ERROR;
  709.     }

  711.     limit->conn = n;
  712.     limit->shm_zone = shm_zone;

  714.     return NGX_CONF_OK;
  715. }


  718. static ngx_int_t
  719. ‌ngx_stream_limit_conn_add_variables(ngx_conf_t *cf)
  720. {
  721.     ngx_stream_variable_t  *var, *v;

  723.     for (v = ngx_stream_limit_conn_vars; v->name.len; v++) {
  724.         var = ngx_stream_add_variable(cf, &v->name, v->flags);
  725.         if (var == NULL) {
  726.             return NGX_ERROR;
  727.         }

  729.         var->get_handler = v->get_handler;
  730.         var->data = v->data;
  731.     }

  733.     return NGX_OK;
  734. }


  737. static ngx_int_t
  738. ‌ngx_stream_limit_conn_init(ngx_conf_t *cf)
  739. {
  740.     ngx_stream_handler_pt        *h;
  741.     ngx_stream_core_main_conf_t  *cmcf;

  743.     cmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_core_module);

  745.     h = ngx_array_push(&cmcf->phases[NGX_STREAM_PREACCESS_PHASE].handlers);
  746.     if (h == NULL) {
  747.         return NGX_ERROR;
  748.     }

  750.     *h = ngx_stream_limit_conn_handler;

  752.     return NGX_OK;
  753. }

One Level Up Top Level