One Level Up Top Level

src/core/ngx_regex.c - nginx source code

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>


  12. ‌typedef struct {
  13.     ngx_flag_t   pcre_jit;
  14.     ngx_list_t  *studies;
  15. ‌} ngx_regex_conf_t;


  18. static ngx_inline void ngx_regex_malloc_init(ngx_pool_t *pool);
  19. static ngx_inline void ngx_regex_malloc_done(void);

  21. #if (NGX_PCRE2)
  22. static void * ngx_libc_cdecl ngx_regex_malloc(size_t size, void *data);
  23. static void ngx_libc_cdecl ngx_regex_free(void *p, void *data);
  24. #else
  25. static void * ngx_libc_cdecl ngx_regex_malloc(size_t size);
  26. static void ngx_libc_cdecl ngx_regex_free(void *p);
  27. #endif
  28. static void ngx_regex_cleanup(void *data);

  30. static ngx_int_t ngx_regex_module_init(ngx_cycle_t *cycle);

  32. static void *ngx_regex_create_conf(ngx_cycle_t *cycle);
  33. static char *ngx_regex_init_conf(ngx_cycle_t *cycle, void *conf);

  35. static char *ngx_regex_pcre_jit(ngx_conf_t *cf, void *post, void *data);
  36. ‌static ngx_conf_post_t  ngx_regex_pcre_jit_post = { ngx_regex_pcre_jit };


  39. ‌static ngx_command_t  ngx_regex_commands[] = {

  41.     { ngx_string("pcre_jit"),
  42.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_FLAG,
  43.       ngx_conf_set_flag_slot,
  44.       0,
  45.       offsetof(ngx_regex_conf_t, pcre_jit),
  46.       &ngx_regex_pcre_jit_post },

  48.       ngx_null_command
  49. };


  52. ‌static ngx_core_module_t  ngx_regex_module_ctx = {
  53.     ngx_string("regex"),
  54.     ngx_regex_create_conf,
  55.     ngx_regex_init_conf
  56. };


  59. ‌ngx_module_t  ngx_regex_module = {
  60.     NGX_MODULE_V1,
  61.     &ngx_regex_module_ctx,                 /* module context */
  62.     ngx_regex_commands,                    /* module directives */
  63.     NGX_CORE_MODULE,                       /* module type */
  64.     NULL,                                  /* init master */
  65.     ngx_regex_module_init,                 /* init module */
  66.     NULL,                                  /* init process */
  67.     NULL,                                  /* init thread */
  68.     NULL,                                  /* exit thread */
  69.     NULL,                                  /* exit process */
  70.     NULL,                                  /* exit master */
  71.     NGX_MODULE_V1_PADDING
  72. };


  75. ‌static ngx_pool_t             *ngx_regex_pool;
  76. ‌static ngx_list_t             *ngx_regex_studies;
  77. ‌static ngx_uint_t              ngx_regex_direct_alloc;

  79. #if (NGX_PCRE2)
  80. ‌static pcre2_compile_context  *ngx_regex_compile_context;
  81. ‌static pcre2_match_data       *ngx_regex_match_data;
  82. ‌static ngx_uint_t              ngx_regex_match_data_size;
  83. #endif


  86. void
  87. ‌ngx_regex_init(void)
  88. {
  89. #if !(NGX_PCRE2)
  90.     pcre_malloc = ngx_regex_malloc;
  91.     pcre_free = ngx_regex_free;
  92. #endif
  93. }


  96. static ngx_inline void
  97. ‌ngx_regex_malloc_init(ngx_pool_t *pool)
  98. {
  99.     ngx_regex_pool = pool;
  100.     ngx_regex_direct_alloc = (pool == NULL) ? 1 : 0;
  101. }


  104. static ngx_inline void
  105. ‌ngx_regex_malloc_done(void)
  106. {
  107.     ngx_regex_pool = NULL;
  108.     ngx_regex_direct_alloc = 0;
  109. }


  112. #if (NGX_PCRE2)

  114. ngx_int_t
  115. ‌ngx_regex_compile(ngx_regex_compile_t *rc)
  116. {
  117.     int                     n, errcode;
  118.     char                   *p;
  119.     u_char                  errstr[128];
  120.     size_t                  erroff;
  121.     uint32_t                options;
  122.     pcre2_code             *re;
  123.     ngx_regex_elt_t        *elt;
  124.     pcre2_general_context  *gctx;
  125.     pcre2_compile_context  *cctx;

  127.     if (ngx_regex_compile_context == NULL) {
  128.         /*
  129.          * Allocate a compile context if not yet allocated.  This uses
  130.          * direct allocations from heap, so the result can be cached
  131.          * even at runtime.
  132.          */

  134.         ngx_regex_malloc_init(NULL);

  136.         gctx = pcre2_general_context_create(ngx_regex_malloc, ngx_regex_free,
  137.                                             NULL);
  138.         if (gctx == NULL) {
  139.             ngx_regex_malloc_done();
  140.             goto nomem;
  141.         }

  143.         cctx = pcre2_compile_context_create(gctx);
  144.         if (cctx == NULL) {
  145.             pcre2_general_context_free(gctx);
  146.             ngx_regex_malloc_done();
  147.             goto nomem;
  148.         }

  150.         ngx_regex_compile_context = cctx;

  152.         pcre2_general_context_free(gctx);
  153.         ngx_regex_malloc_done();
  154.     }

  156.     options = 0;

  158.     if (rc->options & NGX_REGEX_CASELESS) {
  159.         options |= PCRE2_CASELESS;
  160.     }

  162.     if (rc->options & NGX_REGEX_MULTILINE) {
  163.         options |= PCRE2_MULTILINE;
  164.     }

  166.     if (rc->options & ~(NGX_REGEX_CASELESS|NGX_REGEX_MULTILINE)) {
  167.         rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
  168.                             "regex \"%V\" compilation failed: invalid options",
  169.                             &rc->pattern)
  170.                       - rc->err.data;
  171.         return NGX_ERROR;
  172.     }

  174.     ngx_regex_malloc_init(rc->pool);

  176.     re = pcre2_compile(rc->pattern.data, rc->pattern.len, options,
  177.                        &errcode, &erroff, ngx_regex_compile_context);

  179.     /* ensure that there is no current pool */
  180.     ngx_regex_malloc_done();

  182.     if (re == NULL) {
  183.         pcre2_get_error_message(errcode, errstr, 128);

  185.         if ((size_t) erroff == rc->pattern.len) {
  186.             rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
  187.                               "pcre2_compile() failed: %s in \"%V\"",
  188.                                errstr, &rc->pattern)
  189.                           - rc->err.data;

  191.         } else {
  192.             rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
  193.                               "pcre2_compile() failed: %s in \"%V\" at \"%s\"",
  194.                                errstr, &rc->pattern, rc->pattern.data + erroff)
  195.                           - rc->err.data;
  196.         }

  198.         return NGX_ERROR;
  199.     }

  201.     rc->regex = re;

  203.     /* do not study at runtime */

  205.     if (ngx_regex_studies != NULL) {
  206.         elt = ngx_list_push(ngx_regex_studies);
  207.         if (elt == NULL) {
  208.             goto nomem;
  209.         }

  211.         elt->regex = rc->regex;
  212.         elt->name = rc->pattern.data;
  213.     }

  215.     n = pcre2_pattern_info(re, PCRE2_INFO_CAPTURECOUNT, &rc->captures);
  216.     if (n < 0) {
  217.         p = "pcre2_pattern_info(\"%V\", PCRE2_INFO_CAPTURECOUNT) failed: %d";
  218.         goto failed;
  219.     }

  221.     if (rc->captures == 0) {
  222.         return NGX_OK;
  223.     }

  225.     n = pcre2_pattern_info(re, PCRE2_INFO_NAMECOUNT, &rc->named_captures);
  226.     if (n < 0) {
  227.         p = "pcre2_pattern_info(\"%V\", PCRE2_INFO_NAMECOUNT) failed: %d";
  228.         goto failed;
  229.     }

  231.     if (rc->named_captures == 0) {
  232.         return NGX_OK;
  233.     }

  235.     n = pcre2_pattern_info(re, PCRE2_INFO_NAMEENTRYSIZE, &rc->name_size);
  236.     if (n < 0) {
  237.         p = "pcre2_pattern_info(\"%V\", PCRE2_INFO_NAMEENTRYSIZE) failed: %d";
  238.         goto failed;
  239.     }

  241.     n = pcre2_pattern_info(re, PCRE2_INFO_NAMETABLE, &rc->names);
  242.     if (n < 0) {
  243.         p = "pcre2_pattern_info(\"%V\", PCRE2_INFO_NAMETABLE) failed: %d";
  244.         goto failed;
  245.     }

  247.     return NGX_OK;

  249. failed:

  251.     rc->err.len = ngx_snprintf(rc->err.data, rc->err.len, p, &rc->pattern, n)
  252.                   - rc->err.data;
  253.     return NGX_ERROR;

  255. nomem:

  257.     rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
  258.                                "regex \"%V\" compilation failed: no memory",
  259.                                &rc->pattern)
  260.                   - rc->err.data;
  261.     return NGX_ERROR;
  262. }

  264. #else

  266. ngx_int_t
  267. ‌ngx_regex_compile(ngx_regex_compile_t *rc)
  268. {
  269.     int               n, erroff;
  270.     char             *p;
  271.     pcre             *re;
  272.     const char       *errstr;
  273.     ngx_uint_t        options;
  274.     ngx_regex_elt_t  *elt;

  276.     options = 0;

  278.     if (rc->options & NGX_REGEX_CASELESS) {
  279.         options |= PCRE_CASELESS;
  280.     }

  282.     if (rc->options & NGX_REGEX_MULTILINE) {
  283.         options |= PCRE_MULTILINE;
  284.     }

  286.     if (rc->options & ~(NGX_REGEX_CASELESS|NGX_REGEX_MULTILINE)) {
  287.         rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
  288.                             "regex \"%V\" compilation failed: invalid options",
  289.                             &rc->pattern)
  290.                       - rc->err.data;
  291.         return NGX_ERROR;
  292.     }

  294.     ngx_regex_malloc_init(rc->pool);

  296.     re = pcre_compile((const char *) rc->pattern.data, (int) options,
  297.                       &errstr, &erroff, NULL);

  299.     /* ensure that there is no current pool */
  300.     ngx_regex_malloc_done();

  302.     if (re == NULL) {
  303.         if ((size_t) erroff == rc->pattern.len) {
  304.            rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
  305.                               "pcre_compile() failed: %s in \"%V\"",
  306.                                errstr, &rc->pattern)
  307.                          - rc->err.data;

  309.         } else {
  310.            rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
  311.                               "pcre_compile() failed: %s in \"%V\" at \"%s\"",
  312.                                errstr, &rc->pattern, rc->pattern.data + erroff)
  313.                          - rc->err.data;
  314.         }

  316.         return NGX_ERROR;
  317.     }

  319.     rc->regex = ngx_pcalloc(rc->pool, sizeof(ngx_regex_t));
  320.     if (rc->regex == NULL) {
  321.         goto nomem;
  322.     }

  324.     rc->regex->code = re;

  326.     /* do not study at runtime */

  328.     if (ngx_regex_studies != NULL) {
  329.         elt = ngx_list_push(ngx_regex_studies);
  330.         if (elt == NULL) {
  331.             goto nomem;
  332.         }

  334.         elt->regex = rc->regex;
  335.         elt->name = rc->pattern.data;
  336.     }

  338.     n = pcre_fullinfo(re, NULL, PCRE_INFO_CAPTURECOUNT, &rc->captures);
  339.     if (n < 0) {
  340.         p = "pcre_fullinfo(\"%V\", PCRE_INFO_CAPTURECOUNT) failed: %d";
  341.         goto failed;
  342.     }

  344.     if (rc->captures == 0) {
  345.         return NGX_OK;
  346.     }

  348.     n = pcre_fullinfo(re, NULL, PCRE_INFO_NAMECOUNT, &rc->named_captures);
  349.     if (n < 0) {
  350.         p = "pcre_fullinfo(\"%V\", PCRE_INFO_NAMECOUNT) failed: %d";
  351.         goto failed;
  352.     }

  354.     if (rc->named_captures == 0) {
  355.         return NGX_OK;
  356.     }

  358.     n = pcre_fullinfo(re, NULL, PCRE_INFO_NAMEENTRYSIZE, &rc->name_size);
  359.     if (n < 0) {
  360.         p = "pcre_fullinfo(\"%V\", PCRE_INFO_NAMEENTRYSIZE) failed: %d";
  361.         goto failed;
  362.     }

  364.     n = pcre_fullinfo(re, NULL, PCRE_INFO_NAMETABLE, &rc->names);
  365.     if (n < 0) {
  366.         p = "pcre_fullinfo(\"%V\", PCRE_INFO_NAMETABLE) failed: %d";
  367.         goto failed;
  368.     }

  370.     return NGX_OK;

  372. failed:

  374.     rc->err.len = ngx_snprintf(rc->err.data, rc->err.len, p, &rc->pattern, n)
  375.                   - rc->err.data;
  376.     return NGX_ERROR;

  378. nomem:

  380.     rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
  381.                                "regex \"%V\" compilation failed: no memory",
  382.                                &rc->pattern)
  383.                   - rc->err.data;
  384.     return NGX_ERROR;
  385. }

  387. #endif


  390. #if (NGX_PCRE2)

  392. ngx_int_t
  393. ‌ngx_regex_exec(ngx_regex_t *re, ngx_str_t *s, int *captures, ngx_uint_t size)
  394. {
  395.     size_t      *ov;
  396.     ngx_int_t    rc;
  397.     ngx_uint_t   n, i;

  399.     /*
  400.      * The pcre2_match() function might allocate memory for backtracking
  401.      * frames, typical allocations are from 40k and above.  So the allocator
  402.      * is configured to do direct allocations from heap during matching.
  403.      */

  405.     ngx_regex_malloc_init(NULL);

  407.     if (ngx_regex_match_data == NULL
  408.         || size > ngx_regex_match_data_size)
  409.     {
  410.         /*
  411.          * Allocate a match data if not yet allocated or smaller than
  412.          * needed.
  413.          */

  415.         if (ngx_regex_match_data) {
  416.             pcre2_match_data_free(ngx_regex_match_data);
  417.         }

  419.         ngx_regex_match_data_size = size;
  420.         ngx_regex_match_data = pcre2_match_data_create(size / 3, NULL);

  422.         if (ngx_regex_match_data == NULL) {
  423.             rc = PCRE2_ERROR_NOMEMORY;
  424.             goto failed;
  425.         }
  426.     }

  428.     rc = pcre2_match(re, s->data, s->len, 0, 0, ngx_regex_match_data, NULL);

  430.     if (rc < 0) {
  431.         goto failed;
  432.     }

  434.     n = pcre2_get_ovector_count(ngx_regex_match_data);
  435.     ov = pcre2_get_ovector_pointer(ngx_regex_match_data);

  437.     if (n > size / 3) {
  438.         n = size / 3;
  439.     }

  441.     for (i = 0; i < n; i++) {
  442.         captures[i * 2] = ov[i * 2];
  443.         captures[i * 2 + 1] = ov[i * 2 + 1];
  444.     }

  446. failed:

  448.     ngx_regex_malloc_done();

  450.     return rc;
  451. }

  453. #else

  455. ngx_int_t
  456. ‌ngx_regex_exec(ngx_regex_t *re, ngx_str_t *s, int *captures, ngx_uint_t size)
  457. {
  458.     return pcre_exec(re->code, re->extra, (const char *) s->data, s->len,
  459.                      0, 0, captures, size);
  460. }

  462. #endif


  465. ngx_int_t
  466. ‌ngx_regex_exec_array(ngx_array_t *a, ngx_str_t *s, ngx_log_t *log)
  467. {
  468.     ngx_int_t         n;
  469.     ngx_uint_t        i;
  470.     ngx_regex_elt_t  *re;

  472.     re = a->elts;

  474.     for (i = 0; i < a->nelts; i++) {

  476.         n = ngx_regex_exec(re[i].regex, s, NULL, 0);

  478.         if (n == NGX_REGEX_NO_MATCHED) {
  479.             continue;
  480.         }

  482.         if (n < 0) {
  483.             ngx_log_error(NGX_LOG_ALERT, log, 0,
  484.                           ngx_regex_exec_n " failed: %i on \"%V\" using \"%s\"",
  485.                           n, s, re[i].name);
  486.             return NGX_ERROR;
  487.         }

  489.         /* match */

  491.         return NGX_OK;
  492.     }

  494.     return NGX_DECLINED;
  495. }


  498. #if (NGX_PCRE2)

  500. static void * ngx_libc_cdecl
  501. ‌ngx_regex_malloc(size_t size, void *data)
  502. {
  503.     if (ngx_regex_pool) {
  504.         return ngx_palloc(ngx_regex_pool, size);
  505.     }

  507.     if (ngx_regex_direct_alloc) {
  508.         return ngx_alloc(size, ngx_cycle->log);
  509.     }

  511.     return NULL;
  512. }


  515. static void ngx_libc_cdecl
  516. ‌ngx_regex_free(void *p, void *data)
  517. {
  518.     if (ngx_regex_direct_alloc) {
  519.         ngx_free(p);
  520.     }

  522.     return;
  523. }

  525. #else

  527. static void * ngx_libc_cdecl
  528. ‌ngx_regex_malloc(size_t size)
  529. {
  530.     if (ngx_regex_pool) {
  531.         return ngx_palloc(ngx_regex_pool, size);
  532.     }

  534.     return NULL;
  535. }


  538. static void ngx_libc_cdecl
  539. ‌ngx_regex_free(void *p)
  540. {
  541.     return;
  542. }

  544. #endif


  547. static void
  548. ‌ngx_regex_cleanup(void *data)
  549. {
  550. #if (NGX_PCRE2 || NGX_HAVE_PCRE_JIT)
  551.     ngx_regex_conf_t *rcf = data;

  553.     ngx_uint_t        i;
  554.     ngx_list_part_t  *part;
  555.     ngx_regex_elt_t  *elts;

  557.     part = &rcf->studies->part;
  558.     elts = part->elts;

  560.     for (i = 0; /* void */ ; i++) {

  562.         if (i >= part->nelts) {
  563.             if (part->next == NULL) {
  564.                 break;
  565.             }

  567.             part = part->next;
  568.             elts = part->elts;
  569.             i = 0;
  570.         }

  572.         /*
  573.          * The PCRE JIT compiler uses mmap for its executable codes, so we
  574.          * have to explicitly call the pcre_free_study() function to free
  575.          * this memory.  In PCRE2, we call the pcre2_code_free() function
  576.          * for the same reason.
  577.          */

  579. #if (NGX_PCRE2)
  580.         pcre2_code_free(elts[i].regex);
  581. #else
  582.         if (elts[i].regex->extra != NULL) {
  583.             pcre_free_study(elts[i].regex->extra);
  584.         }
  585. #endif
  586.     }
  587. #endif

  589.     /*
  590.      * On configuration parsing errors ngx_regex_module_init() will not
  591.      * be called.  Make sure ngx_regex_studies is properly cleared anyway.
  592.      */

  594.     ngx_regex_studies = NULL;

  596. #if (NGX_PCRE2)

  598.     /*
  599.      * Free compile context and match data.  If needed at runtime by
  600.      * the new cycle, these will be re-allocated.
  601.      */

  603.     ngx_regex_malloc_init(NULL);

  605.     if (ngx_regex_compile_context) {
  606.         pcre2_compile_context_free(ngx_regex_compile_context);
  607.         ngx_regex_compile_context = NULL;
  608.     }

  610.     if (ngx_regex_match_data) {
  611.         pcre2_match_data_free(ngx_regex_match_data);
  612.         ngx_regex_match_data = NULL;
  613.         ngx_regex_match_data_size = 0;
  614.     }

  616.     ngx_regex_malloc_done();

  618. #endif
  619. }


  622. static ngx_int_t
  623. ‌ngx_regex_module_init(ngx_cycle_t *cycle)
  624. {
  625.     int                opt;
  626. #if !(NGX_PCRE2)
  627.     const char        *errstr;
  628. #endif
  629.     ngx_uint_t         i;
  630.     ngx_list_part_t   *part;
  631.     ngx_regex_elt_t   *elts;
  632.     ngx_regex_conf_t  *rcf;

  634.     opt = 0;

  636.     rcf = (ngx_regex_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_regex_module);

  638. #if (NGX_PCRE2 || NGX_HAVE_PCRE_JIT)

  640.     if (rcf->pcre_jit) {
  641. #if (NGX_PCRE2)
  642.         opt = 1;
  643. #else
  644.         opt = PCRE_STUDY_JIT_COMPILE;
  645. #endif
  646.     }

  648. #endif

  650.     ngx_regex_malloc_init(cycle->pool);

  652.     part = &rcf->studies->part;
  653.     elts = part->elts;

  655.     for (i = 0; /* void */ ; i++) {

  657.         if (i >= part->nelts) {
  658.             if (part->next == NULL) {
  659.                 break;
  660.             }

  662.             part = part->next;
  663.             elts = part->elts;
  664.             i = 0;
  665.         }

  667. #if (NGX_PCRE2)

  669.         if (opt) {
  670.             int  n;

  672.             n = pcre2_jit_compile(elts[i].regex, PCRE2_JIT_COMPLETE);

  674.             if (n != 0) {
  675.                 ngx_log_error(NGX_LOG_INFO, cycle->log, 0,
  676.                               "pcre2_jit_compile() failed: %d in \"%s\", "
  677.                               "ignored",
  678.                               n, elts[i].name);
  679.             }
  680.         }

  682. #else

  684.         elts[i].regex->extra = pcre_study(elts[i].regex->code, opt, &errstr);

  686.         if (errstr != NULL) {
  687.             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  688.                           "pcre_study() failed: %s in \"%s\"",
  689.                           errstr, elts[i].name);
  690.         }

  692. #if (NGX_HAVE_PCRE_JIT)
  693.         if (opt & PCRE_STUDY_JIT_COMPILE) {
  694.             int jit, n;

  696.             jit = 0;
  697.             n = pcre_fullinfo(elts[i].regex->code, elts[i].regex->extra,
  698.                               PCRE_INFO_JIT, &jit);

  700.             if (n != 0 || jit != 1) {
  701.                 ngx_log_error(NGX_LOG_INFO, cycle->log, 0,
  702.                               "JIT compiler does not support pattern: \"%s\"",
  703.                               elts[i].name);
  704.             }
  705.         }
  706. #endif
  707. #endif
  708.     }

  710.     ngx_regex_malloc_done();

  712.     ngx_regex_studies = NULL;

  714.     return NGX_OK;
  715. }


  718. static void *
  719. ‌ngx_regex_create_conf(ngx_cycle_t *cycle)
  720. {
  721.     ngx_regex_conf_t    *rcf;
  722.     ngx_pool_cleanup_t  *cln;

  724.     rcf = ngx_pcalloc(cycle->pool, sizeof(ngx_regex_conf_t));
  725.     if (rcf == NULL) {
  726.         return NULL;
  727.     }

  729.     rcf->pcre_jit = NGX_CONF_UNSET;

  731.     cln = ngx_pool_cleanup_add(cycle->pool, 0);
  732.     if (cln == NULL) {
  733.         return NULL;
  734.     }

  736.     rcf->studies = ngx_list_create(cycle->pool, 8, sizeof(ngx_regex_elt_t));
  737.     if (rcf->studies == NULL) {
  738.         return NULL;
  739.     }

  741.     cln->handler = ngx_regex_cleanup;
  742.     cln->data = rcf;

  744.     ngx_regex_studies = rcf->studies;

  746.     return rcf;
  747. }


  750. static char *
  751. ‌ngx_regex_init_conf(ngx_cycle_t *cycle, void *conf)
  752. {
  753.     ngx_regex_conf_t *rcf = conf;

  755.     ngx_conf_init_value(rcf->pcre_jit, 0);

  757.     return NGX_CONF_OK;
  758. }


  761. static char *
  762. ‌ngx_regex_pcre_jit(ngx_conf_t *cf, void *post, void *data)
  763. {
  764.     ngx_flag_t  *fp = data;

  766.     if (*fp == 0) {
  767.         return NGX_CONF_OK;
  768.     }

  770. #if (NGX_PCRE2)
  771.     {
  772.     int       r;
  773.     uint32_t  jit;

  775.     jit = 0;
  776.     r = pcre2_config(PCRE2_CONFIG_JIT, &jit);

  778.     if (r != 0 || jit != 1) {
  779.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  780.                            "PCRE2 library does not support JIT");
  781.         *fp = 0;
  782.     }
  783.     }
  784. #elif (NGX_HAVE_PCRE_JIT)
  785.     {
  786.     int  jit, r;

  788.     jit = 0;
  789.     r = pcre_config(PCRE_CONFIG_JIT, &jit);

  791.     if (r != 0 || jit != 1) {
  792.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  793.                            "PCRE library does not support JIT");
  794.         *fp = 0;
  795.     }
  796.     }
  797. #else
  798.     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  799.                        "nginx was built without PCRE JIT support");
  800.     *fp = 0;
  801. #endif

  803.     return NGX_CONF_OK;
  804. }

One Level Up Top Level