pool/file
SHA256
4
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

OBS-URL: https://build.opensuse.org/package/show/Base:System/file?expand=0&rev=239

Browse Source
This commit is contained in:
Dirk Mueller 2022-03-24 19:18:12 +00:00 committed by Git OBS Bridge
parent 47e53e9dcf
commit 03ac71daa8
1 changed files with 195 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

255
file-5.41-cache-regexps-locale-restore.patch
View File

@ -1,101 +1,236 @@
From c25329eabeaba048cb6ef1448d1ee040c62c415f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dirk=20M=C3=BCller?= <dirk@dmllr.de>
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 <christos@zoulas.com>
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) {