uWSGI 2.0.24__tar.gz → 2.0.25__tar.gz

{uwsgi-2.0.24 → uwsgi-2.0.25}/.github/workflows/compile-test.yml

@@ -10,18 +10,18 @@ jobs:
   build:
     strategy:
       matrix:
+        libpcre: ["libpcre3-dev", "libpcre2-dev"]
+        os: ["ubuntu-20.04", "ubuntu-22.04"]
+        cc: [gcc, clang]
         include:
           - os: ubuntu-20.04
             php: "php7.4"
             php-config: "php-config7.4"
-            cc: "gcc"
-          - os: ubuntu-22.04
-            php: "php8.1"
-            php-config: "php-config8.1"
-            cc: "gcc"
           - os: ubuntu-22.04
             php: "php8.1"
             php-config: "php-config8.1"
+        exclude:
+          - os: ubuntu-20.04
             cc: "clang"
 
     runs-on: ${{ matrix.os }}
@@ -35,7 +35,7 @@ jobs:
       run: |
         sudo apt update -qq
         sudo apt install --no-install-recommends -qqyf python3-dev \
-          libxml2-dev libpcre3-dev libcap2-dev \
+          libxml2-dev ${{ matrix.libpcre }} libcap2-dev \
           libargon2-0-dev libsodium-dev \
           ${{ matrix.php }}-dev lib${{ matrix.php }}-embed \
           liblua5.1-0-dev ruby-dev \

{uwsgi-2.0.24 → uwsgi-2.0.25}/.github/workflows/test.yml

@@ -21,7 +21,7 @@ jobs:
       run: |
         sudo apt update -qq
         sudo apt install --no-install-recommends -qqyf python${{ matrix.python-version }}-dev \
-          libpcre3-dev libjansson-dev libcap2-dev \
+          libpcre2-dev libjansson-dev libcap2-dev \
           curl check
     - name: Install distutils
       if: contains(fromJson('["3.6","3.7","3.8","3.9","3.10","3.11","3.12"]'), matrix.python-version)

