From b05cdb491aff181a82c322152dd8c21ac76bdbc7c57e3d3696ba286894d0cb24 Mon Sep 17 00:00:00 2001 From: Dirk Mueller Date: Thu, 24 Mar 2022 19:18:12 +0000 Subject: [PATCH] OBS-URL: https://build.opensuse.org/package/show/Base:System/file?expand=0&rev=239 --- file-5.41-cache-regexps-locale-restore.patch | 255 ++++++++++++++----- 1 file changed, 195 insertions(+), 60 deletions(-) diff --git a/file-5.41-cache-regexps-locale-restore.patch b/file-5.41-cache-regexps-locale-restore.patch index 3012443..65120b6 100644 --- a/file-5.41-cache-regexps-locale-restore.patch +++ b/file-5.41-cache-regexps-locale-restore.patch @@ -1,101 +1,236 @@ -From c25329eabeaba048cb6ef1448d1ee040c62c415f Mon Sep 17 00:00:00 2001 -From: =?UTF-8?q?Dirk=20M=C3=BCller?= -Date: Tue, 22 Mar 2022 22:28:14 +0100 -Subject: [PATCH] Restore locale handling after regex caching +From 7d438e28c16773e28a3707935c8e5d9927a515a7 Mon Sep 17 00:00:00 2001 +From: Christos Zoulas +Date: Sat, 19 Mar 2022 19:52:09 +0000 +Subject: [PATCH] Now that we are cacheing regex's we cannot assume that we + always do regcomp->regexec->regfree, so this causes memory corruption (and + increased memory use with all the locale copies) in xlocale systems. Instead + save and restore locales in regcomp and regexec as needed. -file_regcomp/file_regfree had the side effect of setting and restoring -locale C_TYPE to C to have predictable regex matching. With regcomp -caching file_regfree has been changed to be only called at destruction -time, which means the library changed the locale setting for anything -else as well. Restore old behavior by splitting save/restore into -separate functions which are surrounding regcomp() and regexec() only. --- - src/funcs.c | 39 ++++++++++++++++++++++++++++++++------- - 1 file changed, 32 insertions(+), 7 deletions(-) + src/apprentice.c | 13 +++++++++-- + src/file.h | 18 +++++++-------- + src/funcs.c | 57 +++++++++++++++++++++++++++++------------------- + src/softmagic.c | 11 +++++----- + 4 files changed, 59 insertions(+), 40 deletions(-) -diff --git a/src/funcs.c b/src/funcs.c -index dcfd352d..7ecaff33 100644 ---- a/src/funcs.c -+++ b/src/funcs.c -@@ -658,35 +658,62 @@ out: - return rv; +Index: file-5.41/src/apprentice.c +=================================================================== +--- file-5.41.orig/src/apprentice.c ++++ file-5.41/src/apprentice.c +@@ -516,6 +516,9 @@ file_ms_free(struct magic_set *ms) + free(ms->o.pbuf); + free(ms->o.buf); + free(ms->c.li); ++#ifdef USE_C_LOCALE ++ freelocale(ms->c_lc_ctype); ++#endif + free(ms); } -+static void -+file_reg_set_ctype(file_regex_t *rx) -+{ +@@ -555,6 +558,10 @@ file_ms_alloc(int flags) + ms->regex_max = FILE_REGEX_MAX; + ms->bytes_max = FILE_BYTES_MAX; + ms->encoding_max = FILE_ENCODING_MAX; +#ifdef USE_C_LOCALE -+ rx->old_lc_ctype = uselocale(rx->c_lc_ctype); -+ assert(rx->old_lc_ctype != NULL); -+#else -+ (void)setlocale(LC_CTYPE, "C"); ++ ms->c_lc_ctype = newlocale(LC_CTYPE_MASK, "C", 0); ++ assert(ms->c_lc_ctype != NULL); +#endif -+} -+ -+static void -+file_reg_restore_ctype(file_regex_t *rx) -+{ -+#ifdef USE_C_LOCALE -+ (void)uselocale(rx->old_lc_ctype); -+#else -+ (void)setlocale(LC_CTYPE, rx->old_lc_ctype); + return ms; + free: + free(ms); +@@ -628,6 +635,7 @@ mlist_free_one(struct mlist *ml) + if (ml->magic_rxcomp[i]) { + file_regfree(ml->magic_rxcomp[i]); + free(ml->magic_rxcomp[i]); ++ ml->magic_rxcomp[i] = NULL; + } + } + free(ml->magic_rxcomp); +@@ -2741,7 +2749,8 @@ getvalue(struct magic_set *ms, struct ma + } + if (m->type == FILE_REGEX) { + file_regex_t rx; +- int rc = file_regcomp(&rx, m->value.s, REG_EXTENDED); ++ int rc = file_regcomp(ms, &rx, m->value.s, ++ REG_EXTENDED); + if (rc) { + if (ms->flags & MAGIC_CHECK) + file_regerror(&rx, rc, ms); +Index: file-5.41/src/file.h +=================================================================== +--- file-5.41.orig/src/file.h ++++ file-5.41/src/file.h +@@ -173,13 +173,6 @@ + + typedef struct { + const char *pat; +-#if defined(HAVE_NEWLOCALE) && defined(HAVE_USELOCALE) && defined(HAVE_FREELOCALE) +-#define USE_C_LOCALE +- locale_t old_lc_ctype; +- locale_t c_lc_ctype; +-#else +- char *old_lc_ctype; +-#endif + int rc; + regex_t rx; + } file_regex_t; +@@ -495,6 +488,10 @@ struct magic_set { + #define FILE_NAME_MAX 50 + #define FILE_REGEX_MAX 8192 + #define FILE_ENCODING_MAX (64 * 1024) ++#if defined(HAVE_NEWLOCALE) && defined(HAVE_USELOCALE) && defined(HAVE_FREELOCALE) ++#define USE_C_LOCALE ++ locale_t c_lc_ctype; +#endif -+} -+ + }; + + /* Type for Unicode characters */ +@@ -588,9 +585,10 @@ protected int buffer_fill(const struct b + + + +-protected int file_regcomp(file_regex_t *, const char *, int); +-protected int file_regexec(file_regex_t *, const char *, size_t, regmatch_t *, ++protected int file_regcomp(struct magic_set *, file_regex_t *, const char *, + int); ++protected int file_regexec(struct magic_set *, file_regex_t *, const char *, ++ size_t, regmatch_t *, int); + protected void file_regfree(file_regex_t *); + protected void file_regerror(file_regex_t *, int, struct magic_set *); + +Index: file-5.41/src/funcs.c +=================================================================== +--- file-5.41.orig/src/funcs.c ++++ file-5.41/src/funcs.c +@@ -634,13 +634,13 @@ file_replace(struct magic_set *ms, const + file_regex_t rx; + int rc, rv = -1; + +- rc = file_regcomp(&rx, pat, REG_EXTENDED); ++ rc = file_regcomp(ms, &rx, pat, REG_EXTENDED); + if (rc) { + file_regerror(&rx, rc, ms); + } else { + regmatch_t rm; + int nm = 0; +- while (file_regexec(&rx, ms->o.buf, 1, &rm, 0) == 0) { ++ while (file_regexec(ms, &rx, ms->o.buf, 1, &rm, 0) == 0) { + ms->o.buf[rm.rm_so] = '\0'; + if (file_printf(ms, "%s%s", rep, + rm.rm_eo != 0 ? ms->o.buf + rm.rm_eo : "") == -1) +@@ -655,34 +655,52 @@ out: + } + protected int - file_regcomp(file_regex_t *rx, const char *pat, int flags) +-file_regcomp(file_regex_t *rx, const char *pat, int flags) ++file_regcomp(struct magic_set *ms, file_regex_t *rx, const char *pat, int flags) { #ifdef USE_C_LOCALE - rx->c_lc_ctype = newlocale(LC_CTYPE_MASK, "C", 0); - assert(rx->c_lc_ctype != NULL); +- rx->c_lc_ctype = newlocale(LC_CTYPE_MASK, "C", 0); +- assert(rx->c_lc_ctype != NULL); - rx->old_lc_ctype = uselocale(rx->c_lc_ctype); - assert(rx->old_lc_ctype != NULL); ++ locale_t old = uselocale(ms->c_lc_ctype); ++ assert(old != NULL); #else - rx->old_lc_ctype = setlocale(LC_CTYPE, NULL); - assert(rx->old_lc_ctype != NULL); - rx->old_lc_ctype = strdup(rx->old_lc_ctype); - assert(rx->old_lc_ctype != NULL); -- (void)setlocale(LC_CTYPE, "C"); +- rx->old_lc_ctype = setlocale(LC_CTYPE, NULL); +- assert(rx->old_lc_ctype != NULL); +- rx->old_lc_ctype = strdup(rx->old_lc_ctype); +- assert(rx->old_lc_ctype != NULL); ++ char old[1024]; ++ strlcpy(old, setlocale(LC_CTYPE, NULL), sizeof(old)); + (void)setlocale(LC_CTYPE, "C"); #endif rx->pat = pat; - return rx->rc = regcomp(&rx->rx, pat, flags); -+ file_reg_set_ctype(rx); + rx->rc = regcomp(&rx->rx, pat, flags); -+ file_reg_restore_ctype(rx); + ++#ifdef USE_C_LOCALE ++ uselocale(old); ++#else ++ (void)setlocale(LC_CTYPE, old); ++#endif + return rx->rc; } protected int - file_regexec(file_regex_t *rx, const char *str, size_t nmatch, - regmatch_t* pmatch, int eflags) +-file_regexec(file_regex_t *rx, const char *str, size_t nmatch, +- regmatch_t* pmatch, int eflags) ++file_regexec(struct magic_set *ms, file_regex_t *rx, const char *str, ++ size_t nmatch, regmatch_t* pmatch, int eflags) { ++#ifdef USE_C_LOCALE ++ locale_t old = uselocale(ms->c_lc_ctype); ++ assert(old != NULL); ++#else ++ char old[1024]; ++ strlcpy(old, setlocale(LC_CTYPE, NULL), sizeof(old)); ++ (void)setlocale(LC_CTYPE, "C"); ++#endif + int rc; assert(rx->rc == 0); /* XXX: force initialization because glibc does not always do this */ if (nmatch != 0) memset(pmatch, 0, nmatch * sizeof(*pmatch)); - return regexec(&rx->rx, str, nmatch, pmatch, eflags); -+ file_reg_set_ctype(rx); + rc = regexec(&rx->rx, str, nmatch, pmatch, eflags); -+ file_reg_restore_ctype(rx); -+ ++#ifdef USE_C_LOCALE ++ uselocale(old); ++#else ++ (void)setlocale(LC_CTYPE, old); ++#endif + return rc; } protected void -@@ -695,10 +722,8 @@ file_regfree(file_regex_t *rx) +@@ -690,13 +708,6 @@ file_regfree(file_regex_t *rx) + { if (rx->rc == 0) regfree(&rx->rx); - #ifdef USE_C_LOCALE +-#ifdef USE_C_LOCALE - (void)uselocale(rx->old_lc_ctype); - freelocale(rx->c_lc_ctype); - #else +- freelocale(rx->c_lc_ctype); +-#else - (void)setlocale(LC_CTYPE, rx->old_lc_ctype); - free(rx->old_lc_ctype); - #endif +- free(rx->old_lc_ctype); +-#endif } --- -2.35.1 - + + protected void +Index: file-5.41/src/softmagic.c +=================================================================== +--- file-5.41.orig/src/softmagic.c ++++ file-5.41/src/softmagic.c +@@ -479,11 +479,11 @@ check_fmt(struct magic_set *ms, const ch + if (strchr(fmt, '%') == NULL) + return 0; + +- rc = file_regcomp(&rx, "%[-0-9\\.]*s", REG_EXTENDED|REG_NOSUB); ++ rc = file_regcomp(ms, &rx, "%[-0-9\\.]*s", REG_EXTENDED|REG_NOSUB); + if (rc) { + file_regerror(&rx, rc, ms); + } else { +- rc = file_regexec(&rx, fmt, 0, 0, 0); ++ rc = file_regexec(ms, &rx, fmt, 0, 0, 0); + rv = !rc; + } + file_regfree(&rx); +@@ -2192,7 +2192,7 @@ magiccheck(struct magic_set *ms, struct + + if (rx == NULL) { + rx = *m_cache = CAST(file_regex_t*, malloc(sizeof(file_regex_t))); +- rc = file_regcomp(rx, m->value.s, ++ rc = file_regcomp(ms, rx, m->value.s, + REG_EXTENDED|REG_NEWLINE| + ((m->str_flags & STRING_IGNORE_CASE) ? REG_ICASE : 0)); + if (rc) { +@@ -2222,7 +2222,7 @@ magiccheck(struct magic_set *ms, struct + search = CCAST(char *, ""); + copy = NULL; + } +- rc = file_regexec(rx, RCAST(const char *, search), ++ rc = file_regexec(ms, rx, RCAST(const char *, search), + 1, &pmatch, 0); + free(copy); + switch (rc) {