One Level Up Top Level

src/http/modules/ngx_http_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_http.h>


  13. ‌#define NGX_HTTP_LIMIT_CONN_PASSED            1
  14. ‌#define NGX_HTTP_LIMIT_CONN_REJECTED          2
  15. ‌#define NGX_HTTP_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_http_limit_conn_node_t;


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


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


  38. ‌typedef struct {
  39.     ngx_http_limit_conn_shctx_t  *sh;
  40.     ngx_slab_pool_t              *shpool;
  41.     ngx_http_complex_value_t      key;
  42. ‌} ngx_http_limit_conn_ctx_t;


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


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


  59. static ngx_rbtree_node_t *ngx_http_limit_conn_lookup(ngx_rbtree_t *rbtree,
  60.     ngx_str_t *key, uint32_t hash);
  61. static void ngx_http_limit_conn_cleanup(void *data);
  62. static ngx_inline void ngx_http_limit_conn_cleanup_all(ngx_pool_t *pool);
  63. static void ngx_http_limit_conn_cleanup_node(ngx_shm_zone_t *shm_zone,
  64.     ngx_rbtree_node_t *node);

  66. static ngx_int_t ngx_http_limit_conn_status_variable(ngx_http_request_t *r,
  67.     ngx_http_variable_value_t *v, uintptr_t data);
  68. static void *ngx_http_limit_conn_create_conf(ngx_conf_t *cf);
  69. static char *ngx_http_limit_conn_merge_conf(ngx_conf_t *cf, void *parent,
  70.     void *child);
  71. static char *ngx_http_limit_conn_zone(ngx_conf_t *cf, ngx_command_t *cmd,
  72.     void *conf);
  73. static char *ngx_http_limit_conn(ngx_conf_t *cf, ngx_command_t *cmd,
  74.     void *conf);
  75. static ngx_int_t ngx_http_limit_conn_add_variables(ngx_conf_t *cf);
  76. static ngx_int_t ngx_http_limit_conn_init(ngx_conf_t *cf);


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


  88. ‌static ngx_conf_num_bounds_t  ngx_http_limit_conn_status_bounds = {
  89.     ngx_conf_check_num_bounds, 400, 599
  90. };


  93. ‌static ngx_command_t  ngx_http_limit_conn_commands[] = {

  95.     { ngx_string("limit_conn_zone"),
  96.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE2,
  97.       ngx_http_limit_conn_zone,
  98.       0,
  99.       0,
  100.       NULL },

  102.     { ngx_string("limit_conn"),
  103.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE2,
  104.       ngx_http_limit_conn,
  105.       NGX_HTTP_LOC_CONF_OFFSET,
  106.       0,
  107.       NULL },

  109.     { ngx_string("limit_conn_log_level"),
  110.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  111.       ngx_conf_set_enum_slot,
  112.       NGX_HTTP_LOC_CONF_OFFSET,
  113.       offsetof(ngx_http_limit_conn_conf_t, log_level),
  114.       &ngx_http_limit_conn_log_levels },

  116.     { ngx_string("limit_conn_status"),
  117.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  118.       ngx_conf_set_num_slot,
  119.       NGX_HTTP_LOC_CONF_OFFSET,
  120.       offsetof(ngx_http_limit_conn_conf_t, status_code),
  121.       &ngx_http_limit_conn_status_bounds },

  123.     { ngx_string("limit_conn_dry_run"),
  124.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_FLAG,
  125.       ngx_conf_set_flag_slot,
  126.       NGX_HTTP_LOC_CONF_OFFSET,
  127.       offsetof(ngx_http_limit_conn_conf_t, dry_run),
  128.       NULL },

  130.       ngx_null_command
  131. };


  134. ‌static ngx_http_module_t  ngx_http_limit_conn_module_ctx = {
  135.     ngx_http_limit_conn_add_variables,     /* preconfiguration */
  136.     ngx_http_limit_conn_init,              /* postconfiguration */

  138.     NULL,                                  /* create main configuration */
  139.     NULL,                                  /* init main configuration */

  141.     NULL,                                  /* create server configuration */
  142.     NULL,                                  /* merge server configuration */

  144.     ngx_http_limit_conn_create_conf,       /* create location configuration */
  145.     ngx_http_limit_conn_merge_conf         /* merge location configuration */
  146. };


  149. ‌ngx_module_t  ngx_http_limit_conn_module = {
  150.     NGX_MODULE_V1,
  151.     &ngx_http_limit_conn_module_ctx,       /* module context */
  152.     ngx_http_limit_conn_commands,          /* module directives */
  153.     NGX_HTTP_MODULE,                       /* module type */
  154.     NULL,                                  /* init master */
  155.     NULL,                                  /* init module */
  156.     NULL,                                  /* init process */
  157.     NULL,                                  /* init thread */
  158.     NULL,                                  /* exit thread */
  159.     NULL,                                  /* exit process */
  160.     NULL,                                  /* exit master */
  161.     NGX_MODULE_V1_PADDING
  162. };


  165. ‌static ngx_http_variable_t  ngx_http_limit_conn_vars[] = {

  167.     { ngx_string("limit_conn_status"), NULL,
  168.       ngx_http_limit_conn_status_variable, 0, NGX_HTTP_VAR_NOCACHEABLE, 0 },

  170.       ngx_http_null_variable
  171. };


  174. ‌static ngx_str_t  ngx_http_limit_conn_status[] = {
  175.     ngx_string("PASSED"),
  176.     ngx_string("REJECTED"),
  177.     ngx_string("REJECTED_DRY_RUN")
  178. };


  181. static ngx_int_t
  182. ‌ngx_http_limit_conn_handler(ngx_http_request_t *r)
  183. {
  184.     size_t                          n;
  185.     uint32_t                        hash;
  186.     ngx_str_t                       key;
  187.     ngx_uint_t                      i;
  188.     ngx_rbtree_node_t              *node;
  189.     ngx_pool_cleanup_t             *cln;
  190.     ngx_http_limit_conn_ctx_t      *ctx;
  191.     ngx_http_limit_conn_node_t     *lc;
  192.     ngx_http_limit_conn_conf_t     *lccf;
  193.     ngx_http_limit_conn_limit_t    *limits;
  194.     ngx_http_limit_conn_cleanup_t  *lccln;

  196.     if (r->main->limit_conn_status) {
  197.         return NGX_DECLINED;
  198.     }

  200.     lccf = ngx_http_get_module_loc_conf(r, ngx_http_limit_conn_module);
  201.     limits = lccf->limits.elts;

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

  206.         if (ngx_http_complex_value(r, &ctx->key, &key) != NGX_OK) {
  207.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  208.         }

  210.         if (key.len == 0) {
  211.             continue;
  212.         }

  214.         if (key.len > 255) {
  215.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  216.                           "the value of the \"%V\" key "
  217.                           "is more than 255 bytes: \"%V\"",
  218.                           &ctx->key.value, &key);
  219.             continue;
  220.         }

  222.         r->main->limit_conn_status = NGX_HTTP_LIMIT_CONN_PASSED;

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

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

  228.         node = ngx_http_limit_conn_lookup(&ctx->sh->rbtree, &key, hash);

  230.         if (node == NULL) {

  232.             n = offsetof(ngx_rbtree_node_t, color)
  233.                 + offsetof(ngx_http_limit_conn_node_t, data)
  234.                 + key.len;

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

  238.             if (node == NULL) {
  239.                 ngx_shmtx_unlock(&ctx->shpool->mutex);
  240.                 ngx_http_limit_conn_cleanup_all(r->pool);

  242.                 if (lccf->dry_run) {
  243.                     r->main->limit_conn_status =
  244.                                           NGX_HTTP_LIMIT_CONN_REJECTED_DRY_RUN;
  245.                     return NGX_DECLINED;
  246.                 }

  248.                 r->main->limit_conn_status = NGX_HTTP_LIMIT_CONN_REJECTED;

  250.                 return lccf->status_code;
  251.             }

  253.             lc = (ngx_http_limit_conn_node_t *) &node->color;

  255.             node->key = hash;
  256.             lc->len = (u_char) key.len;
  257.             lc->conn = 1;
  258.             ngx_memcpy(lc->data, key.data, key.len);

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

  262.         } else {

  264.             lc = (ngx_http_limit_conn_node_t *) &node->color;

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

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

  270.                 ngx_log_error(lccf->log_level, r->connection->log, 0,
  271.                               "limiting connections%s by zone \"%V\"",
  272.                               lccf->dry_run ? ", dry run," : "",
  273.                               &limits[i].shm_zone->shm.name);

  275.                 ngx_http_limit_conn_cleanup_all(r->pool);

  277.                 if (lccf->dry_run) {
  278.                     r->main->limit_conn_status =
  279.                                           NGX_HTTP_LIMIT_CONN_REJECTED_DRY_RUN;
  280.                     return NGX_DECLINED;
  281.                 }

  283.                 r->main->limit_conn_status = NGX_HTTP_LIMIT_CONN_REJECTED;

  285.                 return lccf->status_code;
  286.             }

  288.             lc->conn++;
  289.         }

  291.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  292.                        "limit conn: %08Xi %d", node->key, lc->conn);

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

  296.         cln = ngx_pool_cleanup_add(r->pool,
  297.                                    sizeof(ngx_http_limit_conn_cleanup_t));
  298.         if (cln == NULL) {
  299.             ngx_http_limit_conn_cleanup_node(limits[i].shm_zone, node);
  300.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  301.         }

  303.         cln->handler = ngx_http_limit_conn_cleanup;
  304.         lccln = cln->data;

  306.         lccln->shm_zone = limits[i].shm_zone;
  307.         lccln->node = node;
  308.     }

  310.     return NGX_DECLINED;
  311. }


  314. static void
  315. ‌ngx_http_limit_conn_rbtree_insert_value(ngx_rbtree_node_t *temp,
  316.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
  317. {
  318.     ngx_rbtree_node_t           **p;
  319.     ngx_http_limit_conn_node_t   *lcn, *lcnt;

  321.     for ( ;; ) {

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

  325.             p = &temp->left;

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

  329.             p = &temp->right;

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

  333.             lcn = (ngx_http_limit_conn_node_t *) &node->color;
  334.             lcnt = (ngx_http_limit_conn_node_t *) &temp->color;

  336.             p = (ngx_memn2cmp(lcn->data, lcnt->data, lcn->len, lcnt->len) < 0)
  337.                 ? &temp->left : &temp->right;
  338.         }

  340.         if (*p == sentinel) {
  341.             break;
  342.         }

  344.         temp = *p;
  345.     }

  347.     *p = node;
  348.     node->parent = temp;
  349.     node->left = sentinel;
  350.     node->right = sentinel;
  351.     ngx_rbt_red(node);
  352. }


  355. static ngx_rbtree_node_t *
  356. ‌ngx_http_limit_conn_lookup(ngx_rbtree_t *rbtree, ngx_str_t *key, uint32_t hash)
  357. {
  358.     ngx_int_t                    rc;
  359.     ngx_rbtree_node_t           *node, *sentinel;
  360.     ngx_http_limit_conn_node_t  *lcn;

  362.     node = rbtree->root;
  363.     sentinel = rbtree->sentinel;

  365.     while (node != sentinel) {

  367.         if (hash < node->key) {
  368.             node = node->left;
  369.             continue;
  370.         }

  372.         if (hash > node->key) {
  373.             node = node->right;
  374.             continue;
  375.         }

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

  379.         lcn = (ngx_http_limit_conn_node_t *) &node->color;

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

  383.         if (rc == 0) {
  384.             return node;
  385.         }

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

  390.     return NULL;
  391. }


  394. static void
  395. ‌ngx_http_limit_conn_cleanup(void *data)
  396. {
  397.     ngx_http_limit_conn_cleanup_t  *lccln = data;

  399.     ngx_rbtree_node_t           *node;
  400.     ngx_http_limit_conn_ctx_t   *ctx;
  401.     ngx_http_limit_conn_node_t  *lc;

  403.     ctx = lccln->shm_zone->data;
  404.     node = lccln->node;
  405.     lc = (ngx_http_limit_conn_node_t *) &node->color;

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

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

  412.     lc->conn--;

  414.     if (lc->conn == 0) {
  415.         ngx_rbtree_delete(&ctx->sh->rbtree, node);
  416.         ngx_slab_free_locked(ctx->shpool, node);
  417.     }

  419.     ngx_shmtx_unlock(&ctx->shpool->mutex);
  420. }


  423. static ngx_inline void
  424. ‌ngx_http_limit_conn_cleanup_all(ngx_pool_t *pool)
  425. {
  426.     ngx_pool_cleanup_t  *cln;

  428.     cln = pool->cleanup;

  430.     while (cln && cln->handler == ngx_http_limit_conn_cleanup) {
  431.         ngx_http_limit_conn_cleanup(cln->data);
  432.         cln = cln->next;
  433.     }

  435.     pool->cleanup = cln;
  436. }


  439. static void
  440. ‌ngx_http_limit_conn_cleanup_node(ngx_shm_zone_t *shm_zone,
  441.     ngx_rbtree_node_t *node)
  442. {
  443.     ngx_http_limit_conn_cleanup_t  lccln;

  445.     lccln.shm_zone = shm_zone;
  446.     lccln.node = node;

  448.     ngx_http_limit_conn_cleanup(&lccln);
  449. }


  452. static ngx_int_t
  453. ‌ngx_http_limit_conn_init_zone(ngx_shm_zone_t *shm_zone, void *data)
  454. {
  455.     ngx_http_limit_conn_ctx_t  *octx = data;

  457.     size_t                      len;
  458.     ngx_http_limit_conn_ctx_t  *ctx;

  460.     ctx = shm_zone->data;

  462.     if (octx) {
  463.         if (ctx->key.value.len != octx->key.value.len
  464.             || ngx_strncmp(ctx->key.value.data, octx->key.value.data,
  465.                            ctx->key.value.len)
  466.                != 0)
  467.         {
  468.             ngx_log_error(NGX_LOG_EMERG, shm_zone->shm.log, 0,
  469.                           "limit_conn_zone \"%V\" uses the \"%V\" key "
  470.                           "while previously it used the \"%V\" key",
  471.                           &shm_zone->shm.name, &ctx->key.value,
  472.                           &octx->key.value);
  473.             return NGX_ERROR;
  474.         }

  476.         ctx->sh = octx->sh;
  477.         ctx->shpool = octx->shpool;

  479.         return NGX_OK;
  480.     }

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

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

  487.         return NGX_OK;
  488.     }

  490.     ctx->sh = ngx_slab_alloc(ctx->shpool, sizeof(ngx_http_limit_conn_shctx_t));
  491.     if (ctx->sh == NULL) {
  492.         return NGX_ERROR;
  493.     }

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

  497.     ngx_rbtree_init(&ctx->sh->rbtree, &ctx->sh->sentinel,
  498.                     ngx_http_limit_conn_rbtree_insert_value);

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

  502.     ctx->shpool->log_ctx = ngx_slab_alloc(ctx->shpool, len);
  503.     if (ctx->shpool->log_ctx == NULL) {
  504.         return NGX_ERROR;
  505.     }

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

  510.     return NGX_OK;
  511. }


  514. static ngx_int_t
  515. ‌ngx_http_limit_conn_status_variable(ngx_http_request_t *r,
  516.     ngx_http_variable_value_t *v, uintptr_t data)
  517. {
  518.     if (r->main->limit_conn_status == 0) {
  519.         v->not_found = 1;
  520.         return NGX_OK;
  521.     }

  523.     v->valid = 1;
  524.     v->no_cacheable = 0;
  525.     v->not_found = 0;
  526.     v->len = ngx_http_limit_conn_status[r->main->limit_conn_status - 1].len;
  527.     v->data = ngx_http_limit_conn_status[r->main->limit_conn_status - 1].data;

  529.     return NGX_OK;
  530. }


  533. static void *
  534. ‌ngx_http_limit_conn_create_conf(ngx_conf_t *cf)
  535. {
  536.     ngx_http_limit_conn_conf_t  *conf;

  538.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_limit_conn_conf_t));
  539.     if (conf == NULL) {
  540.         return NULL;
  541.     }

  543.     /*
  544.      * set by ngx_pcalloc():
  545.      *
  546.      *     conf->limits.elts = NULL;
  547.      */

  549.     conf->log_level = NGX_CONF_UNSET_UINT;
  550.     conf->status_code = NGX_CONF_UNSET_UINT;
  551.     conf->dry_run = NGX_CONF_UNSET;

  553.     return conf;
  554. }


  557. static char *
  558. ‌ngx_http_limit_conn_merge_conf(ngx_conf_t *cf, void *parent, void *child)
  559. {
  560.     ngx_http_limit_conn_conf_t *prev = parent;
  561.     ngx_http_limit_conn_conf_t *conf = child;

  563.     if (conf->limits.elts == NULL) {
  564.         conf->limits = prev->limits;
  565.     }

  567.     ngx_conf_merge_uint_value(conf->log_level, prev->log_level, NGX_LOG_ERR);
  568.     ngx_conf_merge_uint_value(conf->status_code, prev->status_code,
  569.                               NGX_HTTP_SERVICE_UNAVAILABLE);

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

  573.     return NGX_CONF_OK;
  574. }


  577. static char *
  578. ‌ngx_http_limit_conn_zone(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  579. {
  580.     u_char                            *p;
  581.     ssize_t                            size;
  582.     ngx_str_t                         *value, name, s;
  583.     ngx_uint_t                         i;
  584.     ngx_shm_zone_t                    *shm_zone;
  585.     ngx_http_limit_conn_ctx_t         *ctx;
  586.     ngx_http_compile_complex_value_t   ccv;

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

  590.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_limit_conn_ctx_t));
  591.     if (ctx == NULL) {
  592.         return NGX_CONF_ERROR;
  593.     }

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

  597.     ccv.cf = cf;
  598.     ccv.value = &value[1];
  599.     ccv.complex_value = &ctx->key;

  601.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  602.         return NGX_CONF_ERROR;
  603.     }

  605.     size = 0;
  606.     name.len = 0;

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

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

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

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

  616.             if (p == NULL) {
  617.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  618.                                    "invalid zone size \"%V\"", &value[i]);
  619.                 return NGX_CONF_ERROR;
  620.             }

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

  624.             s.data = p + 1;
  625.             s.len = value[i].data + value[i].len - s.data;

  627.             size = ngx_parse_size(&s);

  629.             if (size == NGX_ERROR) {
  630.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  631.                                    "invalid zone size \"%V\"", &value[i]);
  632.                 return NGX_CONF_ERROR;
  633.             }

  635.             if (size < (ssize_t) (8 * ngx_pagesize)) {
  636.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  637.                                    "zone \"%V\" is too small", &value[i]);
  638.                 return NGX_CONF_ERROR;
  639.             }

  641.             continue;
  642.         }

  644.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  645.                            "invalid parameter \"%V\"", &value[i]);
  646.         return NGX_CONF_ERROR;
  647.     }

  649.     if (name.len == 0) {
  650.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  651.                            "\"%V\" must have \"zone\" parameter",
  652.                            &cmd->name);
  653.         return NGX_CONF_ERROR;
  654.     }

  656.     shm_zone = ngx_shared_memory_add(cf, &name, size,
  657.                                      &ngx_http_limit_conn_module);
  658.     if (shm_zone == NULL) {
  659.         return NGX_CONF_ERROR;
  660.     }

  662.     if (shm_zone->data) {
  663.         ctx = shm_zone->data;

  665.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  666.                            "%V \"%V\" is already bound to key \"%V\"",
  667.                            &cmd->name, &name, &ctx->key.value);
  668.         return NGX_CONF_ERROR;
  669.     }

  671.     shm_zone->init = ngx_http_limit_conn_init_zone;
  672.     shm_zone->data = ctx;

  674.     return NGX_CONF_OK;
  675. }


  678. static char *
  679. ‌ngx_http_limit_conn(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  680. {
  681.     ngx_shm_zone_t               *shm_zone;
  682.     ngx_http_limit_conn_conf_t   *lccf = conf;
  683.     ngx_http_limit_conn_limit_t  *limit, *limits;

  685.     ngx_str_t  *value;
  686.     ngx_int_t   n;
  687.     ngx_uint_t  i;

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

  691.     shm_zone = ngx_shared_memory_add(cf, &value[1], 0,
  692.                                      &ngx_http_limit_conn_module);
  693.     if (shm_zone == NULL) {
  694.         return NGX_CONF_ERROR;
  695.     }

  697.     limits = lccf->limits.elts;

  699.     if (limits == NULL) {
  700.         if (ngx_array_init(&lccf->limits, cf->pool, 1,
  701.                            sizeof(ngx_http_limit_conn_limit_t))
  702.             != NGX_OK)
  703.         {
  704.             return NGX_CONF_ERROR;
  705.         }
  706.     }

  708.     for (i = 0; i < lccf->limits.nelts; i++) {
  709.         if (shm_zone == limits[i].shm_zone) {
  710.             return "is duplicate";
  711.         }
  712.     }

  714.     n = ngx_atoi(value[2].data, value[2].len);
  715.     if (n <= 0) {
  716.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  717.                            "invalid number of connections \"%V\"", &value[2]);
  718.         return NGX_CONF_ERROR;
  719.     }

  721.     if (n > 65535) {
  722.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  723.                            "connection limit must be less 65536");
  724.         return NGX_CONF_ERROR;
  725.     }

  727.     limit = ngx_array_push(&lccf->limits);
  728.     if (limit == NULL) {
  729.         return NGX_CONF_ERROR;
  730.     }

  732.     limit->conn = n;
  733.     limit->shm_zone = shm_zone;

  735.     return NGX_CONF_OK;
  736. }


  739. static ngx_int_t
  740. ‌ngx_http_limit_conn_add_variables(ngx_conf_t *cf)
  741. {
  742.     ngx_http_variable_t  *var, *v;

  744.     for (v = ngx_http_limit_conn_vars; v->name.len; v++) {
  745.         var = ngx_http_add_variable(cf, &v->name, v->flags);
  746.         if (var == NULL) {
  747.             return NGX_ERROR;
  748.         }

  750.         var->get_handler = v->get_handler;
  751.         var->data = v->data;
  752.     }

  754.     return NGX_OK;
  755. }


  758. static ngx_int_t
  759. ‌ngx_http_limit_conn_init(ngx_conf_t *cf)
  760. {
  761.     ngx_http_handler_pt        *h;
  762.     ngx_http_core_main_conf_t  *cmcf;

  764.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  766.     h = ngx_array_push(&cmcf->phases[NGX_HTTP_PREACCESS_PHASE].handlers);
  767.     if (h == NULL) {
  768.         return NGX_ERROR;
  769.     }

  771.     *h = ngx_http_limit_conn_handler;

  773.     return NGX_OK;
  774. }

One Level Up Top Level