One Level Up Top Level

src/core/ngx_regex.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>


  12. typedef struct {
  13.     ngx_flag_t  pcre_jit;
  14. ‌} ngx_regex_conf_t;


  17. static void * ngx_libc_cdecl ngx_regex_malloc(size_t size);
  18. static void ngx_libc_cdecl ngx_regex_free(void *p);
  19. #if (NGX_HAVE_PCRE_JIT)
  20. static void ngx_pcre_free_studies(void *data);
  21. #endif

  23. static ngx_int_t ngx_regex_module_init(ngx_cycle_t *cycle);

  25. static void *ngx_regex_create_conf(ngx_cycle_t *cycle);
  26. static char *ngx_regex_init_conf(ngx_cycle_t *cycle, void *conf);

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


  32. ‌static ngx_command_t  ngx_regex_commands[] = {

  34.     { ngx_string("pcre_jit"),
  35.       NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
  36.       ngx_conf_set_flag_slot,
  37.       0,
  38.       offsetof(ngx_regex_conf_t, pcre_jit),
  39.       &ngx_regex_pcre_jit_post },

  41.       ngx_null_command
  42. };


  45. ‌static ngx_core_module_t  ngx_regex_module_ctx = {
  46.     ngx_string("regex"),
  47.     ngx_regex_create_conf,
  48.     ngx_regex_init_conf
  49. };


  52. ‌ngx_module_t  ngx_regex_module = {
  53.     NGX_MODULE_V1,
  54.     &ngx_regex_module_ctx,                 /* module context */
  55.     ngx_regex_commands,                    /* module directives */
  56.     NGX_CORE_MODULE,                       /* module type */
  57.     NULL,                                  /* init master */
  58.     ngx_regex_module_init,                 /* init module */
  59.     NULL,                                  /* init process */
  60.     NULL,                                  /* init thread */
  61.     NULL,                                  /* exit thread */
  62.     NULL,                                  /* exit process */
  63.     NULL,                                  /* exit master */
  64.     NGX_MODULE_V1_PADDING
  65. };


  68. ‌static ngx_pool_t  *ngx_pcre_pool;
  69. ‌static ngx_list_t  *ngx_pcre_studies;


  72. void
  73. ‌ngx_regex_init(void)
  74. {
  75.     pcre_malloc = ngx_regex_malloc;
  76.     pcre_free = ngx_regex_free;
  77. }


  80. static ngx_inline void
  81. ‌ngx_regex_malloc_init(ngx_pool_t *pool)
  82. {
  83. #if (NGX_THREADS)
  84.     ngx_core_tls_t  *tls;

  86.     if (ngx_threaded) {
  87.         tls = ngx_thread_get_tls(ngx_core_tls_key);
  88.         tls->pool = pool;
  89.         return;
  90.     }

  92. #endif

  94.     ngx_pcre_pool = pool;
  95. }


  98. static ngx_inline void
  99. ‌ngx_regex_malloc_done(void)
  100. {
  101. #if (NGX_THREADS)
  102.     ngx_core_tls_t  *tls;

  104.     if (ngx_threaded) {
  105.         tls = ngx_thread_get_tls(ngx_core_tls_key);
  106.         tls->pool = NULL;
  107.         return;
  108.     }

  110. #endif

  112.     ngx_pcre_pool = NULL;
  113. }


  116. ngx_int_t
  117. ‌ngx_regex_compile(ngx_regex_compile_t *rc)
  118. {
  119.     int               n, erroff;
  120.     char             *p;
  121.     pcre             *re;
  122.     const char       *errstr;
  123.     ngx_regex_elt_t  *elt;

  125.     ngx_regex_malloc_init(rc->pool);

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

  130.     /* ensure that there is no current pool */
  131.     ngx_regex_malloc_done();

  133.     if (re == NULL) {
  134.         if ((size_t) erroff == rc->pattern.len) {
  135.            rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
  136.                               "pcre_compile() failed: %s in \"%V\"",
  137.                                errstr, &rc->pattern)
  138.                       - rc->err.data;

  140.         } else {
  141.            rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
  142.                               "pcre_compile() failed: %s in \"%V\" at \"%s\"",
  143.                                errstr, &rc->pattern, rc->pattern.data + erroff)
  144.                       - rc->err.data;
  145.         }

  147.         return NGX_ERROR;
  148.     }

  150.     rc->regex = ngx_pcalloc(rc->pool, sizeof(ngx_regex_t));
  151.     if (rc->regex == NULL) {
  152.         goto nomem;
  153.     }

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

  157.     /* do not study at runtime */

  159.     if (ngx_pcre_studies != NULL) {
  160.         elt = ngx_list_push(ngx_pcre_studies);
  161.         if (elt == NULL) {
  162.             goto nomem;
  163.         }

  165.         elt->regex = rc->regex;
  166.         elt->name = rc->pattern.data;
  167.     }

  169.     n = pcre_fullinfo(re, NULL, PCRE_INFO_CAPTURECOUNT, &rc->captures);
  170.     if (n < 0) {
  171.         p = "pcre_fullinfo(\"%V\", PCRE_INFO_CAPTURECOUNT) failed: %d";
  172.         goto failed;
  173.     }

  175.     if (rc->captures == 0) {
  176.         return NGX_OK;
  177.     }

  179.     n = pcre_fullinfo(re, NULL, PCRE_INFO_NAMECOUNT, &rc->named_captures);
  180.     if (n < 0) {
  181.         p = "pcre_fullinfo(\"%V\", PCRE_INFO_NAMECOUNT) failed: %d";
  182.         goto failed;
  183.     }

  185.     if (rc->named_captures == 0) {
  186.         return NGX_OK;
  187.     }

  189.     n = pcre_fullinfo(re, NULL, PCRE_INFO_NAMEENTRYSIZE, &rc->name_size);
  190.     if (n < 0) {
  191.         p = "pcre_fullinfo(\"%V\", PCRE_INFO_NAMEENTRYSIZE) failed: %d";
  192.         goto failed;
  193.     }

  195.     n = pcre_fullinfo(re, NULL, PCRE_INFO_NAMETABLE, &rc->names);
  196.     if (n < 0) {
  197.         p = "pcre_fullinfo(\"%V\", PCRE_INFO_NAMETABLE) failed: %d";
  198.         goto failed;
  199.     }

  201.     return NGX_OK;

  203. failed:

  205.     rc->err.len = ngx_snprintf(rc->err.data, rc->err.len, p, &rc->pattern, n)
  206.                   - rc->err.data;
  207.     return NGX_ERROR;

  209. nomem:

  211.     rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
  212.                                "regex \"%V\" compilation failed: no memory",
  213.                                &rc->pattern)
  214.                   - rc->err.data;
  215.     return NGX_ERROR;
  216. }


  219. ngx_int_t
  220. ‌ngx_regex_exec_array(ngx_array_t *a, ngx_str_t *s, ngx_log_t *log)
  221. {
  222.     ngx_int_t         n;
  223.     ngx_uint_t        i;
  224.     ngx_regex_elt_t  *re;

  226.     re = a->elts;

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

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

  232.         if (n == NGX_REGEX_NO_MATCHED) {
  233.             continue;
  234.         }

  236.         if (n < 0) {
  237.             ngx_log_error(NGX_LOG_ALERT, log, 0,
  238.                           ngx_regex_exec_n " failed: %i on \"%V\" using \"%s\"",
  239.                           n, s, re[i].name);
  240.             return NGX_ERROR;
  241.         }

  243.         /* match */

  245.         return NGX_OK;
  246.     }

  248.     return NGX_DECLINED;
  249. }


  252. static void * ngx_libc_cdecl
  253. ‌ngx_regex_malloc(size_t size)
  254. {
  255.     ngx_pool_t      *pool;
  256. #if (NGX_THREADS)
  257.     ngx_core_tls_t  *tls;

  259.     if (ngx_threaded) {
  260.         tls = ngx_thread_get_tls(ngx_core_tls_key);
  261.         pool = tls->pool;

  263.     } else {
  264.         pool = ngx_pcre_pool;
  265.     }

  267. #else

  269.     pool = ngx_pcre_pool;

  271. #endif

  273.     if (pool) {
  274.         return ngx_palloc(pool, size);
  275.     }

  277.     return NULL;
  278. }


  281. static void ngx_libc_cdecl
  282. ‌ngx_regex_free(void *p)
  283. {
  284.     return;
  285. }


  288. #if (NGX_HAVE_PCRE_JIT)

  290. static void
  291. ‌ngx_pcre_free_studies(void *data)
  292. {
  293.     ngx_list_t *studies = data;

  295.     ngx_uint_t        i;
  296.     ngx_list_part_t  *part;
  297.     ngx_regex_elt_t  *elts;

  299.     part = &studies->part;
  300.     elts = part->elts;

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

  304.         if (i >= part->nelts) {
  305.             if (part->next == NULL) {
  306.                 break;
  307.             }

  309.             part = part->next;
  310.             elts = part->elts;
  311.             i = 0;
  312.         }

  314.         if (elts[i].regex->extra != NULL) {
  315.             pcre_free_study(elts[i].regex->extra);
  316.         }
  317.     }
  318. }

  320. #endif


  323. static ngx_int_t
  324. ‌ngx_regex_module_init(ngx_cycle_t *cycle)
  325. {
  326.     int               opt;
  327.     const char       *errstr;
  328.     ngx_uint_t        i;
  329.     ngx_list_part_t  *part;
  330.     ngx_regex_elt_t  *elts;

  332.     opt = 0;

  334. #if (NGX_HAVE_PCRE_JIT)
  335.     {
  336.     ngx_regex_conf_t    *rcf;
  337.     ngx_pool_cleanup_t  *cln;

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

  341.     if (rcf->pcre_jit) {
  342.         opt = PCRE_STUDY_JIT_COMPILE;

  344.         /*
  345.          * The PCRE JIT compiler uses mmap for its executable codes, so we
  346.          * have to explicitly call the pcre_free_study() function to free
  347.          * this memory.
  348.          */

  350.         cln = ngx_pool_cleanup_add(cycle->pool, 0);
  351.         if (cln == NULL) {
  352.             return NGX_ERROR;
  353.         }

  355.         cln->handler = ngx_pcre_free_studies;
  356.         cln->data = ngx_pcre_studies;
  357.     }
  358.     }
  359. #endif

  361.     ngx_regex_malloc_init(cycle->pool);

  363.     part = &ngx_pcre_studies->part;
  364.     elts = part->elts;

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

  368.         if (i >= part->nelts) {
  369.             if (part->next == NULL) {
  370.                 break;
  371.             }

  373.             part = part->next;
  374.             elts = part->elts;
  375.             i = 0;
  376.         }

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

  380.         if (errstr != NULL) {
  381.             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
  382.                           "pcre_study() failed: %s in \"%s\"",
  383.                           errstr, elts[i].name);
  384.         }

  386. #if (NGX_HAVE_PCRE_JIT)
  387.         if (opt & PCRE_STUDY_JIT_COMPILE) {
  388.             int jit, n;

  390.             jit = 0;
  391.             n = pcre_fullinfo(elts[i].regex->code, elts[i].regex->extra,
  392.                               PCRE_INFO_JIT, &jit);

  394.             if (n != 0 || jit != 1) {
  395.                 ngx_log_error(NGX_LOG_INFO, cycle->log, 0,
  396.                               "JIT compiler does not support pattern: \"%s\"",
  397.                               elts[i].name);
  398.             }
  399.         }
  400. #endif
  401.     }

  403.     ngx_regex_malloc_done();

  405.     ngx_pcre_studies = NULL;

  407.     return NGX_OK;
  408. }


  411. static void *
  412. ‌ngx_regex_create_conf(ngx_cycle_t *cycle)
  413. {
  414.     ngx_regex_conf_t  *rcf;

  416.     rcf = ngx_pcalloc(cycle->pool, sizeof(ngx_regex_conf_t));
  417.     if (rcf == NULL) {
  418.         return NULL;
  419.     }

  421.     rcf->pcre_jit = NGX_CONF_UNSET;

  423.     ngx_pcre_studies = ngx_list_create(cycle->pool, 8, sizeof(ngx_regex_elt_t));
  424.     if (ngx_pcre_studies == NULL) {
  425.         return NULL;
  426.     }

  428.     return rcf;
  429. }


  432. static char *
  433. ‌ngx_regex_init_conf(ngx_cycle_t *cycle, void *conf)
  434. {
  435.     ngx_regex_conf_t *rcf = conf;

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

  439.     return NGX_CONF_OK;
  440. }


  443. static char *
  444. ‌ngx_regex_pcre_jit(ngx_conf_t *cf, void *post, void *data)
  445. {
  446.     ngx_flag_t  *fp = data;

  448.     if (*fp == 0) {
  449.         return NGX_CONF_OK;
  450.     }

  452. #if (NGX_HAVE_PCRE_JIT)
  453.     {
  454.     int  jit, r;

  456.     jit = 0;
  457.     r = pcre_config(PCRE_CONFIG_JIT, &jit);

  459.     if (r != 0 || jit != 1) {
  460.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  461.                            "PCRE library does not support JIT");
  462.         *fp = 0;
  463.     }
  464.     }
  465. #else
  466.     ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  467.                        "nginx was built without PCRE JIT support");
  468.     *fp = 0;
  469. #endif

  471.     return NGX_CONF_OK;
  472. }

One Level Up Top Level