src/http/modules/ngx_http_limit_req_module.c

   1
   2 /*
   3  * Copyright (C) Igor Sysoev
   4  */
   5
   6
   7 #include <ngx_config.h>
   8 #include <ngx_core.h>
   9 #include <ngx_http.h>
  10
  11
  12 typedef struct {
  13     u_char                       color;
  14     u_char                       dummy;
  15     u_short                      len;
  16     ngx_queue_t                  queue;
  17     ngx_msec_t                   last;
  18     /* integer value, 1 corresponds to 0.001 r/s */
  19     ngx_uint_t                   excess;
  20     u_char                       data[1];
  21 } ngx_http_limit_req_node_t;
  22
  23
  24 typedef struct {
  25     ngx_rbtree_t                  rbtree;
  26     ngx_rbtree_node_t             sentinel;
  27     ngx_queue_t                   queue;
  28 } ngx_http_limit_req_shctx_t;
  29
  30
  31 typedef struct {
  32     ngx_http_limit_req_shctx_t  *sh;
  33     ngx_slab_pool_t             *shpool;
  34     /* integer value, 1 corresponds to 0.001 r/s */
  35     ngx_uint_t                   rate;
  36     ngx_int_t                    index;
  37     ngx_str_t                    var;
  38 } ngx_http_limit_req_ctx_t;
  39
  40
  41 typedef struct {
  42     ngx_shm_zone_t              *shm_zone;
  43     /* integer value, 1 corresponds to 0.001 r/s */
  44     ngx_uint_t                   burst;
  45     ngx_uint_t                   limit_log_level;
  46     ngx_uint_t                   delay_log_level;
  47
  48     ngx_uint_t                   nodelay; /* unsigned  nodelay:1 */
  49 } ngx_http_limit_req_conf_t;
  50
  51
  52 static void ngx_http_limit_req_delay(ngx_http_request_t *r);
  53 static ngx_int_t ngx_http_limit_req_lookup(ngx_http_limit_req_conf_t *lrcf,
  54     ngx_uint_t hash, u_char *data, size_t len, ngx_uint_t *ep);
  55 static void ngx_http_limit_req_expire(ngx_http_limit_req_ctx_t *ctx,
  56     ngx_uint_t n);
  57
  58 static void *ngx_http_limit_req_create_conf(ngx_conf_t *cf);
  59 static char *ngx_http_limit_req_merge_conf(ngx_conf_t *cf, void *parent,
  60     void *child);
  61 static char *ngx_http_limit_req_zone(ngx_conf_t *cf, ngx_command_t *cmd,
  62     void *conf);
  63 static char *ngx_http_limit_req(ngx_conf_t *cf, ngx_command_t *cmd,
  64     void *conf);
  65 static ngx_int_t ngx_http_limit_req_init(ngx_conf_t *cf);
  66
  67
  68 static ngx_conf_enum_t  ngx_http_limit_req_log_levels[] = {
  69     { ngx_string("info"), NGX_LOG_INFO },
  70     { ngx_string("notice"), NGX_LOG_NOTICE },
  71     { ngx_string("warn"), NGX_LOG_WARN },
  72     { ngx_string("error"), NGX_LOG_ERR },
  73     { ngx_null_string, 0 }
  74 };
  75
  76
  77 static ngx_command_t  ngx_http_limit_req_commands[] = {
  78
  79     { ngx_string("limit_req_zone"),
  80       NGX_HTTP_MAIN_CONF|NGX_CONF_TAKE3,
  81       ngx_http_limit_req_zone,
  82       0,
  83       0,
  84       NULL },
  85
  86     { ngx_string("limit_req"),
  87       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE123,
  88       ngx_http_limit_req,
  89       NGX_HTTP_LOC_CONF_OFFSET,
  90       0,
  91       NULL },
  92
  93     { ngx_string("limit_req_log_level"),
  94       NGX_HTTP_MAIN_CONF|NGX_HTTP_SRV_CONF|NGX_HTTP_LOC_CONF|NGX_CONF_TAKE1,
  95       ngx_conf_set_enum_slot,
  96       NGX_HTTP_LOC_CONF_OFFSET,
  97       offsetof(ngx_http_limit_req_conf_t, limit_log_level),
  98       &ngx_http_limit_req_log_levels },
  99
 100       ngx_null_command
 101 };
 102
 103
 104 static ngx_http_module_t  ngx_http_limit_req_module_ctx = {
 105     NULL,                                  /* preconfiguration */
 106     ngx_http_limit_req_init,               /* postconfiguration */
 107
 108     NULL,                                  /* create main configuration */
 109     NULL,                                  /* init main configuration */
 110
 111     NULL,                                  /* create server configuration */
 112     NULL,                                  /* merge server configuration */
 113
 114     ngx_http_limit_req_create_conf,        /* create location configration */
 115     ngx_http_limit_req_merge_conf          /* merge location configration */
 116 };
 117
 118
 119 ngx_module_t  ngx_http_limit_req_module = {
 120     NGX_MODULE_V1,
 121     &ngx_http_limit_req_module_ctx,        /* module context */
 122     ngx_http_limit_req_commands,           /* module directives */
 123     NGX_HTTP_MODULE,                       /* module type */
 124     NULL,                                  /* init master */
 125     NULL,                                  /* init module */
 126     NULL,                                  /* init process */
 127     NULL,                                  /* init thread */
 128     NULL,                                  /* exit thread */
 129     NULL,                                  /* exit process */
 130     NULL,                                  /* exit master */
 131     NGX_MODULE_V1_PADDING
 132 };
 133
 134
 135 static ngx_int_t
 136 ngx_http_limit_req_handler(ngx_http_request_t *r)
 137 {
 138     size_t                      len, n;
 139     uint32_t                    hash;
 140     ngx_int_t                   rc;
 141     ngx_uint_t                  excess;
 142     ngx_time_t                 *tp;
 143     ngx_rbtree_node_t          *node;
 144     ngx_http_variable_value_t  *vv;
 145     ngx_http_limit_req_ctx_t   *ctx;
 146     ngx_http_limit_req_node_t  *lr;
 147     ngx_http_limit_req_conf_t  *lrcf;
 148
 149     if (r->main->limit_req_set) {
 150         return NGX_DECLINED;
 151     }
 152
 153     lrcf = ngx_http_get_module_loc_conf(r, ngx_http_limit_req_module);
 154
 155     if (lrcf->shm_zone == NULL) {
 156         return NGX_DECLINED;
 157     }
 158
 159     ctx = lrcf->shm_zone->data;
 160
 161     vv = ngx_http_get_indexed_variable(r, ctx->index);
 162
 163     if (vv == NULL || vv->not_found) {
 164         return NGX_DECLINED;
 165     }
 166
 167     len = vv->len;
 168
 169     if (len == 0) {
 170         return NGX_DECLINED;
 171     }
 172
 173     if (len > 65535) {
 174         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
 175                       "the value of the \"%V\" variable "
 176                       "is more than 65535 bytes: \"%v\"",
 177                       &ctx->var, vv);
 178         return NGX_DECLINED;
 179     }
 180
 181     r->main->limit_req_set = 1;
 182
 183     hash = ngx_crc32_short(vv->data, len);
 184
 185     ngx_shmtx_lock(&ctx->shpool->mutex);
 186
 187     ngx_http_limit_req_expire(ctx, 1);
 188
 189     rc = ngx_http_limit_req_lookup(lrcf, hash, vv->data, len, &excess);
 190
 191     ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
 192                    "limit_req: %i %ui.%03ui", rc, excess / 1000, excess % 1000);
 193
 194     if (rc == NGX_DECLINED) {
 195
 196         n = offsetof(ngx_rbtree_node_t, color)
 197             + offsetof(ngx_http_limit_req_node_t, data)
 198             + len;
 199
 200         node = ngx_slab_alloc_locked(ctx->shpool, n);
 201         if (node == NULL) {
 202
 203             ngx_http_limit_req_expire(ctx, 0);
 204
 205             node = ngx_slab_alloc_locked(ctx->shpool, n);
 206             if (node == NULL) {
 207                 ngx_shmtx_unlock(&ctx->shpool->mutex);
 208                 return NGX_HTTP_SERVICE_UNAVAILABLE;
 209             }
 210         }
 211
 212         lr = (ngx_http_limit_req_node_t *) &node->color;
 213
 214         node->key = hash;
 215         lr->len = (u_char) len;
 216
 217         tp = ngx_timeofday();
 218         lr->last = (ngx_msec_t) (tp->sec * 1000 + tp->msec);
 219
 220         lr->excess = 0;
 221         ngx_memcpy(lr->data, vv->data, len);
 222
 223         ngx_rbtree_insert(&ctx->sh->rbtree, node);
 224
 225         ngx_queue_insert_head(&ctx->sh->queue, &lr->queue);
 226
 227         ngx_shmtx_unlock(&ctx->shpool->mutex);
 228
 229         return NGX_DECLINED;
 230     }
 231
 232     ngx_shmtx_unlock(&ctx->shpool->mutex);
 233
 234     if (rc == NGX_OK) {
 235         return NGX_DECLINED;
 236     }
 237
 238     if (rc == NGX_BUSY) {
 239         ngx_log_error(lrcf->limit_log_level, r->connection->log, 0,
 240                       "limiting requests, excess: %ui.%03ui by zone \"%V\"",
 241                       excess / 1000, excess % 1000, &lrcf->shm_zone->shm.name);
 242
 243         return NGX_HTTP_SERVICE_UNAVAILABLE;
 244     }
 245
 246     /* rc == NGX_AGAIN */
 247
 248     if (lrcf->nodelay) {
 249         return NGX_DECLINED;
 250     }
 251
 252     ngx_log_error(lrcf->delay_log_level, r->connection->log, 0,
 253                   "delaying request, excess: %ui.%03ui, by zone \"%V\"",
 254                   excess / 1000, excess % 1000, &lrcf->shm_zone->shm.name);
 255
 256     if (ngx_handle_read_event(r->connection->read, 0) != NGX_OK) {
 257         return NGX_HTTP_INTERNAL_SERVER_ERROR;
 258     }
 259
 260     r->read_event_handler = ngx_http_test_reading;
 261     r->write_event_handler = ngx_http_limit_req_delay;
 262     ngx_add_timer(r->connection->write,
 263                   (ngx_msec_t) excess * 1000 / ctx->rate);
 264
 265     return NGX_AGAIN;
 266 }
 267
 268
 269 static void
 270 ngx_http_limit_req_delay(ngx_http_request_t *r)
 271 {
 272     ngx_event_t  *wev;
 273
 274     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
 275                    "limit_req delay");
 276
 277     wev = r->connection->write;
 278
 279     if (!wev->timedout) {
 280
 281         if (ngx_handle_write_event(wev, 0) != NGX_OK) {
 282             ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
 283         }
 284
 285         return;
 286     }
 287
 288     wev->timedout = 0;
 289
 290     if (ngx_handle_read_event(r->connection->read, 0) != NGX_OK) {
 291         ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
 292         return;
 293     }
 294
 295     r->read_event_handler = ngx_http_block_reading;
 296     r->write_event_handler = ngx_http_core_run_phases;
 297
 298     ngx_http_core_run_phases(r);
 299 }
 300
 301
 302 static void
 303 ngx_http_limit_req_rbtree_insert_value(ngx_rbtree_node_t *temp,
 304     ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel)
 305 {
 306     ngx_rbtree_node_t          **p;
 307     ngx_http_limit_req_node_t   *lrn, *lrnt;
 308
 309     for ( ;; ) {
 310
 311         if (node->key < temp->key) {
 312
 313             p = &temp->left;
 314
 315         } else if (node->key > temp->key) {
 316
 317             p = &temp->right;
 318
 319         } else { /* node->key == temp->key */
 320
 321             lrn = (ngx_http_limit_req_node_t *) &node->color;
 322             lrnt = (ngx_http_limit_req_node_t *) &temp->color;
 323
 324             p = (ngx_memn2cmp(lrn->data, lrnt->data, lrn->len, lrnt->len) < 0)
 325                 ? &temp->left : &temp->right;
 326         }
 327
 328         if (*p == sentinel) {
 329             break;
 330         }
 331
 332         temp = *p;
 333     }
 334
 335     *p = node;
 336     node->parent = temp;
 337     node->left = sentinel;
 338     node->right = sentinel;
 339     ngx_rbt_red(node);
 340 }
 341
 342
 343 static ngx_int_t
 344 ngx_http_limit_req_lookup(ngx_http_limit_req_conf_t *lrcf, ngx_uint_t hash,
 345     u_char *data, size_t len, ngx_uint_t *ep)
 346 {
 347     ngx_int_t                   rc, excess;
 348     ngx_time_t                 *tp;
 349     ngx_msec_t                  now;
 350     ngx_msec_int_t              ms;
 351     ngx_rbtree_node_t          *node, *sentinel;
 352     ngx_http_limit_req_ctx_t   *ctx;
 353     ngx_http_limit_req_node_t  *lr;
 354
 355     ctx = lrcf->shm_zone->data;
 356
 357     node = ctx->sh->rbtree.root;
 358     sentinel = ctx->sh->rbtree.sentinel;
 359
 360     while (node != sentinel) {
 361
 362         if (hash < node->key) {
 363             node = node->left;
 364             continue;
 365         }
 366
 367         if (hash > node->key) {
 368             node = node->right;
 369             continue;
 370         }
 371
 372         /* hash == node->key */
 373
 374         do {
 375             lr = (ngx_http_limit_req_node_t *) &node->color;
 376
 377             rc = ngx_memn2cmp(data, lr->data, len, (size_t) lr->len);
 378
 379             if (rc == 0) {
 380                 ngx_queue_remove(&lr->queue);
 381                 ngx_queue_insert_head(&ctx->sh->queue, &lr->queue);
 382
 383                 tp = ngx_timeofday();
 384
 385                 now = (ngx_msec_t) (tp->sec * 1000 + tp->msec);
 386                 ms = (ngx_msec_int_t) (now - lr->last);
 387
 388                 excess = lr->excess - ctx->rate * ngx_abs(ms) / 1000 + 1000;
 389
 390                 if (excess < 0) {
 391                     excess = 0;
 392                 }
 393
 394                 *ep = excess;
 395
 396                 if ((ngx_uint_t) excess > lrcf->burst) {
 397                     return NGX_BUSY;
 398                 }
 399
 400                 lr->excess = excess;
 401                 lr->last = now;
 402
 403                 if (excess) {
 404                     return NGX_AGAIN;
 405                 }
 406
 407                 return NGX_OK;
 408             }
 409
 410             node = (rc < 0) ? node->left : node->right;
 411
 412         } while (node != sentinel && hash == node->key);
 413
 414         break;
 415     }
 416
 417     *ep = 0;
 418
 419     return NGX_DECLINED;
 420 }
 421
 422
 423 static void
 424 ngx_http_limit_req_expire(ngx_http_limit_req_ctx_t *ctx, ngx_uint_t n)
 425 {
 426     ngx_int_t                   excess;
 427     ngx_time_t                 *tp;
 428     ngx_msec_t                  now;
 429     ngx_queue_t                *q;
 430     ngx_msec_int_t              ms;
 431     ngx_rbtree_node_t          *node;
 432     ngx_http_limit_req_node_t  *lr;
 433
 434     tp = ngx_timeofday();
 435
 436     now = (ngx_msec_t) (tp->sec * 1000 + tp->msec);
 437
 438     /*
 439      * n == 1 deletes one or two zero rate entries
 440      * n == 0 deletes oldest entry by force
 441      *        and one or two zero rate entries
 442      */
 443
 444     while (n < 3) {
 445
 446         if (ngx_queue_empty(&ctx->sh->queue)) {
 447             return;
 448         }
 449
 450         q = ngx_queue_last(&ctx->sh->queue);
 451
 452         lr = ngx_queue_data(q, ngx_http_limit_req_node_t, queue);
 453
 454         if (n++ != 0) {
 455
 456             ms = (ngx_msec_int_t) (now - lr->last);
 457             ms = ngx_abs(ms);
 458
 459             if (ms < 60000) {
 460                 return;
 461             }
 462
 463             excess = lr->excess - ctx->rate * ms / 1000;
 464
 465             if (excess > 0) {
 466                 return;
 467             }
 468         }
 469
 470         ngx_queue_remove(q);
 471
 472         node = (ngx_rbtree_node_t *)
 473                    ((u_char *) lr - offsetof(ngx_rbtree_node_t, color));
 474
 475         ngx_rbtree_delete(&ctx->sh->rbtree, node);
 476
 477         ngx_slab_free_locked(ctx->shpool, node);
 478     }
 479 }
 480
 481
 482 static ngx_int_t
 483 ngx_http_limit_req_init_zone(ngx_shm_zone_t *shm_zone, void *data)
 484 {
 485     ngx_http_limit_req_ctx_t  *octx = data;
 486
 487     size_t                     len;
 488     ngx_http_limit_req_ctx_t  *ctx;
 489
 490     ctx = shm_zone->data;
 491
 492     if (octx) {
 493         if (ngx_strcmp(ctx->var.data, octx->var.data) != 0) {
 494             ngx_log_error(NGX_LOG_EMERG, shm_zone->shm.log, 0,
 495                           "limit_req \"%V\" uses the \"%V\" variable "
 496                           "while previously it used the \"%V\" variable",
 497                           &shm_zone->shm.name, &ctx->var, &octx->var);
 498             return NGX_ERROR;
 499         }
 500
 501         ctx->sh = octx->sh;
 502         ctx->shpool = octx->shpool;
 503
 504         return NGX_OK;
 505     }
 506
 507     ctx->shpool = (ngx_slab_pool_t *) shm_zone->shm.addr;
 508
 509     if (shm_zone->shm.exists) {
 510         ctx->sh = ctx->shpool->data;
 511
 512         return NGX_OK;
 513     }
 514
 515     ctx->sh = ngx_slab_alloc(ctx->shpool, sizeof(ngx_http_limit_req_shctx_t));
 516     if (ctx->sh == NULL) {
 517         return NGX_ERROR;
 518     }
 519
 520     ctx->shpool->data = ctx->sh;
 521
 522     ngx_rbtree_init(&ctx->sh->rbtree, &ctx->sh->sentinel,
 523                     ngx_http_limit_req_rbtree_insert_value);
 524
 525     ngx_queue_init(&ctx->sh->queue);
 526
 527     len = sizeof(" in limit_req zone \"\"") + shm_zone->shm.name.len;
 528
 529     ctx->shpool->log_ctx = ngx_slab_alloc(ctx->shpool, len);
 530     if (ctx->shpool->log_ctx == NULL) {
 531         return NGX_ERROR;
 532     }
 533
 534     ngx_sprintf(ctx->shpool->log_ctx, " in limit_req zone \"%V\"%Z",
 535                 &shm_zone->shm.name);
 536
 537     return NGX_OK;
 538 }
 539
 540
 541 static void *
 542 ngx_http_limit_req_create_conf(ngx_conf_t *cf)
 543 {
 544     ngx_http_limit_req_conf_t  *conf;
 545
 546     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_limit_req_conf_t));
 547     if (conf == NULL) {
 548         return NULL;
 549     }
 550
 551     /*
 552      * set by ngx_pcalloc():
 553      *
 554      *     conf->shm_zone = NULL;
 555      *     conf->burst = 0;
 556      *     conf->nodelay = 0;
 557      */
 558
 559     conf->limit_log_level = NGX_CONF_UNSET_UINT;
 560
 561     return conf;
 562 }
 563
 564
 565 static char *
 566 ngx_http_limit_req_merge_conf(ngx_conf_t *cf, void *parent, void *child)
 567 {
 568     ngx_http_limit_req_conf_t *prev = parent;
 569     ngx_http_limit_req_conf_t *conf = child;
 570
 571     if (conf->shm_zone == NULL) {
 572         *conf = *prev;
 573     }
 574
 575     ngx_conf_merge_uint_value(conf->limit_log_level, prev->limit_log_level,
 576                               NGX_LOG_ERR);
 577
 578     conf->delay_log_level = (conf->limit_log_level == NGX_LOG_INFO) ?
 579                                 NGX_LOG_INFO : conf->limit_log_level + 1;
 580
 581     return NGX_CONF_OK;
 582 }
 583
 584
 585 static char *
 586 ngx_http_limit_req_zone(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 587 {
 588     u_char                    *p;
 589     size_t                     size, len;
 590     ngx_str_t                 *value, name, s;
 591     ngx_int_t                  rate, scale;
 592     ngx_uint_t                 i;
 593     ngx_shm_zone_t            *shm_zone;
 594     ngx_http_limit_req_ctx_t  *ctx;
 595
 596     value = cf->args->elts;
 597
 598     ctx = NULL;
 599     size = 0;
 600     rate = 1;
 601     scale = 1;
 602     name.len = 0;
 603
 604     for (i = 1; i < cf->args->nelts; i++) {
 605
 606         if (ngx_strncmp(value[i].data, "zone=", 5) == 0) {
 607
 608             name.data = value[i].data + 5;
 609
 610             p = (u_char *) ngx_strchr(name.data, ':');
 611
 612             if (p) {
 613                 *p = '\0';
 614
 615                 name.len = p - name.data;
 616
 617                 p++;
 618
 619                 s.len = value[i].data + value[i].len - p;
 620                 s.data = p;
 621
 622                 size = ngx_parse_size(&s);
 623                 if (size > 8191) {
 624                     continue;
 625                 }
 626             }
 627
 628             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 629                                "invalid zone size \"%V\"", &value[i]);
 630             return NGX_CONF_ERROR;
 631         }
 632
 633         if (ngx_strncmp(value[i].data, "rate=", 5) == 0) {
 634
 635             len = value[i].len;
 636             p = value[i].data + len - 3;
 637
 638             if (ngx_strncmp(p, "r/s", 3) == 0) {
 639                 scale = 1;
 640                 len -= 3;
 641
 642             } else if (ngx_strncmp(p, "r/m", 3) == 0) {
 643                 scale = 60;
 644                 len -= 3;
 645             }
 646
 647             rate = ngx_atoi(value[i].data + 5, len - 5);
 648             if (rate <= NGX_ERROR) {
 649                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 650                                    "invalid rate \"%V\"", &value[i]);
 651                 return NGX_CONF_ERROR;
 652             }
 653
 654             continue;
 655         }
 656
 657         if (value[i].data[0] == '$') {
 658
 659             value[i].len--;
 660             value[i].data++;
 661
 662             ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_limit_req_ctx_t));
 663             if (ctx == NULL) {
 664                 return NGX_CONF_ERROR;
 665             }
 666
 667             ctx->index = ngx_http_get_variable_index(cf, &value[i]);
 668             if (ctx->index == NGX_ERROR) {
 669                 return NGX_CONF_ERROR;
 670             }
 671
 672             ctx->var = value[i];
 673
 674             continue;
 675         }
 676
 677         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 678                            "invalid parameter \"%V\"", &value[i]);
 679         return NGX_CONF_ERROR;
 680     }
 681
 682     if (name.len == 0 || size == 0) {
 683         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 684                            "\"%V\" must have \"zone\" parameter",
 685                            &cmd->name);
 686         return NGX_CONF_ERROR;
 687     }
 688
 689     if (ctx == NULL) {
 690         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 691                            "no variable is defined for limit_req_zone \"%V\"",
 692                            &cmd->name);
 693         return NGX_CONF_ERROR;
 694     }
 695
 696     ctx->rate = rate * 1000 / scale;
 697
 698     shm_zone = ngx_shared_memory_add(cf, &name, size,
 699                                      &ngx_http_limit_req_module);
 700     if (shm_zone == NULL) {
 701         return NGX_CONF_ERROR;
 702     }
 703
 704     if (shm_zone->data) {
 705         ctx = shm_zone->data;
 706
 707         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 708                    "limit_req_zone \"%V\" is already bound to variable \"%V\"",
 709                    &value[1], &ctx->var);
 710         return NGX_CONF_ERROR;
 711     }
 712
 713     shm_zone->init = ngx_http_limit_req_init_zone;
 714     shm_zone->data = ctx;
 715
 716     return NGX_CONF_OK;
 717 }
 718
 719
 720 static char *
 721 ngx_http_limit_req(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
 722 {
 723     ngx_http_limit_req_conf_t  *lrcf = conf;
 724
 725     ngx_int_t    burst;
 726     ngx_str_t   *value, s;
 727     ngx_uint_t   i;
 728
 729     if (lrcf->shm_zone) {
 730         return "is duplicate";
 731     }
 732
 733     value = cf->args->elts;
 734
 735     burst = 0;
 736
 737     for (i = 1; i < cf->args->nelts; i++) {
 738
 739         if (ngx_strncmp(value[i].data, "zone=", 5) == 0) {
 740
 741             s.len = value[i].len - 5;
 742             s.data = value[i].data + 5;
 743
 744             lrcf->shm_zone = ngx_shared_memory_add(cf, &s, 0,
 745                                                    &ngx_http_limit_req_module);
 746             if (lrcf->shm_zone == NULL) {
 747                 return NGX_CONF_ERROR;
 748             }
 749
 750             continue;
 751         }
 752
 753         if (ngx_strncmp(value[i].data, "burst=", 6) == 0) {
 754
 755             burst = ngx_atoi(value[i].data + 6, value[i].len - 6);
 756             if (burst <= 0) {
 757                 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 758                                    "invalid burst rate \"%V\"", &value[i]);
 759                 return NGX_CONF_ERROR;
 760             }
 761
 762             continue;
 763         }
 764
 765         if (ngx_strncmp(value[i].data, "nodelay", 7) == 0) {
 766             lrcf->nodelay = 1;
 767             continue;
 768         }
 769
 770         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 771                            "invalid parameter \"%V\"", &value[i]);
 772         return NGX_CONF_ERROR;
 773     }
 774
 775     if (lrcf->shm_zone == NULL) {
 776         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 777                            "\"%V\" must have \"zone\" parameter",
 778                            &cmd->name);
 779         return NGX_CONF_ERROR;
 780     }
 781
 782     if (lrcf->shm_zone->data == NULL) {
 783         ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
 784                            "unknown limit_req_zone \"%V\"",
 785                            &lrcf->shm_zone->shm.name);
 786         return NGX_CONF_ERROR;
 787     }
 788
 789     lrcf->burst = burst * 1000;
 790
 791     return NGX_CONF_OK;
 792 }
 793
 794
 795 static ngx_int_t
 796 ngx_http_limit_req_init(ngx_conf_t *cf)
 797 {
 798     ngx_http_handler_pt        *h;
 799     ngx_http_core_main_conf_t  *cmcf;
 800
 801     cmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_core_module);
 802
 803     h = ngx_array_push(&cmcf->phases[NGX_HTTP_PREACCESS_PHASE].handlers);
 804     if (h == NULL) {
 805         return NGX_ERROR;
 806     }
 807
 808     *h = ngx_http_limit_req_handler;
 809
 810     return NGX_OK;
 811 }