One Level Up Top Level

src/http/modules/ngx_http_limit_req_module.c - nginx-1.7.10

Global variables defined

Data types defined

Functions 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. typedef struct {
  14.     u_char                       color;
  15.     u_char                       dummy;
  16.     u_short                      len;
  17.     ngx_queue_t                  queue;
  18.     ngx_msec_t                   last;
  19.     /* integer value, 1 corresponds to 0.001 r/s */
  20.     ngx_uint_t                   excess;
  21.     ngx_uint_t                   count;
  22.     u_char                       data[1];
  23. ‌} ngx_http_limit_req_node_t;


  26. typedef struct {
  27.     ngx_rbtree_t                  rbtree;
  28.     ngx_rbtree_node_t             sentinel;
  29.     ngx_queue_t                   queue;
  30. ‌} ngx_http_limit_req_shctx_t;


  33. typedef struct {
  34.     ngx_http_limit_req_shctx_t  *sh;
  35.     ngx_slab_pool_t             *shpool;
  36.     /* integer value, 1 corresponds to 0.001 r/s */
  37.     ngx_uint_t                   rate;
  38.     ngx_http_complex_value_t     key;
  39.     ngx_http_limit_req_node_t   *node;
  40. ‌} ngx_http_limit_req_ctx_t;


  43. typedef struct {
  44.     ngx_shm_zone_t              *shm_zone;
  45.     /* integer value, 1 corresponds to 0.001 r/s */
  46.     ngx_uint_t                   burst;
  47.     ngx_uint_t                   nodelay; /* unsigned  nodelay:1 */
  48. ‌} ngx_http_limit_req_limit_t;


  51. typedef struct {
  52.     ngx_array_t                  limits;
  53.     ngx_uint_t                   limit_log_level;
  54.     ngx_uint_t                   delay_log_level;
  55.     ngx_uint_t                   status_code;
  56. ‌} ngx_http_limit_req_conf_t;


  59. static void ngx_http_limit_req_delay(ngx_http_request_t *r);
  60. static ngx_int_t ngx_http_limit_req_lookup(ngx_http_limit_req_limit_t *limit,
  61.     ngx_uint_t hash, ngx_str_t *key, ngx_uint_t *ep, ngx_uint_t account);
  62. static ngx_msec_t ngx_http_limit_req_account(ngx_http_limit_req_limit_t *limits,
  63.     ngx_uint_t n, ngx_uint_t *ep, ngx_http_limit_req_limit_t **limit);
  64. static void ngx_http_limit_req_expire(ngx_http_limit_req_ctx_t *ctx,
  65.     ngx_uint_t n);

  67. static void *ngx_http_limit_req_create_conf(ngx_conf_t *cf);
  68. static char *ngx_http_limit_req_merge_conf(ngx_conf_t *cf, void *parent,
  69.     void *child);
  70. static char *ngx_http_limit_req_zone(ngx_conf_t *cf, ngx_command_t *cmd,
  71.     void *conf);
  72. static char *ngx_http_limit_req(ngx_conf_t *cf, ngx_command_t *cmd,
  73.     void *conf);
  74. static ngx_int_t ngx_http_limit_req_init(ngx_conf_t *cf);


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


  86. ‌static ngx_conf_num_bounds_t  ngx_http_limit_req_status_bounds = {
  87.     ngx_conf_check_num_bounds, 400, 599
  88. };


  91. ‌static ngx_command_t  ngx_http_limit_req_commands[] = {

  93.     { ngx_string("limit_req_zone"),
  94.       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE3,
  95.       ngx_http_limit_req_zone,
  96.       0,
  97.       0,
  98.       NULL },

  100.     { ngx_string("limit_req"),
  101.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE123,
  102.       ngx_http_limit_req,
  103.       NGX_HTTP_LOC_CONF_OFFSET,
  104.       0,
  105.       NULL },

  107.     { ngx_string("limit_req_log_level"),
  108.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  109.       ngx_conf_set_enum_slot,
  110.       NGX_HTTP_LOC_CONF_OFFSET,
  111.       offsetof(ngx_http_limit_req_conf_t, limit_log_level),
  112.       &ngx_http_limit_req_log_levels },

  114.     { ngx_string("limit_req_status"),
  115.       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  116.       ngx_conf_set_num_slot,
  117.       NGX_HTTP_LOC_CONF_OFFSET,
  118.       offsetof(ngx_http_limit_req_conf_t, status_code),
  119.       &ngx_http_limit_req_status_bounds },

  121.       ngx_null_command
  122. };


  125. ‌static ngx_http_module_t  ngx_http_limit_req_module_ctx = {
  126.     NULL,                                  /* preconfiguration */
  127.     ngx_http_limit_req_init,               /* postconfiguration */

  129.     NULL,                                  /* create main configuration */
  130.     NULL,                                  /* init main configuration */

  132.     NULL,                                  /* create server configuration */
  133.     NULL,                                  /* merge server configuration */

  135.     ngx_http_limit_req_create_conf,        /* create location configuration */
  136.     ngx_http_limit_req_merge_conf          /* merge location configuration */
  137. };


  140. ‌ngx_module_t  ngx_http_limit_req_module = {
  141.     NGX_MODULE_V1,
  142.     &ngx_http_limit_req_module_ctx,        /* module context */
  143.     ngx_http_limit_req_commands,           /* module directives */
  144.     NGX_HTTP_MODULE,                       /* module type */
  145.     NULL,                                  /* init master */
  146.     NULL,                                  /* init module */
  147.     NULL,                                  /* init process */
  148.     NULL,                                  /* init thread */
  149.     NULL,                                  /* exit thread */
  150.     NULL,                                  /* exit process */
  151.     NULL,                                  /* exit master */
  152.     NGX_MODULE_V1_PADDING
  153. };


  156. static ngx_int_t
  157. ‌ngx_http_limit_req_handler(ngx_http_request_t *r)
  158. {
  159.     uint32_t                     hash;
  160.     ngx_str_t                    key;
  161.     ngx_int_t                    rc;
  162.     ngx_uint_t                   n, excess;
  163.     ngx_msec_t                   delay;
  164.     ngx_http_limit_req_ctx_t    *ctx;
  165.     ngx_http_limit_req_conf_t   *lrcf;
  166.     ngx_http_limit_req_limit_t  *limit, *limits;

  168.     if (r->main->limit_req_set) {
  169.         return NGX_DECLINED;
  170.     }

  172.     lrcf = ngx_http_get_module_loc_conf(r, ngx_http_limit_req_module);
  173.     limits = lrcf->limits.elts;

  175.     excess = 0;

  177.     rc = NGX_DECLINED;

  179. #if (NGX_SUPPRESS_WARN)
  180.     limit = NULL;
  181. #endif

  183.     for (n = 0; n < lrcf->limits.nelts; n++) {

  185.         limit = &limits[n];

  187.         ctx = limit->shm_zone->data;

  189.         if (ngx_http_complex_value(r, &ctx->key, &key) != NGX_OK) {
  190.             return NGX_HTTP_INTERNAL_SERVER_ERROR;
  191.         }

  193.         if (key.len == 0) {
  194.             continue;
  195.         }

  197.         if (key.len > 65535) {
  198.             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  199.                           "the value of the \"%V\" key "
  200.                           "is more than 65535 bytes: \"%V\"",
  201.                           &ctx->key.value, &key);
  202.             continue;
  203.         }

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

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

  209.         rc = ngx_http_limit_req_lookup(limit, hash, &key, &excess,
  210.                                        (n == lrcf->limits.nelts - 1));

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

  214.         ngx_log_debug4(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  215.                        "limit_req[%ui]: %i %ui.%03ui",
  216.                        n, rc, excess / 1000, excess % 1000);

  218.         if (rc != NGX_AGAIN) {
  219.             break;
  220.         }
  221.     }

  223.     if (rc == NGX_DECLINED) {
  224.         return NGX_DECLINED;
  225.     }

  227.     r->main->limit_req_set = 1;

  229.     if (rc == NGX_BUSY || rc == NGX_ERROR) {

  231.         if (rc == NGX_BUSY) {
  232.             ngx_log_error(lrcf->limit_log_level, r->connection->log, 0,
  233.                           "limiting requests, excess: %ui.%03ui by zone \"%V\"",
  234.                           excess / 1000, excess % 1000,
  235.                           &limit->shm_zone->shm.name);
  236.         }

  238.         while (n--) {
  239.             ctx = limits[n].shm_zone->data;

  241.             if (ctx->node == NULL) {
  242.                 continue;
  243.             }

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

  247.             ctx->node->count--;

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

  251.             ctx->node = NULL;
  252.         }

  254.         return lrcf->status_code;
  255.     }

  257.     /* rc == NGX_AGAIN || rc == NGX_OK */

  259.     if (rc == NGX_AGAIN) {
  260.         excess = 0;
  261.     }

  263.     delay = ngx_http_limit_req_account(limits, n, &excess, &limit);

  265.     if (!delay) {
  266.         return NGX_DECLINED;
  267.     }

  269.     ngx_log_error(lrcf->delay_log_level, r->connection->log, 0,
  270.                   "delaying request, excess: %ui.%03ui, by zone \"%V\"",
  271.                   excess / 1000, excess % 1000, &limit->shm_zone->shm.name);

  273.     if (ngx_handle_read_event(r->connection->read, 0) != NGX_OK) {
  274.         return NGX_HTTP_INTERNAL_SERVER_ERROR;
  275.     }

  277.     r->read_event_handler = ngx_http_test_reading;
  278.     r->write_event_handler = ngx_http_limit_req_delay;
  279.     ngx_add_timer(r->connection->write, delay);

  281.     return NGX_AGAIN;
  282. }


  285. static void
  286. ‌ngx_http_limit_req_delay(ngx_http_request_t *r)
  287. {
  288.     ngx_event_t  *wev;

  290.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  291.                    "limit_req delay");

  293.     wev = r->connection->write;

  295.     if (!wev->timedout) {

  297.         if (ngx_handle_write_event(wev, 0) != NGX_OK) {
  298.             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  299.         }

  301.         return;
  302.     }

  304.     wev->timedout = 0;

  306.     if (ngx_handle_read_event(r->connection->read, 0) != NGX_OK) {
  307.         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
  308.         return;
  309.     }

  311.     r->read_event_handler = ngx_http_block_reading;
  312.     r->write_event_handler = ngx_http_core_run_phases;

  314.     ngx_http_core_run_phases(r);
  315. }


  318. static void
  319. ‌ngx_http_limit_req_rbtree_insert_value(ngx_rbtree_node_t *temp,
  320.     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
  321. {
  322.     ngx_rbtree_node_t          **p;
  323.     ngx_http_limit_req_node_t   *lrn, *lrnt;

  325.     for ( ;; ) {

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

  329.             p = &temp->left;

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

  333.             p = &temp->right;

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

  337.             lrn = (ngx_http_limit_req_node_t *) &node->color;
  338.             lrnt = (ngx_http_limit_req_node_t *) &temp->color;

  340.             p = (ngx_memn2cmp(lrn->data, lrnt->data, lrn->len, lrnt->len) < 0)
  341.                 ? &temp->left : &temp->right;
  342.         }

  344.         if (*p == sentinel) {
  345.             break;
  346.         }

  348.         temp = *p;
  349.     }

  351.     *p = node;
  352.     node->parent = temp;
  353.     node->left = sentinel;
  354.     node->right = sentinel;
  355.     ngx_rbt_red(node);
  356. }


  359. static ngx_int_t
  360. ‌ngx_http_limit_req_lookup(ngx_http_limit_req_limit_t *limit, ngx_uint_t hash,
  361.     ngx_str_t *key, ngx_uint_t *ep, ngx_uint_t account)
  362. {
  363.     size_t                      size;
  364.     ngx_int_t                   rc, excess;
  365.     ngx_time_t                 *tp;
  366.     ngx_msec_t                  now;
  367.     ngx_msec_int_t              ms;
  368.     ngx_rbtree_node_t          *node, *sentinel;
  369.     ngx_http_limit_req_ctx_t   *ctx;
  370.     ngx_http_limit_req_node_t  *lr;

  372.     tp = ngx_timeofday();
  373.     now = (ngx_msec_t) (tp->sec * 1000 + tp->msec);

  375.     ctx = limit->shm_zone->data;

  377.     node = ctx->sh->rbtree.root;
  378.     sentinel = ctx->sh->rbtree.sentinel;

  380.     while (node != sentinel) {

  382.         if (hash < node->key) {
  383.             node = node->left;
  384.             continue;
  385.         }

  387.         if (hash > node->key) {
  388.             node = node->right;
  389.             continue;
  390.         }

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

  394.         lr = (ngx_http_limit_req_node_t *) &node->color;

  396.         rc = ngx_memn2cmp(key->data, lr->data, key->len, (size_t) lr->len);

  398.         if (rc == 0) {
  399.             ngx_queue_remove(&lr->queue);
  400.             ngx_queue_insert_head(&ctx->sh->queue, &lr->queue);

  402.             ms = (ngx_msec_int_t) (now - lr->last);

  404.             excess = lr->excess - ctx->rate * ngx_abs(ms) / 1000 + 1000;

  406.             if (excess < 0) {
  407.                 excess = 0;
  408.             }

  410.             *ep = excess;

  412.             if ((ngx_uint_t) excess > limit->burst) {
  413.                 return NGX_BUSY;
  414.             }

  416.             if (account) {
  417.                 lr->excess = excess;
  418.                 lr->last = now;
  419.                 return NGX_OK;
  420.             }

  422.             lr->count++;

  424.             ctx->node = lr;

  426.             return NGX_AGAIN;
  427.         }

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

  432.     *ep = 0;

  434.     size = offsetof(ngx_rbtree_node_t, color)
  435.            + offsetof(ngx_http_limit_req_node_t, data)
  436.            + key->len;

  438.     ngx_http_limit_req_expire(ctx, 1);

  440.     node = ngx_slab_alloc_locked(ctx->shpool, size);

  442.     if (node == NULL) {
  443.         ngx_http_limit_req_expire(ctx, 0);

  445.         node = ngx_slab_alloc_locked(ctx->shpool, size);
  446.         if (node == NULL) {
  447.             ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
  448.                           "could not allocate node%s", ctx->shpool->log_ctx);
  449.             return NGX_ERROR;
  450.         }
  451.     }

  453.     node->key = hash;

  455.     lr = (ngx_http_limit_req_node_t *) &node->color;

  457.     lr->len = (u_short) key->len;
  458.     lr->excess = 0;

  460.     ngx_memcpy(lr->data, key->data, key->len);

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

  464.     ngx_queue_insert_head(&ctx->sh->queue, &lr->queue);

  466.     if (account) {
  467.         lr->last = now;
  468.         lr->count = 0;
  469.         return NGX_OK;
  470.     }

  472.     lr->last = 0;
  473.     lr->count = 1;

  475.     ctx->node = lr;

  477.     return NGX_AGAIN;
  478. }


  481. static ngx_msec_t
  482. ‌ngx_http_limit_req_account(ngx_http_limit_req_limit_t *limits, ngx_uint_t n,
  483.     ngx_uint_t *ep, ngx_http_limit_req_limit_t **limit)
  484. {
  485.     ngx_int_t                   excess;
  486.     ngx_time_t                 *tp;
  487.     ngx_msec_t                  now, delay, max_delay;
  488.     ngx_msec_int_t              ms;
  489.     ngx_http_limit_req_ctx_t   *ctx;
  490.     ngx_http_limit_req_node_t  *lr;

  492.     excess = *ep;

  494.     if (excess == 0 || (*limit)->nodelay) {
  495.         max_delay = 0;

  497.     } else {
  498.         ctx = (*limit)->shm_zone->data;
  499.         max_delay = excess * 1000 / ctx->rate;
  500.     }

  502.     while (n--) {
  503.         ctx = limits[n].shm_zone->data;
  504.         lr = ctx->node;

  506.         if (lr == NULL) {
  507.             continue;
  508.         }

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

  512.         tp = ngx_timeofday();

  514.         now = (ngx_msec_t) (tp->sec * 1000 + tp->msec);
  515.         ms = (ngx_msec_int_t) (now - lr->last);

  517.         excess = lr->excess - ctx->rate * ngx_abs(ms) / 1000 + 1000;

  519.         if (excess < 0) {
  520.             excess = 0;
  521.         }

  523.         lr->last = now;
  524.         lr->excess = excess;
  525.         lr->count--;

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

  529.         ctx->node = NULL;

  531.         if (limits[n].nodelay) {
  532.             continue;
  533.         }

  535.         delay = excess * 1000 / ctx->rate;

  537.         if (delay > max_delay) {
  538.             max_delay = delay;
  539.             *ep = excess;
  540.             *limit = &limits[n];
  541.         }
  542.     }

  544.     return max_delay;
  545. }


  548. static void
  549. ‌ngx_http_limit_req_expire(ngx_http_limit_req_ctx_t *ctx, ngx_uint_t n)
  550. {
  551.     ngx_int_t                   excess;
  552.     ngx_time_t                 *tp;
  553.     ngx_msec_t                  now;
  554.     ngx_queue_t                *q;
  555.     ngx_msec_int_t              ms;
  556.     ngx_rbtree_node_t          *node;
  557.     ngx_http_limit_req_node_t  *lr;

  559.     tp = ngx_timeofday();

  561.     now = (ngx_msec_t) (tp->sec * 1000 + tp->msec);

  563.     /*
  564.      * n == 1 deletes one or two zero rate entries
  565.      * n == 0 deletes oldest entry by force
  566.      *        and one or two zero rate entries
  567.      */

  569.     while (n < 3) {

  571.         if (ngx_queue_empty(&ctx->sh->queue)) {
  572.             return;
  573.         }

  575.         q = ngx_queue_last(&ctx->sh->queue);

  577.         lr = ngx_queue_data(q, ngx_http_limit_req_node_t, queue);

  579.         if (lr->count) {

  581.             /*
  582.              * There is not much sense in looking further,
  583.              * because we bump nodes on the lookup stage.
  584.              */

  586.             return;
  587.         }

  589.         if (n++ != 0) {

  591.             ms = (ngx_msec_int_t) (now - lr->last);
  592.             ms = ngx_abs(ms);

  594.             if (ms < 60000) {
  595.                 return;
  596.             }

  598.             excess = lr->excess - ctx->rate * ms / 1000;

  600.             if (excess > 0) {
  601.                 return;
  602.             }
  603.         }

  605.         ngx_queue_remove(q);

  607.         node = (ngx_rbtree_node_t *)
  608.                    ((u_char *) lr - offsetof(ngx_rbtree_node_t, color));

  610.         ngx_rbtree_delete(&ctx->sh->rbtree, node);

  612.         ngx_slab_free_locked(ctx->shpool, node);
  613.     }
  614. }


  617. static ngx_int_t
  618. ‌ngx_http_limit_req_init_zone(ngx_shm_zone_t *shm_zone, void *data)
  619. {
  620.     ngx_http_limit_req_ctx_t  *octx = data;

  622.     size_t                     len;
  623.     ngx_http_limit_req_ctx_t  *ctx;

  625.     ctx = shm_zone->data;

  627.     if (octx) {
  628.         if (ctx->key.value.len != octx->key.value.len
  629.             || ngx_strncmp(ctx->key.value.data, octx->key.value.data,
  630.                            ctx->key.value.len)
  631.                != 0)
  632.         {
  633.             ngx_log_error(NGX_LOG_EMERG, shm_zone->shm.log, 0,
  634.                           "limit_req \"%V\" uses the \"%V\" key "
  635.                           "while previously it used the \"%V\" key",
  636.                           &shm_zone->shm.name, &ctx->key.value,
  637.                           &octx->key.value);
  638.             return NGX_ERROR;
  639.         }

  641.         ctx->sh = octx->sh;
  642.         ctx->shpool = octx->shpool;

  644.         return NGX_OK;
  645.     }

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

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

  652.         return NGX_OK;
  653.     }

  655.     ctx->sh = ngx_slab_alloc(ctx->shpool, sizeof(ngx_http_limit_req_shctx_t));
  656.     if (ctx->sh == NULL) {
  657.         return NGX_ERROR;
  658.     }

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

  662.     ngx_rbtree_init(&ctx->sh->rbtree, &ctx->sh->sentinel,
  663.                     ngx_http_limit_req_rbtree_insert_value);

  665.     ngx_queue_init(&ctx->sh->queue);

  667.     len = sizeof(" in limit_req zone \"\"") + shm_zone->shm.name.len;

  669.     ctx->shpool->log_ctx = ngx_slab_alloc(ctx->shpool, len);
  670.     if (ctx->shpool->log_ctx == NULL) {
  671.         return NGX_ERROR;
  672.     }

  674.     ngx_sprintf(ctx->shpool->log_ctx, " in limit_req zone \"%V\"%Z",
  675.                 &shm_zone->shm.name);

  677.     ctx->shpool->log_nomem = 0;

  679.     return NGX_OK;
  680. }


  683. static void *
  684. ‌ngx_http_limit_req_create_conf(ngx_conf_t *cf)
  685. {
  686.     ngx_http_limit_req_conf_t  *conf;

  688.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_limit_req_conf_t));
  689.     if (conf == NULL) {
  690.         return NULL;
  691.     }

  693.     /*
  694.      * set by ngx_pcalloc():
  695.      *
  696.      *     conf->limits.elts = NULL;
  697.      */

  699.     conf->limit_log_level = NGX_CONF_UNSET_UINT;
  700.     conf->status_code = NGX_CONF_UNSET_UINT;

  702.     return conf;
  703. }


  706. static char *
  707. ‌ngx_http_limit_req_merge_conf(ngx_conf_t *cf, void *parent, void *child)
  708. {
  709.     ngx_http_limit_req_conf_t *prev = parent;
  710.     ngx_http_limit_req_conf_t *conf = child;

  712.     if (conf->limits.elts == NULL) {
  713.         conf->limits = prev->limits;
  714.     }

  716.     ngx_conf_merge_uint_value(conf->limit_log_level, prev->limit_log_level,
  717.                               NGX_LOG_ERR);

  719.     conf->delay_log_level = (conf->limit_log_level == NGX_LOG_INFO) ?
  720.                                 NGX_LOG_INFO : conf->limit_log_level + 1;

  722.     ngx_conf_merge_uint_value(conf->status_code, prev->status_code,
  723.                               NGX_HTTP_SERVICE_UNAVAILABLE);

  725.     return NGX_CONF_OK;
  726. }


  729. static char *
  730. ‌ngx_http_limit_req_zone(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  731. {
  732.     u_char                            *p;
  733.     size_t                             len;
  734.     ssize_t                            size;
  735.     ngx_str_t                         *value, name, s;
  736.     ngx_int_t                          rate, scale;
  737.     ngx_uint_t                         i;
  738.     ngx_shm_zone_t                    *shm_zone;
  739.     ngx_http_limit_req_ctx_t          *ctx;
  740.     ngx_http_compile_complex_value_t   ccv;

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

  744.     ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_limit_req_ctx_t));
  745.     if (ctx == NULL) {
  746.         return NGX_CONF_ERROR;
  747.     }

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

  751.     ccv.cf = cf;
  752.     ccv.value = &value[1];
  753.     ccv.complex_value = &ctx->key;

  755.     if (ngx_http_compile_complex_value(&ccv) != NGX_OK) {
  756.         return NGX_CONF_ERROR;
  757.     }

  759.     size = 0;
  760.     rate = 1;
  761.     scale = 1;
  762.     name.len = 0;

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

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

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

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

  772.             if (p == NULL) {
  773.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  774.                                    "invalid zone size \"%V\"", &value[i]);
  775.                 return NGX_CONF_ERROR;
  776.             }

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

  780.             s.data = p + 1;
  781.             s.len = value[i].data + value[i].len - s.data;

  783.             size = ngx_parse_size(&s);

  785.             if (size == NGX_ERROR) {
  786.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  787.                                    "invalid zone size \"%V\"", &value[i]);
  788.                 return NGX_CONF_ERROR;
  789.             }

  791.             if (size < (ssize_t) (8 * ngx_pagesize)) {
  792.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  793.                                    "zone \"%V\" is too small", &value[i]);
  794.                 return NGX_CONF_ERROR;
  795.             }

  797.             continue;
  798.         }

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

  802.             len = value[i].len;
  803.             p = value[i].data + len - 3;

  805.             if (ngx_strncmp(p, "r/s", 3) == 0) {
  806.                 scale = 1;
  807.                 len -= 3;

  809.             } else if (ngx_strncmp(p, "r/m", 3) == 0) {
  810.                 scale = 60;
  811.                 len -= 3;
  812.             }

  814.             rate = ngx_atoi(value[i].data + 5, len - 5);
  815.             if (rate <= 0) {
  816.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  817.                                    "invalid rate \"%V\"", &value[i]);
  818.                 return NGX_CONF_ERROR;
  819.             }

  821.             continue;
  822.         }

  824.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  825.                            "invalid parameter \"%V\"", &value[i]);
  826.         return NGX_CONF_ERROR;
  827.     }

  829.     if (name.len == 0) {
  830.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  831.                            "\"%V\" must have \"zone\" parameter",
  832.                            &cmd->name);
  833.         return NGX_CONF_ERROR;
  834.     }

  836.     ctx->rate = rate * 1000 / scale;

  838.     shm_zone = ngx_shared_memory_add(cf, &name, size,
  839.                                      &ngx_http_limit_req_module);
  840.     if (shm_zone == NULL) {
  841.         return NGX_CONF_ERROR;
  842.     }

  844.     if (shm_zone->data) {
  845.         ctx = shm_zone->data;

  847.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  848.                            "%V \"%V\" is already bound to key \"%V\"",
  849.                            &cmd->name, &name, &ctx->key.value);
  850.         return NGX_CONF_ERROR;
  851.     }

  853.     shm_zone->init = ngx_http_limit_req_init_zone;
  854.     shm_zone->data = ctx;

  856.     return NGX_CONF_OK;
  857. }


  860. static char *
  861. ‌ngx_http_limit_req(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  862. {
  863.     ngx_http_limit_req_conf_t  *lrcf = conf;

  865.     ngx_int_t                    burst;
  866.     ngx_str_t                   *value, s;
  867.     ngx_uint_t                   i, nodelay;
  868.     ngx_shm_zone_t              *shm_zone;
  869.     ngx_http_limit_req_limit_t  *limit, *limits;

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

  873.     shm_zone = NULL;
  874.     burst = 0;
  875.     nodelay = 0;

  877.     for (i = 1; i < cf->args->nelts; i++) {

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

  881.             s.len = value[i].len - 5;
  882.             s.data = value[i].data + 5;

  884.             shm_zone = ngx_shared_memory_add(cf, &s, 0,
  885.                                              &ngx_http_limit_req_module);
  886.             if (shm_zone == NULL) {
  887.                 return NGX_CONF_ERROR;
  888.             }

  890.             continue;
  891.         }

  893.         if (ngx_strncmp(value[i].data, "burst=", 6) == 0) {

  895.             burst = ngx_atoi(value[i].data + 6, value[i].len - 6);
  896.             if (burst <= 0) {
  897.                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  898.                                    "invalid burst rate \"%V\"", &value[i]);
  899.                 return NGX_CONF_ERROR;
  900.             }

  902.             continue;
  903.         }

  905.         if (ngx_strcmp(value[i].data, "nodelay") == 0) {
  906.             nodelay = 1;
  907.             continue;
  908.         }

  910.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  911.                            "invalid parameter \"%V\"", &value[i]);
  912.         return NGX_CONF_ERROR;
  913.     }

  915.     if (shm_zone == NULL) {
  916.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  917.                            "\"%V\" must have \"zone\" parameter",
  918.                            &cmd->name);
  919.         return NGX_CONF_ERROR;
  920.     }

  922.     if (shm_zone->data == NULL) {
  923.         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  924.                            "unknown limit_req_zone \"%V\"",
  925.                            &shm_zone->shm.name);
  926.         return NGX_CONF_ERROR;
  927.     }

  929.     limits = lrcf->limits.elts;

  931.     if (limits == NULL) {
  932.         if (ngx_array_init(&lrcf->limits, cf->pool, 1,
  933.                            sizeof(ngx_http_limit_req_limit_t))
  934.             != NGX_OK)
  935.         {
  936.             return NGX_CONF_ERROR;
  937.         }
  938.     }

  940.     for (i = 0; i < lrcf->limits.nelts; i++) {
  941.         if (shm_zone == limits[i].shm_zone) {
  942.             return "is duplicate";
  943.         }
  944.     }

  946.     limit = ngx_array_push(&lrcf->limits);
  947.     if (limit == NULL) {
  948.         return NGX_CONF_ERROR;
  949.     }

  951.     limit->shm_zone = shm_zone;
  952.     limit->burst = burst * 1000;
  953.     limit->nodelay = nodelay;

  955.     return NGX_CONF_OK;
  956. }


  959. static ngx_int_t
  960. ‌ngx_http_limit_req_init(ngx_conf_t *cf)
  961. {
  962.     ngx_http_handler_pt        *h;
  963.     ngx_http_core_main_conf_t  *cmcf;

  965.     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);

  967.     h = ngx_array_push(&cmcf->phases[NGX_HTTP_PREACCESS_PHASE].handlers);
  968.     if (h == NULL) {
  969.         return NGX_ERROR;
  970.     }

  972.     *h = ngx_http_limit_req_handler;

  974.     return NGX_OK;
  975. }

One Level Up Top Level