Fossil SCM

Add a new setting "regexp-limit" that determines the maximum size of a REGEXP virtual machine. Default value 1000.

drh 2025-09-26 20:07 trunk

Commit 82888a0d35a80944460eff38b34a25d942e141b1778af1e56451d7029361660c

Parent 28483bfc5a45f9d…

9 files changed +1 -1 +2 -2 +4 -4 +3 -3 +1 -1 +2 -2 +51 -17 +1 -1 +2 -2

~ src/browse.c ~ src/diff.c ~ src/dispatch.c ~ src/info.c ~ src/json.c ~ src/match.c ~ src/regexp.c ~ src/robot.c ~ src/th_main.c

M src/browse.c

+1 -1

		--- src/browse.c
		+++ src/browse.c
		@@ -747,11 +747,11 @@
747	747	}
748	748
749	749	/* If a regular expression is specified, compile it */
750	750	zRE = P("re");
751	751	if( zRE ){
752		- re_compile(&pRE, zRE, 0);
	752	+ fossil_re_compile(&pRE, zRE, 0);
753	753	zREx = mprintf("&re=%T", zRE);
754	754	}
755	755	cgi_check_for_malice();
756	756
757	757	/* If the name= parameter is an empty string, make it a NULL pointer */
758	758

	--- src/browse.c
	+++ src/browse.c
	@@ -747,11 +747,11 @@
747	}
748
749	/* If a regular expression is specified, compile it */
750	zRE = P("re");
751	if( zRE ){
752	re_compile(&pRE, zRE, 0);
753	zREx = mprintf("&re=%T", zRE);
754	}
755	cgi_check_for_malice();
756
757	/* If the name= parameter is an empty string, make it a NULL pointer */
758

	--- src/browse.c
	+++ src/browse.c
	@@ -747,11 +747,11 @@
747	}
748
749	/* If a regular expression is specified, compile it */
750	zRE = P("re");
751	if( zRE ){
752	fossil_re_compile(&pRE, zRE, 0);
753	zREx = mprintf("&re=%T", zRE);
754	}
755	cgi_check_for_malice();
756
757	/* If the name= parameter is an empty string, make it a NULL pointer */
758

M src/diff.c

+2 -2

		--- src/diff.c
		+++ src/diff.c
		@@ -3386,11 +3386,11 @@
3386	3386	find_option("i",0,0);
3387	3387	find_option("v",0,0);
3388	3388	diff_options(&DCfg, 0, 0);
3389	3389	zRe = find_option("regexp","e",1);
3390	3390	if( zRe ){
3391		- const char *zErr = re_compile(&DCfg.pRe, zRe, 0);
	3391	+ const char *zErr = fossil_re_compile(&DCfg.pRe, zRe, 0);
3392	3392	if( zErr ) fossil_fatal("regex error: %s", zErr);
3393	3393	}
3394	3394	verify_all_options();
3395	3395	if( g.argc!=4 ) usage("FILE1 FILE2");
3396	3396	blob_zero(&out);
		@@ -3429,11 +3429,11 @@
3429	3429	find_option("i",0,0);
3430	3430	find_option("v",0,0);
3431	3431	diff_options(&DCfg, 0, 0);
3432	3432	zRe = find_option("regexp","e",1);
3433	3433	if( zRe ){
3434		- const char *zErr = re_compile(&DCfg.pRe, zRe, 0);
	3434	+ const char *zErr = fossil_re_compile(&DCfg.pRe, zRe, 0);
3435	3435	if( zErr ) fossil_fatal("regex error: %s", zErr);
3436	3436	}
3437	3437	db_find_and_open_repository(0, 0);
3438	3438	verify_all_options();
3439	3439	if( g.argc!=4 ) usage("HASH1 HASH2");
3440	3440

	--- src/diff.c
	+++ src/diff.c
	@@ -3386,11 +3386,11 @@
3386	find_option("i",0,0);
3387	find_option("v",0,0);
3388	diff_options(&DCfg, 0, 0);
3389	zRe = find_option("regexp","e",1);
3390	if( zRe ){
3391	const char *zErr = re_compile(&DCfg.pRe, zRe, 0);
3392	if( zErr ) fossil_fatal("regex error: %s", zErr);
3393	}
3394	verify_all_options();
3395	if( g.argc!=4 ) usage("FILE1 FILE2");
3396	blob_zero(&out);
	@@ -3429,11 +3429,11 @@
3429	find_option("i",0,0);
3430	find_option("v",0,0);
3431	diff_options(&DCfg, 0, 0);
3432	zRe = find_option("regexp","e",1);
3433	if( zRe ){
3434	const char *zErr = re_compile(&DCfg.pRe, zRe, 0);
3435	if( zErr ) fossil_fatal("regex error: %s", zErr);
3436	}
3437	db_find_and_open_repository(0, 0);
3438	verify_all_options();
3439	if( g.argc!=4 ) usage("HASH1 HASH2");
3440

	--- src/diff.c
	+++ src/diff.c
	@@ -3386,11 +3386,11 @@
3386	find_option("i",0,0);
3387	find_option("v",0,0);
3388	diff_options(&DCfg, 0, 0);
3389	zRe = find_option("regexp","e",1);
3390	if( zRe ){
3391	const char *zErr = fossil_re_compile(&DCfg.pRe, zRe, 0);
3392	if( zErr ) fossil_fatal("regex error: %s", zErr);
3393	}
3394	verify_all_options();
3395	if( g.argc!=4 ) usage("FILE1 FILE2");
3396	blob_zero(&out);
	@@ -3429,11 +3429,11 @@
3429	find_option("i",0,0);
3430	find_option("v",0,0);
3431	diff_options(&DCfg, 0, 0);
3432	zRe = find_option("regexp","e",1);
3433	if( zRe ){
3434	const char *zErr = fossil_re_compile(&DCfg.pRe, zRe, 0);
3435	if( zErr ) fossil_fatal("regex error: %s", zErr);
3436	}
3437	db_find_and_open_repository(0, 0);
3438	verify_all_options();
3439	if( g.argc!=4 ) usage("HASH1 HASH2");
3440

M src/dispatch.c

+4 -4

		--- src/dispatch.c
		+++ src/dispatch.c
		@@ -1155,11 +1155,11 @@
1155	1155	}else{
1156	1156	zPattern = mprintf("> ?fossil [-a-z]+ .*\\b%s\\b", zQSub);
1157	1157	}
1158	1158	fossil_free(zQTop);
1159	1159	fossil_free(zQSub);
1160		- re_compile(&pRe, zPattern, 0);
	1160	+ fossil_re_compile(&pRe, zPattern, 0);
