technocloud-public/nginx-unit
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Router: matching regular expressions support.

Browse Source
This commit is contained in:
Axel Duch
2020-11-17 15:03:30 +00:00
parent 2a381a82a6
commit e3af18834d
13 changed files with 575 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
src/nxt_conf_validation.c
View File

@@ -11,6 +11,7 @@
#include <nxt_http.h>
#include <nxt_sockaddr.h>
#include <nxt_http_route_addr.h>
#include <nxt_regex.h>
typedef enum {
@@ -1504,8 +1505,12 @@ static nxt_int_t
nxt_conf_vldt_match_pattern(nxt_conf_validation_t *vldt,
nxt_conf_value_t *value)
{
nxt_str_t pattern;
nxt_uint_t i, first, last;
nxt_str_t pattern;
nxt_uint_t i, first, last;
#if (NXT_HAVE_REGEX)
nxt_regex_t *re;
nxt_regex_err_t err;
#endif
if (nxt_conf_type(value) != NXT_CONF_STRING) {
return nxt_conf_vldt_error(vldt, "The \"match\" patterns for \"host\", "
@@ -1519,6 +1524,32 @@ nxt_conf_vldt_match_pattern(nxt_conf_validation_t *vldt,
}
first = (pattern.start[0] == '!');
if (first < pattern.length && pattern.start[first] == '~') {
#if (NXT_HAVE_REGEX)
pattern.start += first + 1;
pattern.length -= first + 1;
re = nxt_regex_compile(vldt->pool, &pattern, &err);
if (nxt_slow_path(re == NULL)) {
if (err.offset < pattern.length) {
return nxt_conf_vldt_error(vldt, "Invalid regular expression: "
"%s at offset %d",
err.msg, err.offset);
}
return nxt_conf_vldt_error(vldt, "Invalid regular expression: %s",
err.msg);
}
return NXT_OK;
#else
return nxt_conf_vldt_error(vldt, "Unit is built without support of "
"regular expressions: \"--no-regex\" "
"./configure option was set.");
#endif
}
last = pattern.length - 1;
for (i = first; i < last; i++) {

6
src/nxt_http.h
View File

@@ -7,6 +7,8 @@
#ifndef _NXT_HTTP_H_INCLUDED_
#define _NXT_HTTP_H_INCLUDED_
#include <nxt_regex.h>
typedef enum {
NXT_HTTP_UNSET = -1,
@@ -168,6 +170,10 @@ struct nxt_http_request_s {
void *req_rpc_data;
#if (NXT_HAVE_REGEX)
nxt_regex_match_t *regex_match;
#endif
nxt_http_peer_t *peer;
nxt_buf_t *last;

99
src/nxt_http_route.c
View File

@@ -8,6 +8,7 @@
#include <nxt_http.h>
#include <nxt_sockaddr.h>
#include <nxt_http_route_addr.h>
#include <nxt_regex.h>
typedef enum {
@@ -76,12 +77,20 @@ typedef struct {
typedef struct {
union {
nxt_array_t *pattern_slices;
#if (NXT_HAVE_REGEX)
nxt_regex_t *regex;
#endif
} u;
uint32_t min_length;
nxt_array_t *pattern_slices;
uint8_t case_sensitive; /* 1 bit */
uint8_t negative; /* 1 bit */
uint8_t any; /* 1 bit */
#if (NXT_HAVE_REGEX)
uint8_t regex; /* 1 bit */
#endif
} nxt_http_route_pattern_t;
@@ -1060,24 +1069,24 @@ nxt_http_route_pattern_create(nxt_task_t *task, nxt_mp_t *mp,
nxt_str_t test, tmp;
nxt_int_t ret;
nxt_array_t *slices;
#if (NXT_HAVE_REGEX)
nxt_regex_t *re;
nxt_regex_err_t err;
#endif
nxt_http_route_pattern_type_t type;
nxt_http_route_pattern_slice_t *slice;
type = NXT_HTTP_ROUTE_PATTERN_EXACT;
nxt_conf_get_string(cv, &test);
slices = nxt_array_create(mp, 1, sizeof(nxt_http_route_pattern_slice_t));
if (nxt_slow_path(slices == NULL)) {
return NXT_ERROR;
}
pattern->pattern_slices = slices;
pattern->u.pattern_slices = NULL;
pattern->negative = 0;
pattern->any = 1;
pattern->min_length = 0;
#if (NXT_HAVE_REGEX)
pattern->regex = 0;
#endif
if (test.length != 0 && test.start[0] == '!') {
test.start++;
@@ -1087,6 +1096,41 @@ nxt_http_route_pattern_create(nxt_task_t *task, nxt_mp_t *mp,
pattern->any = 0;
}
if (test.length > 0 && test.start[0] == '~') {
#if (NXT_HAVE_REGEX)
test.start++;
test.length--;
re = nxt_regex_compile(mp, &test, &err);
if (nxt_slow_path(re == NULL)) {
if (err.offset < test.length) {
nxt_alert(task, "nxt_regex_compile(%V) failed: %s at offset %d",
&test, err.msg, (int) err.offset);
return NXT_ERROR;
}
nxt_alert(task, "nxt_regex_compile(%V) failed %s", &test, err.msg);
return NXT_ERROR;
}
pattern->u.regex = re;
pattern->regex = 1;
return NXT_OK;
#else
return NXT_ERROR;
#endif
}
slices = nxt_array_create(mp, 1, sizeof(nxt_http_route_pattern_slice_t));
if (nxt_slow_path(slices == NULL)) {
return NXT_ERROR;
}
pattern->u.pattern_slices = slices;
if (test.length == 0) {
slice = nxt_array_add(slices);
if (nxt_slow_path(slice == NULL)) {
@@ -1980,6 +2024,9 @@ nxt_http_route_header(nxt_http_request_t *r, nxt_http_route_rule_t *rule)
}
ret = nxt_http_route_test_rule(r, rule, f->value, f->value_length);
if (nxt_slow_path(ret == NXT_ERROR)) {
return NXT_ERROR;
}
if (ret == 0) {
return ret;
@@ -2155,7 +2202,7 @@ static nxt_int_t
nxt_http_route_test_argument(nxt_http_request_t *r,
nxt_http_route_rule_t *rule, nxt_array_t *array)
{
nxt_bool_t ret;
nxt_int_t ret;
nxt_http_name_value_t *nv, *end;
ret = 0;
@@ -2171,6 +2218,10 @@ nxt_http_route_test_argument(nxt_http_request_t *r,
{
ret = nxt_http_route_test_rule(r, rule, nv->value,
nv->value_length);
if (nxt_slow_path(ret == NXT_ERROR)) {
return NXT_ERROR;
}
if (ret == 0) {
break;
}
@@ -2189,7 +2240,7 @@ nxt_http_route_scheme(nxt_http_request_t *r, nxt_http_route_rule_t *rule)
nxt_bool_t tls, https;
nxt_http_route_pattern_slice_t *pattern_slice;
pattern_slice = rule->pattern[0].pattern_slices->elts;
pattern_slice = rule->pattern[0].u.pattern_slices->elts;
https = (pattern_slice->length == nxt_length("https"));
tls = (r->tls != NULL);
@@ -2337,7 +2388,7 @@ static nxt_int_t
nxt_http_route_test_cookie(nxt_http_request_t *r,
nxt_http_route_rule_t *rule, nxt_array_t *array)
{
nxt_bool_t ret;
nxt_int_t ret;
nxt_http_name_value_t *nv, *end;
ret = 0;
@@ -2353,6 +2404,10 @@ nxt_http_route_test_cookie(nxt_http_request_t *r,
{
ret = nxt_http_route_test_rule(r, rule, nv->value,
nv->value_length);
if (nxt_slow_path(ret == NXT_ERROR)) {
return NXT_ERROR;
}
if (ret == 0) {
break;
}
@@ -2378,6 +2433,9 @@ nxt_http_route_test_rule(nxt_http_request_t *r, nxt_http_route_rule_t *rule,
while (pattern < end) {
ret = nxt_http_route_pattern(r, pattern, start, length);
if (nxt_slow_path(ret == NXT_ERROR)) {
return NXT_ERROR;
}
/* nxt_http_route_pattern() returns either 1 or 0. */
ret ^= pattern->negative;
@@ -2403,11 +2461,26 @@ nxt_http_route_pattern(nxt_http_request_t *r, nxt_http_route_pattern_t *pattern,
nxt_array_t *pattern_slices;
nxt_http_route_pattern_slice_t *pattern_slice;
#if (NXT_HAVE_REGEX)
if (pattern->regex) {
if (r->regex_match == NULL) {
r->regex_match = nxt_regex_match_create(r->mem_pool, 0);
if (nxt_slow_path(r->regex_match == NULL)) {
return NXT_ERROR;
}
}
return nxt_regex_match(pattern->u.regex, start, length, r->regex_match);
}
#endif
if (length < pattern->min_length) {
return 0;
}
pattern_slices = pattern->pattern_slices;
nxt_assert(pattern->u.pattern_slices != NULL);
pattern_slices = pattern->u.pattern_slices;
pattern_slice = pattern_slices->elts;
end = start + length;

135
src/nxt_pcre.c Normal file
View File

@@ -0,0 +1,135 @@
/*
* Copyright (C) Axel Duch
* Copyright (C) NGINX, Inc.
*/
#include <nxt_main.h>
#include <nxt_regex.h>
#include <pcre.h>
struct nxt_regex_s {
pcre *code;
pcre_extra *extra;
nxt_str_t pattern;
};
struct nxt_regex_match_s {
int ovecsize;
int ovec[];
};
static void *nxt_pcre_malloc(size_t size);
static void nxt_pcre_free(void *p);
static nxt_mp_t *nxt_pcre_mp;
nxt_regex_t *
nxt_regex_compile(nxt_mp_t *mp, nxt_str_t *source, nxt_regex_err_t *err)
{
int erroffset;
char *pattern;
void *saved_malloc, *saved_free;
nxt_regex_t *re;
err->offset = source->length;
re = nxt_mp_get(mp, sizeof(nxt_regex_t) + source->length + 1);
if (nxt_slow_path(re == NULL)) {
err->msg = "memory allocation failed";
return NULL;
}
pattern = nxt_pointer_to(re, sizeof(nxt_regex_t));
nxt_memcpy(pattern, source->start, source->length);
pattern[source->length] = '\0';
re->pattern.length = source->length;
re->pattern.start = (u_char *) pattern;
saved_malloc = pcre_malloc;
saved_free = pcre_free;
pcre_malloc = nxt_pcre_malloc;
pcre_free = nxt_pcre_free;
nxt_pcre_mp = mp;
re->code = pcre_compile(pattern, 0, &err->msg, &erroffset, NULL);
if (nxt_fast_path(re->code != NULL)) {
#if 0
re->extra = pcre_study(re->code, PCRE_STUDY_JIT_COMPILE, &err->msg);
if (nxt_slow_path(re->extra == NULL && err->msg != NULL)) {
nxt_log_warn(thr->log, "pcre_study(%V) failed: %s", source, err->msg);
}
#else
re->extra = NULL;
#endif
} else {
err->offset = erroffset;
re = NULL;
}
pcre_malloc = saved_malloc;
pcre_free = saved_free;
return re;
}
static void*
nxt_pcre_malloc(size_t size)
{
if (nxt_slow_path(nxt_pcre_mp == NULL)) {
nxt_thread_log_alert("pcre_malloc(%uz) called without memory pool",
size);
return NULL;
}
nxt_thread_log_debug("pcre_malloc(%uz), pool %p", size, nxt_pcre_mp);
return nxt_mp_get(nxt_pcre_mp, size);
}
static void
nxt_pcre_free(void *p)
{
}
nxt_regex_match_t *
nxt_regex_match_create(nxt_mp_t *mp, size_t size)
{
nxt_regex_match_t *match;
match = nxt_mp_get(mp, sizeof(nxt_regex_match_t) + sizeof(int) * size);
if (nxt_fast_path(match != NULL)) {
match->ovecsize = size;
}
return match;
}
nxt_int_t
nxt_regex_match(nxt_regex_t *re, u_char *subject, size_t length,
nxt_regex_match_t *match)
{
int ret;
ret = pcre_exec(re->code, re->extra, (const char *) subject, length, 0, 0,
match->ovec, match->ovecsize);
if (nxt_slow_path(ret < PCRE_ERROR_NOMATCH)) {
nxt_thread_log_error(NXT_LOG_ERR,
"pcre_exec() failed: %d on \"%*s\" using \"%V\"",
ret, length, subject, &re->pattern);
return NXT_ERROR;
}
return (ret != PCRE_ERROR_NOMATCH);
}

161
src/nxt_pcre2.c Normal file
View File

@@ -0,0 +1,161 @@
/*
* Copyright (C) Axel Duch
* Copyright (C) NGINX, Inc.
*/
#include <nxt_main.h>
#include <nxt_regex.h>
#define PCRE2_CODE_UNIT_WIDTH 8
#include <pcre2.h>
static void *nxt_pcre2_malloc(PCRE2_SIZE size, void *memory_data);
static void nxt_pcre2_free(void *p, void *memory_data);
struct nxt_regex_s {
pcre2_code *code;
nxt_str_t pattern;
};
nxt_regex_t *
nxt_regex_compile(nxt_mp_t *mp, nxt_str_t *source, nxt_regex_err_t *err)
{
int errcode;
nxt_int_t ret;
PCRE2_SIZE erroffset;
nxt_regex_t *re;
pcre2_general_context *general_ctx;
pcre2_compile_context *compile_ctx;
static const u_char alloc_error[] = "memory allocation failed";
general_ctx = pcre2_general_context_create(nxt_pcre2_malloc,
nxt_pcre2_free, mp);
if (nxt_slow_path(general_ctx == NULL)) {
goto alloc_fail;
}
compile_ctx = pcre2_compile_context_create(general_ctx);
if (nxt_slow_path(compile_ctx == NULL)) {
goto alloc_fail;
}
re = nxt_mp_get(mp, sizeof(nxt_regex_t));
if (nxt_slow_path(re == NULL)) {
goto alloc_fail;
}
if (nxt_slow_path(nxt_str_dup(mp, &re->pattern, source) == NULL)) {
goto alloc_fail;
}
re->code = pcre2_compile((PCRE2_SPTR) source->start, source->length, 0,
&errcode, &erroffset, compile_ctx);
if (nxt_slow_path(re->code == NULL)) {
err->offset = erroffset;
ret = pcre2_get_error_message(errcode, (PCRE2_UCHAR *) err->msg,
ERR_BUF_SIZE);
if (ret < 0) {
(void) nxt_sprintf(err->msg, err->msg + ERR_BUF_SIZE,
"compilation failed with unknown "
"error code: %d%Z", errcode);
}
return NULL;
}
#if 0
errcode = pcre2_jit_compile(re, PCRE2_JIT_COMPLETE);
if (nxt_slow_path(errcode != 0 && errcode != PCRE2_ERROR_JIT_BADOPTION)) {
ret = pcre2_get_error_message(errcode, (PCRE2_UCHAR *) err->msg,
ERR_BUF_SIZE);
if (ret < 0) {
(void) nxt_sprintf(err->msg, err->msg + ERR_BUF_SIZE,
"JIT compilation failed with unknown "
"error code: %d%Z", errcode);
}
return NULL;
}
#endif
return re;
alloc_fail:
err->offset = source->length;
nxt_memcpy(err->msg, alloc_error, sizeof(alloc_error));
return NULL;
}
static void *
nxt_pcre2_malloc(PCRE2_SIZE size, void *mp)
{
return nxt_mp_get(mp, size);
}
static void
nxt_pcre2_free(void *p, void *mp)
{
}
nxt_regex_match_t *
nxt_regex_match_create(nxt_mp_t *mp, size_t size)
{
nxt_regex_match_t *match;
pcre2_general_context *ctx;
ctx = pcre2_general_context_create(nxt_pcre2_malloc, nxt_pcre2_free, mp);
if (nxt_slow_path(ctx == NULL)) {
nxt_thread_log_alert("pcre2_general_context_create() failed");
return NULL;
}
match = pcre2_match_data_create(size, ctx);
if (nxt_slow_path(match == NULL)) {
nxt_thread_log_alert("pcre2_match_data_create(%uz) failed", size);
return NULL;
}
return match;
}
nxt_int_t
nxt_regex_match(nxt_regex_t *re, u_char *subject, size_t length,
nxt_regex_match_t *match)
{
nxt_int_t ret;
PCRE2_UCHAR errptr[ERR_BUF_SIZE];
ret = pcre2_match(re->code, (PCRE2_SPTR) subject, length, 0, 0, match,
NULL);
if (nxt_slow_path(ret < PCRE2_ERROR_NOMATCH)) {
if (pcre2_get_error_message(ret, errptr, ERR_BUF_SIZE) < 0) {
nxt_thread_log_error(NXT_LOG_ERR,
"pcre2_match() failed: %d on \"%*s\" "
"using \"%V\"", ret, subject, length, subject,
&re->pattern);
} else {
nxt_thread_log_error(NXT_LOG_ERR,
"pcre2_match() failed: %s (%d) on \"%*s\" "
"using \"%V\"", errptr, ret, length, subject,
&re->pattern);
}
return NXT_ERROR;
}
return (ret != PCRE2_ERROR_NOMATCH);
}

41
src/nxt_regex.h Normal file
View File

@@ -0,0 +1,41 @@
/*
* Copyright (C) Axel Duch
* Copyright (C) NGINX, Inc.
*/
#ifndef _NXT_REGEX_H_INCLUDED_
#define _NXT_REGEX_H_INCLUDED_
#if (NXT_HAVE_REGEX)
typedef struct nxt_regex_s nxt_regex_t;
#if (NXT_HAVE_PCRE2)
typedef void nxt_regex_match_t;
#else
typedef struct nxt_regex_match_s nxt_regex_match_t;
#endif
typedef struct {
size_t offset;
#if (NXT_HAVE_PCRE2)
#define ERR_BUF_SIZE 256
u_char msg[ERR_BUF_SIZE];
#else
const char *msg;
#endif
} nxt_regex_err_t;
NXT_EXPORT void nxt_regex_init(void);
NXT_EXPORT nxt_regex_t *nxt_regex_compile(nxt_mp_t *mp, nxt_str_t *source,
nxt_regex_err_t *err);
NXT_EXPORT nxt_regex_match_t *nxt_regex_match_create(nxt_mp_t *mp, size_t size);
NXT_EXPORT nxt_int_t nxt_regex_match(nxt_regex_t *re, u_char *subject,
size_t length, nxt_regex_match_t *match);
#endif /* NXT_HAVE_REGEX */
#endif /* _NXT_REGEX_H_INCLUDED_ */

4
src/nxt_runtime.c
View File

@@ -10,6 +10,7 @@
#include <nxt_port.h>
#include <nxt_main_process.h>
#include <nxt_router.h>
#include <nxt_regex.h>
static nxt_int_t nxt_runtime_inherited_listen_sockets(nxt_task_t *task,
@@ -702,9 +703,6 @@ nxt_runtime_thread_pool_destroy(nxt_task_t *task, nxt_runtime_t *rt,
static void
nxt_runtime_thread_pool_init(void)
{
#if (NXT_REGEX)
nxt_regex_init(0);
#endif
}