2003-11-26 04:44:56 +08:00
|
|
|
|
2004-09-28 16:34:51 +08:00
|
|
|
/*
|
2004-09-30 00:00:49 +08:00
|
|
|
* Copyright (C) Igor Sysoev
|
2012-01-18 23:07:43 +08:00
|
|
|
* Copyright (C) Nginx, Inc.
|
2004-09-28 16:34:51 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
2003-11-26 04:44:56 +08:00
|
|
|
#include <ngx_config.h>
|
|
|
|
#include <ngx_core.h>
|
|
|
|
|
|
|
|
|
2011-12-26 21:10:36 +08:00
|
|
|
typedef struct {
|
|
|
|
ngx_flag_t pcre_jit;
|
|
|
|
} ngx_regex_conf_t;
|
|
|
|
|
|
|
|
|
2005-03-23 00:02:46 +08:00
|
|
|
static void * ngx_libc_cdecl ngx_regex_malloc(size_t size);
|
|
|
|
static void ngx_libc_cdecl ngx_regex_free(void *p);
|
2003-11-26 04:44:56 +08:00
|
|
|
|
2011-12-26 21:10:36 +08:00
|
|
|
static ngx_int_t ngx_regex_module_init(ngx_cycle_t *cycle);
|
|
|
|
|
|
|
|
static void *ngx_regex_create_conf(ngx_cycle_t *cycle);
|
|
|
|
static char *ngx_regex_init_conf(ngx_cycle_t *cycle, void *conf);
|
|
|
|
|
|
|
|
static char *ngx_regex_pcre_jit(ngx_conf_t *cf, void *post, void *data);
|
|
|
|
static ngx_conf_post_t ngx_regex_pcre_jit_post = { ngx_regex_pcre_jit };
|
|
|
|
|
|
|
|
|
|
|
|
static ngx_command_t ngx_regex_commands[] = {
|
|
|
|
|
|
|
|
{ ngx_string("pcre_jit"),
|
|
|
|
NGX_MAIN_CONF|NGX_DIRECT_CONF|NGX_CONF_TAKE1,
|
|
|
|
ngx_conf_set_flag_slot,
|
|
|
|
0,
|
|
|
|
offsetof(ngx_regex_conf_t, pcre_jit),
|
|
|
|
&ngx_regex_pcre_jit_post },
|
|
|
|
|
|
|
|
ngx_null_command
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static ngx_core_module_t ngx_regex_module_ctx = {
|
|
|
|
ngx_string("regex"),
|
|
|
|
ngx_regex_create_conf,
|
|
|
|
ngx_regex_init_conf
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
ngx_module_t ngx_regex_module = {
|
|
|
|
NGX_MODULE_V1,
|
|
|
|
&ngx_regex_module_ctx, /* module context */
|
|
|
|
ngx_regex_commands, /* module directives */
|
|
|
|
NGX_CORE_MODULE, /* module type */
|
|
|
|
NULL, /* init master */
|
|
|
|
ngx_regex_module_init, /* init module */
|
|
|
|
NULL, /* init process */
|
|
|
|
NULL, /* init thread */
|
|
|
|
NULL, /* exit thread */
|
|
|
|
NULL, /* exit process */
|
|
|
|
NULL, /* exit master */
|
|
|
|
NGX_MODULE_V1_PADDING
|
|
|
|
};
|
|
|
|
|
2003-11-26 04:44:56 +08:00
|
|
|
|
|
|
|
static ngx_pool_t *ngx_pcre_pool;
|
2011-12-26 21:10:36 +08:00
|
|
|
static ngx_list_t *ngx_pcre_studies;
|
2003-11-26 04:44:56 +08:00
|
|
|
|
|
|
|
|
2005-03-23 00:02:46 +08:00
|
|
|
void
|
|
|
|
ngx_regex_init(void)
|
2003-11-26 04:44:56 +08:00
|
|
|
{
|
|
|
|
pcre_malloc = ngx_regex_malloc;
|
|
|
|
pcre_free = ngx_regex_free;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-11-16 20:19:02 +08:00
|
|
|
static ngx_inline void
|
|
|
|
ngx_regex_malloc_init(ngx_pool_t *pool)
|
2003-11-26 04:44:56 +08:00
|
|
|
{
|
2004-07-07 23:01:00 +08:00
|
|
|
#if (NGX_THREADS)
|
|
|
|
ngx_core_tls_t *tls;
|
|
|
|
|
|
|
|
if (ngx_threaded) {
|
|
|
|
tls = ngx_thread_get_tls(ngx_core_tls_key);
|
|
|
|
tls->pool = pool;
|
2009-11-16 20:19:02 +08:00
|
|
|
return;
|
2004-07-07 23:01:00 +08:00
|
|
|
}
|
|
|
|
|
2009-11-17 18:24:45 +08:00
|
|
|
#endif
|
2003-11-26 04:44:56 +08:00
|
|
|
|
|
|
|
ngx_pcre_pool = pool;
|
2009-11-16 20:19:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static ngx_inline void
|
|
|
|
ngx_regex_malloc_done(void)
|
|
|
|
{
|
|
|
|
#if (NGX_THREADS)
|
|
|
|
ngx_core_tls_t *tls;
|
|
|
|
|
|
|
|
if (ngx_threaded) {
|
|
|
|
tls = ngx_thread_get_tls(ngx_core_tls_key);
|
|
|
|
tls->pool = NULL;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-11-17 18:24:45 +08:00
|
|
|
#endif
|
2009-11-16 20:19:02 +08:00
|
|
|
|
|
|
|
ngx_pcre_pool = NULL;
|
|
|
|
}
|
2004-07-07 23:01:00 +08:00
|
|
|
|
2009-11-16 20:19:02 +08:00
|
|
|
|
|
|
|
ngx_int_t
|
|
|
|
ngx_regex_compile(ngx_regex_compile_t *rc)
|
|
|
|
{
|
2011-12-26 21:10:36 +08:00
|
|
|
int n, erroff;
|
|
|
|
char *p;
|
|
|
|
pcre *re;
|
|
|
|
const char *errstr;
|
|
|
|
ngx_regex_elt_t *elt;
|
2009-11-16 20:19:02 +08:00
|
|
|
|
|
|
|
ngx_regex_malloc_init(rc->pool);
|
|
|
|
|
|
|
|
re = pcre_compile((const char *) rc->pattern.data, (int) rc->options,
|
2004-03-16 15:10:12 +08:00
|
|
|
&errstr, &erroff, NULL);
|
2003-11-26 04:44:56 +08:00
|
|
|
|
2009-11-16 20:19:02 +08:00
|
|
|
/* ensure that there is no current pool */
|
|
|
|
ngx_regex_malloc_done();
|
|
|
|
|
2003-11-26 04:44:56 +08:00
|
|
|
if (re == NULL) {
|
2009-11-16 20:19:02 +08:00
|
|
|
if ((size_t) erroff == rc->pattern.len) {
|
|
|
|
rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
|
|
|
|
"pcre_compile() failed: %s in \"%V\"",
|
|
|
|
errstr, &rc->pattern)
|
|
|
|
- rc->err.data;
|
|
|
|
|
2003-11-26 04:44:56 +08:00
|
|
|
} else {
|
2009-11-16 20:19:02 +08:00
|
|
|
rc->err.len = ngx_snprintf(rc->err.data, rc->err.len,
|
|
|
|
"pcre_compile() failed: %s in \"%V\" at \"%s\"",
|
|
|
|
errstr, &rc->pattern, rc->pattern.data + erroff)
|
|
|
|
- rc->err.data;
|
2003-11-26 04:44:56 +08:00
|
|
|
}
|
2009-11-16 20:19:02 +08:00
|
|
|
|
|
|
|
return NGX_ERROR;
|
2003-11-26 04:44:56 +08:00
|
|
|
}
|
|
|
|
|
2011-12-26 21:10:36 +08:00
|
|
|
rc->regex = ngx_pcalloc(rc->pool, sizeof(ngx_regex_t));
|
|
|
|
if (rc->regex == NULL) {
|
|
|
|
return NGX_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc->regex->pcre = re;
|
|
|
|
|
|
|
|
/* do not study at runtime */
|
|
|
|
|
|
|
|
if (ngx_pcre_studies != NULL) {
|
|
|
|
elt = ngx_list_push(ngx_pcre_studies);
|
|
|
|
if (elt == NULL) {
|
|
|
|
return NGX_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
elt->regex = rc->regex;
|
|
|
|
elt->name = rc->pattern.data;
|
|
|
|
}
|
2004-03-23 14:01:52 +08:00
|
|
|
|
2009-11-16 20:19:02 +08:00
|
|
|
n = pcre_fullinfo(re, NULL, PCRE_INFO_CAPTURECOUNT, &rc->captures);
|
|
|
|
if (n < 0) {
|
|
|
|
p = "pcre_fullinfo(\"%V\", PCRE_INFO_CAPTURECOUNT) failed: %d";
|
|
|
|
goto failed;
|
2004-07-07 23:01:00 +08:00
|
|
|
}
|
2004-03-23 14:01:52 +08:00
|
|
|
|
2009-11-16 20:19:02 +08:00
|
|
|
if (rc->captures == 0) {
|
|
|
|
return NGX_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
n = pcre_fullinfo(re, NULL, PCRE_INFO_NAMECOUNT, &rc->named_captures);
|
|
|
|
if (n < 0) {
|
|
|
|
p = "pcre_fullinfo(\"%V\", PCRE_INFO_NAMECOUNT) failed: %d";
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rc->named_captures == 0) {
|
|
|
|
return NGX_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
n = pcre_fullinfo(re, NULL, PCRE_INFO_NAMEENTRYSIZE, &rc->name_size);
|
|
|
|
if (n < 0) {
|
|
|
|
p = "pcre_fullinfo(\"%V\", PCRE_INFO_NAMEENTRYSIZE) failed: %d";
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
n = pcre_fullinfo(re, NULL, PCRE_INFO_NAMETABLE, &rc->names);
|
|
|
|
if (n < 0) {
|
|
|
|
p = "pcre_fullinfo(\"%V\", PCRE_INFO_NAMETABLE) failed: %d";
|
|
|
|
goto failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NGX_OK;
|
|
|
|
|
|
|
|
failed:
|
|
|
|
|
|
|
|
rc->err.len = ngx_snprintf(rc->err.data, rc->err.len, p, &rc->pattern, n)
|
|
|
|
- rc->err.data;
|
|
|
|
return NGX_OK;
|
2003-11-26 04:44:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-12-27 21:15:08 +08:00
|
|
|
ngx_int_t
|
|
|
|
ngx_regex_exec_array(ngx_array_t *a, ngx_str_t *s, ngx_log_t *log)
|
|
|
|
{
|
|
|
|
ngx_int_t n;
|
|
|
|
ngx_uint_t i;
|
|
|
|
ngx_regex_elt_t *re;
|
|
|
|
|
|
|
|
re = a->elts;
|
|
|
|
|
|
|
|
for (i = 0; i < a->nelts; i++) {
|
|
|
|
|
|
|
|
n = ngx_regex_exec(re[i].regex, s, NULL, 0);
|
|
|
|
|
|
|
|
if (n == NGX_REGEX_NO_MATCHED) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (n < 0) {
|
|
|
|
ngx_log_error(NGX_LOG_ALERT, log, 0,
|
2009-11-16 20:19:02 +08:00
|
|
|
ngx_regex_exec_n " failed: %i on \"%V\" using \"%s\"",
|
2007-12-27 21:15:08 +08:00
|
|
|
n, s, re[i].name);
|
|
|
|
return NGX_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* match */
|
|
|
|
|
|
|
|
return NGX_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NGX_DECLINED;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-03-23 00:02:46 +08:00
|
|
|
static void * ngx_libc_cdecl
|
|
|
|
ngx_regex_malloc(size_t size)
|
2003-11-26 04:44:56 +08:00
|
|
|
{
|
2004-07-07 23:01:00 +08:00
|
|
|
ngx_pool_t *pool;
|
|
|
|
#if (NGX_THREADS)
|
|
|
|
ngx_core_tls_t *tls;
|
|
|
|
|
|
|
|
if (ngx_threaded) {
|
|
|
|
tls = ngx_thread_get_tls(ngx_core_tls_key);
|
|
|
|
pool = tls->pool;
|
2009-11-16 20:19:02 +08:00
|
|
|
|
2004-07-07 23:01:00 +08:00
|
|
|
} else {
|
|
|
|
pool = ngx_pcre_pool;
|
|
|
|
}
|
2009-11-16 20:19:02 +08:00
|
|
|
|
2004-07-07 23:01:00 +08:00
|
|
|
#else
|
2009-11-16 20:19:02 +08:00
|
|
|
|
2004-07-07 23:01:00 +08:00
|
|
|
pool = ngx_pcre_pool;
|
2009-11-16 20:19:02 +08:00
|
|
|
|
2004-07-07 23:01:00 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
if (pool) {
|
2008-06-17 23:00:30 +08:00
|
|
|
return ngx_palloc(pool, size);
|
2004-03-23 14:01:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
2003-11-26 04:44:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-03-23 00:02:46 +08:00
|
|
|
static void ngx_libc_cdecl
|
|
|
|
ngx_regex_free(void *p)
|
2003-11-26 04:44:56 +08:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2011-12-26 21:10:36 +08:00
|
|
|
|
|
|
|
|
|
|
|
static ngx_int_t
|
|
|
|
ngx_regex_module_init(ngx_cycle_t *cycle)
|
|
|
|
{
|
|
|
|
int opt;
|
|
|
|
const char *errstr;
|
|
|
|
ngx_uint_t i;
|
|
|
|
ngx_list_part_t *part;
|
|
|
|
ngx_regex_elt_t *elts;
|
|
|
|
|
|
|
|
opt = 0;
|
|
|
|
|
|
|
|
#if (NGX_HAVE_PCRE_JIT)
|
|
|
|
{
|
|
|
|
ngx_regex_conf_t *rcf;
|
|
|
|
|
|
|
|
rcf = (ngx_regex_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_regex_module);
|
|
|
|
|
|
|
|
if (rcf->pcre_jit) {
|
|
|
|
opt = PCRE_STUDY_JIT_COMPILE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
ngx_regex_malloc_init(cycle->pool);
|
|
|
|
|
|
|
|
part = &ngx_pcre_studies->part;
|
|
|
|
elts = part->elts;
|
|
|
|
|
|
|
|
for (i = 0 ; /* void */ ; i++) {
|
|
|
|
|
|
|
|
if (i >= part->nelts) {
|
|
|
|
if (part->next == NULL) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
part = part->next;
|
|
|
|
elts = part->elts;
|
|
|
|
i = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
elts[i].regex->extra = pcre_study(elts[i].regex->pcre, opt, &errstr);
|
|
|
|
|
|
|
|
if (errstr != NULL) {
|
|
|
|
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
|
|
|
|
"pcre_study() failed: %s in \"%s\"",
|
|
|
|
errstr, elts[i].name);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if (NGX_HAVE_PCRE_JIT)
|
|
|
|
if (opt & PCRE_STUDY_JIT_COMPILE) {
|
|
|
|
int jit, n;
|
|
|
|
|
|
|
|
jit = 0;
|
|
|
|
n = pcre_fullinfo(elts[i].regex->pcre, elts[i].regex->extra,
|
|
|
|
PCRE_INFO_JIT, &jit);
|
|
|
|
|
|
|
|
if (n != 0 || jit != 1) {
|
|
|
|
ngx_log_error(NGX_LOG_INFO, cycle->log, 0,
|
|
|
|
"JIT compiler does not support pattern: \"%s\"",
|
|
|
|
elts[i].name);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
ngx_regex_malloc_done();
|
|
|
|
|
|
|
|
ngx_pcre_studies = NULL;
|
|
|
|
|
|
|
|
return NGX_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void *
|
|
|
|
ngx_regex_create_conf(ngx_cycle_t *cycle)
|
|
|
|
{
|
|
|
|
ngx_regex_conf_t *rcf;
|
|
|
|
|
|
|
|
rcf = ngx_pcalloc(cycle->pool, sizeof(ngx_regex_conf_t));
|
|
|
|
if (rcf == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
rcf->pcre_jit = NGX_CONF_UNSET;
|
|
|
|
|
|
|
|
ngx_pcre_studies = ngx_list_create(cycle->pool, 8, sizeof(ngx_regex_elt_t));
|
|
|
|
if (ngx_pcre_studies == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rcf;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
ngx_regex_init_conf(ngx_cycle_t *cycle, void *conf)
|
|
|
|
{
|
|
|
|
ngx_regex_conf_t *rcf = conf;
|
|
|
|
|
|
|
|
ngx_conf_init_value(rcf->pcre_jit, 0);
|
|
|
|
|
|
|
|
return NGX_CONF_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
ngx_regex_pcre_jit(ngx_conf_t *cf, void *post, void *data)
|
|
|
|
{
|
|
|
|
ngx_flag_t *fp = data;
|
|
|
|
|
|
|
|
if (*fp == 0) {
|
|
|
|
return NGX_CONF_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
#if (NGX_HAVE_PCRE_JIT)
|
|
|
|
{
|
|
|
|
int jit, r;
|
|
|
|
|
|
|
|
jit = 0;
|
|
|
|
r = pcre_config(PCRE_CONFIG_JIT, &jit);
|
|
|
|
|
|
|
|
if (r != 0 || jit != 1) {
|
|
|
|
ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
|
|
|
|
"PCRE library does not support JIT");
|
|
|
|
*fp = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
|
2012-01-24 18:20:42 +08:00
|
|
|
"nginx was built without PCRE JIT support");
|
2011-12-26 21:10:36 +08:00
|
|
|
*fp = 0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return NGX_CONF_OK;
|
|
|
|
}
|