commit c6d5f24b72461786c3cd41669b554bcd281e4636 Author: zyppe <210hcl@gmail.com> Date: Wed Feb 28 22:01:09 2024 +0800 Initialize for pcre2 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ddba13e --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +pcre2-10.39.tar.bz2 diff --git a/.pcre2.metadata b/.pcre2.metadata new file mode 100644 index 0000000..7e5d6c1 --- /dev/null +++ b/.pcre2.metadata @@ -0,0 +1 @@ +ee4fb4e65033e8d7b1a23549cc8504b93a4f32d1750ba1cb3c7d5e104451699e pcre2-10.39.tar.bz2 diff --git a/baselibs.conf b/baselibs.conf new file mode 100644 index 0000000..207e231 --- /dev/null +++ b/baselibs.conf @@ -0,0 +1,4 @@ +libpcre2-8-0 +libpcre2-16-0 +libpcre2-32-0 +libpcre2-posix2 diff --git a/pcre2-10.10-multilib.patch b/pcre2-10.10-multilib.patch new file mode 100644 index 0000000..f157346 --- /dev/null +++ b/pcre2-10.10-multilib.patch @@ -0,0 +1,34 @@ +From 1d5ce3e2e6341b01609aefab20786a8638fee17a Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Petr=20P=C3=ADsa=C5=99?= +Date: Tue, 6 Dec 2011 18:44:11 +0100 +Subject: [PATCH] Fix multilib + +Do not set RPATH nor add explicit -L path to compiler. +--- + pcre2-config.in | 12 ------------ + 1 file changed, 12 deletions(-) + +Index: pcre2-10.10/pcre2-config.in +=================================================================== +--- pcre2-10.10.orig/pcre2-config.in 2014-10-17 17:07:57.000000000 +0200 ++++ pcre2-10.10/pcre2-config.in 2015-06-18 20:56:20.000000000 +0200 +@@ -28,19 +28,7 @@ if test $# -eq 0; then + fi + + libR= +-case `uname -s` in +- *SunOS*) +- libR=" -R@libdir@" +- ;; +- *BSD*) +- libR=" -Wl,-R@libdir@" +- ;; +-esac +- + libS= +-if test @libdir@ != /usr/lib ; then +- libS=-L@libdir@ +-fi + + while test $# -gt 0; do + case "$1" in diff --git a/pcre2-10.39-bsc1199232-unicode-property-matching.patch b/pcre2-10.39-bsc1199232-unicode-property-matching.patch new file mode 100644 index 0000000..005141b --- /dev/null +++ b/pcre2-10.39-bsc1199232-unicode-property-matching.patch @@ -0,0 +1,39 @@ +diff --git a/ChangeLog b/ChangeLog +index d27542d..cb7a0f2 100644 +--- a/ChangeLog ++++ b/ChangeLog +@@ -1081,6 +1081,9 @@ recursions. Iterators at the ends of capturing groups are no longer considered + for auto-possessification if the pattern contains any recursions. Fixes + Bugzilla #2232. + ++23. Fixed a unicode properrty matching issue in JIT. The character was not ++fully read in caseless matching. ++ + + Version 10.30 14-August-2017 + ---------------------------- +diff --git a/src/pcre2_jit_compile.c b/src/pcre2_jit_compile.c +index db2ce65..5fbee09 100644 +--- a/src/pcre2_jit_compile.c ++++ b/src/pcre2_jit_compile.c +@@ -7473,7 +7473,7 @@ while (*cc != XCL_END) + { + SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP); + cc++; +- if (*cc == PT_CLIST) ++ if (*cc == PT_CLIST && cc[-1] == XCL_PROP) + { + other_cases = PRIV(ucd_caseless_sets) + cc[1]; + while (*other_cases != NOTACHAR) +diff --git a/src/pcre2_jit_test.c b/src/pcre2_jit_test.c +index 8dee16e..bf94c6d 100644 +--- a/src/pcre2_jit_test.c ++++ b/src/pcre2_jit_test.c +@@ -412,6 +412,7 @@ static struct regression_test_case regression_test_cases[] = { + { MUP, A, 0, 0 | F_PROPERTY, "[\\P{L&}]{2}[^\xc2\x85-\xc2\x89\\p{Ll}\\p{Lu}]{2}", "\xc3\xa9\xe6\x92\xad.a\xe6\x92\xad|\xc2\x8a#" }, + { PCRE2_UCP, 0, 0, 0 | F_PROPERTY, "[a-b\\s]{2,5}[^a]", "AB baaa" }, + { MUP, 0, 0, 0 | F_NOMATCH, "[^\\p{Hangul}\\p{Z}]", " " }, ++ { CMUP, 0, 0, 0, "[^S]\\B", "\xe2\x80\x8a" }, + + /* Possible empty brackets. */ + { MU, A, 0, 0, "(?:|ab||bc|a)+d", "abcxabcabd" }, diff --git a/pcre2-10.39.tar.bz2.sig b/pcre2-10.39.tar.bz2.sig new file mode 100644 index 0000000..c42c513 Binary files /dev/null and b/pcre2-10.39.tar.bz2.sig differ diff --git a/pcre2-CVE-2022-41409.patch b/pcre2-CVE-2022-41409.patch new file mode 100644 index 0000000..95e455c --- /dev/null +++ b/pcre2-CVE-2022-41409.patch @@ -0,0 +1,73 @@ +From 94e1c001761373b7d9450768aa15d04c25547a35 Mon Sep 17 00:00:00 2001 +From: Philip Hazel +Date: Tue, 16 Aug 2022 17:00:45 +0100 +Subject: [PATCH] Diagnose negative repeat value in pcre2test subject line + +--- + ChangeLog | 3 +++ + src/pcre2test.c | 4 ++-- + testdata/testinput2 | 3 +++ + testdata/testoutput2 | 4 ++++ + 4 files changed, 12 insertions(+), 2 deletions(-) + +Index: pcre2-10.39/ChangeLog +=================================================================== +--- pcre2-10.39.orig/ChangeLog ++++ pcre2-10.39/ChangeLog +@@ -1,6 +1,13 @@ + Change Log for PCRE2 + -------------------- + ++Version 10.41 06-December-2022 ++------------------------------ ++ ++20. A negative repeat value in a pcre2test subject line was not being ++diagnosed, leading to infinite looping. ++ ++ + Version 10.39 29-October-2021 + ----------------------------- + +Index: pcre2-10.39/src/pcre2test.c +=================================================================== +--- pcre2-10.39.orig/src/pcre2test.c ++++ pcre2-10.39/src/pcre2test.c +@@ -6766,9 +6766,9 @@ while ((c = *p++) != 0) + } + + i = (int32_t)li; +- if (i-- == 0) ++ if (i-- <= 0) + { +- fprintf(outfile, "** Zero repeat not allowed\n"); ++ fprintf(outfile, "** Zero or negative repeat not allowed\n"); + return PR_OK; + } + +Index: pcre2-10.39/testdata/testinput2 +=================================================================== +--- pcre2-10.39.orig/testdata/testinput2 ++++ pcre2-10.39/testdata/testinput2 +@@ -5902,4 +5902,7 @@ a)"xI + + # --------- + ++-- ++ \[X]{-10} ++ + # End of testinput2 +Index: pcre2-10.39/testdata/testoutput2 +=================================================================== +--- pcre2-10.39.orig/testdata/testoutput2 ++++ pcre2-10.39/testdata/testoutput2 +@@ -17674,6 +17674,10 @@ Failed: error 199 at offset 14: \K is no + + # --------- + ++-- ++ \[X]{-10} ++** Zero or negative repeat not allowed ++ + # End of testinput2 + Error -70: PCRE2_ERROR_BADDATA (unknown error number) + Error -62: bad serialized data diff --git a/pcre2-bsc1199235-CVE-2022-1587.patch b/pcre2-bsc1199235-CVE-2022-1587.patch new file mode 100644 index 0000000..faab986 --- /dev/null +++ b/pcre2-bsc1199235-CVE-2022-1587.patch @@ -0,0 +1,642 @@ +diff --git a/ChangeLog b/ChangeLog +index cb7a0f2..2567c62 100644 +--- a/ChangeLog ++++ b/ChangeLog +@@ -123,6 +123,9 @@ whenever a lookahead was processed, leading to some fuzzer-generated patterns + taking a very long time to compile when (?|) was present in the pattern, + because (?|) disables caching of group lengths. + ++24. Fixed an issue affecting recursions in JIT caused by duplicated data ++transfers. ++ + + Version 10.37 26-May-2021 + ------------------------- +diff --git a/src/pcre2_jit_compile.c b/src/pcre2_jit_compile.c +index 5fbee09..6c42318 100644 +--- a/src/pcre2_jit_compile.c ++++ b/src/pcre2_jit_compile.c +@@ -413,6 +413,9 @@ typedef struct compiler_common { + /* Locals used by fast fail optimization. */ + sljit_s32 early_fail_start_ptr; + sljit_s32 early_fail_end_ptr; ++ /* Variables used by recursive call generator. */ ++ sljit_s32 recurse_bitset_size; ++ uint8_t *recurse_bitset; + + /* Flipped and lower case tables. */ + const sljit_u8 *fcc; +@@ -2315,19 +2318,39 @@ for (i = 0; i < RECURSE_TMP_REG_COUNT; i++) + + #undef RECURSE_TMP_REG_COUNT + ++static BOOL recurse_check_bit(compiler_common *common, sljit_sw bit_index) ++{ ++uint8_t *byte; ++uint8_t mask; ++ ++SLJIT_ASSERT((bit_index & (sizeof(sljit_sw) - 1)) == 0); ++ ++bit_index >>= SLJIT_WORD_SHIFT; ++ ++mask = 1 << (bit_index & 0x7); ++byte = common->recurse_bitset + (bit_index >> 3); ++ ++if (*byte & mask) ++ return FALSE; ++ ++*byte |= mask; ++return TRUE; ++} ++ + static int get_recurse_data_length(compiler_common *common, PCRE2_SPTR cc, PCRE2_SPTR ccend, + BOOL *needs_control_head, BOOL *has_quit, BOOL *has_accept) + { + int length = 1; +-int size; ++int size, offset; + PCRE2_SPTR alternative; + BOOL quit_found = FALSE; + BOOL accept_found = FALSE; + BOOL setsom_found = FALSE; + BOOL setmark_found = FALSE; +-BOOL capture_last_found = FALSE; + BOOL control_head_found = FALSE; + ++memset(common->recurse_bitset, 0, common->recurse_bitset_size); ++ + #if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD + SLJIT_ASSERT(common->control_head_ptr != 0); + control_head_found = TRUE; +@@ -2350,15 +2373,17 @@ while (cc < ccend) + setsom_found = TRUE; + if (common->mark_ptr != 0) + setmark_found = TRUE; +- if (common->capture_last_ptr != 0) +- capture_last_found = TRUE; ++ if (common->capture_last_ptr != 0 && recurse_check_bit(common, common->capture_last_ptr)) ++ length++; + cc += 1 + LINK_SIZE; + break; + + case OP_KET: +- if (PRIVATE_DATA(cc) != 0) ++ offset = PRIVATE_DATA(cc); ++ if (offset != 0) + { +- length++; ++ if (recurse_check_bit(common, offset)) ++ length++; + SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0); + cc += PRIVATE_DATA(cc + 1); + } +@@ -2377,39 +2402,55 @@ while (cc < ccend) + case OP_SBRA: + case OP_SBRAPOS: + case OP_SCOND: +- length++; + SLJIT_ASSERT(PRIVATE_DATA(cc) != 0); ++ if (recurse_check_bit(common, PRIVATE_DATA(cc))) ++ length++; + cc += 1 + LINK_SIZE; + break; + + case OP_CBRA: + case OP_SCBRA: +- length += 2; +- if (common->capture_last_ptr != 0) +- capture_last_found = TRUE; +- if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0) ++ offset = GET2(cc, 1 + LINK_SIZE); ++ if (recurse_check_bit(common, OVECTOR(offset << 1))) ++ { ++ SLJIT_ASSERT(recurse_check_bit(common, OVECTOR((offset << 1) + 1))); ++ length += 2; ++ } ++ if (common->optimized_cbracket[offset] == 0 && recurse_check_bit(common, OVECTOR_PRIV(offset))) ++ length++; ++ if (common->capture_last_ptr != 0 && recurse_check_bit(common, common->capture_last_ptr)) + length++; + cc += 1 + LINK_SIZE + IMM2_SIZE; + break; + + case OP_CBRAPOS: + case OP_SCBRAPOS: +- length += 2 + 2; +- if (common->capture_last_ptr != 0) +- capture_last_found = TRUE; ++ offset = GET2(cc, 1 + LINK_SIZE); ++ if (recurse_check_bit(common, OVECTOR(offset << 1))) ++ { ++ SLJIT_ASSERT(recurse_check_bit(common, OVECTOR((offset << 1) + 1))); ++ length += 2; ++ } ++ if (recurse_check_bit(common, OVECTOR_PRIV(offset))) ++ length++; ++ if (recurse_check_bit(common, PRIVATE_DATA(cc))) ++ length++; ++ if (common->capture_last_ptr != 0 && recurse_check_bit(common, common->capture_last_ptr)) ++ length++; + cc += 1 + LINK_SIZE + IMM2_SIZE; + break; + + case OP_COND: + /* Might be a hidden SCOND. */ + alternative = cc + GET(cc, 1); +- if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN) ++ if ((*alternative == OP_KETRMAX || *alternative == OP_KETRMIN) && recurse_check_bit(common, PRIVATE_DATA(cc))) + length++; + cc += 1 + LINK_SIZE; + break; + + CASE_ITERATOR_PRIVATE_DATA_1 +- if (PRIVATE_DATA(cc) != 0) ++ offset = PRIVATE_DATA(cc); ++ if (offset != 0 && recurse_check_bit(common, offset)) + length++; + cc += 2; + #ifdef SUPPORT_UNICODE +@@ -2418,8 +2459,12 @@ while (cc < ccend) + break; + + CASE_ITERATOR_PRIVATE_DATA_2A +- if (PRIVATE_DATA(cc) != 0) ++ offset = PRIVATE_DATA(cc); ++ if (offset != 0 && recurse_check_bit(common, offset)) ++ { ++ SLJIT_ASSERT(recurse_check_bit(common, offset + sizeof(sljit_sw))); + length += 2; ++ } + cc += 2; + #ifdef SUPPORT_UNICODE + if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); +@@ -2427,8 +2472,12 @@ while (cc < ccend) + break; + + CASE_ITERATOR_PRIVATE_DATA_2B +- if (PRIVATE_DATA(cc) != 0) ++ offset = PRIVATE_DATA(cc); ++ if (offset != 0 && recurse_check_bit(common, offset)) ++ { ++ SLJIT_ASSERT(recurse_check_bit(common, offset + sizeof(sljit_sw))); + length += 2; ++ } + cc += 2 + IMM2_SIZE; + #ifdef SUPPORT_UNICODE + if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); +@@ -2436,20 +2485,29 @@ while (cc < ccend) + break; + + CASE_ITERATOR_TYPE_PRIVATE_DATA_1 +- if (PRIVATE_DATA(cc) != 0) ++ offset = PRIVATE_DATA(cc); ++ if (offset != 0 && recurse_check_bit(common, offset)) + length++; + cc += 1; + break; + + CASE_ITERATOR_TYPE_PRIVATE_DATA_2A +- if (PRIVATE_DATA(cc) != 0) ++ offset = PRIVATE_DATA(cc); ++ if (offset != 0 && recurse_check_bit(common, offset)) ++ { ++ SLJIT_ASSERT(recurse_check_bit(common, offset + sizeof(sljit_sw))); + length += 2; ++ } + cc += 1; + break; + + CASE_ITERATOR_TYPE_PRIVATE_DATA_2B +- if (PRIVATE_DATA(cc) != 0) ++ offset = PRIVATE_DATA(cc); ++ if (offset != 0 && recurse_check_bit(common, offset)) ++ { ++ SLJIT_ASSERT(recurse_check_bit(common, offset + sizeof(sljit_sw))); + length += 2; ++ } + cc += 1 + IMM2_SIZE; + break; + +@@ -2461,7 +2519,9 @@ while (cc < ccend) + #else + size = 1 + 32 / (int)sizeof(PCRE2_UCHAR); + #endif +- if (PRIVATE_DATA(cc) != 0) ++ ++ offset = PRIVATE_DATA(cc); ++ if (offset != 0 && recurse_check_bit(common, offset)) + length += get_class_iterator_size(cc + size); + cc += size; + break; +@@ -2496,8 +2556,7 @@ while (cc < ccend) + case OP_THEN: + SLJIT_ASSERT(common->control_head_ptr != 0); + quit_found = TRUE; +- if (!control_head_found) +- control_head_found = TRUE; ++ control_head_found = TRUE; + cc++; + break; + +@@ -2517,8 +2576,6 @@ SLJIT_ASSERT(cc == ccend); + + if (control_head_found) + length++; +-if (capture_last_found) +- length++; + if (quit_found) + { + if (setsom_found) +@@ -2551,14 +2608,12 @@ sljit_sw shared_srcw[3]; + sljit_sw kept_shared_srcw[2]; + int private_count, shared_count, kept_shared_count; + int from_sp, base_reg, offset, i; +-BOOL setsom_found = FALSE; +-BOOL setmark_found = FALSE; +-BOOL capture_last_found = FALSE; +-BOOL control_head_found = FALSE; ++ ++memset(common->recurse_bitset, 0, common->recurse_bitset_size); + + #if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD + SLJIT_ASSERT(common->control_head_ptr != 0); +-control_head_found = TRUE; ++recurse_check_bit(common, common->control_head_ptr); + #endif + + switch (type) +@@ -2646,11 +2701,10 @@ while (cc < ccend) + { + case OP_SET_SOM: + SLJIT_ASSERT(common->has_set_som); +- if (has_quit && !setsom_found) ++ if (has_quit && recurse_check_bit(common, OVECTOR(0))) + { + kept_shared_srcw[0] = OVECTOR(0); + kept_shared_count = 1; +- setsom_found = TRUE; + } + cc += 1; + break; +@@ -2658,33 +2712,31 @@ while (cc < ccend) + case OP_RECURSE: + if (has_quit) + { +- if (common->has_set_som && !setsom_found) ++ if (common->has_set_som && recurse_check_bit(common, OVECTOR(0))) + { + kept_shared_srcw[0] = OVECTOR(0); + kept_shared_count = 1; +- setsom_found = TRUE; + } +- if (common->mark_ptr != 0 && !setmark_found) ++ if (common->mark_ptr != 0 && recurse_check_bit(common, common->mark_ptr)) + { + kept_shared_srcw[kept_shared_count] = common->mark_ptr; + kept_shared_count++; +- setmark_found = TRUE; + } + } +- if (common->capture_last_ptr != 0 && !capture_last_found) ++ if (common->capture_last_ptr != 0 && recurse_check_bit(common, common->capture_last_ptr)) + { + shared_srcw[0] = common->capture_last_ptr; + shared_count = 1; +- capture_last_found = TRUE; + } + cc += 1 + LINK_SIZE; + break; + + case OP_KET: +- if (PRIVATE_DATA(cc) != 0) ++ private_srcw[0] = PRIVATE_DATA(cc); ++ if (private_srcw[0] != 0) + { +- private_count = 1; +- private_srcw[0] = PRIVATE_DATA(cc); ++ if (recurse_check_bit(common, private_srcw[0])) ++ private_count = 1; + SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0); + cc += PRIVATE_DATA(cc + 1); + } +@@ -2703,50 +2755,66 @@ while (cc < ccend) + case OP_SBRA: + case OP_SBRAPOS: + case OP_SCOND: +- private_count = 1; + private_srcw[0] = PRIVATE_DATA(cc); ++ if (recurse_check_bit(common, private_srcw[0])) ++ private_count = 1; + cc += 1 + LINK_SIZE; + break; + + case OP_CBRA: + case OP_SCBRA: +- offset = (GET2(cc, 1 + LINK_SIZE)) << 1; +- shared_srcw[0] = OVECTOR(offset); +- shared_srcw[1] = OVECTOR(offset + 1); +- shared_count = 2; ++ offset = GET2(cc, 1 + LINK_SIZE); ++ shared_srcw[0] = OVECTOR(offset << 1); ++ if (recurse_check_bit(common, shared_srcw[0])) ++ { ++ shared_srcw[1] = shared_srcw[0] + sizeof(sljit_sw); ++ SLJIT_ASSERT(recurse_check_bit(common, shared_srcw[1])); ++ shared_count = 2; ++ } + +- if (common->capture_last_ptr != 0 && !capture_last_found) ++ if (common->capture_last_ptr != 0 && recurse_check_bit(common, common->capture_last_ptr)) + { +- shared_srcw[2] = common->capture_last_ptr; +- shared_count = 3; +- capture_last_found = TRUE; ++ shared_srcw[shared_count] = common->capture_last_ptr; ++ shared_count++; + } + +- if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0) ++ if (common->optimized_cbracket[offset] == 0) + { +- private_count = 1; +- private_srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE)); ++ private_srcw[0] = OVECTOR_PRIV(offset); ++ if (recurse_check_bit(common, private_srcw[0])) ++ private_count = 1; + } ++ + cc += 1 + LINK_SIZE + IMM2_SIZE; + break; + + case OP_CBRAPOS: + case OP_SCBRAPOS: +- offset = (GET2(cc, 1 + LINK_SIZE)) << 1; +- shared_srcw[0] = OVECTOR(offset); +- shared_srcw[1] = OVECTOR(offset + 1); +- shared_count = 2; ++ offset = GET2(cc, 1 + LINK_SIZE); ++ shared_srcw[0] = OVECTOR(offset << 1); ++ if (recurse_check_bit(common, shared_srcw[0])) ++ { ++ shared_srcw[1] = shared_srcw[0] + sizeof(sljit_sw); ++ SLJIT_ASSERT(recurse_check_bit(common, shared_srcw[1])); ++ shared_count = 2; ++ } + +- if (common->capture_last_ptr != 0 && !capture_last_found) ++ if (common->capture_last_ptr != 0 && recurse_check_bit(common, common->capture_last_ptr)) + { +- shared_srcw[2] = common->capture_last_ptr; +- shared_count = 3; +- capture_last_found = TRUE; ++ shared_srcw[shared_count] = common->capture_last_ptr; ++ shared_count++; + } + +- private_count = 2; + private_srcw[0] = PRIVATE_DATA(cc); +- private_srcw[1] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE)); ++ if (recurse_check_bit(common, private_srcw[0])) ++ private_count = 1; ++ ++ offset = OVECTOR_PRIV(offset); ++ if (recurse_check_bit(common, offset)) ++ { ++ private_srcw[private_count] = offset; ++ private_count++; ++ } + cc += 1 + LINK_SIZE + IMM2_SIZE; + break; + +@@ -2755,18 +2823,17 @@ while (cc < ccend) + alternative = cc + GET(cc, 1); + if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN) + { +- private_count = 1; + private_srcw[0] = PRIVATE_DATA(cc); ++ if (recurse_check_bit(common, private_srcw[0])) ++ private_count = 1; + } + cc += 1 + LINK_SIZE; + break; + + CASE_ITERATOR_PRIVATE_DATA_1 +- if (PRIVATE_DATA(cc)) +- { ++ private_srcw[0] = PRIVATE_DATA(cc); ++ if (private_srcw[0] != 0 && recurse_check_bit(common, private_srcw[0])) + private_count = 1; +- private_srcw[0] = PRIVATE_DATA(cc); +- } + cc += 2; + #ifdef SUPPORT_UNICODE + if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]); +@@ -2774,11 +2841,12 @@ while (cc < ccend) + break; + + CASE_ITERATOR_PRIVATE_DATA_2A +- if (PRIVATE_DATA(cc)) ++ private_srcw[0] = PRIVATE_DATA(cc); ++ if (private_srcw[0] != 0 && recurse_check_bit(common, private_srcw[0])) + { + private_count = 2; +- private_srcw[0] = PRIVATE_DATA(cc); +- private_srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw); ++ private_srcw[1] = private_srcw[0] + sizeof(sljit_sw); ++ SLJIT_ASSERT(recurse_check_bit(common, private_srcw[1])); + } + cc += 2; + #ifdef SUPPORT_UNICODE +@@ -2787,11 +2855,12 @@ while (cc < ccend) + break; + + CASE_ITERATOR_PRIVATE_DATA_2B +- if (PRIVATE_DATA(cc)) ++ private_srcw[0] = PRIVATE_DATA(cc); ++ if (private_srcw[0] != 0 && recurse_check_bit(common, private_srcw[0])) + { + private_count = 2; +- private_srcw[0] = PRIVATE_DATA(cc); +- private_srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw); ++ private_srcw[1] = private_srcw[0] + sizeof(sljit_sw); ++ SLJIT_ASSERT(recurse_check_bit(common, private_srcw[1])); + } + cc += 2 + IMM2_SIZE; + #ifdef SUPPORT_UNICODE +@@ -2800,30 +2869,30 @@ while (cc < ccend) + break; + + CASE_ITERATOR_TYPE_PRIVATE_DATA_1 +- if (PRIVATE_DATA(cc)) +- { ++ private_srcw[0] = PRIVATE_DATA(cc); ++ if (private_srcw[0] != 0 && recurse_check_bit(common, private_srcw[0])) + private_count = 1; +- private_srcw[0] = PRIVATE_DATA(cc); +- } + cc += 1; + break; + + CASE_ITERATOR_TYPE_PRIVATE_DATA_2A +- if (PRIVATE_DATA(cc)) ++ private_srcw[0] = PRIVATE_DATA(cc); ++ if (private_srcw[0] != 0 && recurse_check_bit(common, private_srcw[0])) + { + private_count = 2; +- private_srcw[0] = PRIVATE_DATA(cc); + private_srcw[1] = private_srcw[0] + sizeof(sljit_sw); ++ SLJIT_ASSERT(recurse_check_bit(common, private_srcw[1])); + } + cc += 1; + break; + + CASE_ITERATOR_TYPE_PRIVATE_DATA_2B +- if (PRIVATE_DATA(cc)) ++ private_srcw[0] = PRIVATE_DATA(cc); ++ if (private_srcw[0] != 0 && recurse_check_bit(common, private_srcw[0])) + { + private_count = 2; +- private_srcw[0] = PRIVATE_DATA(cc); + private_srcw[1] = private_srcw[0] + sizeof(sljit_sw); ++ SLJIT_ASSERT(recurse_check_bit(common, private_srcw[1])); + } + cc += 1 + IMM2_SIZE; + break; +@@ -2840,14 +2909,17 @@ while (cc < ccend) + switch(get_class_iterator_size(cc + i)) + { + case 1: +- private_count = 1; + private_srcw[0] = PRIVATE_DATA(cc); + break; + + case 2: +- private_count = 2; + private_srcw[0] = PRIVATE_DATA(cc); +- private_srcw[1] = private_srcw[0] + sizeof(sljit_sw); ++ if (recurse_check_bit(common, private_srcw[0])) ++ { ++ private_count = 2; ++ private_srcw[1] = private_srcw[0] + sizeof(sljit_sw); ++ SLJIT_ASSERT(recurse_check_bit(common, private_srcw[1])); ++ } + break; + + default: +@@ -2862,28 +2934,25 @@ while (cc < ccend) + case OP_PRUNE_ARG: + case OP_THEN_ARG: + SLJIT_ASSERT(common->mark_ptr != 0); +- if (has_quit && !setmark_found) ++ if (has_quit && recurse_check_bit(common, common->mark_ptr)) + { + kept_shared_srcw[0] = common->mark_ptr; + kept_shared_count = 1; +- setmark_found = TRUE; + } +- if (common->control_head_ptr != 0 && !control_head_found) ++ if (common->control_head_ptr != 0 && recurse_check_bit(common, common->control_head_ptr)) + { + private_srcw[0] = common->control_head_ptr; + private_count = 1; +- control_head_found = TRUE; + } + cc += 1 + 2 + cc[1]; + break; + + case OP_THEN: + SLJIT_ASSERT(common->control_head_ptr != 0); +- if (!control_head_found) ++ if (recurse_check_bit(common, common->control_head_ptr)) + { + private_srcw[0] = common->control_head_ptr; + private_count = 1; +- control_head_found = TRUE; + } + cc++; + break; +@@ -2891,7 +2960,7 @@ while (cc < ccend) + default: + cc = next_opcode(common, cc); + SLJIT_ASSERT(cc != NULL); +- break; ++ continue; + } + + if (type != recurse_copy_shared_to_global && type != recurse_copy_kept_shared_to_global) +@@ -13652,7 +13721,7 @@ SLJIT_ASSERT(!(common->req_char_ptr != 0 && common->start_used_ptr != 0)); + common->cbra_ptr = OVECTOR_START + (re->top_bracket + 1) * 2 * sizeof(sljit_sw); + + total_length = ccend - common->start; +-common->private_data_ptrs = (sljit_s32 *)SLJIT_MALLOC(total_length * (sizeof(sljit_s32) + (common->has_then ? 1 : 0)), allocator_data); ++common->private_data_ptrs = (sljit_s32*)SLJIT_MALLOC(total_length * (sizeof(sljit_s32) + (common->has_then ? 1 : 0)), allocator_data); + if (!common->private_data_ptrs) + { + SLJIT_FREE(common->optimized_cbracket, allocator_data); +@@ -13693,6 +13762,7 @@ if (!compiler) + common->compiler = compiler; + + /* Main pcre_jit_exec entry. */ ++SLJIT_ASSERT((private_data_size & (sizeof(sljit_sw) - 1)) == 0); + sljit_emit_enter(compiler, 0, SLJIT_ARG1(SW), 5, 5, 0, 0, private_data_size); + + /* Register init. */ +@@ -13915,20 +13985,40 @@ common->early_fail_end_ptr = 0; + common->currententry = common->entries; + common->local_quit_available = TRUE; + quit_label = common->quit_label; +-while (common->currententry != NULL) ++if (common->currententry != NULL) + { +- /* Might add new entries. */ +- compile_recurse(common); +- if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) ++ /* A free bit for each private data. */ ++ common->recurse_bitset_size = ((private_data_size / (int)sizeof(sljit_sw)) + 7) >> 3; ++ SLJIT_ASSERT(common->recurse_bitset_size > 0); ++ common->recurse_bitset = (sljit_u8*)SLJIT_MALLOC(common->recurse_bitset_size, allocator_data);; ++ ++ if (common->recurse_bitset != NULL) ++ { ++ do ++ { ++ /* Might add new entries. */ ++ compile_recurse(common); ++ if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) ++ break; ++ flush_stubs(common); ++ common->currententry = common->currententry->next; ++ } ++ while (common->currententry != NULL); ++ ++ SLJIT_FREE(common->recurse_bitset, allocator_data); ++ } ++ ++ if (common->currententry != NULL) + { ++ /* The common->recurse_bitset has been freed. */ ++ SLJIT_ASSERT(sljit_get_compiler_error(compiler) || common->recurse_bitset == NULL); ++ + sljit_free_compiler(compiler); + SLJIT_FREE(common->optimized_cbracket, allocator_data); + SLJIT_FREE(common->private_data_ptrs, allocator_data); + PRIV(jit_free_rodata)(common->read_only_data_head, allocator_data); + return PCRE2_ERROR_NOMEMORY; + } +- flush_stubs(common); +- common->currententry = common->currententry->next; + } + common->local_quit_available = FALSE; + common->quit_label = quit_label; +diff --git a/src/pcre2_jit_test.c b/src/pcre2_jit_test.c +index bf94c6d..26de6c7 100644 +--- a/src/pcre2_jit_test.c ++++ b/src/pcre2_jit_test.c +@@ -748,6 +748,7 @@ static struct regression_test_case regression_test_cases[] = { + { MU, A, 0, 0, "((?(R)a|(?1)){1,3}?)M", "aaaM" }, + { MU, A, 0, 0, "((.)(?:.|\\2(?1))){0}#(?1)#", "#aabbccdde# #aabbccddee#" }, + { MU, A, 0, 0, "((.)(?:\\2|\\2{4}b)){0}#(?:(?1))+#", "#aaaab# #aaaaab#" }, ++ { MU, A, 0, 0 | F_NOMATCH, "(?1)$((.|\\2xx){1,2})", "abc" }, + + /* 16 bit specific tests. */ + { CM, A, 0, 0 | F_FORCECONV, "\xc3\xa1", "\xc3\x81\xc3\xa1" }, diff --git a/pcre2-readd-wrappers-POSIX.patch b/pcre2-readd-wrappers-POSIX.patch new file mode 100644 index 0000000..3aec504 --- /dev/null +++ b/pcre2-readd-wrappers-POSIX.patch @@ -0,0 +1,38 @@ +Index: pcre2-10.39/src/pcre2posix.c +=================================================================== +--- pcre2-10.39.orig/src/pcre2posix.c 2021-08-31 18:12:05.000000000 +0200 ++++ pcre2-10.39/src/pcre2posix.c 2022-03-15 17:46:34.705052429 +0100 +@@ -176,19 +176,7 @@ static const char *const pstring[] = { + + + +-#if 0 /* REMOVE THIS CODE */ +- +-The code below was created for 10.33 (see ChangeLog 10.33 #4) when the +-POSIX functions were given pcre2_... names instead of the traditional POSIX +-names. However, it has proved to be more troublesome than useful. There have +-been at least two cases where a program links with two others, one of which +-uses the POSIX library and the other uses the PCRE2 POSIX functions, thus +-causing two instances of the POSIX runctions to exist, leading to trouble. For +-10.37 this code is commented out. In due course it can be removed if there are +-no issues. The only small worry is the comment below about languages that do +-not include pcre2posix.h. If there are any such cases, they will have to use +-the PCRE2 names. +- ++#if 1 + + /************************************************* + * Wrappers with traditional POSIX names * +Index: pcre2-10.39/configure.ac +=================================================================== +--- pcre2-10.39.orig/configure.ac 2021-10-29 17:30:33.000000000 +0200 ++++ pcre2-10.39/configure.ac 2022-03-15 17:46:47.681128564 +0100 +@@ -17,7 +17,7 @@ m4_define(pcre2_date, [2021-10-29]) + m4_define(libpcre2_8_version, [10:4:10]) + m4_define(libpcre2_16_version, [10:4:10]) + m4_define(libpcre2_32_version, [10:4:10]) +-m4_define(libpcre2_posix_version, [3:1:0]) ++m4_define(libpcre2_posix_version, [2:4:0]) + + # NOTE: The CMakeLists.txt file searches for the above variables in the first + # 50 lines of this file. Please update that if the variables above are moved. diff --git a/pcre2.changes b/pcre2.changes new file mode 100644 index 0000000..ff68a4d --- /dev/null +++ b/pcre2.changes @@ -0,0 +1,919 @@ +* Fri Jul 21 2023 pmonreal@suse.com +- Security fix: [bsc#1213514, CVE-2022-41409] + * Integer overflow vulnerability in pcre2test before 10.41 + allows attackers to cause a denial of service or other + unspecified impacts via negative input. + * Add pcre2-CVE-2022-41409.patch +* Wed Jul 20 2022 jsikes@suse.com +- Added pcre2-bsc1199235-CVE-2022-1587.patch + * CVE-2022-1587 / bsc#1199235 + * Fix out-of-bounds read due to bug in recursions + * Sourced from: + - https://github.com/PCRE2Project/pcre2/commit/03654e751e7f0700693526b67dfcadda6b42c9d0 +* Thu Jun 16 2022 jsikes@suse.com +- Added pcre2-10.39-bsc1199232-unicode-property-matching.patch + * bsc#1199232 + * CVE-2022-1586 + * Fixes unicode property matching issue +* Thu May 5 2022 pgajdos@suse.com +- do not enable jit-sealloc [bsc#1182864] [bsc#1199208] +* Thu May 5 2022 pgajdos@suse.com +- enable jit for s390x [bsc#1199196] +* Mon Mar 14 2022 pgajdos@suse.com +- version update to 10.39 + * Fix incorrect detection of alternatives in first character + search in JIT + * Update to Unicode 14.0.0 +- 0001-Fixed-atomic-group-backtracking-bug.patch released for 15:Update + due to bsc#1187937 is already upstreamed + https://bugzilla.suse.com/show_bug.cgi?id=1187937#c7 +* Thu Nov 11 2021 pgajdos@suse.com +- added patches + fix revert https://github.com/PhilipHazel/pcre2/commit/080d7789eba00b570181dfe28809b01aa88c01f8 + + pcre2-readd-wrappers-POSIX.patch +* Sun Oct 24 2021 andreas.stieger@gmx.de +- pcre2 10.38: + * Following Perl's lead, \K is now locked out in lookaround + assertions by default, but an option is provided to re-enable + the previous behaviour +* Thu May 27 2021 andreas.stieger@gmx.de +- pcre2 10.37: + * removal of the actual POSIX names regcomp etc. from the POSIX + wrapper library because these have caused issues for some + applications, replacing pcre2-symbol-clash.patch + * fix a hypothetical NULL dereference + * fix two bugs related to over-large numbers so the behaviour is + now the same as Perl + * Fix propagation of \K back from the full pattern recursion + * Restore single character repetition optimization in JIT +* Wed Apr 14 2021 jengelh@inai.de +- Remove regcomp, regexec etc. from libpcre2-posix. + (Add pcre2-symbol-clash.patch) +* Sat Dec 5 2020 andreas.stieger@gmx.de +- pcre2 10.36: + * add GNU grep's -m (aka --max-count) option to pcre2grep + * unify the handling of substitution strings for both -O and + callouts in pcre2grep, with the addition of $x{...} and + $o{...} to allow for characters whose code points are greater + than 255 in Unicode mode +* Wed May 13 2020 ilya@ilya.pp.ua +- Refresh spec-file via spec-cleaner. + * Add %%make_build and %%license macros. +- Update to 10.35 + * https://www.pcre.org/changelog.txt + * Use PCRE2_MATCH_EMPTY flag to detect empty matches in JIT. + * A JIT bug is fixed which allowed to read the fields + of the compiled pattern before its existence is checked. + * Added PCRE2_SUBSTITUTE_LITERAL. + * Avoid some VS compiler warnings. + * Added PCRE2_SUBSTITUTE_MATCHED. + * Added (?* and (?<* as synonms for (*napla: and (*naplb: + to match another regex engine. + * Fix *THEN verbs in lookahead assertions in JIT. + * Added PCRE2_SUBSTITUTE_REPLACEMENT_ONLY. + * The JIT stack should be freed when the low-level stack + allocation fails. + * Changed setting of CMAKE_MODULE_PATH in CMakeLists.txt from SET + to LIST(APPEND...) to allow a setting from the command line + to be included. + * Updated to Unicode 13.0.0. + * CMake build now checks for secure_getenv() and strerror(). + * Restrict the configuration setting for the SELinux compatible + execmem allocator (change 10.30/44) to Linux and NetBSD. +* Fri Mar 27 2020 mcalabkova@suse.com +- Resubmit the package (bsc#1167890, jsc#SLE-11608) +* Tue Nov 26 2019 schwab@suse.de +- Enable JIT on aarch64 +* Fri Nov 22 2019 andreas.stieger@gmx.de +- pcre2 10.34: + * implement the documented maximum number of capturing + subpatterns of 65535 + * Improve the invalid utf32 support of the JIT compiler + * Add support for matching in invalid UTF strings to the pcre2_match() + * Give more error detail for invalid UTF-8 when detected in pcre2grep + * support for invalid UTF-8 to pcre2grep. + * Adjust the limit for "must have" code unit searching, in particular, + * increase it substantially for non-anchored patterns. + * Allow (*ACCEPT) to be quantified, because an ungreedy quantifier + with a zero minimum is potentially useful. + * Some changes to the way the minimum subject length is handled + * Check for integer overflow when computing lookbehind lengths + * Implement non-atomic positive lookaround assertions + * Upgraded to Unicode 12.1.0 + * Make pcre2test -C show if libreadline or libedit is supported + * Various bug fixes and improvements +* Thu May 2 2019 jsikes@suse.de +- Update to 10.33-RC1 to fix issue with LTO (boo#1133274). + * Callouts from pcre2_substitute() are now available. + * The POSIX functions are now all called pcre2_regcomp() etc., with wrapper + functions that use the standard POSIX names. However, in pcre2posix.h the POSIX + names are defined as macros. This should help avoid linking with the wrong + library in some environments, while still exporting the POSIX names for + pre-existing programs that use them. + * Some new options: + (a) PCRE2_EXTRA_ESCAPED_CR_IS_LF makes \r behave as \n. + (b) PCRE2_EXTRA_ALT_BSUX enables support for ECMAScript 6's \u{hh...} + construct. + (c) PCRE2_COPY_MATCHED_SUBJECT causes a copy of a matched subject to be + made, instead of just remembering a pointer. + * Some new Perl features: + (a) Perl 5.28's experimental alphabetic names for atomic groups and + lookaround assertions, for example, (*pla:...) and (*atomic:...). + (b) The new Perl "script run" features (*script_run:...) and + (*atomic_script_run:...) aka (*sr:...) and (*asr:...). + (c) When PCRE2_UTF is set, allow non-ASCII letters and decimal digits in + capture group names. + * --disable-percent-zt disables the use of %%zu and %%td in formatting strings + in pcre2test. They were already automatically disabled for VC and older C + compilers. + * Some changes related to callouts in pcre2grep: + (a) Support for running an external program under VMS has been added, in + addition to Windows and fork() support. + (b) --disable-pcre2grep-callout-fork restricts the callout support in + to the inbuilt echo facility. +* Wed Apr 24 2019 mliska@suse.cz +- Disable LTO (boo#1133274). +* Wed Jan 23 2019 bwiedemann@suse.com +- Do not run profiling in parallel for reproducible builds (boo#1040589) +* Mon Jan 14 2019 kukuk@suse.de +- Mark all license files as %%license +* Tue Dec 11 2018 crrodriguez@opensuse.org +- Build with --enable-jit-sealloc option, otherwise when + selinux is enabled or systemd memory protections are on, + programs will fail to work with execmem violations. +* Thu Oct 25 2018 astieger@suse.com +- pcre2 10.32: + * pcre2grep now supports the inclusion of binary zeros in + patterns that are read from files via the -f option. + * In pcre2_dfa_match(), internal recursive calls no longer use + the stack for local workspace and local ovectors + * Updated to Unicode version 11.0.0. + * (*ACCEPT:ARG), (*FAIL:ARG), and (*COMMIT:ARG) are now supported. + * Add support for \N{U+dddd}, but only in Unicode mode. + * Addesupport for (?^) to unset all imnsx options +* Fri Jul 20 2018 mpluskal@suse.com +- Drop conditions for old distributions +- Do profile guided build +* Sun Feb 18 2018 avindra@opensuse.org +- Update to new upstream release 10.31 + * New pcre2_config() options: PCRE2_CONFIG_NEVER_BACKSLASH_C and + PCRE2_CONFIG_COMPILED_WIDTHS. + * New pcre2_pattern_info() option PCRE2_INFO_EXTRAOPTIONS to + retrieve the extra compile time options. + * Public names for all pcre2_compile() error numbers. + * Added PCRE2_CALLOUT_STARTMATCH and PCRE2_CALLOUT_BACKTRACK + bits to a new field callout_flags in callout blocks. +- use https for main site +- cleanup with spec-cleaner +* Mon Sep 11 2017 jengelh@inai.de +- Update to new upstream release 10.30 + * The main interpreter, pcre2_match(), has been refactored into + a new version that does not use recursive function calls for + remembering backtracking positions. The new implementation + allows backtracking into recursive group calls in patterns, + making it more compatible with Perl. For patterns that have a + lot of backtracking, the heap is now used, and there is + explicit limit on the amount, settable by + pcre2_set_heap_limit(). The "recursion limit" is retained, + but is renamed as "depth limit". + * The new option PCRE2_ENDANCHORED insists that a pattern match + must end at the end of the subject. + * The new option PCRE2_EXTENDED_MORE implements Perl's /xx + feature, and pcre2test is upgraded to support it. Setting + within the pattern by (?xx) is Also supported. + * (?n) can be used to set PCRE2_NO_AUTO_CAPTURE, because Perl + now has this. + * Additional pattern compile options in the compile context are + now available: PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES and + PCRE2_EXTRA_BAD_ESCAPE_IS LITERAL. + * The newline type PCRE2_NEWLINE_NUL is now available. + * The match limit value now also applies to pcre2_dfa_match() + as there are patterns that can use up a lot of resources + without necessarily recursing very deeply. + * Various minor security fixes found by fuzzers: + + bsc#1037165: crash for forward reference in lookbehind with + PCRE2_ANCHORED + + CVE-2017-8786: heap-based buffer overflow write in pcre2test + (bsc#1036942) + + CVE-2017-7186: DoS by triggering an invalid Unicode property + lookup (bsc#1030066) +- Switch source URLs to use HTTP. +* Sat Aug 5 2017 astieger@suse.com +- fix SLE 11 build +* Tue May 2 2017 astieger@suse.com +- pcre2grep can now read .gz and .bz2 files directly +- pcre2test is now built to support line editing +* Thu Feb 16 2017 astieger@suse.com +- pcre2 10.23: + * major re-factoring of the pcre2_compile.c file + * Back references are now permitted in lookbehind assertions when + there are no duplicated group numbers (that is, (?| has not + been used), and, if the reference is by name, there is only one + group of that name. The referenced group must, of course be of + fixed length. + * \g{+} (e.g. \g{+2} ) is now supported. It is a "forward + back reference" and can be useful in repetitions + (compare \g{-} ). Perl does not recognize this syntax. + * pcre2grep now automatically expands its buffer up to a maximum + set by --max-buffer-size. + * The -t option (grand total) has been added to pcre2grep. + * A new function called pcre2_code_copy_with_tables() exists to + copy a compiled pattern along with a private copy of the + character tables that is uses. +* Tue Feb 7 2017 dimstar@opensuse.org +- Explicitly package %%{_docdir}/%%{name} to fix build with RPM 4.13. +* Mon Aug 1 2016 astieger@suse.com +- pcre2 10.22: + * The POSIX wrapper function regcomp() did not used to + support back references and subroutine calls if called with the + REG_NOSUB option. It now does. + * A new function, pcre2_code_copy(), is added, to make a copy of a + compiled pattern. + * Support for string callouts is added to pcre2grep. + * Added the PCRE2_NO_JIT option to pcre2_match(). + * The pcre2_get_error_message() function now returns with a + negative error code if the error number it is given is unknown. + * Several updates have been made to pcre2test and test scripts + * Fix CVE-2016-3191: workspace overflow for (*ACCEPT) with deeply + nested parentheses (boo#971741) +* Sun Jan 17 2016 jengelh@inai.de +- Update to new upstream release 10.21 + * Improve JIT matching speed of patterns starting with + or *. + * Use memchr() to find the first character in an unanchored match + in 8-bit mode in the interpreter. This gives a significant speed + improvement. + * 10.20 broke the handling of [[:>:]] and [[:<:]] in that + processing them could involve a buffer overflow if the + following character was an opening parenthesis. + * 10.20 also introduced a bug in processing this pattern: + /((?x)(*:0))#(?'/, which was fixed. + * A callout with a string argument containing an opening square + bracket, for example /(?C$[$)(?<]/, was incorrectly processed and + could provoke a buffer overflow. + * A possessively repeated conditional group that could match an empty + string, for example, /(?(R))*+/, was incorrectly compiled. + * The Unicode tables have been updated to Unicode 8.0.0. + * An empty comment (?#) in a pattern was incorrectly processed and + could provoke a buffer overflow. + * Fix infinite recursion in the JIT compiler when certain patterns + /such as (?:|a|){100}x/ are analysed. + * Some patterns with character classes involving [: and \\ were + incorrectly compiled and could cause reading from uninitialized + memory or an incorrect error diagnosis. Examples are: + /[[:\\](?<[::]/ and /[[:\\](?'abc')[a:]. + * A missing closing parenthesis for a callout with a string argument + was not being diagnosed, possibly leading to a buffer overflow. + * If (?R was followed by - or + incorrect behaviour happened instead + of a diagnostic. + * Fixed an issue when \p{Any} inside an xclass did not read the current + character. + * About 80 more fixes, which you can read about in the ChangeLog + shipped with the libpcre2-8-0 package. +* Tue Jul 14 2015 astieger@suse.com +- PCRE2 10.20: + * Callouts with string arguments and the + pcre2_callout_enumerate() function have been implemented. + * The PCRE2_NEVER_BACKSLASH_C option, which locks out the use of + \C, is added. + * The PCRE2_ALT_CIRCUMFLEX option lets ^ match after a newline at + the end of a subject in multiline mode. + * The way named subpatterns are handled has been refactored. The + previous approach had several bugs. + * The handling of \c in EBCDIC environments has been changed to + conform to the perlebcdic document. (Incompatible change) + * Bugs have been mended, many of them discovered by fuzzers. +* Thu Jun 18 2015 astieger@suse.com +- PCRE2, a re-working of the original PCRE library to provide an + entirely new API, version 10.10. Not source compatible. +- copy of the pcre package, with the following adjustments: + * required name changes + * adjust pcre-8.21-multilib.patch to pcre2-10.10-multilib.patch + * drop upstreamed pcre-8.32-visibility.patch + * --enable-{utf8,unicode-properties} became --enable-unicode + * drop cpp subpackage + * make test -> check + * enable 32 bit character support +* Thu Apr 30 2015 astieger@suse.com +- pcre 8.37: + * CVE-2015-2325: Patterns with certain groups specifying a zero + minimum quantifier caused incorrect code to be compiled, + leading to an incorrect memory read. [boo#924960] + * CVE-2015-2326: Specific patterns containing a forward reference + with subroutine calls caused incorrect code to be compiled + [boo#924961] + * CVE-2014-8964: If an assertion condition was quantified with a + minimum of zero, SIGSEGV or other misbehaviour could occur. + [boo#906574] + * further bug fixes as listed in ChangeLog +* Mon Mar 9 2015 p.drouand@gmail.com +- Update to version 3.16 + * This is primarily a bug-fix release. + * The Unicode data tables have been updated to Unicode 7.0.0. +- Remove pcre-commit1472.patch; fixed on upstream release +- Remove obsolete "Obsoletes" tag +* Tue Sep 2 2014 jengelh@inai.de +- Improve on RPM group classification +- Remove defunct %%gpg_verify (replaced by source validators), + defunct freecode link +* Thu Aug 28 2014 crrodriguez@opensuse.org +- Harden build with full RELRO as this libraries end linked + to at least one setuid root executable. +* Mon Jun 16 2014 dvaleev@suse.com +- Enable JIT on ppc64le as well +* Sat May 3 2014 coolo@suse.com +- update to 0.35: + There have been performance improvements for classes containing non-ASCII + characters and the "auto-possessification" feature has been extended. Other + minor improvements have been implemented and bugs fixed. There is a new callout + feature to enable applications to do detailed stack checks at compile time, to + avoid running out of stack for deeply nested parentheses. The JIT compiler has + been extended with experimental support for ARM-64, MIPS-64, and PPC-LE. +- add pcre-commit1472.patch from SVN to work with gcc49, see + http://bugs.exim.org/show_bug.cgi?id=1463 +* Sun Mar 23 2014 tchvatal@suse.com +- Add automake and autoconf as explicit deps as we run autoreconf +* Sun Mar 23 2014 tchvatal@suse.com +- Add patch pcre-8.21-multilib.patch to fix RPATH issues. + * The patch is taken from RedHat. +* Sun Mar 23 2014 tchvatal@suse.com +- Clean up with the spec cleaner. Use -j1 in tests as it is not + really thread safe +* Sun Mar 23 2014 tchvatal@suse.com +- Version bump to 8.34: + * warning fixes + * perl fixes + * unocode6.3.0 support + * gconv support +* Wed Nov 13 2013 sweet_f_a@gmx.de +- enable tests for all archs +- --enable-jit for sparc +* Thu Jun 13 2013 jengelh@inai.de +- Update to new upstream release 8.33 + * The Just-In-Time compiler (JIT) now supports all pattern + features, including callouts and the backtracking verbs. In + addition, some bugs are fixed and there are minor performance + enhancements. +- More robust make install call. Provide signature verification + files (avoid depending on gpg-offline due to bootstrap cycle). +* Sat Jun 8 2013 crrodriguez@opensuse.org +- Ensure the PCRE library and tools are built with large file + support in 32 bit archs. +* Sun Jan 6 2013 p.drouand@gmail.com +- Update to 8.32 version: + * There is now support for 32-bit character strings and UTF-32. Like the + 16-bit support, this is done by compiling a separate 32-bit library. + * \X now matches a Unicode extended grapheme cluster. + * Case-independent matching of Unicode characters that have more than one + "other case" now makes all three (or more) characters equivalent. This + applies, for example, to Greek Sigma, which has two lowercase versions. + * Unicode character properties are updated to Unicode 6.2.0. + * The EBCDIC support, which had decayed, has had a spring clean. + * A number of JIT optimizations have been added, which give faster JIT + execution speed. In addition, a new direct interface to JIT execution is + available. This bypasses some of the sanity checks of pcre_exec() to give a + noticeable speed-up. + * A number of issues in pcregrep have been fixed, making it more compatible + with GNU grep. In particular, --exclude and --include (and variants) apply + to all files now, not just those obtained from scanning a directory + recursively. In Windows environments, the default action for directories is + now "skip" instead of "read" (which provokes an error). + * If the --only-matching (-o) option in pcregrep is specified multiple + times, each one causes appropriate output. For example, -o1 -o2 outputs the + substrings matched by the 1st and 2nd capturing parentheses. A separating + string can be specified by --om-separator (default empty). + * When PCRE is built via Autotools using a version of gcc that has the + "visibility" feature, it is used to hide internal library functions that are + not part of the public API. +- updated and versionned pcre-visibility.patch to svn trunk + * Modifications on configure.ac and makefile have been merged on upstream release +* Fri Nov 23 2012 jengelh@inai.de +- Update package descriptions about the differences between the + PCRE library subpackages. +* Wed Nov 7 2012 cgiboudeaux@gmx.com +- Use the --enable-pcre16 configure flag. + This switch enables 16 bit character support that will be required by Qt5 +* Fri Aug 17 2012 dimstar@opensuse.org +- Upate to version 8.31: + + The JIT compiler now supports partial matching and the (*MARK) + and (*COMMIT) verbs + + PCRE_INFO_MAXLOOKBEHIND can be used to find the longest + lookbehing in a pattern. + + There should be a performance improvement when using the heap + instead of the stack for recursion + + pcregrep can now be linked with libedit as an alternative to + libreadline + + pcregrep now has a --file-list option where the list of files + to scan is given as a file + + pcregrep now recognizes binary files and there are related + options + + The Unicode tables have been updated to 6.1.0 +- Rebase pcre-visibility.patch. +* Thu Jul 19 2012 jengelh@inai.de +- Only use --enable-jit on supported architectures; the build will + otherwise fail (e.g. on sparc). +* Thu May 10 2012 afaerber@suse.de +- Add devel-static package +* Tue Feb 7 2012 crrodriguez@opensuse.org +- fix baselibs +* Tue Feb 7 2012 crrodriguez@opensuse.org +- Update to PCRE 8.30, upstream SONAME bump, libpcre1 +- Drop no longer needed ppc patch. +- move library back to %%{_libdir} +* Wed Feb 1 2012 dvaleev@suse.com +- Fix cache-flush on PPC +* Wed Nov 16 2011 coolo@suse.com +- add libtool as buildrequire to avoid implicit dependency +* Tue Nov 1 2011 crrodriguez@opensuse.org +- Update to version 8.20 + * too many fixes to list here, see included ChangeLog + * replace pcre-visibility patch with the one I submitted to + upstream for inclusion. +* Tue Oct 11 2011 dmueller@suse.de +- udpate to 8.13: + * too many fixes to list here, see included ChangeLog + * the Unicode data tables have been updated to Unicode 6.0.0. +* Mon Sep 19 2011 coolo@suse.com +- remove fragile _service +* Wed Mar 9 2011 coolo@novell.com +- Update to version 8.12 + * This release fixes some bugs in pcregrep, one of which caused the tests to fail + on 64-bit big-endian systems. There are no changes to the code of the library. +- Update to version 8.11 + * A number of bugs in the library and in pcregrep have been fixed. As always, see + ChangeLog for details. The following are the non-bug-fix changes: + Added --match-limit and --recursion-limit to pcregrep. + Added an optional parentheses number to the -o and --only-matching options + of pcregrep. + Changed the way PCRE_PARTIAL_HARD affects the matching of $, \z, \Z, \b, and + \B. + Added PCRE_ERROR_SHORTUTF8 to make it possible to distinguish between a + bad UTF-8 sequence and one that is incomplete when using PCRE_PARTIAL_HARD. + Recognize (*NO_START_OPT) at the start of a pattern to set the PCRE_NO_ + START_OPTIMIZE option, which is now allowed at compile time +* Sat Oct 30 2010 cristian.rodriguez@opensuse.org +- Support GCC visibility, symbol clashes no more. +* Sun Sep 19 2010 vuntz@opensuse.org +- Update to version 8.10: + + Major additions: + - support for (*MARK) and friends + - PCRE_UCP option, which changes the behaviour of \b, \d, \s, + and \w (and their opposites) so that they make use of Unicode + properties + + Other additions: + - support for \N, which always matches any character other than + newline + - added --line-buffered to pcregrep + + Several small new features and bugfixes +- Changes from version 8.02: + + Update Unicode data tables to Unicode 5.2.0 + + Update the licensing terms in the pcregexp.pas file + + Several bug fixes +- Changes from version 8.01: + + Several bug fixes and build system improvements +- Changes from version 8.00: + + Enhancements: + - remove restrictions on patterns used for partial matching + - give extra information for partial matches + - improve the partial matching process + - add option to make a partial match override a full match + - enhance "study" process by finding a lower bound matching + length + - groups with duplicate numbers may now have duplicated names + without the use of PCRE_DUPNAMES, but they may not have + different names + - add REG_UNGREEDY to the pcreposix interface, which maps to + PCRE_UNGREEDY. + + Several bug fixes +- Drop pcre-7.9.patch: fixed upstream. +- Rearrange spec file to have all the %%files sections together, as + well as all the scriptlets together. +- Kill the main package that only included doc files like AUTHORS, + NEWS, and license, and put those files in libpcre0: this really + makes more sense. Therefore, make libpcre0 Provides/Obsoletes + libpcre0. +- We can also remove the other dependencies on the main package, + since everything already depends on libpcre0. +- Remove AutoReqProv: it's default now. +- Remove references to perl 5.005 in descriptons: it's not + mentioned anywhere anymore upstream. +* Mon Jun 28 2010 jengelh@medozas.de +- use %%_smp_mflags +* Sat Apr 24 2010 coolo@novell.com +- buildrequire pkg-config to fix provides +* Thu Feb 25 2010 prusnak@suse.cz +- build noarch docs only for >= 11.2 +* Wed Feb 10 2010 ms@suse.de +- fixed license statement according to the conversation + and permissions granted in (bnc #578724) +* Sat Dec 12 2009 jengelh@medozas.de +- add baselibs.conf as a source +- package documentation as noarch +* Wed Oct 7 2009 coolo@novell.com +- add obsolete/provides for pcre-32bit (bnc#539543) +* Wed Jun 10 2009 coolo@novell.com +- split package into tools, docs and libraries +* Fri Jun 5 2009 crrodriguez@suse.de +- disable static libraries, shouldn't be used now +* Sat May 30 2009 dmueller@suse.de +- fix symlinks to libpcre and libpcreposix to fix the build +* Wed May 27 2009 ms@suse.de +- moved libpcre and libpcreposix to %%{_lib} (bnc #507449) +* Tue May 5 2009 ms@suse.de +- Release 7.9 11-Apr-09 (bnc #500734) + Mostly bugfixes and tidies with just a couple of minor + functional additions. +* Wed Jan 7 2009 olh@suse.de +- obsolete old -XXbit packages (bnc#437293) +* Thu Sep 11 2008 crrodriguez@suse.de +- update to PCRE 7.8 + * More bug fixes, plus a performance improvement + in Unicode character property lookup. + see complete changelog at http://www.pcre.org/changelog.txt +* Thu Apr 10 2008 ro@suse.de +- added baselibs.conf file to build xxbit packages + for multilib support +* Fri Feb 1 2008 crrodriguez@suse.de +- update to version 7.6 +- The main reason for having this release so soon after 7.5 + is because it fixes a potential buffer overflow problem in pcre_compile() + when run in UTF-8 mode. In addition, the CMake configuration files have been brought up to date. +* Sun Jan 13 2008 crrodriguez@suse.de +- update version 7.5 + 1. Applied a patch from Craig: "This patch makes it possible to 'ignore' + values in parens when parsing an RE using the C++ wrapper." + 2. Negative specials like \S did not work in character classes in UTF-8 mode. + Characters greater than 255 were excluded from the class instead of being + included. + 3. The same bug as (2) above applied to negated POSIX classes such as + [:^space:]. + 4. PCRECPP_STATIC was referenced in pcrecpp_internal.h, but nowhere was it + defined or documented. It seems to have been a typo for PCRE_STATIC, so + I have changed it. + 5. The construct (?&) was not diagnosed as a syntax error (it referenced the + first named subpattern) and a construct such as (?&a) would reference the + first named subpattern whose name started with "a" (in other words, the + length check was missing). Both these problems are fixed. "Subpattern name + expected" is now given for (?&) (a zero-length name), and this patch also + makes it give the same error for \k'' (previously it complained that that + was a reference to a non-existent subpattern). + 6. The erroneous patterns (?+-a) and (?-+a) give different error messages; + this is right because (?- can be followed by option settings as well as by + digits. I have, however, made the messages clearer. + 7. Patterns such as (?(1)a|b) (a pattern that contains fewer subpatterns + than the number used in the conditional) now cause a compile-time error. + This is actually not compatible with Perl, which accepts such patterns, but + treats the conditional as always being FALSE (as PCRE used to), but it + seems to me that giving a diagnostic is better. + 8. Change "alphameric" to the more common word "alphanumeric" in comments + and messages. + 9. Fix two occurrences of "backslash" in comments that should have been + "backspace". + 10. Remove two redundant lines of code that can never be obeyed (their function + was moved elsewhere). + 11. The program that makes PCRE's Unicode character property table had a bug + which caused it to generate incorrect table entries for sequences of + characters that have the same character type, but are in different scripts. + It amalgamated them into a single range, with the script of the first of + them. In other words, some characters were in the wrong script. There were + thirteen such cases, affecting characters in the following ranges: + U+002b0 - U+002c1 + U+0060c - U+0060d + U+0061e - U+00612 + U+0064b - U+0065e + U+0074d - U+0076d + U+01800 - U+01805 + U+01d00 - U+01d77 + U+01d9b - U+01dbf + U+0200b - U+0200f + U+030fc - U+030fe + U+03260 - U+0327f + U+0fb46 - U+0fbb1 + U+10450 - U+1049d + 12. The -o option (show only the matching part of a line) for pcregrep was not + compatible with GNU grep in that, if there was more than one match in a + line, it showed only the first of them. It now behaves in the same way as + GNU grep. + 13. If the -o and -v options were combined for pcregrep, it printed a blank + line for every non-matching line. GNU grep prints nothing, and pcregrep now + does the same. The return code can be used to tell if there were any + non-matching lines. + 14. Added --file-offsets and --line-offsets to pcregrep. + 15. The pattern (?=something)(?R) was not being diagnosed as a potentially + infinitely looping recursion. The bug was that positive lookaheads were not + being skipped when checking for a possible empty match (negative lookaheads + and both kinds of lookbehind were skipped). + 16. Fixed two typos in the Windows-only code in pcregrep.c, and moved the + inclusion of to before rather than after the definition of + INVALID_FILE_ATTRIBUTES (patch from David Byron). + 17. Specifying a possessive quantifier with a specific limit for a Unicode + character property caused pcre_compile() to compile bad code, which led at + runtime to PCRE_ERROR_INTERNAL (-14). Examples of patterns that caused this + are: /\p{Zl}{2,3}+/8 and /\p{Cc}{2}+/8. It was the possessive "+" that + caused the error; without that there was no problem. + 18. Added --enable-pcregrep-libz and --enable-pcregrep-libbz2. + 19. Added --enable-pcretest-libreadline. + 20. In pcrecpp.cc, the variable 'count' was incremented twice in + RE::GlobalReplace(). As a result, the number of replacements returned was + double what it should be. I removed one of the increments, but Craig sent a + later patch that removed the other one (the right fix) and added unit tests + that check the return values (which was not done before). + 21. Several CMake things: + (1) Arranged that, when cmake is used on Unix, the libraries end up with + the names libpcre and libpcreposix, not just pcre and pcreposix. + (2) The above change means that pcretest and pcregrep are now correctly + linked with the newly-built libraries, not previously installed ones. + (3) Added PCRE_SUPPORT_LIBREADLINE, PCRE_SUPPORT_LIBZ, PCRE_SUPPORT_LIBBZ2. + 22. In UTF-8 mode, with newline set to "any", a pattern such as .*a.*=.b.* + crashed when matching a string such as a\x{2029}b (note that \x{2029} is a + UTF-8 newline character). The key issue is that the pattern starts .*; + this means that the match must be either at the beginning, or after a + newline. The bug was in the code for advancing after a failed match and + checking that the new position followed a newline. It was not taking + account of UTF-8 characters correctly. + 23. PCRE was behaving differently from Perl in the way it recognized POSIX + character classes. PCRE was not treating the sequence [:...:] as a + character class unless the ... were all letters. Perl, however, seems to + allow any characters between [: and :], though of course it rejects as + unknown any "names" that contain non-letters, because all the known class + names consist only of letters. Thus, Perl gives an error for [[:1234:]], + for example, whereas PCRE did not - it did not recognize a POSIX character + class. This seemed a bit dangerous, so the code has been changed to be + closer to Perl. The behaviour is not identical to Perl, because PCRE will + diagnose an unknown class for, for example, [[:l\ower:]] where Perl will + treat it as [[:lower:]]. However, PCRE does now give "unknown" errors where + Perl does, and where it didn't before. + 24. Rewrite so as to remove the single use of %%n from pcregrep because in some + Windows environments %%n is disabled by default. +* Tue Nov 6 2007 crrodriguez@suse.de +- update to version 7.4, since version 7.2, more than 40 bugs were fixed + including multiple vulnerabilities [#325921] . The list of changes is too long + to mention here, see changelog.txt for details. +* Wed Aug 8 2007 ms@suse.de +- added fix to run ldconfig for libpcre*, Thanks to + Cristian Rodriguez who provided + the patch (#298291) +* Mon Jul 23 2007 ms@suse.de +- update to version 7.2, fixes bug: (#293752) +- Changes from 7.1 to 7.2 + 1. If the fr_FR locale cannot be found for test 3, try the "french" locale, + which is apparently normally available under Windows. + 2. Re-jig the pcregrep tests with different newline settings in an attempt + to make them independent of the local environment's newline setting. + 3. Add code to configure.ac to remove -g from the CFLAGS default settings. + 4. Some of the "internals" tests were previously cut out when the link size + was not 2, because the output contained actual offsets. The recent new + "Z" feature of pcretest means that these can be cut out, making the tests + usable with all link sizes. + 5. Implemented Stan Switzer's goto replacement for longjmp() when not using + stack recursion. This gives a massive performance boost under BSD, but just + a small improvement under Linux. However, it saves one field in the frame + in all cases. + 6. Added more features from the forthcoming Perl 5.10: + (a) (?-n) (where n is a string of digits) is a relative subroutine or + recursion call. It refers to the nth most recently opened parentheses. + (b) (?+n) is also a relative subroutine call; it refers to the nth next + to be opened parentheses. + (c) Conditions that refer to capturing parentheses can be specified + relatively, for example, (?(-2)... or (?(+3)... + (d) \K resets the start of the current match so that everything before + is not part of it. + (e) \k{name} is synonymous with \k and \k'name' (.NET compatible). + (f) \g{name} is another synonym - part of Perl 5.10's unification of + reference syntax. + (g) (?| introduces a group in which the numbering of parentheses in each + alternative starts with the same number. + (h) \h, \H, \v, and \V match horizontal and vertical whitespace. + 7. Added two new calls to pcre_fullinfo(): PCRE_INFO_OKPARTIAL and + PCRE_INFO_JCHANGED. + 8. A pattern such as (.*(.)?)* caused pcre_exec() to fail by either not + terminating or by crashing. Diagnosed by Viktor Griph; it was in the code + for detecting groups that can match an empty string. + 9. A pattern with a very large number of alternatives (more than several + hundred) was running out of internal workspace during the pre-compile + phase, where pcre_compile() figures out how much memory will be needed. A + bit of new cunning has reduced the workspace needed for groups with + alternatives. The 1000-alternative test pattern now uses 12 bytes of + workspace instead of running out of the 4096 that are available. + 10. Inserted some missing (unsigned int) casts to get rid of compiler warnings. + 11. Applied patch from Google to remove an optimization that didn't quite work. + The report of the bug said: + pcrecpp::RE("a*").FullMatch("aaa") matches, while + pcrecpp::RE("a*?").FullMatch("aaa") does not, and + pcrecpp::RE("a*?\\z").FullMatch("aaa") does again. + 12. If \p or \P was used in non-UTF-8 mode on a character greater than 127 + it matched the wrong number of bytes. +* Tue May 1 2007 ms@suse.de +- added --enable-unicode-properties configure option to support + UTF-8 character strings in \P, \p, and \X (#269749) +* Mon Apr 30 2007 trenn@suse.de +- corrected assert compile error +* Wed Apr 25 2007 ms@suse.de +- update to pcre 7.1 + 1. Applied Bob Rossi and Daniel G's patches to convert the build system to one + that is more "standard", making use of automake and other Autotools. There + is some re-arrangement of the files and adjustment of comments consequent + on this. + 2. Part of the patch fixed a problem with the pcregrep tests. The test of -r + for recursive directory scanning broke on some systems because the files + are not scanned in any specific order and on different systems the order + was different. A call to "sort" has been inserted into RunGrepTest for the + approprate test as a short-term fix. In the longer term there may be an + alternative. + 3. I had an email from Eric Raymond about problems translating some of PCRE's + man pages to HTML (despite the fact that I distribute HTML pages, some + people do their own conversions for various reasons). The problems + concerned the use of low-level troff macros .br and .in. I have therefore + removed all such uses from the man pages (some were redundant, some could + be replaced by .nf/.fi pairs). The 132html script that I use to generate + HTML has been updated to handle .nf/.fi and to complain if it encounters + .br or .in. + 4. Updated comments in configure.ac that get placed in config.h.in and also + arranged for config.h to be included in the distribution, with the name + config.h.generic, for the benefit of those who have to compile without + Autotools (compare pcre.h, which is now distributed as pcre.h.generic). + 5. Updated the support (such as it is) for Virtual Pascal, thanks to Stefan + Weber: (1) pcre_internal.h was missing some function renames; (2) updated + makevp.bat for the current PCRE, using the additional files + makevp_c.txt, makevp_l.txt, and pcregexp.pas. + 6. A Windows user reported a minor discrepancy with test 2, which turned out + to be caused by a trailing space on an input line that had got lost in his + copy. The trailing space was an accident, so I've just removed it. + 7. Add -Wl,-R... flags in pcre-config.in for *BSD* systems, as I'm told + that is needed. + 8. Mark ucp_table (in ucptable.h) and ucp_gentype (in pcre_ucp_searchfuncs.c) + as "const" (a) because they are and (b) because it helps the PHP + maintainers who have recently made a script to detect big data structures + in the php code that should be moved to the .rodata section. I remembered + to update Builducptable as well, so it won't revert if ucptable.h is ever + re-created. + 9. Added some extra #ifdef SUPPORT_UTF8 conditionals into pcretest.c, + pcre_printint.src, pcre_compile.c, pcre_study.c, and pcre_tables.c, in + order to be able to cut out the UTF-8 tables in the latter when UTF-8 + support is not required. This saves 1.5-2K of code, which is important in + some applications. + Later: more #ifdefs are needed in pcre_ord2utf8.c and pcre_valid_utf8.c + so as not to refer to the tables, even though these functions will never be + called when UTF-8 support is disabled. Otherwise there are problems with a + shared library. + 10. Fixed two bugs in the emulated memmove() function in pcre_internal.h: + (a) It was defining its arguments as char * instead of void *. + (b) It was assuming that all moves were upwards in memory; this was true + a long time ago when I wrote it, but is no longer the case. + The emulated memove() is provided for those environments that have neither + memmove() nor bcopy(). I didn't think anyone used it these days, but that + is clearly not the case, as these two bugs were recently reported. + 11. The script PrepareRelease is now distributed: it calls 132html, CleanTxt, + and Detrail to create the HTML documentation, the .txt form of the man + pages, and it removes trailing spaces from listed files. It also creates + pcre.h.generic and config.h.generic from pcre.h and config.h. In the latter + case, it wraps all the #defines with #ifndefs. This script should be run + before "make dist". + 12. Fixed two fairly obscure bugs concerned with quantified caseless matching + with Unicode property support. + (a) For a maximizing quantifier, if the two different cases of the + character were of different lengths in their UTF-8 codings (there are + some cases like this - I found 11), and the matching function had to + back up over a mixture of the two cases, it incorrectly assumed they + were both the same length. + (b) When PCRE was configured to use the heap rather than the stack for + recursion during matching, it was not correctly preserving the data for + the other case of a UTF-8 character when checking ahead for a match + while processing a minimizing repeat. If the check also involved + matching a wide character, but failed, corruption could cause an + erroneous result when trying to check for a repeat of the original + character. + 13. Some tidying changes to the testing mechanism: + (a) The RunTest script now detects the internal link size and whether there + is UTF-8 and UCP support by running ./pcretest -C instead of relying on + values substituted by "configure". (The RunGrepTest script already did + this for UTF-8.) The configure.ac script no longer substitutes the + relevant variables. + (b) The debugging options /B and /D in pcretest show the compiled bytecode + with length and offset values. This means that the output is different + for different internal link sizes. Test 2 is skipped for link sizes + other than 2 because of this, bypassing the problem. Unfortunately, + there was also a test in test 3 (the locale tests) that used /B and + failed for link sizes other than 2. Rather than cut the whole test out, + I have added a new /Z option to pcretest that replaces the length and + offset values with spaces. This is now used to make test 3 independent + of link size. (Test 2 will be tidied up later.) + 14. If erroroffset was passed as NULL to pcre_compile, it provoked a + segmentation fault instead of returning the appropriate error message. + 15. In multiline mode when the newline sequence was set to "any", the pattern + ^$ would give a match between the \r and \n of a subject such as "A\r\nB". + This doesn't seem right; it now treats the CRLF combination as the line + ending, and so does not match in that case. It's only a pattern such as ^$ + that would hit this one: something like ^ABC$ would have failed after \r + and then tried again after \r\n. + 16. Changed the comparison command for RunGrepTest from "diff -u" to "diff -ub" + in an attempt to make files that differ only in their line terminators + compare equal. This works on Linux. + 17. Under certain error circumstances pcregrep might try to free random memory + as it exited. This is now fixed, thanks to valgrind. + 19. In pcretest, if the pattern /(?m)^$/g was matched against the string + "abc\r\n\r\n", it found an unwanted second match after the second \r. This + was because its rules for how to advance for /g after matching an empty + string at the end of a line did not allow for this case. They now check for + it specially. + 20. pcretest is supposed to handle patterns and data of any length, by + extending its buffers when necessary. It was getting this wrong when the + buffer for a data line had to be extended. + 21. Added PCRE_NEWLINE_ANYCRLF which is like ANY, but matches only CR, LF, or + CRLF as a newline sequence. + 22. Code for handling Unicode properties in pcre_dfa_exec() wasn't being cut + out by #ifdef SUPPORT_UCP. This did no harm, as it could never be used, but + I have nevertheless tidied it up. + 23. Added some casts to kill warnings from HP-UX ia64 compiler. + 24. Added a man page for pcre-config. +* Fri Feb 9 2007 ms@suse.de +- fixed wrong usage of assert() call +* Tue Jan 9 2007 ms@suse.de +- fixed build for all architectures +* Mon Jan 8 2007 ms@suse.de +- update to new version 7.0 + Changes: As well as a number of bugfixes, there has been a major + refactoring of the compiling code, which makes it easier to add new + features, including some new optimizations. A QuoteMeta function has been + added to the C++ wrapper. There is now a mode in which all Unicode newline + sequences are recognized. Support for the Perl 5.10 syntax for features + that were previously in PCRE but not in Perl (named groups, possessive + quantifiers) has been added. +* Sat Oct 28 2006 meissner@suse.de +- CXXFLAGS needs RPM_OPT_FLAGS too. +* Mon Jul 10 2006 ms@suse.de +- update to new version 6.7 +- finally removed evil configure patch +- When UTF-8 mode was not set, PCRE looped when compiling certain patterns + containing an extended class (one that cannot be represented by a bitmap + because it contains high-valued characters or Unicode property items, e.g. + [\pZ]). Almost always one would set UTF-8 mode when processing such a + pattern, but PCRE should not loop if you do not (it no longer does). + [Detail: two cases were found: (a) a repeated subpattern containing an + extended class; (b) a recursive reference to a subpattern that followed a + previous extended class. It wasn't skipping over the extended class + correctly when UTF-8 mode was not set.] +- Applied a patch from the folks at Google to pcrecpp.cc, to fix "another + instance of the 'standard' template library not being so standard". +* Wed Jan 25 2006 mls@suse.de +- converted neededforbuild to BuildRequires +* Thu Jan 12 2006 mmj@suse.de +- build with -fstack-protector +* Thu Dec 1 2005 ro@suse.de +- hack libtool core in configure script + since configure.in is too broken for a autoreconf ... +* Mon Sep 19 2005 mmj@suse.de +- update to the latest version v6.4 +* Tue Aug 2 2005 mmj@suse.de +- update to the latest version v6.2 +* Thu Jun 23 2005 mmj@suse.de +- update to latest version v6.1 +* Mon Jun 13 2005 mmj@suse.de +- add gcc-c++ to #nfb as well +* Wed Jun 8 2005 mmj@suse.de +- update to latest version v6.0 +* Mon May 23 2005 mmj@suse.de +- use --enable-utf8 +- use $RPM_OPT_FLAGS +* Thu Mar 31 2005 uli@suse.de +- ignore test suite errors on ARM +* Mon Nov 22 2004 choeger@suse.de +- update to latest version v5.0 +* Mon Jun 7 2004 choeger@suse.de +- update to latest version v4.5 +* Mon Jan 5 2004 schwab@suse.de +- Move pcre-config to pcre-devel. +* Fri Oct 31 2003 choeger@suse.de +- Don't build as root +* Thu Aug 21 2003 choeger@suse.de +- update to v4.4 +* Fri Aug 1 2003 choeger@suse.de +- disabled Test2, because it is not 64bit arch clean + (contacted author, he knows about that problem) +* Wed Jul 30 2003 choeger@suse.de +- update to most recent version v4.3 +- splitted into -devel subpackage +* Fri Dec 6 2002 coolo@suse.de +- removed undefined symbols in libpcreposix +* Tue Sep 17 2002 ro@suse.de +- removed bogus self-provides +* Fri Apr 5 2002 coolo@suse.de +- fixing autoheader usage +- forward ported %%libdir changes from sles7-s390x +* Tue Jan 22 2002 choeger@suse.de +- update to version 3.9 +- added BuildRoot +* Mon Aug 20 2001 mge@suse.de +- pcre 3.5 +* Wed Apr 11 2001 froh@suse.de +- suse_update_config +* Mon Dec 4 2000 mge@suse.de +- pcre 3.4 +* Tue Jun 27 2000 mge@suse.de +- pcre 3.2 +* Thu Mar 2 2000 mge@suse.de +- fixed manpath +* Sun Feb 13 2000 mge@suse.de +- update to 3.1 +- group tag +* Mon Oct 25 1999 mge@suse.de +- initial SuSE-RPM: changed Makefile to install into /usr diff --git a/pcre2.keyring b/pcre2.keyring new file mode 100644 index 0000000..95dbb71 --- /dev/null +++ b/pcre2.keyring @@ -0,0 +1,39 @@ +This is Philip Hazel's public GPG key. + +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v1.2.0 (SunOS) + +mQEMBD2z9g0BCACpGWJ4K2mjR6K9nv7/K+HLjJtDO0E0ckudeNjg2JvnuUU7m1bK +87nSklHTSMNiqmuVU5hFAuGiMGBMj31GPpce3VbABdm6TmAJB8ZndvJXyf8lC7Ko +5iZX/gCYU6817UI5pFwYR3MTIUSSxTGqk1y62pYLKUq9keSU5Cew4q1KMwl46Bn3 +SwlfQeST4WGwL2w9b8mWNltBBY23bgzwYu7vFBD4GQnfzJsvMC9lj825wob2nKy5 +CL4bY6tiYUqALzDYaIVCBqJ1Ky1rpPzRcDZUeeF8Ta3njh18Y0KzPEj+Xu5Ksexg +7LUy/2wFzVRtJgqvAFZo43KIOptsj/63zxJjAAkBAbQhUGhpbGlwIEhhemVsIDxw +aDEwQGN1cy5jYW0uYWMudWs+iQEyBBMBAgAcBQI9s/YNAhsDBAsHAwIDFQIDAxYC +AQIeAQIXgAAKCRCXZuCE+w9D2JbrCACBHrxybV+9t3TGR3+uk2QnUuct90a+udcB +cbWgKQgX345ZgwIfyoPKAbG84mN/+SFUN/Ie4ZHZxVsbN//l2P/Osx0CNQBfem4e +HUWegkFGzC5DxQhN5nsJ/GR6pnxG1l/DbNhupNY73oTajWFdi7K8jYfamU/zS/Da +VCwUKxWtGqyEqOxvbdqcjsnTMmLVfXtefx7CbKyhaClPP8Pe4FL+eqyfHJF7uywK +VWlUNmQa4E+ZAK8tkoK9sZAc0ImWwZMumiKZDEpr2D8Ty+Gg2umTS2OMIcbY8QF1 +r6DeubFabdPIe1kn0BGXtdAurhbdJCIbcAEQS0eEeWC4A4LiDprntB1QaGlsaXAg +SGF6ZWwgPHBoMTBAY2FtLmFjLnVrPokBMgQTAQIAHAUCPbaC8QIbAwQLBwMCAxUC +AwMWAgECHgECF4AACgkQl2bghPsPQ9ho5Qf+I2HUhZeXOUneeqSa+cITsIELJMrZ +UWcydY1z+L68yOqURVHB1jF4aC6QSlq0pLjozwF6KfZO5AfN9FvkRQ0DzCEXH48W +OXqzbjzgNxRMdaP5+49Axl0UQuhupGJg66T4FiGnSVBhK8kTURPCSpLLgkCJqNcY +t5zuNwk3e7JvleT59EVpk/kw3a5p9oeKYBln57pHwq+HdPLSCdkedQBKdsbNrazy +qduYEXen4ogsIoTpA9lLH1Xsi9wL+soLAlWXtl/GNa1h7Jpwn41zp1hqIZe1ebIM +dSGbtMEaGJlqgDauYJSl0lkVgaPtZCTmfAf57TsGfD0IckN2XNGLuwb6DLkBCwQ9 +s/eJAQgAuXq2I1VTDB108O0NAB6QKfA2gMHafoj3OcwEUHnJgXrHqjYOpFr0r5lC +YjwMRMvHO7r4jgtwKjGACI/1IE2hiGXkKFOWZFkCf7Qjoi13a78myC/VRwe4uEIs +xdz++w8WfzuC1sYw8d/rlybVzHTfTsKfmFOQamuyLCTm3Kdx/wZyGM7JMmgVn2zF +HWasdID0n7QJFZGR3yEfqis5zq1t3w28AaXlTZG7QtFj9V0cWIhZRjjjVe1biPA8 +Btp+eFkmcat79N9hHbiEiAY3u2qmQCcn1fiBBC0Og09cY4dRyX0/bXUo4n8lHysp +JcL/sIZ7Ahd1LOfg9h+yQfoaey78LQAGKYkBHwQYAQIACQUCPbP3iQIbDAAKCRCX +ZuCE+w9D2P0BCACXsbwFerd4wlnt8PxxQlRGXi1t4EGBFf2zSdgQvIXJ3ntPzcDU ++8hnIWQJhCTZ3PfVmoqB6ZOM1RWI/IcP6b4qVb6vJGI/VxRICraAczw+4bdFxFiB +n2+SyD4MxZg8t66FcH3fHugQqsApHTmtKmahv5BXB+0dPmP/BRUmzxYUv8hdnhHl +91S4R4BDu84DvKYyJK9jlqUl06pvqXrBSNsbWKgAJnmnDe8FaLUk+p0IXeMSavUn +T5E26MRIioxAz/G4FZI8IdO92GHTz82O7/mQMhveAdpspDvpV3M4wnldU425GlxZ +nmq1bbjAU4QVuIS9nkk2GrGx5+N6cYMy8JqG +=EHsz +-----END PGP PUBLIC KEY BLOCK----- diff --git a/pcre2.spec b/pcre2.spec new file mode 100644 index 0000000..20105c2 --- /dev/null +++ b/pcre2.spec @@ -0,0 +1,259 @@ +# +# spec file for package pcre2 +# +# Copyright (c) 2022-2023 ZhuningOS +# + + +%global _lto_cflags %{_lto_cflags} -ffat-lto-objects +Name: pcre2 +Version: 10.39 +Release: 150400.4.9.1 +Summary: A library for Perl-compatible regular expressions +License: BSD-3-Clause +Group: Development/Libraries/C and C++ +URL: https://www.pcre.org +Source0: https://github.com/PhilipHazel/pcre2/releases/download/%{name}-%{version}/%{name}-%{version}.tar.bz2 +Source2: https://github.com/PhilipHazel/pcre2/releases/download/%{name}-%{version}/%{name}-%{version}.tar.bz2.sig +Source3: %{name}.keyring +Source4: baselibs.conf +#PATCH-FIX-OPENSUSE tchvatal@suse.cz upstream thinks it is good idea to use rpath, taken from RH +Patch1: pcre2-10.10-multilib.patch +# revert https://github.com/PhilipHazel/pcre2/commit/080d7789eba00b570181dfe28809b01aa88c01f8 +Patch2: pcre2-readd-wrappers-POSIX.patch +Patch3: pcre2-10.39-bsc1199232-unicode-property-matching.patch +Patch4: pcre2-bsc1199235-CVE-2022-1587.patch +#PATCH-FIX-UPSTREAM bsc#1213514 CVE-2022-41409 Integer overflow vulnerability +Patch5: pcre2-CVE-2022-41409.patch +BuildRequires: autoconf +BuildRequires: automake +BuildRequires: gcc-c++ +BuildRequires: libbz2-devel +BuildRequires: libedit-devel +BuildRequires: libtool +BuildRequires: pkgconfig +BuildRequires: zlib-devel + +%description +The PCRE2 library is a set of functions that implement regular +expression pattern matching using the same syntax and semantics +as Perl 5. + +PCRE2 is a re-working of the original PCRE library to provide an entirely new +API. + +%package devel +Summary: A library for Perl-compatible regular expressions +Group: Development/Libraries/C and C++ +Requires: libpcre2-16-0 = %{version} +Requires: libpcre2-32-0 = %{version} +Requires: libpcre2-8-0 = %{version} +Requires: libpcre2-posix2 = %{version} +Requires: libstdc++-devel + +%description devel +The PCRE2 library is a set of functions that implement regular +expression pattern matching using the same syntax and semantics +as Perl 5. + +PCRE2 is a re-working of the original PCRE library to provide an entirely new +API. + +%package devel-static +Summary: A library for Perl-compatible regular expressions +Group: Development/Libraries/C and C++ +Requires: pcre2-devel = %{version} + +%description devel-static +The PCRE2 library is a set of functions that implement regular +expression pattern matching using the same syntax and semantics +as Perl 5. + +PCRE2 is a re-working of the original PCRE library to provide an entirely new +API. + +This package contains static versions of the PCRE2 libraries. + +%package -n libpcre2-8-0 +Summary: A library for Perl-compatible regular expressions +Group: System/Libraries + +%description -n libpcre2-8-0 +The PCRE2 library is a set of functions that implement regular +expression pattern matching using the same syntax and semantics +as Perl 5. + +PCRE2 is a re-working of the original PCRE library to provide an entirely new +API. + +This PCRE2 library variant supports 8-bit and UTF-8 strings. +(See also libpcre2-16 and libpcre2-32) + +%package -n libpcre2-16-0 +Summary: A library for Perl-compatible regular expressions +Group: System/Libraries + +%description -n libpcre2-16-0 +The PCRE2 library is a set of functions that implement regular +expression pattern matching using the same syntax and semantics +as Perl 5. + +PCRE2 is a re-working of the original PCRE library to provide an entirely new +API. + +libpcre2-16 supports 16-bit and UTF-16 strings. + +%package -n libpcre2-32-0 +Summary: A library for Perl-compatible regular expressions +Group: System/Libraries + +%description -n libpcre2-32-0 +The PCRE2 library is a set of functions that implement regular +expression pattern matching using the same syntax and semantics +as Perl 5. + +PCRE2 is a re-working of the original PCRE library to provide an entirely new +API. + +libpcre2-32 supports 32-bit and UTF-32 strings. + +%package -n libpcre2-posix2 +Summary: A library for Perl-compatible regular expressions +Group: System/Libraries + +%description -n libpcre2-posix2 +The PCRE2 library is a set of functions that implement regular +expression pattern matching using the same syntax and semantics +as Perl 5. + +PCRE2 is a re-working of the original PCRE library to provide an entirely new +API. + +pcre2-posix provides a POSIX-compatible API to the PCRE2 engine. + +%package doc +Summary: A library for Perl-compatible regular expressions +Group: Documentation/HTML +BuildArch: noarch + +%description doc +The PCRE2 library is a set of functions that implement regular +expression pattern matching using the same syntax and semantics +as Perl 5. + +PCRE2 is a re-working of the original PCRE library to provide an entirely new +API. + +%package tools +Summary: A library for Perl-compatible regular expressions +Group: Productivity/Text/Utilities +Recommends: %{name}-doc + +%description tools +The PCRE2 library is a set of functions that implement regular +expression pattern matching using the same syntax and semantics +as Perl 5. + +PCRE2 is a re-working of the original PCRE library to provide an entirely new +API. + +%prep +%autosetup -p1 + +%build +%define _lto_cflags %{nil} +# Available JIT archs see sljit/sljitConfig.h +autoreconf -fiv +export LDFLAGS="-Wl,-z,relro,-z,now" +%configure \ +%ifarch %{ix86} x86_64 aarch64 %{arm} ppc ppc64 ppc64le mips sparc s390x + --enable-jit \ +%endif + --enable-static \ + --with-link-size=2 \ + --with-match-limit=10000000 \ + --enable-newline-is-lf \ + --enable-pcre2-16 \ + --enable-pcre2-32 \ + --enable-pcre2grep-libz \ + --enable-pcre2grep-libbz2 \ + --enable-pcre2test-libedit \ + --enable-unicode + +%if 0%{?do_profiling} + %make_build CFLAGS="%{optflags} %{cflags_profile_generate}" + export LANG=POSIX + # do not run profiling in parallel for reproducible builds (boo#1040589 boo#1102408) + %make_build CFLAGS="%{optflags} %{cflags_profile_generate}" check + %make_build clean + %make_build CFLAGS="%{optflags} %{cflags_profile_feedback}" +%else + %make_build CFLAGS="%{optflags}" +%endif + +%install +%make_install +mkdir -p %{buildroot}/%{_defaultdocdir} +mv %{buildroot}%{_datadir}/doc/pcre2 %{buildroot}/%{_defaultdocdir}/pcre2-doc +#empty dependecy_libs +find %{buildroot} -type f -name "*.la" -delete -print + +%check +export LANG=POSIX +%make_build check -j1 + +%post -n libpcre2-8-0 -p /sbin/ldconfig +%postun -n libpcre2-8-0 -p /sbin/ldconfig +%post -n libpcre2-16-0 -p /sbin/ldconfig +%postun -n libpcre2-16-0 -p /sbin/ldconfig +%post -n libpcre2-32-0 -p /sbin/ldconfig +%postun -n libpcre2-32-0 -p /sbin/ldconfig +%post -n libpcre2-posix2 -p /sbin/ldconfig +%postun -n libpcre2-posix2 -p /sbin/ldconfig + +%files -n libpcre2-8-0 +%license COPYING LICENCE +%doc AUTHORS ChangeLog NEWS README +%{_libdir}/libpcre2-8.so.* + +%files -n libpcre2-16-0 +%license LICENCE +%{_libdir}/libpcre2-16.so.* + +%files -n libpcre2-32-0 +%license LICENCE +%{_libdir}/libpcre2-32.so.* + +%files -n libpcre2-posix2 +%license LICENCE +%{_libdir}/libpcre2-posix.so.* + +%files tools +%license LICENCE +%{_bindir}/pcre2grep +%{_bindir}/pcre2test +%{_mandir}/man1/pcre2grep.1%{?ext_man} +%{_mandir}/man1/pcre2test.1%{?ext_man} + +%files doc +%license COPYING LICENCE +%doc AUTHORS ChangeLog NEWS README +%doc doc/html doc/*.txt +%doc %{_defaultdocdir}/pcre2-doc + +%files devel +%license LICENCE +%{_bindir}/pcre2-config +%{_includedir}/* +%{_libdir}/*.so +%{_libdir}/pkgconfig/libpcre2-8.pc +%{_libdir}/pkgconfig/libpcre2-16.pc +%{_libdir}/pkgconfig/libpcre2-32.pc +%{_libdir}/pkgconfig/libpcre2-posix.pc +%{_mandir}/man1/pcre2-config.1%{?ext_man} +%{_mandir}/man3/*%{ext_man} + +%files devel-static +%{_libdir}/*.a + +%changelog