1161	1161	fossil_free(zPattern);
1162	1162	blob_init(&in, z, -1);
1163	1163	while( blob_line(&in, &line) ){
1164	1164	if( re_match(pRe, (unsigned char*)blob_buffer(&line), blob_size(&line)) ){
1165	1165	int atStart = 1;
		@@ -1252,13 +1252,13 @@
1252	1252	ReCompiled *pRe = 0;
1253	1253	Blob in, line;
1254	1254	int n = 0;
1255	1255
1256	1256	if( bAbbrevSubcmd ){
1257		- re_compile(&pRe, "^(Usage: \| [a-z][-a-z\|]+ .*)", 0);
	1257	+ fossil_re_compile(&pRe, "^(Usage: \| [a-z][-a-z\|]+ .*)", 0);
1258	1258	}else{
1259		- re_compile(&pRe, "^(Usage: \| *[Oo]r: +%fossi \|> ?fossil )", 0);
	1259	+ fossil_re_compile(&pRe, "^(Usage: \| *[Oo]r: +%fossi \|> ?fossil )", 0);
1260	1260	}
1261	1261	blob_init(&in, z, -1);
1262	1262	while( blob_line(&in, &line) ){
1263	1263	if( re_match(pRe, (unsigned char*)blob_buffer(&line), blob_strlen(&line)) ){
1264	1264	simplify_usage_line(&line, pOut, bAbbrevSubcmd, zTopic);
		@@ -1285,11 +1285,11 @@
1285	1285	int n = 0;
1286	1286	int bSubsectionSeen = 0;
1287	1287
1288	1288	blob_init(&txt, z, -1);
1289	1289	blob_init(&subsection, 0, 0);
1290		- re_compile(&pRe, "^ +-.* ", 0);
	1290	+ fossil_re_compile(&pRe, "^ +-.* ", 0);
1291	1291	while( blob_line(&txt, &line) ){
1292	1292	int len = blob_size(&line);
1293	1293	unsigned char zLine = (unsigned char )blob_buffer(&line);
1294	1294	if( re_match(pRe, zLine, len) ){
1295	1295	if( blob_size(&subsection) ){
1296	1296

	--- src/dispatch.c
	+++ src/dispatch.c
	@@ -1155,11 +1155,11 @@
1155	}else{
1156	zPattern = mprintf("> ?fossil [-a-z]+ .*\\b%s\\b", zQSub);
1157	}
1158	fossil_free(zQTop);
1159	fossil_free(zQSub);
1160	re_compile(&pRe, zPattern, 0);
1161	fossil_free(zPattern);
1162	blob_init(&in, z, -1);
1163	while( blob_line(&in, &line) ){
1164	if( re_match(pRe, (unsigned char*)blob_buffer(&line), blob_size(&line)) ){
1165	int atStart = 1;
	@@ -1252,13 +1252,13 @@
1252	ReCompiled *pRe = 0;
1253	Blob in, line;
1254	int n = 0;
1255
1256	if( bAbbrevSubcmd ){
1257	re_compile(&pRe, "^(Usage: \| [a-z][-a-z\|]+ .*)", 0);
1258	}else{
1259	re_compile(&pRe, "^(Usage: \| *[Oo]r: +%fossi \|> ?fossil )", 0);
1260	}
1261	blob_init(&in, z, -1);
1262	while( blob_line(&in, &line) ){
1263	if( re_match(pRe, (unsigned char*)blob_buffer(&line), blob_strlen(&line)) ){
1264	simplify_usage_line(&line, pOut, bAbbrevSubcmd, zTopic);
	@@ -1285,11 +1285,11 @@
1285	int n = 0;
1286	int bSubsectionSeen = 0;
1287
1288	blob_init(&txt, z, -1);
1289	blob_init(&subsection, 0, 0);
1290	re_compile(&pRe, "^ +-.* ", 0);
1291	while( blob_line(&txt, &line) ){
1292	int len = blob_size(&line);
1293	unsigned char zLine = (unsigned char )blob_buffer(&line);
1294	if( re_match(pRe, zLine, len) ){
1295	if( blob_size(&subsection) ){
1296

	--- src/dispatch.c
	+++ src/dispatch.c
	@@ -1155,11 +1155,11 @@
1155	}else{
1156	zPattern = mprintf("> ?fossil [-a-z]+ .*\\b%s\\b", zQSub);
1157	}
1158	fossil_free(zQTop);
1159	fossil_free(zQSub);
1160	fossil_re_compile(&pRe, zPattern, 0);
1161	fossil_free(zPattern);
1162	blob_init(&in, z, -1);
1163	while( blob_line(&in, &line) ){
1164	if( re_match(pRe, (unsigned char*)blob_buffer(&line), blob_size(&line)) ){
1165	int atStart = 1;
	@@ -1252,13 +1252,13 @@
1252	ReCompiled *pRe = 0;
1253	Blob in, line;
1254	int n = 0;
1255
1256	if( bAbbrevSubcmd ){
1257	fossil_re_compile(&pRe, "^(Usage: \| [a-z][-a-z\|]+ .*)", 0);
1258	}else{
1259	fossil_re_compile(&pRe, "^(Usage: \| *[Oo]r: +%fossi \|> ?fossil )", 0);
1260	}
1261	blob_init(&in, z, -1);
1262	while( blob_line(&in, &line) ){
1263	if( re_match(pRe, (unsigned char*)blob_buffer(&line), blob_strlen(&line)) ){
1264	simplify_usage_line(&line, pOut, bAbbrevSubcmd, zTopic);
	@@ -1285,11 +1285,11 @@
1285	int n = 0;
1286	int bSubsectionSeen = 0;
1287
1288	blob_init(&txt, z, -1);
1289	blob_init(&subsection, 0, 0);
1290	fossil_re_compile(&pRe, "^ +-.* ", 0);
1291	while( blob_line(&txt, &line) ){
1292	int len = blob_size(&line);
1293	unsigned char zLine = (unsigned char )blob_buffer(&line);
1294	if( re_match(pRe, zLine, len) ){
1295	if( blob_size(&subsection) ){
1296

M src/info.c

+3 -3

		--- src/info.c
		+++ src/info.c
		@@ -936,11 +936,11 @@
936	936	@ No such object: %h(zName)
937	937	style_finish_page();
938	938	return;
939	939	}
940	940	zRe = P("regex");
941		- if( zRe ) re_compile(&pRe, zRe, 0);
	941	+ if( zRe ) fossil_re_compile(&pRe, zRe, 0);
942	942	zUuid = db_text(0, "SELECT uuid FROM blob WHERE rid=%d", rid);
943	943	zParent = db_text(0,
944	944	"SELECT uuid FROM plink, blob"
945	945	" WHERE plink.cid=%d AND blob.rid=plink.pid AND plink.isprim",
946	946	rid
		@@ -1448,11 +1448,11 @@
1448	1448	fossil_nice_default();
1449	1449	blob_init(&qp, 0, 0);
1450	1450	blob_init(&qpGlob, 0, 0);
1451	1451	diffType = preferred_diff_type();
1452	1452	zRe = P("regex");
1453		- if( zRe ) re_compile(&pRe, zRe, 0);
	1453	+ if( zRe ) fossil_re_compile(&pRe, zRe, 0);
1454	1454	zBranch = P("branch");
1455	1455	if( zBranch && zBranch[0]==0 ) zBranch = 0;
1456	1456	if( zBranch ){
1457	1457	blob_appendf(&qp, "branch=%T", zBranch);
1458	1458	zMergeOrigin = mprintf("merge-in:%s", zBranch);
		@@ -2051,11 +2051,11 @@
2051	2051	}
2052	2052	db_finalize(&q);
2053	2053	}
2054	2054	zRe = P("regex");
2055	2055	cgi_check_for_malice();
2056		- if( zRe ) re_compile(&pRe, zRe, 0);
	2056	+ if( zRe ) fossil_re_compile(&pRe, zRe, 0);
2057	2057	if( verbose ) objdescFlags \|= OBJDESC_DETAIL;
2058	2058	if( isPatch ){
2059	2059	Blob c1, c2, *pOut;
2060	2060	DiffConfig DCfg;
2061	2061	pOut = cgi_output_blob();
2062	2062

	--- src/info.c
	+++ src/info.c
	@@ -936,11 +936,11 @@
936	@ No such object: %h(zName)
937	style_finish_page();
938	return;
939	}
940	zRe = P("regex");
941	if( zRe ) re_compile(&pRe, zRe, 0);
942	zUuid = db_text(0, "SELECT uuid FROM blob WHERE rid=%d", rid);
943	zParent = db_text(0,
944	"SELECT uuid FROM plink, blob"
945	" WHERE plink.cid=%d AND blob.rid=plink.pid AND plink.isprim",
946	rid
	@@ -1448,11 +1448,11 @@
1448	fossil_nice_default();
1449	blob_init(&qp, 0, 0);
1450	blob_init(&qpGlob, 0, 0);
1451	diffType = preferred_diff_type();
1452	zRe = P("regex");
1453	if( zRe ) re_compile(&pRe, zRe, 0);
1454	zBranch = P("branch");
1455	if( zBranch && zBranch[0]==0 ) zBranch = 0;
1456	if( zBranch ){
1457	blob_appendf(&qp, "branch=%T", zBranch);
1458	zMergeOrigin = mprintf("merge-in:%s", zBranch);
	@@ -2051,11 +2051,11 @@
2051	}
2052	db_finalize(&q);
2053	}
2054	zRe = P("regex");
2055	cgi_check_for_malice();
2056	if( zRe ) re_compile(&pRe, zRe, 0);
2057	if( verbose ) objdescFlags \|= OBJDESC_DETAIL;
2058	if( isPatch ){
2059	Blob c1, c2, *pOut;
2060	DiffConfig DCfg;
2061	pOut = cgi_output_blob();
2062

	--- src/info.c
	+++ src/info.c
	@@ -936,11 +936,11 @@
936	@ No such object: %h(zName)
937	style_finish_page();
938	return;
939	}
940	zRe = P("regex");
941	if( zRe ) fossil_re_compile(&pRe, zRe, 0);
942	zUuid = db_text(0, "SELECT uuid FROM blob WHERE rid=%d", rid);
943	zParent = db_text(0,
944	"SELECT uuid FROM plink, blob"
945	" WHERE plink.cid=%d AND blob.rid=plink.pid AND plink.isprim",
946	rid
	@@ -1448,11 +1448,11 @@
1448	fossil_nice_default();
1449	blob_init(&qp, 0, 0);
1450	blob_init(&qpGlob, 0, 0);
1451	diffType = preferred_diff_type();
1452	zRe = P("regex");
1453	if( zRe ) fossil_re_compile(&pRe, zRe, 0);
1454	zBranch = P("branch");
1455	if( zBranch && zBranch[0]==0 ) zBranch = 0;
1456	if( zBranch ){
1457	blob_appendf(&qp, "branch=%T", zBranch);
1458	zMergeOrigin = mprintf("merge-in:%s", zBranch);
	@@ -2051,11 +2051,11 @@
2051	}
2052	db_finalize(&q);
2053	}
2054	zRe = P("regex");
2055	cgi_check_for_malice();
2056	if( zRe ) fossil_re_compile(&pRe, zRe, 0);
2057	if( verbose ) objdescFlags \|= OBJDESC_DETAIL;
2058	if( isPatch ){
2059	Blob c1, c2, *pOut;
2060	DiffConfig DCfg;
2061	pOut = cgi_output_blob();
2062

M src/json.c

+1 -1

		--- src/json.c
		+++ src/json.c
		@@ -78,11 +78,11 @@
78	78	** whether or not we're really running in json mode we have to try
79	79	** a bit harder. Problem reported here:
80	80	** https://fossil-scm.org/forum/forumpost/e4953666d6
81	81	*/
82	82	ReCompiled * pReg = 0;
83		- const char * zErr = re_compile(&pReg, "^/[^/]+/json(/.*)?", 0);
	83	+ const char * zErr = fossil_re_compile(&pReg, "^/[^/]+/json(/.*)?", 0);
84	84	assert(zErr==0 && "Regex compilation failed?");
85	85	if(zErr==0 &&
86	86	re_match(pReg, (const unsigned char *)zPathInfo, -1)){
87	87	rc = 2;
88	88	}
89	89

	--- src/json.c
	+++ src/json.c
	@@ -78,11 +78,11 @@
78	** whether or not we're really running in json mode we have to try
79	** a bit harder. Problem reported here:
80	** https://fossil-scm.org/forum/forumpost/e4953666d6
81	*/
82	ReCompiled * pReg = 0;
83	const char * zErr = re_compile(&pReg, "^/[^/]+/json(/.*)?", 0);
84	assert(zErr==0 && "Regex compilation failed?");
85	if(zErr==0 &&
86	re_match(pReg, (const unsigned char *)zPathInfo, -1)){
87	rc = 2;
88	}
89

	--- src/json.c
	+++ src/json.c
	@@ -78,11 +78,11 @@
78	** whether or not we're really running in json mode we have to try
79	** a bit harder. Problem reported here:
80	** https://fossil-scm.org/forum/forumpost/e4953666d6
81	*/
82	ReCompiled * pReg = 0;
83	const char * zErr = fossil_re_compile(&pReg, "^/[^/]+/json(/.*)?", 0);
84	assert(zErr==0 && "Regex compilation failed?");
85	if(zErr==0 &&
86	re_match(pReg, (const unsigned char *)zPathInfo, -1)){
87	rc = 2;
88	}
89

M src/match.c

+2 -2

		--- src/match.c
		+++ src/match.c
		@@ -142,11 +142,11 @@
142	142	if( zPat[0] ) zPat++;
143	143
144	144	/* Check for regular expression syntax errors. */
145	145	if( style==MS_REGEXP ){
146	146	ReCompiled *regexp;
147		- const char *zFail = re_compile(&regexp, zOne, 0);
	147	+ const char *zFail = fossil_re_compile(&regexp, zOne, 0);
148	148	if( zFail ){
149	149	re_free(regexp);
150	150	continue;
151	151	}
152	152	p->nPattern++;
		@@ -375,11 +375,11 @@
375	375
376	376	/* Check for regular expression syntax errors. */
377	377	if( matchStyle==MS_REGEXP ){
378	378	ReCompiled *regexp;
379	379	char *zTagDup = fossil_strndup(zTag, i);
380		- zFail = re_compile(&regexp, zTagDup, 0);
	380	+ zFail = fossil_re_compile(&regexp, zTagDup, 0);
381	381	re_free(regexp);
382	382	fossil_free(zTagDup);
383	383	}
384	384
385	385	/* Process success and error results. */
386	386

	--- src/match.c
	+++ src/match.c
	@@ -142,11 +142,11 @@
142	if( zPat[0] ) zPat++;
143
144	/* Check for regular expression syntax errors. */
145	if( style==MS_REGEXP ){
146	ReCompiled *regexp;
147	const char *zFail = re_compile(&regexp, zOne, 0);
148	if( zFail ){
149	re_free(regexp);
150	continue;
151	}
152	p->nPattern++;
	@@ -375,11 +375,11 @@
375
376	/* Check for regular expression syntax errors. */
377	if( matchStyle==MS_REGEXP ){
378	ReCompiled *regexp;
379	char *zTagDup = fossil_strndup(zTag, i);
380	zFail = re_compile(&regexp, zTagDup, 0);
381	re_free(regexp);
382	fossil_free(zTagDup);
383	}
384
385	/* Process success and error results. */
386

	--- src/match.c
	+++ src/match.c
	@@ -142,11 +142,11 @@
142	if( zPat[0] ) zPat++;
143
144	/* Check for regular expression syntax errors. */
145	if( style==MS_REGEXP ){
146	ReCompiled *regexp;
147	const char *zFail = fossil_re_compile(&regexp, zOne, 0);
148	if( zFail ){
149	re_free(regexp);
150	continue;
151	}
152	p->nPattern++;
	@@ -375,11 +375,11 @@
375
376	/* Check for regular expression syntax errors. */
377	if( matchStyle==MS_REGEXP ){
378	ReCompiled *regexp;
379	char *zTagDup = fossil_strndup(zTag, i);
380	zFail = fossil_re_compile(&regexp, zTagDup, 0);
381	re_free(regexp);
382	fossil_free(zTagDup);
383	}
384
385	/* Process success and error results. */
386

M src/regexp.c

+51 -17

		--- src/regexp.c
		+++ src/regexp.c
		@@ -24,11 +24,11 @@
24	24	** The following regular expression syntax is supported:
25	25	**
26	26	** X* zero or more occurrences of X
27	27	** X+ one or more occurrences of X
28	28	** X? zero or one occurrences of X
29		-** X{p,q} between p and q occurrences of X, 0 <= p,q <= 999
	29	+** X{p,q} between p and q occurrences of X
30	30	** (X) match X
31	31	** X\|Y X or Y
32	32	** ^X X occurring at the beginning of the string
33	33	** X$ X occurring at the end of the string
34	34	** . Match any single character
		@@ -53,13 +53,10 @@
53	53	** expression and M is the size of the input string. The matcher never
54	54	** exhibits exponential behavior. Note that the X{p,q} operator expands
55	55	** to p copies of X following by q-p copies of X? and that the size of the
56	56	** regular expression in the O(N*M) performance bound is computed after
57	57	** this expansion.
58		-**
59		-** To help prevent DoS attacks, the values of p and q in the "{p,q}" syntax
60		-** are limited to SQLITE_MAX_REGEXP_REPEAT, default 999.
61	58	*/
62	59	#include "config.h"
63	60	#include "regexp.h"
64	61
65	62	#ifndef SQLITE_MAX_REGEXP_REPEAT
		@@ -125,10 +122,11 @@
125	122	unsigned (xNextChar)(ReInput); /* Next character function */
126	123	unsigned char zInit[12]; /* Initial text to match */
127	124	int nInit; /* Number of characters in zInit */
128	125	unsigned nState; /* Number of entries in aOp[] and aArg[] */
129	126	unsigned nAlloc; /* Slots allocated for aOp[] and aArg[] */
	127	+ unsigned mxAlloc; /* Complexity limit */
130	128	};
131	129	#endif
132	130
133	131	/* Add a state to the given state set if it is not already there */
134	132	static void re_add_state(ReStateSet *pSet, int newState){
		@@ -341,15 +339,16 @@
341	339	/* Resize the opcode and argument arrays for an RE under construction.
342	340	*/
343	341	static int re_resize(ReCompiled *p, int N){
344	342	char *aOp;
345	343	int *aArg;
	344	+ if( N>p->mxAlloc ){ p->zErr = "REGEXP pattern too big"; return 1; }
346	345	aOp = fossil_realloc(p->aOp, N*sizeof(p->aOp[0]));
347		- if( aOp==0 ) return 1;
	346	+ if( aOp==0 ){ p->zErr = "out of memory"; return 1; }
348	347	p->aOp = aOp;
349	348	aArg = fossil_realloc(p->aArg, N*sizeof(p->aArg[0]));
350		- if( aArg==0 ) return 1;
	349	+ if( aArg==0 ){ p->zErr = "out of memory"; return 1; }
351	350	p->aArg = aArg;
352	351	p->nAlloc = N;
353	352	return 0;
354	353	}
355	354
		@@ -534,20 +533,20 @@
534	533	unsigned int m = 0, n = 0;
535	534	unsigned int sz, j;
536	535	if( iPrev<0 ) return "'{m,n}' without operand";
537	536	while( (c=rePeek(p))>='0' && c<='9' ){
538	537	m = m*10 + c - '0';
539		- if( m>SQLITE_MAX_REGEXP_REPEAT ) return "integer too large";
	538	+ if( m*2>p->mxAlloc ) return "REGEXP pattern too big";
540	539	p->sIn.i++;
541	540	}
542	541	n = m;
543	542	if( c==',' ){
544	543	p->sIn.i++;
545	544	n = 0;
546	545	while( (c=rePeek(p))>='0' && c<='9' ){
547	546	n = n*10 + c-'0';
548		- if( n>SQLITE_MAX_REGEXP_REPEAT ) return "integer too large";
	547	+ if( n*2>p->mxAlloc ) return "REGEXP pattern too big";
549	548	p->sIn.i++;
550	549	}
551	550	}
552	551	if( c!='}' ) return "unmatched '{'";
553	552	if( n>0 && n<m ) return "n less than m in '{m,n}'";
		@@ -564,11 +563,11 @@
564	563	for(j=m; j<n; j++){
565	564	re_append(p, RE_OP_FORK, sz+1);
566	565	re_copy(p, iPrev, sz);
567	566	}
568	567	if( n==0 && m>0 ){
569		- re_append(p, RE_OP_FORK, -sz);
	568	+ re_append(p, RE_OP_FORK, -(int)sz);
570	569	}
571	570	break;
572	571	}
573	572	case '[': {
574	573	unsigned int iFirst = p->nState;
		@@ -644,11 +643,16 @@
644	643	** Compile a textual regular expression in zIn[] into a compiled regular
645	644	** expression suitable for us by re_match() and return a pointer to the
646	645	** compiled regular expression in *ppRe. Return NULL on success or an
647	646	** error message if something goes wrong.
648	647	*/
649		-const char re_compile(ReCompiled ppRe, const char zIn, int noCase){
	648	+const char *re_compile(
	649	+ ReCompiled *ppRe, / OUT: write compiled NFA here */
	650	+ const char zIn, / Input regular expression */
	651	+ int mxRe, /* Complexity limit */
	652	+ int noCase /* True for caseless comparisons */
	653	+){
650	654	ReCompiled *pRe;
651	655	const char *zErr;
652	656	int i, j;
653	657
654	658	*ppRe = 0;
		@@ -656,13 +660,15 @@
656	660	if( pRe==0 ){
657	661	return "out of memory";
658	662	}
659	663	memset(pRe, 0, sizeof(*pRe));
660	664	pRe->xNextChar = noCase ? re_next_char_nocase : re_next_char;
	665	+ pRe->mxAlloc = mxRe;
661	666	if( re_resize(pRe, 30) ){
	667	+ zErr = pRe->zErr;
662	668	re_free(pRe);
663		- return "out of memory";
	669	+ return zErr;
664	670	}
665	671	if( zIn[0]=='^' ){
666	672	zIn++;
667	673	}else{
668	674	re_append(pRe, RE_OP_ANYSTAR, 0);
		@@ -749,10 +755,36 @@
749	755	zIn++;
750	756	}
751	757	blob_materialize(&out);
752	758	return out.aData;
753	759	}
	760	+
	761	+/*
	762	+** SETTING: regexp-limit width=8 default=1000
	763	+**
	764	+** Limit the size of the bytecode used to implement a regular expression
	765	+** to this many steps. It is important to limit this to avoid possible
	766	+** DoS attacks.
	767	+*/
	768	+
	769	+/*
	770	+** Compute a reasonable limit on the length of the REGEXP NFA.
	771	+*/
	772	+int re_maxlen(void){
	773	+ return g.db ? db_get_int("regexp-limit", 1000) : 1000;
	774	+}
	775	+
	776	+/*
	777	+** Compile an RE using re_maxlen().
	778	+*/
	779	+const char *fossil_re_compile(
	780	+ ReCompiled *ppRe, / OUT: write compiled NFA here */
	781	+ const char zIn, / Input regular expression */
	782	+ int noCase /* True for caseless comparisons */
	783	+){
	784	+ return re_compile(ppRe, zIn, re_maxlen(), noCase);
	785	+}
754	786
755	787	/*
756	788	** Implementation of the regexp() SQL function. This function implements
757	789	** the build-in REGEXP operator. The first argument to the function is the
758	790	** pattern and the second argument is the string. So, the SQL statements:
		@@ -775,11 +807,11 @@
775	807	(void)argc; /* Unused */
776	808	pRe = sqlite3_get_auxdata(context, 0);
777	809	if( pRe==0 ){
778	810	zPattern = (const char*)sqlite3_value_text(argv[0]);
779	811	if( zPattern==0 ) return;
780		- zErr = re_compile(&pRe, zPattern, sqlite3_user_data(context)!=0);
	812	+ zErr = fossil_re_compile(&pRe, zPattern, sqlite3_user_data(context)!=0);
781	813	if( zErr ){
782	814	re_free(pRe);
783	815	sqlite3_result_int(context, 0);
784	816	/* sqlite3_result_error(context, zErr, -1); */
785	817	return;
		@@ -803,16 +835,18 @@
803	835	** Invoke this routine to register the regexp() function with the
804	836	** SQLite database connection.
805	837	*/
806	838	int re_add_sql_func(sqlite3 *db){
807	839	int rc;
808		- rc = sqlite3_create_function(db, "regexp", 2, SQLITE_UTF8\|SQLITE_INNOCUOUS,
	840	+ rc = sqlite3_create_function(db, "regexp", 2,
	841	+ SQLITE_UTF8\|SQLITE_INNOCUOUS\|SQLITE_DETERMINISTIC,
809	842	0, re_sql_func, 0, 0);
810	843	if( rc==SQLITE_OK ){
811	844	/* The regexpi(PATTERN,STRING) function is a case-insensitive version
812	845	** of regexp(PATTERN,STRING). */
813		- rc = sqlite3_create_function(db, "regexpi", 2, SQLITE_UTF8\|SQLITE_INNOCUOUS,
	846	+ rc = sqlite3_create_function(db, "regexpi", 2,
	847	+ SQLITE_UTF8\|SQLITE_INNOCUOUS\|SQLITE_DETERMINISTIC,
814	848	(void*)db, re_sql_func, 0, 0);
815	849	}
816	850	return rc;
817	851	}
818	852
		@@ -891,18 +925,18 @@
891	925	if( bRobot ){
892	926	const char *zRe;
893	927	db_find_and_open_repository(0,0);
894	928	verify_all_options();
895	929	zRe = db_get("robot-exception","^$");
896		- zErr = re_compile(&pRe, zRe, ignoreCase);
	930	+ zErr = fossil_re_compile(&pRe, zRe, ignoreCase);
897	931	iFileList = 2;
898	932	}else{
899	933	verify_all_options();
900	934	if( g.argc<3 ){
901	935	usage("REGEXP [FILE...]");
902	936	}
903		- zErr = re_compile(&pRe, g.argv[2], ignoreCase);
	937	+ zErr = fossil_re_compile(&pRe, g.argv[2], ignoreCase);
904	938	}
905	939	if( zErr ) fossil_fatal("%s", zErr);
906	940	if( g.argc==iFileList ){
907	941	grep_file(pRe, "-", stdin);
908	942	}else{
		@@ -980,11 +1014,11 @@
980	1014	db_find_and_open_repository(0, 0);
981	1015	verify_all_options();
982	1016	if( g.argc<4 ){
983	1017	usage("REGEXP FILENAME ...");
984	1018	}
985		- zErr = re_compile(&pRe, g.argv[2], ignoreCase);
	1019	+ zErr = fossil_re_compile(&pRe, g.argv[2], ignoreCase);
986	1020	if( zErr ) fossil_fatal("%s", zErr);
987	1021
988	1022	add_content_sql_commands(g.db);
989	1023	db_multi_exec("CREATE TEMP TABLE arglist(iname,fname,fnid);");
990	1024	for(ii=3; ii<g.argc; ii++){
991	1025

	--- src/regexp.c
	+++ src/regexp.c
	@@ -24,11 +24,11 @@
24	** The following regular expression syntax is supported:
25	**
26	** X* zero or more occurrences of X
27	** X+ one or more occurrences of X
28	** X? zero or one occurrences of X
29	** X{p,q} between p and q occurrences of X, 0 <= p,q <= 999
30	** (X) match X
31	** X\|Y X or Y
32	** ^X X occurring at the beginning of the string
33	** X$ X occurring at the end of the string
34	** . Match any single character
	@@ -53,13 +53,10 @@
53	** expression and M is the size of the input string. The matcher never
54	** exhibits exponential behavior. Note that the X{p,q} operator expands
55	** to p copies of X following by q-p copies of X? and that the size of the
56	** regular expression in the O(N*M) performance bound is computed after
57	** this expansion.
58	**
59	** To help prevent DoS attacks, the values of p and q in the "{p,q}" syntax
60	** are limited to SQLITE_MAX_REGEXP_REPEAT, default 999.
61	*/
62	#include "config.h"
63	#include "regexp.h"
64
65	#ifndef SQLITE_MAX_REGEXP_REPEAT
	@@ -125,10 +122,11 @@
125	unsigned (xNextChar)(ReInput); /* Next character function */
126	unsigned char zInit[12]; /* Initial text to match */
127	int nInit; /* Number of characters in zInit */
128	unsigned nState; /* Number of entries in aOp[] and aArg[] */
129	unsigned nAlloc; /* Slots allocated for aOp[] and aArg[] */

130	};
131	#endif
132
133	/* Add a state to the given state set if it is not already there */
134	static void re_add_state(ReStateSet *pSet, int newState){
	@@ -341,15 +339,16 @@
341	/* Resize the opcode and argument arrays for an RE under construction.
342	*/
343	static int re_resize(ReCompiled *p, int N){
344	char *aOp;
345	int *aArg;

346	aOp = fossil_realloc(p->aOp, N*sizeof(p->aOp[0]));
347	if( aOp==0 ) return 1;
348	p->aOp = aOp;
349	aArg = fossil_realloc(p->aArg, N*sizeof(p->aArg[0]));
350	if( aArg==0 ) return 1;
351	p->aArg = aArg;
352	p->nAlloc = N;
353	return 0;
354	}
355
	@@ -534,20 +533,20 @@
534	unsigned int m = 0, n = 0;
535	unsigned int sz, j;
536	if( iPrev<0 ) return "'{m,n}' without operand";
537	while( (c=rePeek(p))>='0' && c<='9' ){
538	m = m*10 + c - '0';
539	if( m>SQLITE_MAX_REGEXP_REPEAT ) return "integer too large";
540	p->sIn.i++;
541	}
542	n = m;
543	if( c==',' ){
544	p->sIn.i++;
545	n = 0;
546	while( (c=rePeek(p))>='0' && c<='9' ){
547	n = n*10 + c-'0';
548	if( n>SQLITE_MAX_REGEXP_REPEAT ) return "integer too large";
549	p->sIn.i++;
550	}
551	}
552	if( c!='}' ) return "unmatched '{'";
553	if( n>0 && n<m ) return "n less than m in '{m,n}'";
	@@ -564,11 +563,11 @@
564	for(j=m; j<n; j++){
565	re_append(p, RE_OP_FORK, sz+1);
566	re_copy(p, iPrev, sz);
567	}
568	if( n==0 && m>0 ){
569	re_append(p, RE_OP_FORK, -sz);
570	}
571	break;
572	}
573	case '[': {
574	unsigned int iFirst = p->nState;
	@@ -644,11 +643,16 @@
644	** Compile a textual regular expression in zIn[] into a compiled regular
645	** expression suitable for us by re_match() and return a pointer to the
646	** compiled regular expression in *ppRe. Return NULL on success or an
647	** error message if something goes wrong.
648	*/
649	const char re_compile(ReCompiled ppRe, const char zIn, int noCase){





650	ReCompiled *pRe;
651	const char *zErr;
652	int i, j;
653
654	*ppRe = 0;
	@@ -656,13 +660,15 @@
656	if( pRe==0 ){
657	return "out of memory";
658	}
659	memset(pRe, 0, sizeof(*pRe));
660	pRe->xNextChar = noCase ? re_next_char_nocase : re_next_char;

661	if( re_resize(pRe, 30) ){

662	re_free(pRe);
663	return "out of memory";
664	}
665	if( zIn[0]=='^' ){
666	zIn++;
667	}else{
668	re_append(pRe, RE_OP_ANYSTAR, 0);
	@@ -749,10 +755,36 @@
749	zIn++;
750	}
751	blob_materialize(&out);
752	return out.aData;
753	}


























754
755	/*
756	** Implementation of the regexp() SQL function. This function implements
757	** the build-in REGEXP operator. The first argument to the function is the
758	** pattern and the second argument is the string. So, the SQL statements:
	@@ -775,11 +807,11 @@
775	(void)argc; /* Unused */
776	pRe = sqlite3_get_auxdata(context, 0);
777	if( pRe==0 ){
778	zPattern = (const char*)sqlite3_value_text(argv[0]);
779	if( zPattern==0 ) return;
780	zErr = re_compile(&pRe, zPattern, sqlite3_user_data(context)!=0);
781	if( zErr ){
782	re_free(pRe);
783	sqlite3_result_int(context, 0);
784	/* sqlite3_result_error(context, zErr, -1); */
785	return;
	@@ -803,16 +835,18 @@
803	** Invoke this routine to register the regexp() function with the
804	** SQLite database connection.
805	*/
806	int re_add_sql_func(sqlite3 *db){
807	int rc;
808	rc = sqlite3_create_function(db, "regexp", 2, SQLITE_UTF8\|SQLITE_INNOCUOUS,

809	0, re_sql_func, 0, 0);
810	if( rc==SQLITE_OK ){
811	/* The regexpi(PATTERN,STRING) function is a case-insensitive version
812	** of regexp(PATTERN,STRING). */
813	rc = sqlite3_create_function(db, "regexpi", 2, SQLITE_UTF8\|SQLITE_INNOCUOUS,

814	(void*)db, re_sql_func, 0, 0);
815	}
816	return rc;
817	}
818
	@@ -891,18 +925,18 @@
891	if( bRobot ){
892	const char *zRe;
893	db_find_and_open_repository(0,0);
894	verify_all_options();
895	zRe = db_get("robot-exception","^$");
896	zErr = re_compile(&pRe, zRe, ignoreCase);
897	iFileList = 2;
898	}else{
899	verify_all_options();
900	if( g.argc<3 ){
901	usage("REGEXP [FILE...]");
902	}
903	zErr = re_compile(&pRe, g.argv[2], ignoreCase);
904	}
905	if( zErr ) fossil_fatal("%s", zErr);
906	if( g.argc==iFileList ){
907	grep_file(pRe, "-", stdin);
908	}else{
	@@ -980,11 +1014,11 @@
980	db_find_and_open_repository(0, 0);
981	verify_all_options();
982	if( g.argc<4 ){
983	usage("REGEXP FILENAME ...");
984	}
985	zErr = re_compile(&pRe, g.argv[2], ignoreCase);
986	if( zErr ) fossil_fatal("%s", zErr);
987
988	add_content_sql_commands(g.db);
989	db_multi_exec("CREATE TEMP TABLE arglist(iname,fname,fnid);");
990	for(ii=3; ii<g.argc; ii++){
991

	--- src/regexp.c
	+++ src/regexp.c
	@@ -24,11 +24,11 @@
24	** The following regular expression syntax is supported:
25	**
26	** X* zero or more occurrences of X
27	** X+ one or more occurrences of X
28	** X? zero or one occurrences of X
29	** X{p,q} between p and q occurrences of X
30	** (X) match X
31	** X\|Y X or Y
32	** ^X X occurring at the beginning of the string
33	** X$ X occurring at the end of the string
34	** . Match any single character
	@@ -53,13 +53,10 @@
53	** expression and M is the size of the input string. The matcher never
54	** exhibits exponential behavior. Note that the X{p,q} operator expands
55	** to p copies of X following by q-p copies of X? and that the size of the
56	** regular expression in the O(N*M) performance bound is computed after
57	** this expansion.



58	*/
59	#include "config.h"
60	#include "regexp.h"
61
62	#ifndef SQLITE_MAX_REGEXP_REPEAT
	@@ -125,10 +122,11 @@
122	unsigned (xNextChar)(ReInput); /* Next character function */
123	unsigned char zInit[12]; /* Initial text to match */
124	int nInit; /* Number of characters in zInit */
125	unsigned nState; /* Number of entries in aOp[] and aArg[] */
126	unsigned nAlloc; /* Slots allocated for aOp[] and aArg[] */
127	unsigned mxAlloc; /* Complexity limit */
128	};
129	#endif
130
131	/* Add a state to the given state set if it is not already there */
132	static void re_add_state(ReStateSet *pSet, int newState){
	@@ -341,15 +339,16 @@
339	/* Resize the opcode and argument arrays for an RE under construction.
340	*/
341	static int re_resize(ReCompiled *p, int N){
342	char *aOp;
343	int *aArg;
344	if( N>p->mxAlloc ){ p->zErr = "REGEXP pattern too big"; return 1; }
345	aOp = fossil_realloc(p->aOp, N*sizeof(p->aOp[0]));
346	if( aOp==0 ){ p->zErr = "out of memory"; return 1; }
347	p->aOp = aOp;
348	aArg = fossil_realloc(p->aArg, N*sizeof(p->aArg[0]));
349	if( aArg==0 ){ p->zErr = "out of memory"; return 1; }
350	p->aArg = aArg;
351	p->nAlloc = N;
352	return 0;
353	}
354
	@@ -534,20 +533,20 @@
533	unsigned int m = 0, n = 0;
534	unsigned int sz, j;
535	if( iPrev<0 ) return "'{m,n}' without operand";
536	while( (c=rePeek(p))>='0' && c<='9' ){
537	m = m*10 + c - '0';
538	if( m*2>p->mxAlloc ) return "REGEXP pattern too big";
539	p->sIn.i++;
540	}
541	n = m;
542	if( c==',' ){
543	p->sIn.i++;
544	n = 0;
545	while( (c=rePeek(p))>='0' && c<='9' ){
546	n = n*10 + c-'0';
547	if( n*2>p->mxAlloc ) return "REGEXP pattern too big";
548	p->sIn.i++;
549	}
550	}
551	if( c!='}' ) return "unmatched '{'";
552	if( n>0 && n<m ) return "n less than m in '{m,n}'";
	@@ -564,11 +563,11 @@
563	for(j=m; j<n; j++){
564	re_append(p, RE_OP_FORK, sz+1);
565	re_copy(p, iPrev, sz);
566	}
567	if( n==0 && m>0 ){
568	re_append(p, RE_OP_FORK, -(int)sz);
569	}
570	break;
571	}
572	case '[': {
573	unsigned int iFirst = p->nState;
	@@ -644,11 +643,16 @@
643	** Compile a textual regular expression in zIn[] into a compiled regular
644	** expression suitable for us by re_match() and return a pointer to the
645	** compiled regular expression in *ppRe. Return NULL on success or an
646	** error message if something goes wrong.
647	*/
648	const char *re_compile(
649	ReCompiled *ppRe, / OUT: write compiled NFA here */
650	const char zIn, / Input regular expression */
651	int mxRe, /* Complexity limit */
652	int noCase /* True for caseless comparisons */
653	){
654	ReCompiled *pRe;
655	const char *zErr;
656	int i, j;
657
658	*ppRe = 0;
	@@ -656,13 +660,15 @@
660	if( pRe==0 ){
661	return "out of memory";
662	}
663	memset(pRe, 0, sizeof(*pRe));
664	pRe->xNextChar = noCase ? re_next_char_nocase : re_next_char;
665	pRe->mxAlloc = mxRe;
666	if( re_resize(pRe, 30) ){
667	zErr = pRe->zErr;
668	re_free(pRe);
669	return zErr;
670	}
671	if( zIn[0]=='^' ){
672	zIn++;
673	}else{
674	re_append(pRe, RE_OP_ANYSTAR, 0);
	@@ -749,10 +755,36 @@
755	zIn++;
756	}
757	blob_materialize(&out);
758	return out.aData;
759	}
760
761	/*
762	** SETTING: regexp-limit width=8 default=1000
763	**
764	** Limit the size of the bytecode used to implement a regular expression
765	** to this many steps. It is important to limit this to avoid possible
766	** DoS attacks.
767	*/
768
769	/*
770	** Compute a reasonable limit on the length of the REGEXP NFA.
771	*/
772	int re_maxlen(void){
773	return g.db ? db_get_int("regexp-limit", 1000) : 1000;
774	}
775
776	/*
777	** Compile an RE using re_maxlen().
778	*/
779	const char *fossil_re_compile(
780	ReCompiled *ppRe, / OUT: write compiled NFA here */
781	const char zIn, / Input regular expression */
782	int noCase /* True for caseless comparisons */
783	){
784	return re_compile(ppRe, zIn, re_maxlen(), noCase);
785	}
786
787	/*
788	** Implementation of the regexp() SQL function. This function implements
789	** the build-in REGEXP operator. The first argument to the function is the
790	** pattern and the second argument is the string. So, the SQL statements:
	@@ -775,11 +807,11 @@
807	(void)argc; /* Unused */
808	pRe = sqlite3_get_auxdata(context, 0);
809	if( pRe==0 ){
810	zPattern = (const char*)sqlite3_value_text(argv[0]);
811	if( zPattern==0 ) return;
812	zErr = fossil_re_compile(&pRe, zPattern, sqlite3_user_data(context)!=0);
813	if( zErr ){
814	re_free(pRe);
815	sqlite3_result_int(context, 0);
816	/* sqlite3_result_error(context, zErr, -1); */
817	return;
	@@ -803,16 +835,18 @@
835	** Invoke this routine to register the regexp() function with the
836	** SQLite database connection.
837	*/
838	int re_add_sql_func(sqlite3 *db){
839	int rc;
840	rc = sqlite3_create_function(db, "regexp", 2,
841	SQLITE_UTF8\|SQLITE_INNOCUOUS\|SQLITE_DETERMINISTIC,
842	0, re_sql_func, 0, 0);
843	if( rc==SQLITE_OK ){
844	/* The regexpi(PATTERN,STRING) function is a case-insensitive version
845	** of regexp(PATTERN,STRING). */
846	rc = sqlite3_create_function(db, "regexpi", 2,
847	SQLITE_UTF8\|SQLITE_INNOCUOUS\|SQLITE_DETERMINISTIC,
848	(void*)db, re_sql_func, 0, 0);
849	}
850	return rc;
851	}
852
	@@ -891,18 +925,18 @@
925	if( bRobot ){
926	const char *zRe;
927	db_find_and_open_repository(0,0);
928	verify_all_options();
929	zRe = db_get("robot-exception","^$");
930	zErr = fossil_re_compile(&pRe, zRe, ignoreCase);
931	iFileList = 2;
932	}else{
933	verify_all_options();
934	if( g.argc<3 ){
935	usage("REGEXP [FILE...]");
936	}
937	zErr = fossil_re_compile(&pRe, g.argv[2], ignoreCase);
938	}
939	if( zErr ) fossil_fatal("%s", zErr);
940	if( g.argc==iFileList ){
941	grep_file(pRe, "-", stdin);
942	}else{
	@@ -980,11 +1014,11 @@
1014	db_find_and_open_repository(0, 0);
1015	verify_all_options();
1016	if( g.argc<4 ){
1017	usage("REGEXP FILENAME ...");
1018	}
1019	zErr = fossil_re_compile(&pRe, g.argv[2], ignoreCase);
1020	if( zErr ) fossil_fatal("%s", zErr);
1021
1022	add_content_sql_commands(g.db);
1023	db_multi_exec("CREATE TEMP TABLE arglist(iname,fname,fnid);");
1024	for(ii=3; ii<g.argc; ii++){
1025

M src/robot.c

+1 -1

		--- src/robot.c
		+++ src/robot.c
		@@ -367,11 +367,11 @@
367	367	}else{
368	368	n = strlen(zRE);
369	369	}
370	370	z = mprintf("%.*s", (int)(zNL - zRE)+1, zRE);
371	371	zRE += n;
372		- zErr = re_compile(&pRe, z, 0);
	372	+ zErr = fossil_re_compile(&pRe, z, 0);
373	373	if( zErr ){
374	374	fossil_warning("robot-exception error \"%s\" in expression \"%s\"\n",
375	375	zErr, z);
376	376	fossil_free(z);
377	377	continue;
378	378

	--- src/robot.c
	+++ src/robot.c
	@@ -367,11 +367,11 @@
367	}else{
368	n = strlen(zRE);
369	}
370	z = mprintf("%.*s", (int)(zNL - zRE)+1, zRE);
371	zRE += n;
372	zErr = re_compile(&pRe, z, 0);
373	if( zErr ){
374	fossil_warning("robot-exception error \"%s\" in expression \"%s\"\n",
375	zErr, z);
376	fossil_free(z);
377	continue;
378

	--- src/robot.c
	+++ src/robot.c
	@@ -367,11 +367,11 @@
367	}else{
368	n = strlen(zRE);
369	}
370	z = mprintf("%.*s", (int)(zNL - zRE)+1, zRE);
371	zRE += n;
372	zErr = fossil_re_compile(&pRe, z, 0);
373	if( zErr ){
374	fossil_warning("robot-exception error \"%s\" in expression \"%s\"\n",
375	zErr, z);
376	fossil_free(z);
377	continue;
378

M src/th_main.c

+2 -2

		--- src/th_main.c
		+++ src/th_main.c
		@@ -2145,11 +2145,11 @@
2145	2145	}
2146	2146	if( fossil_strcmp(argv[nArg], "--")==0 ) nArg++;
2147	2147	if( nArg+2!=argc ){
2148	2148	return Th_WrongNumArgs(interp, REGEXP_WRONGNUMARGS);
2149	2149	}
2150		- zErr = re_compile(&pRe, argv[nArg], noCase);
	2150	+ zErr = fossil_re_compile(&pRe, argv[nArg], noCase);
2151	2151	if( !zErr ){
2152	2152	Th_SetResultInt(interp, re_match(pRe,
2153	2153	(const unsigned char *)argv[nArg+1], TH1_LEN(argl[nArg+1])));
2154	2154	rc = TH_OK;
2155	2155	}else{
		@@ -2202,11 +2202,11 @@
2202	2202	Th_ErrorMessage(interp, "url must be http:// or https://", 0, 0);
2203	2203	return TH_ERROR;
2204	2204	}
2205	2205	zRegexp = db_get("th1-uri-regexp", 0);
2206	2206	if( zRegexp && zRegexp[0] ){
2207		- const char *zErr = re_compile(&pRe, zRegexp, 0);
	2207	+ const char *zErr = fossil_re_compile(&pRe, zRegexp, 0);
2208	2208	if( zErr ){
2209	2209	Th_SetResult(interp, zErr, -1);
2210	2210	return TH_ERROR;
2211	2211	}
2212	2212	}
2213	2213

	--- src/th_main.c
	+++ src/th_main.c
	@@ -2145,11 +2145,11 @@
2145	}
2146	if( fossil_strcmp(argv[nArg], "--")==0 ) nArg++;
2147	if( nArg+2!=argc ){
2148	return Th_WrongNumArgs(interp, REGEXP_WRONGNUMARGS);
2149	}
2150	zErr = re_compile(&pRe, argv[nArg], noCase);
2151	if( !zErr ){
2152	Th_SetResultInt(interp, re_match(pRe,
2153	(const unsigned char *)argv[nArg+1], TH1_LEN(argl[nArg+1])));
2154	rc = TH_OK;
2155	}else{
	@@ -2202,11 +2202,11 @@
2202	Th_ErrorMessage(interp, "url must be http:// or https://", 0, 0);
2203	return TH_ERROR;
2204	}
2205	zRegexp = db_get("th1-uri-regexp", 0);
2206	if( zRegexp && zRegexp[0] ){
2207	const char *zErr = re_compile(&pRe, zRegexp, 0);
2208	if( zErr ){
2209	Th_SetResult(interp, zErr, -1);
2210	return TH_ERROR;
2211	}
2212	}
2213

	--- src/th_main.c
	+++ src/th_main.c
	@@ -2145,11 +2145,11 @@
2145	}
2146	if( fossil_strcmp(argv[nArg], "--")==0 ) nArg++;
2147	if( nArg+2!=argc ){
2148	return Th_WrongNumArgs(interp, REGEXP_WRONGNUMARGS);
2149	}
2150	zErr = fossil_re_compile(&pRe, argv[nArg], noCase);
2151	if( !zErr ){
2152	Th_SetResultInt(interp, re_match(pRe,
2153	(const unsigned char *)argv[nArg+1], TH1_LEN(argl[nArg+1])));
2154	rc = TH_OK;
2155	}else{
	@@ -2202,11 +2202,11 @@
2202	Th_ErrorMessage(interp, "url must be http:// or https://", 0, 0);
2203	return TH_ERROR;
2204	}
2205	zRegexp = db_get("th1-uri-regexp", 0);
2206	if( zRegexp && zRegexp[0] ){
2207	const char *zErr = fossil_re_compile(&pRe, zRegexp, 0);
2208	if( zErr ){
2209	Th_SetResult(interp, zErr, -1);
2210	return TH_ERROR;
2211	}
2212	}
2213

Fossil SCM

Keyboard Shortcuts