{uwsgi-2.0.24 → uwsgi-2.0.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: uWSGI
-Version: 2.0.24
+Version: 2.0.25
 Summary: The uWSGI server
 Home-page: https://uwsgi-docs.readthedocs.io/en/latest/
 Author: Unbit

{uwsgi-2.0.24 → uwsgi-2.0.25}/core/alarm.c

@@ -160,7 +160,7 @@ static struct uwsgi_alarm_instance *uwsgi_alarm_get_instance(char *name) {
 }
 
 
-#ifdef UWSGI_PCRE
+#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)
 static int uwsgi_alarm_log_add(char *alarms, char *regexp, int negate) {
 
 	struct uwsgi_alarm_log *old_ual = NULL, *ual = uwsgi.alarm_logs;
@@ -170,7 +170,8 @@ static int uwsgi_alarm_log_add(char *alarms, char *regexp, int negate) {
 	}
 
 	ual = uwsgi_calloc(sizeof(struct uwsgi_alarm_log));
-	if (uwsgi_regexp_build(regexp, &ual->pattern, &ual->pattern_extra)) {
+	if (uwsgi_regexp_build(regexp, &ual->pattern)) {
+		free(ual);
 		return -1;
 	}
 	ual->negate = negate;
@@ -330,7 +331,7 @@ void uwsgi_alarms_init() {
 		usl = usl->next;
 	}
 
-#ifdef UWSGI_PCRE
+#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)
 	// then map log-alarm
 	usl = uwsgi.alarm_logs_list;
 	while (usl) {
@@ -376,14 +377,14 @@ void uwsgi_alarm_trigger_uai(struct uwsgi_alarm_instance *uai, char *msg, size_t
 	}
 }
 
-#ifdef UWSGI_PCRE
+#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)
 // check if a log should raise an alarm
 void uwsgi_alarm_log_check(char *msg, size_t len) {
 	if (!uwsgi_strncmp(msg, len, "[uwsgi-alarm", 12))
 		return;
 	struct uwsgi_alarm_log *ual = uwsgi.alarm_logs;
 	while (ual) {
-		if (uwsgi_regexp_match(ual->pattern, ual->pattern_extra, msg, len) >= 0) {
+		if (uwsgi_regexp_match(ual->pattern, msg, len) >= 0) {
 			if (!ual->negate) {
 				struct uwsgi_alarm_ll *uall = ual->alarms;
 				while (uall) {

{uwsgi-2.0.24 → uwsgi-2.0.25}/core/config.c

@@ -314,7 +314,7 @@ int uwsgi_logic_opt_if_not_hostname(char *key, char *value) {
         return 0;
 }
 
-#ifdef UWSGI_PCRE
+#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)
 int uwsgi_logic_opt_if_hostname_match(char *key, char *value) {
 	if (uwsgi_regexp_match_pattern(uwsgi.logic_opt_data, uwsgi.hostname)) {
 		add_exported_option(key, uwsgi_substitute(value, "%(_)", uwsgi.logic_opt_data), 0);

{uwsgi-2.0.24 → uwsgi-2.0.25}/core/logging.c

@@ -414,7 +414,7 @@ void uwsgi_setup_log_master(void) {
                 usl = usl->next;
         }
 
-#ifdef UWSGI_PCRE
+#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)
 	// set logger by its id
 	struct uwsgi_regexp_list *url = uwsgi.log_route;
 	while (url) {
@@ -1398,11 +1398,11 @@ int uwsgi_master_log(void) {
 
         ssize_t rlen = read(uwsgi.shared->worker_log_pipe[0], uwsgi.log_master_buf, uwsgi.log_master_bufsize);
         if (rlen > 0) {
-#ifdef UWSGI_PCRE
+#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)
                 uwsgi_alarm_log_check(uwsgi.log_master_buf, rlen);
                 struct uwsgi_regexp_list *url = uwsgi.log_drain_rules;
                 while (url) {
-                        if (uwsgi_regexp_match(url->pattern, url->pattern_extra, uwsgi.log_master_buf, rlen) >= 0) {
+                        if (uwsgi_regexp_match(url->pattern, uwsgi.log_master_buf, rlen) >= 0) {
                                 return 0;
                         }
                         url = url->next;
@@ -1411,7 +1411,7 @@ int uwsgi_master_log(void) {
                         int show = 0;
                         url = uwsgi.log_filter_rules;
                         while (url) {
-                                if (uwsgi_regexp_match(url->pattern, url->pattern_extra, uwsgi.log_master_buf, rlen) >= 0) {
+                                if (uwsgi_regexp_match(url->pattern, uwsgi.log_master_buf, rlen) >= 0) {
                                         show = 1;
                                         break;
                                 }
@@ -1424,7 +1424,7 @@ int uwsgi_master_log(void) {
                 url = uwsgi.log_route;
                 int finish = 0;
                 while (url) {
-                        if (uwsgi_regexp_match(url->pattern, url->pattern_extra, uwsgi.log_master_buf, rlen) >= 0) {
+                        if (uwsgi_regexp_match(url->pattern, uwsgi.log_master_buf, rlen) >= 0) {
                                 struct uwsgi_logger *ul_route = (struct uwsgi_logger *) url->custom_ptr;
                                 if (ul_route) {
 					uwsgi_log_func_do(uwsgi.requested_log_encoders, ul_route, uwsgi.log_master_buf, rlen);
@@ -1464,11 +1464,11 @@ int uwsgi_master_req_log(void) {
 
         ssize_t rlen = read(uwsgi.shared->worker_req_log_pipe[0], uwsgi.log_master_buf, uwsgi.log_master_bufsize);
         if (rlen > 0) {
-#ifdef UWSGI_PCRE
+#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)
                 struct uwsgi_regexp_list *url = uwsgi.log_req_route;
                 int finish = 0;
                 while (url) {
-                        if (uwsgi_regexp_match(url->pattern, url->pattern_extra, uwsgi.log_master_buf, rlen) >= 0) {
+                        if (uwsgi_regexp_match(url->pattern, uwsgi.log_master_buf, rlen) >= 0) {
                                 struct uwsgi_logger *ul_route = (struct uwsgi_logger *) url->custom_ptr;
                                 if (ul_route) {
                                         uwsgi_log_func_do(uwsgi.requested_log_req_encoders, ul_route, uwsgi.log_master_buf, rlen);

{uwsgi-2.0.24 → uwsgi-2.0.25}/core/loop.c

@@ -60,6 +60,9 @@ void *uwsgi_get_loop(char *name) {
 
 void simple_loop() {
 	uwsgi_loop_cores_run(simple_loop_run);
+	// Other threads may still run. Make sure they will stop.
+	uwsgi.workers[uwsgi.mywid].manage_next_request = 0;
+
 	if (uwsgi.workers[uwsgi.mywid].shutdown_sockets)
 		uwsgi_shutdown_all_sockets();
 }
@@ -78,9 +81,6 @@ void uwsgi_setup_thread_req(long core_id, struct wsgi_request *wsgi_req) {
 	int i;
 	sigset_t smask;
 
-
-	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &i);
-	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &i);
 	pthread_setspecific(uwsgi.tur_key, (void *) wsgi_req);
 
 	if (core_id > 0) {

uwsgi-2.0.25/core/regexp.c

@@ -0,0 +1,178 @@
+#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)
+#include "uwsgi.h"
+
+extern struct uwsgi_server uwsgi;
+
+void uwsgi_opt_pcre_jit(char *opt, char *value, void *foobar) {
+#if defined(PCRE_STUDY_JIT_COMPILE) && defined(PCRE_CONFIG_JIT)
+	int has_jit = 0, ret;
+	ret = pcre_config(PCRE_CONFIG_JIT, &has_jit);
+	if (ret != 0 || has_jit != 1)
+		return;
+	uwsgi.pcre_jit = PCRE_STUDY_JIT_COMPILE;
+#elif defined(PCRE2_CONFIG_JIT)
+	int has_jit = 0, ret;
+	ret = pcre2_config(PCRE2_CONFIG_JIT, &has_jit);
+	if (ret != 0)
+		return;
+	uwsgi.pcre_jit = has_jit;
+#endif
+}
+
+int uwsgi_regexp_build(char *re, uwsgi_pcre ** pattern) {
+
+#ifdef UWSGI_PCRE2
+	int errnbr;
+	long unsigned int erroff;
+
+	*pattern = pcre2_compile((const unsigned char *) re, PCRE2_ZERO_TERMINATED, 0, &errnbr, &erroff, NULL);
+#else
+	const char *errstr;
+	int erroff;
+
+	*pattern = uwsgi_malloc(sizeof(uwsgi_pcre));
+	(*pattern)->p = pcre_compile((const char *) re, 0, &errstr, &erroff, NULL);
+#endif
+#ifdef UWSGI_PCRE2
+	if (!(*pattern)) {
+		uwsgi_log("pcre error: code %d at offset %d\n", errnbr, erroff);
+#else
+	if (!((*pattern)->p)) {
+		uwsgi_log("pcre error: %s at offset %d\n", errstr, erroff);
+#endif
+		return -1;
+	}
+
+#ifdef UWSGI_PCRE2
+	if (uwsgi.pcre_jit) {
+		errnbr = pcre2_jit_compile(*pattern, PCRE2_JIT_COMPLETE);
+		if (errnbr) {
+			pcre2_code_free(*pattern);
+			uwsgi_log("pcre JIT compile error code %d\n", errnbr);
+			return -1;
+		}
+#else
+	int opt = uwsgi.pcre_jit;
+
+	(*pattern)->extra = (pcre_extra *) pcre_study((const pcre *) (*pattern)->p, opt, &errstr);
+	if ((*pattern)->extra == NULL && errstr != NULL) {
+		pcre_free((*pattern)->p);
+		free(*pattern);
+		uwsgi_log("pcre (study) error: %s\n", errstr);
+		return -1;
+#endif
+	}
+
+	return 0;
+
+}
+
+int uwsgi_regexp_match(uwsgi_pcre *pattern, const char *subject, int length) {
+#ifdef UWSGI_PCRE2
+	return pcre2_match(pattern, (const unsigned char *)subject, length, 0, 0, NULL, NULL);
+#else
+	return pcre_exec((const pcre *) pattern->p, (const pcre_extra *) pattern->extra, subject, length, 0, 0, NULL, 0);
+#endif
+}
+
+int uwsgi_regexp_match_ovec(uwsgi_pcre *pattern, const char *subject, int length, int *ovec, int n) {
+
+#ifdef UWSGI_PCRE2
+	int rc;
+	int i;
+	pcre2_match_data *match_data;
+	size_t *pcre2_ovec;
+
+	match_data = pcre2_match_data_create_from_pattern(pattern, NULL);
+	rc = pcre2_match(pattern, (const unsigned char *)subject, length, 0, 0, match_data, NULL);
+
+	/*
+	 * Quoting PCRE{,2} spec, "The first pair of integers, ovector[0]
+	 * and ovector[1], identify the portion of the subject string matched
+	 * by the entire pattern. The next pair is used for the first capturing
+	 * subpattern, and so on." Therefore, the ovector size is the number of
+	 * capturing subpatterns (INFO_CAPTURECOUNT), from uwsgi_regexp_ovector(),
+	 * as matching pairs, plus room for the first pair.
+	 */
+	if (n > 0) {
+		// copy pcre2 output vector to uwsgi output vector
+		pcre2_ovec = pcre2_get_ovector_pointer(match_data);
+		for (i=0;i<(n+1)*2;i++) {
+			ovec[i] = pcre2_ovec[i];
+		}
+#else
+	if (n > 0) {
+		return pcre_exec((const pcre *) pattern->p, (const pcre_extra *) pattern->extra, subject, length, 0, 0, ovec, PCRE_OVECTOR_BYTESIZE(n));
+#endif
+	}
+
+#ifdef UWSGI_PCRE2
+	pcre2_match_data_free(match_data);
+
+	return rc;
+#else
+	return pcre_exec((const pcre *) pattern->p, (const pcre_extra *) pattern->extra, subject, length, 0, 0, NULL, 0);
+#endif
+}
+
+int uwsgi_regexp_ovector(const uwsgi_pcre *pattern) {
+
+	int n;
+#ifdef UWSGI_PCRE2
+	if (pcre2_pattern_info(pattern, PCRE2_INFO_CAPTURECOUNT, &n))
+#else
+	if (pcre_fullinfo((const pcre *) pattern->p, (const pcre_extra *) pattern->extra, PCRE_INFO_CAPTURECOUNT, &n))
+#endif
+		return 0;
+
+	return n;
+}
+
+char *uwsgi_regexp_apply_ovec(char *src, int src_n, char *dst, int dst_n, int *ovector, int n) {
+
+	int i;
+	int dollar = 0;
+
+	size_t dollars = n;
+
+	for(i=0;i<dst_n;i++) {
+		if (dst[i] == '$') {
+			dollars++;
+		}
+	}
+
+	char *res = uwsgi_malloc(dst_n + (src_n * dollars) + 1);
+	char *ptr = res;
+
+	for (i = 0; i < dst_n; i++) {
+		if (dollar) {
+			if (isdigit((int) dst[i])) {
+				int pos = (dst[i] - 48);
+				if (pos <= n) {
+					pos = pos * 2;
+					memcpy(ptr, src + ovector[pos], ovector[pos + 1] - ovector[pos]);
+					ptr += ovector[pos + 1] - ovector[pos];
+				}
+			}
+			else {
+				*ptr++ = '$';
+				*ptr++ = dst[i];
+			}
+			dollar = 0;
+		}
+		else {
+			if (dst[i] == '$') {
+				dollar = 1;
+			}
+			else {
+				*ptr++ = dst[i];
+			}
+		}
+	}
+
+	*ptr++ = 0;
+
+	return res;
+}
+
+#endif

{uwsgi-2.0.24 → uwsgi-2.0.25}/core/routing.c

@@ -211,7 +211,7 @@ int uwsgi_apply_routes_do(struct uwsgi_route *routes, struct wsgi_request *wsgi_
 				subject = *subject2 ;
 				subject_len = *subject_len2;
 			}
-			n = uwsgi_regexp_match_ovec(routes->pattern, routes->pattern_extra, subject, subject_len, routes->ovector[wsgi_req->async_id], routes->ovn[wsgi_req->async_id]);
+			n = uwsgi_regexp_match_ovec(routes->pattern, subject, subject_len, routes->ovector[wsgi_req->async_id], routes->ovn[wsgi_req->async_id]);
 		}
 		else {
 			int ret = routes->if_func(wsgi_req, routes);
@@ -506,15 +506,15 @@ void uwsgi_fixup_routes(struct uwsgi_route *ur) {
 
 		// fill them if needed... (this is an optimization for route with a static subject)
 		if (ur->subject && ur->subject_len) {
-                	if (uwsgi_regexp_build(ur->orig_route, &ur->pattern, &ur->pattern_extra)) {
+			if (uwsgi_regexp_build(ur->orig_route, &ur->pattern)) {
                         	exit(1);
                 	}
 
 			int i;
 			for(i=0;i<uwsgi.cores;i++) {
-                		ur->ovn[i] = uwsgi_regexp_ovector(ur->pattern, ur->pattern_extra);
+				ur->ovn[i] = uwsgi_regexp_ovector(ur->pattern);
                 		if (ur->ovn[i] > 0) {
-                        		ur->ovector[i] = uwsgi_calloc(sizeof(int) * (3 * (ur->ovn[i] + 1)));
+                        		ur->ovector[i] = uwsgi_calloc(sizeof(int) * PCRE_OVECTOR_BYTESIZE(ur->ovn[i]));
                 		}
 			}
 		}
@@ -1484,38 +1484,47 @@ static int uwsgi_route_condition_regexp(struct wsgi_request *wsgi_req, struct uw
         ur->condition_ub[wsgi_req->async_id] = uwsgi_routing_translate(wsgi_req, ur, NULL, 0, ur->subject_str, semicolon - ur->subject_str);
         if (!ur->condition_ub[wsgi_req->async_id]) return -1;
 
-	pcre *pattern;
-	pcre_extra *pattern_extra;
+	uwsgi_pcre *pattern;
 	char *re = uwsgi_concat2n(semicolon+1, ur->subject_str_len - ((semicolon+1) - ur->subject_str), "", 0);
-	if (uwsgi_regexp_build(re, &pattern, &pattern_extra)) {
+	if (uwsgi_regexp_build(re, &pattern)) {
 		free(re);
 		return -1;
 	}
 	free(re);
 
 	// a condition has no initialized vectors, let's create them
-	ur->ovn[wsgi_req->async_id] = uwsgi_regexp_ovector(pattern, pattern_extra);
+	ur->ovn[wsgi_req->async_id] = uwsgi_regexp_ovector(pattern);
         if (ur->ovn[wsgi_req->async_id] > 0) {
         	ur->ovector[wsgi_req->async_id] = uwsgi_calloc(sizeof(int) * (3 * (ur->ovn[wsgi_req->async_id] + 1)));
         }
 
-	if (uwsgi_regexp_match_ovec(pattern, pattern_extra, ur->condition_ub[wsgi_req->async_id]->buf, ur->condition_ub[wsgi_req->async_id]->pos, ur->ovector[wsgi_req->async_id], ur->ovn[wsgi_req->async_id] ) >= 0) {
-		pcre_free(pattern);
+	if (uwsgi_regexp_match_ovec(pattern, ur->condition_ub[wsgi_req->async_id]->buf, ur->condition_ub[wsgi_req->async_id]->pos, ur->ovector[wsgi_req->async_id], ur->ovn[wsgi_req->async_id] ) >= 0) {
+#ifdef UWSGI_PCRE2
+		pcre2_code_free(pattern);
+#else
+		pcre_free(pattern->p);
 #ifdef PCRE_STUDY_JIT_COMPILE
-		pcre_free_study(pattern_extra);
+		pcre_free_study(pattern->extra);
 #else
-		pcre_free(pattern_extra);
+		pcre_free(pattern->extra);
+#endif
+		free(pattern);
 #endif
 		return 1;
 	}
 
-	pcre_free(pattern);
+#ifdef UWSGI_PCRE2
+	pcre2_code_free(pattern);
+#else
+	pcre_free(pattern->p);
 #ifdef PCRE_STUDY_JIT_COMPILE
-	pcre_free_study(pattern_extra);
+	pcre_free_study(pattern->extra);
 #else
-	pcre_free(pattern_extra);
+	pcre_free(pattern->extra);
 #endif
-        return 0;
+	free(pattern);
+#endif
+	return 0;
 }
 
 static int uwsgi_route_condition_empty(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {

{uwsgi-2.0.24 → uwsgi-2.0.25}/core/ssl.c

@@ -145,10 +145,10 @@ static int uwsgi_sni_cb(SSL *ssl, int *ad, void *arg) {
 
 	if (uwsgi.subscription_dotsplit) goto end;
 
-#ifdef UWSGI_PCRE
+#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)
         struct uwsgi_regexp_list *url = uwsgi.sni_regexp;
         while(url) {
-                if (uwsgi_regexp_match(url->pattern, url->pattern_extra, (char *)servername, servername_len) >= 0) {
+                if (uwsgi_regexp_match(url->pattern, (char *)servername, servername_len) >= 0) {
                         SSL_set_SSL_CTX(ssl, url->custom_ptr);
                         return SSL_TLSEXT_ERR_OK;
                 }
@@ -621,7 +621,7 @@ void uwsgi_opt_sni(char *opt, char *value, void *foobar) {
                 return;
         }
 
-#ifdef UWSGI_PCRE
+#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)
         if (!strcmp(opt, "sni-regexp")) {
                 struct uwsgi_regexp_list *url = uwsgi_regexp_new_list(&uwsgi.sni_regexp, v);
                 url->custom_ptr = ctx;
@@ -630,7 +630,7 @@ void uwsgi_opt_sni(char *opt, char *value, void *foobar) {
 #endif
                 struct uwsgi_string_list *usl = uwsgi_string_new_list(&uwsgi.sni, v);
                 usl->custom_ptr = ctx;
-#ifdef UWSGI_PCRE
+#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)
         }
 #endif
 

{uwsgi-2.0.24 → uwsgi-2.0.25}/core/static.c

@@ -35,11 +35,11 @@ int uwsgi_static_want_gzip(struct wsgi_request *wsgi_req, char *filename, size_t
 		usl = usl->next;
 	}
 
-#ifdef UWSGI_PCRE
+#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)
 	// check for regexp
 	struct uwsgi_regexp_list *url = uwsgi.static_gzip;
 	while(url) {
-		if (uwsgi_regexp_match(url->pattern, url->pattern_extra, filename, *filename_len) >= 0) {
+		if (uwsgi_regexp_match(url->pattern, filename, *filename_len) >= 0) {
 			goto gzip;
 		}
 		url = url->next;
@@ -216,7 +216,7 @@ int uwsgi_add_expires_type(struct wsgi_request *wsgi_req, char *mime_type, int m
 	return 0;
 }
 
-#ifdef UWSGI_PCRE
+#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)
 int uwsgi_add_expires(struct wsgi_request *wsgi_req, char *filename, int filename_len, struct stat *st) {
 
 	struct uwsgi_dyn_dict *udd = uwsgi.static_expires;
@@ -225,7 +225,7 @@ int uwsgi_add_expires(struct wsgi_request *wsgi_req, char *filename, int filenam
 	char expires[31];
 
 	while (udd) {
-		if (uwsgi_regexp_match(udd->pattern, udd->pattern_extra, filename, filename_len) >= 0) {
+		if (uwsgi_regexp_match(udd->pattern, filename, filename_len) >= 0) {
 			int delta = uwsgi_str_num(udd->value, udd->vallen);
 			int size = uwsgi_http_date(now + delta, expires);
 			if (size > 0) {
@@ -238,7 +238,7 @@ int uwsgi_add_expires(struct wsgi_request *wsgi_req, char *filename, int filenam
 
 	udd = uwsgi.static_expires_mtime;
 	while (udd) {
-		if (uwsgi_regexp_match(udd->pattern, udd->pattern_extra, filename, filename_len) >= 0) {
+		if (uwsgi_regexp_match(udd->pattern, filename, filename_len) >= 0) {
 			int delta = uwsgi_str_num(udd->value, udd->vallen);
 			int size = uwsgi_http_date(st->st_mtime + delta, expires);
 			if (size > 0) {
@@ -260,7 +260,7 @@ int uwsgi_add_expires_path_info(struct wsgi_request *wsgi_req, struct stat *st)
 	char expires[31];
 
 	while (udd) {
-		if (uwsgi_regexp_match(udd->pattern, udd->pattern_extra, wsgi_req->path_info, wsgi_req->path_info_len) >= 0) {
+		if (uwsgi_regexp_match(udd->pattern, wsgi_req->path_info, wsgi_req->path_info_len) >= 0) {
 			int delta = uwsgi_str_num(udd->value, udd->vallen);
 			int size = uwsgi_http_date(now + delta, expires);
 			if (size > 0) {
@@ -273,7 +273,7 @@ int uwsgi_add_expires_path_info(struct wsgi_request *wsgi_req, struct stat *st)
 
 	udd = uwsgi.static_expires_path_info_mtime;
 	while (udd) {
-		if (uwsgi_regexp_match(udd->pattern, udd->pattern_extra, wsgi_req->path_info, wsgi_req->path_info_len) >= 0) {
+		if (uwsgi_regexp_match(udd->pattern, wsgi_req->path_info, wsgi_req->path_info_len) >= 0) {
 			int delta = uwsgi_str_num(udd->value, udd->vallen);
 			int size = uwsgi_http_date(st->st_mtime + delta, expires);
 			if (size > 0) {
@@ -295,7 +295,7 @@ int uwsgi_add_expires_uri(struct wsgi_request *wsgi_req, struct stat *st) {
 	char expires[31];
 
 	while (udd) {
-		if (uwsgi_regexp_match(udd->pattern, udd->pattern_extra, wsgi_req->uri, wsgi_req->uri_len) >= 0) {
+		if (uwsgi_regexp_match(udd->pattern, wsgi_req->uri, wsgi_req->uri_len) >= 0) {
 			int delta = uwsgi_str_num(udd->value, udd->vallen);
 			int size = uwsgi_http_date(now + delta, expires);
 			if (size > 0) {
@@ -308,7 +308,7 @@ int uwsgi_add_expires_uri(struct wsgi_request *wsgi_req, struct stat *st) {
 
 	udd = uwsgi.static_expires_uri_mtime;
 	while (udd) {
-		if (uwsgi_regexp_match(udd->pattern, udd->pattern_extra, wsgi_req->uri, wsgi_req->uri_len) >= 0) {
+		if (uwsgi_regexp_match(udd->pattern, wsgi_req->uri, wsgi_req->uri_len) >= 0) {
 			int delta = uwsgi_str_num(udd->value, udd->vallen);
 			int size = uwsgi_http_date(st->st_mtime + delta, expires);
 			if (size > 0) {
@@ -507,7 +507,7 @@ int uwsgi_real_file_serve(struct wsgi_request *wsgi_req, char *real_filename, si
 		if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) return -1;
 	}
 
-#ifdef UWSGI_PCRE
+#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)
 	uwsgi_add_expires(wsgi_req, real_filename, real_filename_len, st);
 	uwsgi_add_expires_path_info(wsgi_req, st);
 	uwsgi_add_expires_uri(wsgi_req, st);

{uwsgi-2.0.24 → uwsgi-2.0.25}/core/utils.c

@@ -1036,12 +1036,6 @@ void uwsgi_destroy_request(struct wsgi_request *wsgi_req) {
 
 	close_and_free_request(wsgi_req);
 
-	int foo;
-        if (uwsgi.threads > 1) {
-                // now the thread can die...
-                pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &foo);
-        }
-
 	// reset for avoiding following requests to fail on non-uwsgi protocols
 	// thanks Marko Tiikkaja for catching it
 	wsgi_req->uh->pktsize = 0;
@@ -1122,11 +1116,6 @@ void uwsgi_close_request(struct wsgi_request *wsgi_req) {
 		func(wsgi_req);
 	}
 
-	if (uwsgi.threads > 1) {
-		// now the thread can die...
-		pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &tmp_id);
-	}
-
 	// leave harakiri mode
 	if (uwsgi.workers[uwsgi.mywid].harakiri > 0) {
 		set_harakiri(0);
@@ -1546,18 +1535,12 @@ int wsgi_req_accept(int queue, struct wsgi_request *wsgi_req) {
 		}
 	}
 
-	// kill the thread after the request completion
-	if (uwsgi.threads > 1)
-		pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &ret);
-
 	if (uwsgi.signal_socket > -1 && (interesting_fd == uwsgi.signal_socket || interesting_fd == uwsgi.my_signal_socket)) {
 
 		thunder_unlock;
 
 		uwsgi_receive_signal(interesting_fd, "worker", uwsgi.mywid);
 
-		if (uwsgi.threads > 1)
-			pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &ret);
 		return -1;
 	}
 
@@ -1568,8 +1551,6 @@ int wsgi_req_accept(int queue, struct wsgi_request *wsgi_req) {
 			wsgi_req->fd = wsgi_req->socket->proto_accept(wsgi_req, interesting_fd);
 			thunder_unlock;
 			if (wsgi_req->fd < 0) {
-				if (uwsgi.threads > 1)
-					pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &ret);
 				return -1;
 			}
 
@@ -1584,8 +1565,6 @@ int wsgi_req_accept(int queue, struct wsgi_request *wsgi_req) {
 	}
 
 	thunder_unlock;
-	if (uwsgi.threads > 1)
-		pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &ret);
 	return -1;
 }
 
@@ -2301,7 +2280,7 @@ struct uwsgi_string_list *uwsgi_string_new_list(struct uwsgi_string_list **list,
 	return uwsgi_string;
 }
 
-#ifdef UWSGI_PCRE
+#if defined(UWSGI_PCRE) || defined(UWSGI_PCRE2)
 struct uwsgi_regexp_list *uwsgi_regexp_custom_new_list(struct uwsgi_regexp_list **list, char *value, char *custom) {
 
 	struct uwsgi_regexp_list *url = *list, *old_url;
@@ -2320,7 +2299,7 @@ struct uwsgi_regexp_list *uwsgi_regexp_custom_new_list(struct uwsgi_regexp_list
 		old_url->next = url;
 	}
 
-	if (uwsgi_regexp_build(value, &url->pattern, &url->pattern_extra)) {
+	if (uwsgi_regexp_build(value, &url->pattern)) {
 		exit(1);
 	}
 	url->next = NULL;
@@ -2333,14 +2312,13 @@ struct uwsgi_regexp_list *uwsgi_regexp_custom_new_list(struct uwsgi_regexp_list
 
 int uwsgi_regexp_match_pattern(char *pattern, char *str) {
 
-	pcre *regexp;
-	pcre_extra *regexp_extra;
+	uwsgi_pcre *regexp;
 
-	if (uwsgi_regexp_build(pattern, &regexp, &regexp_extra))
+	if (uwsgi_regexp_build(pattern, &regexp))
 		return 1;
-	return !uwsgi_regexp_match(regexp, regexp_extra, str, strlen(str));
-}
 
+	return !uwsgi_regexp_match(regexp, str, strlen(str));
+}
 
 #endif