diff options
Diffstat (limited to 'ngx_stream_lua-0.0.16/src/ngx_stream_lua_regex.c')
| -rw-r--r-- | ngx_stream_lua-0.0.16/src/ngx_stream_lua_regex.c | 1007 |
1 files changed, 1007 insertions, 0 deletions
diff --git a/ngx_stream_lua-0.0.16/src/ngx_stream_lua_regex.c b/ngx_stream_lua-0.0.16/src/ngx_stream_lua_regex.c new file mode 100644 index 0000000..080e5dd --- /dev/null +++ b/ngx_stream_lua-0.0.16/src/ngx_stream_lua_regex.c @@ -0,0 +1,1007 @@ + +/* + * !!! DO NOT EDIT DIRECTLY !!! + * This file was automatically generated from the following template: + * + * src/subsys/ngx_subsys_lua_regex.c.tt2 + */ + + +/* + * Copyright (C) Yichun Zhang (agentzh) + */ + + +#ifndef DDEBUG +#define DDEBUG 0 +#endif +#include "ddebug.h" + + +#if (NGX_PCRE) + +#include "ngx_stream_lua_pcrefix.h" +#include "ngx_stream_lua_script.h" +#include "ngx_stream_lua_util.h" + + +#if (PCRE_MAJOR >= 6 || NGX_PCRE2) +# define LUA_HAVE_PCRE_DFA 1 +#else +# define LUA_HAVE_PCRE_DFA 0 +#endif + + +#if (NGX_PCRE2) +static pcre2_compile_context *ngx_regex_compile_context; +static pcre2_match_context *ngx_regex_match_context; +static pcre2_match_data *ngx_regex_match_data; +static ngx_uint_t ngx_regex_match_data_size = 0; + +#define PCRE2_VERSION_SIZE 64 +static char ngx_pcre2_version[PCRE2_VERSION_SIZE]; +#endif + + +#define NGX_LUA_RE_MODE_DFA (1<<1) +#define NGX_LUA_RE_MODE_JIT (1<<2) +#define NGX_LUA_RE_NO_UTF8_CHECK (1<<4) + +#define NGX_LUA_RE_DFA_MODE_WORKSPACE_COUNT (100) + +#define NGX_LUA_RE_MIN_JIT_STACK_SIZE 32 * 1024 + + +typedef struct { + ngx_pool_t *pool; + u_char *name_table; + int name_count; + int name_entry_size; + + int ncaptures; + int *captures; + +#if (NGX_PCRE2) + pcre2_code *regex; + /* + * pcre2 doesn't use pcre_extra any more, + * just for keeping same memory layout in the lua ffi cdef + */ + void *regex_sd; +#else + pcre *regex; + pcre_extra *regex_sd; +#endif + + ngx_stream_lua_complex_value_t *replace; + + /* only for (stap) debugging, and may be an invalid pointer */ + const u_char *pattern; +} ngx_stream_lua_regex_t; + + +typedef struct { + ngx_str_t pattern; + ngx_pool_t *pool; + ngx_int_t options; + +#if (NGX_PCRE2) + pcre2_code *regex; +#else + pcre *regex; +#endif + int captures; + ngx_str_t err; +} ngx_stream_lua_regex_compile_t; + + +typedef struct { + ngx_stream_lua_request_t *request; + +#if (NGX_PCRE2) + pcre2_code *regex; +#else + pcre *regex; + pcre_extra *regex_sd; +#endif + int ncaptures; + int *captures; + int captures_len; + uint8_t flags; +} ngx_stream_lua_regex_ctx_t; + + +static ngx_int_t ngx_stream_lua_regex_compile( + ngx_stream_lua_regex_compile_t *rc); + + +#define ngx_stream_lua_regex_exec(re, e, s, start, captures, size, \ + opts) \ + pcre_exec(re, e, (const char *) (s)->data, (s)->len, start, opts, \ + captures, size) + + +#define ngx_stream_lua_regex_dfa_exec(re, e, s, start, captures, size, \ + ws, wscount, opts) \ + pcre_dfa_exec(re, e, (const char *) (s)->data, (s)->len, start, opts, \ + captures, size, ws, wscount) + + +static void +ngx_stream_lua_regex_free_study_data(ngx_pool_t *pool, + ngx_stream_lua_regex_t *re) +{ + ngx_pool_t *old_pool; + +#if (NGX_PCRE2) + if (re && re->regex) { + old_pool = ngx_stream_lua_pcre_malloc_init(pool); + + pcre2_code_free(re->regex); + + ngx_stream_lua_pcre_malloc_done(old_pool); + + re->regex = NULL; + } +#else + if (re && re->regex_sd) { + old_pool = ngx_stream_lua_pcre_malloc_init(pool); +#if LUA_HAVE_PCRE_JIT + pcre_free_study(re->regex_sd); +#else + pcre_free(re->regex_sd); +#endif + ngx_stream_lua_pcre_malloc_done(old_pool); + + re->regex_sd = NULL; + } +#endif +} + + +#if (NGX_PCRE2) +static ngx_int_t +ngx_stream_lua_regex_compile(ngx_stream_lua_regex_compile_t *rc) +{ + int n, errcode; + char *p; + size_t erroff; + u_char errstr[128]; + pcre2_code *re; + ngx_pool_t *old_pool; + pcre2_general_context *gctx; + pcre2_compile_context *cctx; + + ngx_stream_lua_main_conf_t *lmcf; + + if (ngx_regex_compile_context == NULL) { + /* + * Allocate a compile context if not yet allocated. This uses + * direct allocations from heap, so the result can be cached + * even at runtime. + */ + + old_pool = ngx_stream_lua_pcre_malloc_init(NULL); + + gctx = pcre2_general_context_create(ngx_stream_lua_pcre_malloc, + ngx_stream_lua_pcre_free, + NULL); + if (gctx == NULL) { + ngx_stream_lua_pcre_malloc_done(old_pool); + goto nomem; + } + + cctx = pcre2_compile_context_create(gctx); + if (cctx == NULL) { + pcre2_general_context_free(gctx); + ngx_stream_lua_pcre_malloc_done(old_pool); + goto nomem; + } + + ngx_regex_compile_context = cctx; + + ngx_regex_match_context = pcre2_match_context_create(gctx); + if (ngx_regex_match_context == NULL) { + pcre2_general_context_free(gctx); + ngx_stream_lua_pcre_malloc_done(old_pool); + goto nomem; + } + + lmcf = ngx_stream_cycle_get_module_main_conf(ngx_cycle, + ngx_stream_lua_module); + if (lmcf && lmcf->regex_match_limit > 0) { + pcre2_set_match_limit(ngx_regex_match_context, + lmcf->regex_match_limit); + } + + pcre2_general_context_free(gctx); + ngx_stream_lua_pcre_malloc_done(old_pool); + } + + old_pool = ngx_stream_lua_pcre_malloc_init(rc->pool); + + re = pcre2_compile(rc->pattern.data, + rc->pattern.len, rc->options, + &errcode, &erroff, ngx_regex_compile_context); + + ngx_stream_lua_pcre_malloc_done(old_pool); + + if (re == NULL) { + pcre2_get_error_message(errcode, errstr, 128); + + if ((size_t) erroff == rc->pattern.len) { + rc->err.len = ngx_snprintf(rc->err.data, rc->err.len, + "pcre2_compile() failed: %s in \"%V\"", + errstr, &rc->pattern) + - rc->err.data; + + } else { + rc->err.len = ngx_snprintf(rc->err.data, rc->err.len, + "pcre2_compile() failed: %s in " + "\"%V\" at \"%s\"", errstr, &rc->pattern, + rc->pattern.data + erroff) + - rc->err.data; + } + + return NGX_ERROR; + } + + rc->regex = re; + + n = pcre2_pattern_info(re, PCRE2_INFO_CAPTURECOUNT, &rc->captures); + if (n < 0) { + p = "pcre2_pattern_info(\"%V\", PCRE_INFO_CAPTURECOUNT) failed: %d"; + goto failed; + } + +#if (NGX_DEBUG) + ngx_log_debug3(NGX_LOG_DEBUG_STREAM, ngx_cycle->log, 0, + "pcre2_compile: pattern[%V], options 0x%08Xd, ncaptures %d", + &rc->pattern, rc->options, rc->captures); +#endif + + return NGX_OK; + +failed: + + rc->err.len = ngx_snprintf(rc->err.data, rc->err.len, p, &rc->pattern, n) + - rc->err.data; + return NGX_ERROR; + +nomem: + + rc->err.len = ngx_snprintf(rc->err.data, rc->err.len, + "regex \"%V\" compilation failed: no memory", + &rc->pattern) + - rc->err.data; + return NGX_ERROR; +} + +#else + +static ngx_int_t +ngx_stream_lua_regex_compile(ngx_stream_lua_regex_compile_t *rc) +{ + int n, erroff; + char *p; + const char *errstr; + pcre *re; + ngx_pool_t *old_pool; + + old_pool = ngx_stream_lua_pcre_malloc_init(rc->pool); + + re = pcre_compile((const char *) rc->pattern.data, (int) rc->options, + &errstr, &erroff, NULL); + + ngx_stream_lua_pcre_malloc_done(old_pool); + + if (re == NULL) { + 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; + + } else { + 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; + } + + return NGX_ERROR; + } + + rc->regex = re; + +#if 1 + n = pcre_fullinfo(re, NULL, PCRE_INFO_CAPTURECOUNT, &rc->captures); + if (n < 0) { + p = "pcre_fullinfo(\"%V\", PCRE_INFO_CAPTURECOUNT) failed: %d"; + goto failed; + } +#endif + + 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; +} +#endif + + +ngx_int_t +ngx_stream_lua_ffi_set_jit_stack_size(int size, u_char *errstr, + size_t *errstr_size) +{ +#if (LUA_HAVE_PCRE_JIT) + + ngx_stream_lua_main_conf_t *lmcf; + ngx_pool_t *pool, *old_pool; + + lmcf = ngx_stream_cycle_get_module_main_conf(ngx_cycle, + ngx_stream_lua_module); + + if (size < NGX_LUA_RE_MIN_JIT_STACK_SIZE) { + size = NGX_LUA_RE_MIN_JIT_STACK_SIZE; + } + + pool = lmcf->pool; + + dd("server pool %p", lmcf->pool); + + if (lmcf->jit_stack) { + old_pool = ngx_stream_lua_pcre_malloc_init(pool); + +#if (NGX_PCRE2) + pcre2_jit_stack_free(lmcf->jit_stack); +#else + pcre_jit_stack_free(lmcf->jit_stack); +#endif + + ngx_stream_lua_pcre_malloc_done(old_pool); + } + + old_pool = ngx_stream_lua_pcre_malloc_init(pool); + +#if (NGX_PCRE2) + lmcf->jit_stack = pcre2_jit_stack_create(NGX_LUA_RE_MIN_JIT_STACK_SIZE, + size, NULL); +#else + lmcf->jit_stack = pcre_jit_stack_alloc(NGX_LUA_RE_MIN_JIT_STACK_SIZE, + size); +#endif + + ngx_stream_lua_pcre_malloc_done(old_pool); + + if (lmcf->jit_stack == NULL) { + *errstr_size = ngx_snprintf(errstr, *errstr_size, + "pcre jit stack allocation failed") + - errstr; + return NGX_ERROR; + } + + return NGX_OK; + +#else /* LUA_HAVE_PCRE_JIT */ + + *errstr_size = ngx_snprintf(errstr, *errstr_size, + "no pcre jit support found") - errstr; + return NGX_ERROR; + +#endif +} + + +#if (NGX_PCRE2) +static void +ngx_stream_lua_regex_jit_compile(ngx_stream_lua_regex_t *re, int flags, + ngx_pool_t *pool, ngx_stream_lua_main_conf_t *lmcf, + ngx_stream_lua_regex_compile_t *re_comp) +{ + ngx_int_t ret; + ngx_pool_t *old_pool; + + if (flags & NGX_LUA_RE_MODE_JIT) { + old_pool = ngx_stream_lua_pcre_malloc_init(pool); + ret = pcre2_jit_compile(re_comp->regex, PCRE2_JIT_COMPLETE); + + if (ret != 0) { + ngx_log_error(NGX_LOG_INFO, ngx_cycle->log, 0, + "pcre2_jit_compile() failed: %d in \"%V\", " + "ignored", + ret, &re_comp->pattern); + +#if (NGX_DEBUG) + + } else { + ngx_log_debug0(NGX_LOG_DEBUG_STREAM, ngx_cycle->log, 0, + "pcre2 JIT compiled successfully"); +# endif /* !(NGX_DEBUG) */ + } + + ngx_stream_lua_pcre_malloc_done(old_pool); + + } + + if (lmcf && lmcf->jit_stack) { + pcre2_jit_stack_assign(ngx_regex_match_context, NULL, + lmcf->jit_stack); + } + + return; +} + +#else + +static void +ngx_stream_lua_regex_jit_compile(ngx_stream_lua_regex_t *re, int flags, + ngx_pool_t *pool, ngx_stream_lua_main_conf_t *lmcf, + ngx_stream_lua_regex_compile_t *re_comp) +{ + const char *msg; + pcre_extra *sd = NULL; + ngx_pool_t *old_pool; + + +#if (LUA_HAVE_PCRE_JIT) + if (flags & NGX_LUA_RE_MODE_JIT) { + old_pool = ngx_stream_lua_pcre_malloc_init(pool); + sd = pcre_study(re_comp->regex, PCRE_STUDY_JIT_COMPILE, &msg); + ngx_stream_lua_pcre_malloc_done(old_pool); + +# if (NGX_DEBUG) + if (msg != NULL) { + ngx_log_debug2(NGX_LOG_DEBUG_STREAM, ngx_cycle->log, 0, + "pcre study failed with PCRE_STUDY_JIT_COMPILE: " + "%s (%p)", msg, sd); + } + + if (sd != NULL) { + int jitted; + + old_pool = ngx_stream_lua_pcre_malloc_init(pool); + + pcre_fullinfo(re_comp->regex, sd, PCRE_INFO_JIT, &jitted); + + ngx_stream_lua_pcre_malloc_done(old_pool); + + ngx_log_debug1(NGX_LOG_DEBUG_STREAM, ngx_cycle->log, 0, + "pcre JIT compiling result: %d", jitted); + } +# endif /* !(NGX_DEBUG) */ + + } else { + old_pool = ngx_stream_lua_pcre_malloc_init(pool); + sd = pcre_study(re_comp->regex, 0, &msg); + ngx_stream_lua_pcre_malloc_done(old_pool); + } + + if (sd && lmcf && lmcf->jit_stack) { + pcre_assign_jit_stack(sd, NULL, lmcf->jit_stack); + } + + if (sd + && lmcf && lmcf->regex_match_limit > 0 + && !(flags & NGX_LUA_RE_MODE_DFA)) + { + sd->flags |= PCRE_EXTRA_MATCH_LIMIT; + sd->match_limit = lmcf->regex_match_limit; + } + +#endif /* LUA_HAVE_PCRE_JIT */ + + re->regex_sd = sd; +} +#endif + + +#if (NGX_PCRE2) +void +ngx_stream_lua_regex_cleanup(void *data) +{ + ngx_pool_t *old_pool; + ngx_stream_lua_main_conf_t *lmcf; + + lmcf = data; + + if (ngx_regex_compile_context) { + old_pool = ngx_stream_lua_pcre_malloc_init(NULL); + pcre2_compile_context_free(ngx_regex_compile_context); + ngx_regex_compile_context = NULL; + ngx_stream_lua_pcre_malloc_done(old_pool); + } + + if (lmcf && lmcf->jit_stack) { + old_pool = ngx_stream_lua_pcre_malloc_init(NULL); + + pcre2_jit_stack_free(lmcf->jit_stack); + lmcf->jit_stack = NULL; + + ngx_stream_lua_pcre_malloc_done(old_pool); + } + + if (ngx_regex_match_data) { + old_pool = ngx_stream_lua_pcre_malloc_init(NULL); + pcre2_match_data_free(ngx_regex_match_data); + ngx_regex_match_data = NULL; + ngx_regex_match_data_size = 0; + ngx_stream_lua_pcre_malloc_done(old_pool); + } + +} +#endif + + +ngx_stream_lua_regex_t * +ngx_stream_lua_ffi_compile_regex(const unsigned char *pat, size_t pat_len, + int flags, int pcre_opts, u_char *errstr, + size_t errstr_size) +{ + int *cap = NULL, ovecsize; + u_char *p; + ngx_int_t rc; + const char *msg; + ngx_pool_t *pool, *old_pool; + ngx_stream_lua_regex_t *re = NULL; + ngx_stream_lua_main_conf_t *lmcf; + ngx_stream_lua_regex_compile_t re_comp; + + pool = ngx_create_pool(512, ngx_cycle->log); + if (pool == NULL) { + msg = "no memory"; + goto error; + } + + pool->log = (ngx_log_t *) &ngx_cycle->new_log; + + re = ngx_palloc(pool, sizeof(ngx_stream_lua_regex_t)); + if (re == NULL) { + ngx_destroy_pool(pool); + pool = NULL; + msg = "no memory"; + goto error; + } + + re->pool = pool; + re->regex = NULL; + re->regex_sd = NULL; + + re_comp.options = pcre_opts; + re_comp.pattern.data = (u_char *) pat; + re_comp.pattern.len = pat_len; + re_comp.err.len = errstr_size - 1; + re_comp.err.data = errstr; + re_comp.pool = pool; + + old_pool = ngx_stream_lua_pcre_malloc_init(pool); + rc = ngx_stream_lua_regex_compile(&re_comp); + ngx_stream_lua_pcre_malloc_done(old_pool); + + if (rc != NGX_OK) { + re_comp.err.data[re_comp.err.len] = '\0'; + msg = (char *) re_comp.err.data; + goto error; + } + + lmcf = ngx_stream_cycle_get_module_main_conf(ngx_cycle, + ngx_stream_lua_module); + + ngx_stream_lua_regex_jit_compile(re, flags, pool, lmcf, &re_comp); + + if (flags & NGX_LUA_RE_MODE_DFA) { + ovecsize = 2; + re_comp.captures = 0; + + } else { +#if (NGX_PCRE2) + ovecsize = (re_comp.captures + 1) * 2; +#else + ovecsize = (re_comp.captures + 1) * 3; +#endif + } + + dd("allocating cap with size: %d", (int) ovecsize); + + cap = ngx_palloc(pool, ovecsize * sizeof(int)); + if (cap == NULL) { + msg = "no memory"; + goto error; + } + +#if (NGX_PCRE2) + if (pcre2_pattern_info(re_comp.regex, PCRE2_INFO_NAMECOUNT, + &re->name_count) < 0) + { + msg = "cannot acquire named subpattern count"; + goto error; + } + + if (re->name_count > 0) { + if (pcre2_pattern_info(re_comp.regex, PCRE2_INFO_NAMEENTRYSIZE, + &re->name_entry_size) != 0) + { + msg = "cannot acquire named subpattern entry size"; + goto error; + } + + if (pcre2_pattern_info(re_comp.regex, PCRE2_INFO_NAMETABLE, + &re->name_table) != 0) + { + msg = "cannot acquire named subpattern table"; + goto error; + } + } + +#else + if (pcre_fullinfo(re_comp.regex, NULL, PCRE_INFO_NAMECOUNT, + &re->name_count) != 0) + { + msg = "cannot acquire named subpattern count"; + goto error; + } + + if (re->name_count > 0) { + if (pcre_fullinfo(re_comp.regex, NULL, PCRE_INFO_NAMEENTRYSIZE, + &re->name_entry_size) != 0) + { + msg = "cannot acquire named subpattern entry size"; + goto error; + } + + if (pcre_fullinfo(re_comp.regex, NULL, PCRE_INFO_NAMETABLE, + &re->name_table) != 0) + { + msg = "cannot acquire named subpattern table"; + goto error; + } + } +#endif + + re->regex = re_comp.regex; + re->ncaptures = re_comp.captures; + re->captures = cap; + re->replace = NULL; + + /* only for (stap) debugging, the pointer might be invalid when the + * string is collected later on.... */ + re->pattern = pat; + + return re; + +error: + + p = ngx_snprintf(errstr, errstr_size - 1, "%s", msg); + *p = '\0'; + + ngx_stream_lua_regex_free_study_data(pool, re); + + if (pool) { + ngx_destroy_pool(pool); + } + + return NULL; +} + + +#if (NGX_PCRE2) +int +ngx_stream_lua_ffi_exec_regex(ngx_stream_lua_regex_t *re, int flags, + const u_char *s, size_t len, int pos) +{ + int rc, exec_opts = 0; + size_t *ov; + ngx_uint_t ovecpair, n, i; + ngx_pool_t *old_pool; + + if (flags & NGX_LUA_RE_MODE_DFA) { + ovecpair = 1; + re->ncaptures = 0; + + } else { + ovecpair = re->ncaptures + 1; + } + + old_pool = ngx_stream_lua_pcre_malloc_init(NULL); + + if (ngx_regex_match_data == NULL + || ovecpair > ngx_regex_match_data_size) + { + /* + * Allocate a match data if not yet allocated or smaller than + * needed. + */ + + if (ngx_regex_match_data) { + pcre2_match_data_free(ngx_regex_match_data); + } + + ngx_regex_match_data_size = ovecpair; + ngx_regex_match_data = pcre2_match_data_create(ovecpair, NULL); + + if (ngx_regex_match_data == NULL) { + rc = PCRE2_ERROR_NOMEMORY; + goto failed; + } + } + + if (flags & NGX_LUA_RE_NO_UTF8_CHECK) { + exec_opts = PCRE2_NO_UTF_CHECK; + + } else { + exec_opts = 0; + } + + if (flags & NGX_LUA_RE_MODE_DFA) { + int ws[NGX_LUA_RE_DFA_MODE_WORKSPACE_COUNT]; + rc = pcre2_dfa_match(re->regex, s, len, pos, exec_opts, + ngx_regex_match_data, ngx_regex_match_context, + ws, sizeof(ws) / sizeof(ws[0])); + + } else { + rc = pcre2_match(re->regex, s, len, pos, exec_opts, + ngx_regex_match_data, ngx_regex_match_context); + } + + if (rc < 0) { +#if (NGX_DEBUG) + ngx_log_debug4(NGX_LOG_DEBUG_STREAM, ngx_cycle->log, 0, + "pcre2_match failed: flags 0x%05Xd, options 0x%08Xd, rc %d, " + "ovecpair %ui", flags, exec_opts, rc, ovecpair); +#endif + + goto failed; + } + + n = pcre2_get_ovector_count(ngx_regex_match_data); + ov = pcre2_get_ovector_pointer(ngx_regex_match_data); + +#if (NGX_DEBUG) + ngx_log_debug5(NGX_LOG_DEBUG_STREAM, ngx_cycle->log, 0, + "pcre2_match: flags 0x%05Xd, options 0x%08Xd, rc %d, " + "n %ui, ovecpair %ui", flags, exec_opts, rc, n, ovecpair); +#endif + + if (n > ovecpair) { + n = ovecpair; + } + + for (i = 0; i < n; i++) { + re->captures[i * 2] = ov[i * 2]; + re->captures[i * 2 + 1] = ov[i * 2 + 1]; + } + +failed: + + ngx_stream_lua_pcre_malloc_done(old_pool); + + return rc; +} + +#else + +int +ngx_stream_lua_ffi_exec_regex(ngx_stream_lua_regex_t *re, int flags, + const u_char *s, size_t len, int pos) +{ + int rc, ovecsize, exec_opts, *cap; + ngx_str_t subj; + pcre_extra *sd; + + cap = re->captures; + sd = re->regex_sd; + + if (flags & NGX_LUA_RE_MODE_DFA) { + ovecsize = 2; + re->ncaptures = 0; + + } else { + /* How pcre_exec() returns captured substrings + * The first two-thirds of the vector is used to pass back captured + * substrings, each substring using a pair of integers. The remaining + * third of the vector is used as workspace by pcre_exec() while + * matching capturing subpatterns, and is not available for passing + * back information. The number passed in ovecsize should always be a + * multiple of three. If it is not, it is rounded down. + * + * When a match is successful, information about captured substrings is + * returned in pairs of integers, starting at the beginning of ovector, + * and continuing up to two-thirds of its length at the most. The first + * element of each pair is set to the byte offset of the first character + * in a substring, and the second is set to the byte offset of the first + * character after the end of a substring. + */ + ovecsize = (re->ncaptures + 1) * 3; + } + + if (flags & NGX_LUA_RE_NO_UTF8_CHECK) { + exec_opts = PCRE_NO_UTF8_CHECK; + + } else { + exec_opts = 0; + } + + subj.data = (u_char *) s; + subj.len = len; + + if (flags & NGX_LUA_RE_MODE_DFA) { + +#if LUA_HAVE_PCRE_DFA + + int ws[NGX_LUA_RE_DFA_MODE_WORKSPACE_COUNT]; + rc = ngx_stream_lua_regex_dfa_exec(re->regex, sd, &subj, + (int) pos, cap, ovecsize, ws, + sizeof(ws) / sizeof(ws[0]), exec_opts); + +#else + + return PCRE_ERROR_BADOPTION; + +#endif /* LUA_HAVE_PCRE_DFA */ + + } else { + rc = ngx_stream_lua_regex_exec(re->regex, sd, &subj, (int) pos, cap, + ovecsize, exec_opts); + } + + return rc; +} + +#endif + + +void +ngx_stream_lua_ffi_destroy_regex(ngx_stream_lua_regex_t *re) +{ + dd("destroy regex called"); + + if (re == NULL || re->pool == NULL) { + return; + } + + ngx_stream_lua_regex_free_study_data(re->pool, re); + + ngx_destroy_pool(re->pool); +} + + +int +ngx_stream_lua_ffi_compile_replace_template(ngx_stream_lua_regex_t *re, + const u_char *replace_data, size_t replace_len) +{ + ngx_int_t rc; + ngx_str_t tpl; + + ngx_stream_lua_complex_value_t *ctpl; + ngx_stream_lua_compile_complex_value_t ccv; + + ctpl = ngx_palloc(re->pool, sizeof(ngx_stream_lua_complex_value_t)); + if (ctpl == NULL) { + return NGX_ERROR; + } + + if (replace_len != 0) { + /* copy the string buffer pointed to by tpl.data from Lua VM */ + tpl.data = ngx_palloc(re->pool, replace_len + 1); + if (tpl.data == NULL) { + return NGX_ERROR; + } + + ngx_memcpy(tpl.data, replace_data, replace_len); + tpl.data[replace_len] = '\0'; + + } else { + tpl.data = (u_char *) replace_data; + } + + tpl.len = replace_len; + + ngx_memzero(&ccv, sizeof(ngx_stream_lua_compile_complex_value_t)); + ccv.pool = re->pool; + ccv.log = ngx_cycle->log; + ccv.value = &tpl; + ccv.complex_value = ctpl; + + rc = ngx_stream_lua_compile_complex_value(&ccv); + + re->replace = ctpl; + + return rc; +} + + +ngx_stream_lua_script_engine_t * +ngx_stream_lua_ffi_create_script_engine(void) +{ + return ngx_calloc(sizeof(ngx_stream_lua_script_engine_t), ngx_cycle->log); +} + + +void +ngx_stream_lua_ffi_init_script_engine(ngx_stream_lua_script_engine_t *e, + const unsigned char *subj, ngx_stream_lua_regex_t *compiled, int count) +{ + e->log = ngx_cycle->log; + e->ncaptures = count * 2; + e->captures = compiled->captures; + e->captures_data = (u_char *) subj; +} + + +void +ngx_stream_lua_ffi_destroy_script_engine(ngx_stream_lua_script_engine_t *e) +{ + ngx_free(e); +} + + +size_t +ngx_stream_lua_ffi_script_eval_len(ngx_stream_lua_script_engine_t *e, + ngx_stream_lua_complex_value_t *val) +{ + size_t len; + + ngx_stream_lua_script_len_code_pt lcode; + + e->ip = val->lengths; + len = 0; + + while (*(uintptr_t *) e->ip) { + lcode = *(ngx_stream_lua_script_len_code_pt *) e->ip; + len += lcode(e); + } + + return len; +} + + +void +ngx_stream_lua_ffi_script_eval_data(ngx_stream_lua_script_engine_t *e, + ngx_stream_lua_complex_value_t *val, u_char *dst) +{ + ngx_stream_lua_script_code_pt code; + + e->ip = val->values; + e->pos = dst; + + while (*(uintptr_t *) e->ip) { + code = *(ngx_stream_lua_script_code_pt *) e->ip; + code(e); + } +} + + +uint32_t +ngx_stream_lua_ffi_max_regex_cache_size(void) +{ + ngx_stream_lua_main_conf_t *lmcf; + lmcf = ngx_stream_cycle_get_module_main_conf(ngx_cycle, + ngx_stream_lua_module); + if (lmcf == NULL) { + return 0; + } + return (uint32_t) lmcf->regex_cache_max_entries; +} + + +const char * +ngx_stream_lua_ffi_pcre_version(void) +{ +#if (NGX_PCRE2) + pcre2_config(PCRE2_CONFIG_VERSION, ngx_pcre2_version); + + return ngx_pcre2_version; +#else + return pcre_version(); +#endif +} + + +#endif /* NGX_PCRE */ + + +/* vi:set ft=c ts=4 sw=4 et fdm=marker: */ |