Compare commits
No commits in common. 'i10c-beta' and 'c9' have entirely different histories.
@ -1 +1 @@
|
||||
c16a9cf107ad1f0f791b6d00852dc5e961c1c451 SOURCES/diffutils-3.10.tar.xz
|
||||
ad4e0a05ee2e7f5529db6cb84474f45e086e609b SOURCES/diffutils-3.7.tar.xz
|
||||
|
||||
@ -1 +1 @@
|
||||
SOURCES/diffutils-3.10.tar.xz
|
||||
SOURCES/diffutils-3.7.tar.xz
|
||||
|
||||
@ -1,31 +0,0 @@
|
||||
diff --git a/src/cmp.c b/src/cmp.c
|
||||
index 4bf0a4c..936125c 100644
|
||||
--- a/src/cmp.c
|
||||
+++ b/src/cmp.c
|
||||
@@ -338,13 +338,14 @@ main (int argc, char **argv)
|
||||
}
|
||||
|
||||
/* If only a return code is needed,
|
||||
- and if both input descriptors are associated with plain files,
|
||||
+ and both input descriptors are associated with plain files,
|
||||
+ and the file sizes are nonzero so they are not Linux /proc files,
|
||||
conclude that the files differ if they have different sizes
|
||||
and if more bytes will be compared than are in the smaller file. */
|
||||
|
||||
if (comparison_type == type_status
|
||||
- && 0 <= stat_buf[0].st_size && S_ISREG (stat_buf[0].st_mode)
|
||||
- && 0 <= stat_buf[1].st_size && S_ISREG (stat_buf[1].st_mode))
|
||||
+ && 0 < stat_buf[0].st_size && S_ISREG (stat_buf[0].st_mode)
|
||||
+ && 0 < stat_buf[1].st_size && S_ISREG (stat_buf[1].st_mode))
|
||||
{
|
||||
off_t s0 = stat_buf[0].st_size - file_position (0);
|
||||
off_t s1 = stat_buf[1].st_size - file_position (1);
|
||||
@@ -401,7 +402,7 @@ cmp (void)
|
||||
? bytes : TYPE_MAXIMUM (off_t));
|
||||
|
||||
for (f = 0; f < 2; f++)
|
||||
- if (0 <= stat_buf[f].st_size && S_ISREG (stat_buf[f].st_mode))
|
||||
+ if (0 < stat_buf[f].st_size && S_ISREG (stat_buf[f].st_mode))
|
||||
{
|
||||
off_t file_bytes = stat_buf[f].st_size - file_position (f);
|
||||
if (file_bytes < byte_number_max)
|
||||
@ -1,184 +0,0 @@
|
||||
diff -up diffutils-3.10/lib/nstrftime.c.orig diffutils-3.10/lib/nstrftime.c
|
||||
--- diffutils-3.10/lib/nstrftime.c.orig 2023-05-20 11:05:07.000000000 +0200
|
||||
+++ diffutils-3.10/lib/nstrftime.c 2024-07-30 16:36:42.914438967 +0200
|
||||
@@ -882,6 +882,7 @@ __strftime_internal (STREAM_OR_CHAR_T *s
|
||||
*u = '\0';
|
||||
len = strftime (ubuf, sizeof ubuf, ufmt, tp);
|
||||
if (len != 0)
|
||||
+ /* coverity[verrun-buffer-arg: FALSE] */
|
||||
cpy (len - 1, ubuf + 1);
|
||||
}
|
||||
break;
|
||||
@@ -1044,10 +1045,13 @@ __strftime_internal (STREAM_OR_CHAR_T *s
|
||||
i += padding;
|
||||
width -= padding;
|
||||
}
|
||||
+ /* coverity[bad_memset : FALSE] */
|
||||
+ /* coverity[overrun-buffer-arg : FALSE] */
|
||||
width_add1 (0, sign_char);
|
||||
width--;
|
||||
}
|
||||
|
||||
+ /* coverity[bad_memset : FALSE] */
|
||||
cpy (numlen, bufp);
|
||||
}
|
||||
break;
|
||||
@@ -1126,7 +1130,9 @@ __strftime_internal (STREAM_OR_CHAR_T *s
|
||||
buf[j - 1] = n % 10 + L_('0'), n /= 10;
|
||||
if (!pad)
|
||||
pad = L_('0');
|
||||
+ /* coverity[bad_memset : FALSE] */
|
||||
width_cpy (0, ndigs, buf);
|
||||
+ /* coverity[bad_memset : FALSE] */
|
||||
width_add (width - ndigs, 0, (void) 0);
|
||||
}
|
||||
break;
|
||||
@@ -1495,6 +1501,7 @@ __strftime_internal (STREAM_OR_CHAR_T *s
|
||||
since this is most likely the right thing to do if a
|
||||
multibyte string has been misparsed. */
|
||||
bad_format:
|
||||
+ /* coverity[bad_memset : FALSE] */
|
||||
cpy (f - percent + 1, percent);
|
||||
break;
|
||||
}
|
||||
diff -up diffutils-3.10/lib/regcomp.c.orig diffutils-3.10/lib/regcomp.c
|
||||
--- diffutils-3.10/lib/regcomp.c.orig 2024-07-30 16:42:46.745614022 +0200
|
||||
+++ diffutils-3.10/lib/regcomp.c 2024-07-30 16:45:16.815548192 +0200
|
||||
@@ -1175,6 +1175,8 @@ analyze (regex_t *preg)
|
||||
dfa->inveclosures = re_malloc (re_node_set, dfa->nodes_len);
|
||||
if (__glibc_unlikely (dfa->inveclosures == NULL))
|
||||
return REG_ESPACE;
|
||||
+ /* The 'postorder' function initializes that memory */
|
||||
+ /* coverity[alloc_fn: FALSE] */
|
||||
ret = calc_inveclosure (dfa);
|
||||
}
|
||||
|
||||
diff -up diffutils-3.10/lib/sigsegv.c.orig diffutils-3.10/lib/sigsegv.c
|
||||
--- diffutils-3.10/lib/sigsegv.c.orig 2023-05-20 11:05:07.000000000 +0200
|
||||
+++ diffutils-3.10/lib/sigsegv.c 2024-07-30 16:36:42.914438967 +0200
|
||||
@@ -1459,6 +1459,7 @@ stackoverflow_deinstall_handler (void)
|
||||
{
|
||||
stack_t ss;
|
||||
ss.ss_flags = SS_DISABLE;
|
||||
+ /* coverity[uninit_use_in_call : FALSE] */
|
||||
if (sigaltstack (&ss, (stack_t *) 0) < 0)
|
||||
perror ("gnulib sigsegv (stackoverflow_deinstall_handler)");
|
||||
}
|
||||
diff -up diffutils-3.10/lib/stackvma.c.orig diffutils-3.10/lib/stackvma.c
|
||||
--- diffutils-3.10/lib/stackvma.c.orig 2023-01-30 01:17:41.000000000 +0100
|
||||
+++ diffutils-3.10/lib/stackvma.c 2024-07-30 16:38:45.404872853 +0200
|
||||
@@ -176,7 +176,7 @@ rof_open (struct rofile *rof, const char
|
||||
/* Attempt to read the contents in a single system call. */
|
||||
if (size > MIN_LEFTOVER)
|
||||
{
|
||||
- int n = read (fd, rof->buffer, size);
|
||||
+ size_t n = read (fd, rof->buffer, size);
|
||||
if (n < 0 && errno == EINTR)
|
||||
goto retry;
|
||||
# if defined __DragonFly__
|
||||
@@ -186,7 +186,7 @@ rof_open (struct rofile *rof, const char
|
||||
if (n <= 0)
|
||||
/* Empty file. */
|
||||
goto fail1;
|
||||
- if (n + MIN_LEFTOVER <= size)
|
||||
+ if (MIN_LEFTOVER <= size -n)
|
||||
{
|
||||
/* The buffer was sufficiently large. */
|
||||
rof->filled = n;
|
||||
@@ -195,21 +195,23 @@ rof_open (struct rofile *rof, const char
|
||||
large enough. We need the equivalent of full_read(). */
|
||||
for (;;)
|
||||
{
|
||||
+ /* rof->filled cannot exceed size (due to the buffer size check), the subtraction is unlikely to overflow. */
|
||||
+ /* coverity[overflow_sink : FALSE] */
|
||||
n = read (fd, rof->buffer + rof->filled, size - rof->filled);
|
||||
if (n < 0 && errno == EINTR)
|
||||
goto retry;
|
||||
if (n < 0)
|
||||
/* Some error. */
|
||||
goto fail1;
|
||||
- if (n + MIN_LEFTOVER > size - rof->filled)
|
||||
- /* Allocate a larger buffer. */
|
||||
- break;
|
||||
if (n == 0)
|
||||
{
|
||||
/* Reached the end of file. */
|
||||
close (fd);
|
||||
return 0;
|
||||
}
|
||||
+ if (size - rof->filled - n < MIN_LEFTOVER)
|
||||
+ /* Allocate a larger buffer. */
|
||||
+ break;
|
||||
rof->filled += n;
|
||||
}
|
||||
# else
|
||||
diff -up diffutils-3.10/lib/time_rz.c.orig diffutils-3.10/lib/time_rz.c
|
||||
--- diffutils-3.10/lib/time_rz.c.orig 2023-01-02 02:20:08.000000000 +0100
|
||||
+++ diffutils-3.10/lib/time_rz.c 2024-07-30 16:36:42.914438967 +0200
|
||||
@@ -303,10 +303,12 @@ mktime_z (timezone_t tz, struct tm *tm)
|
||||
time_t t = mktime (&tm_1);
|
||||
bool ok = 0 <= tm_1.tm_yday;
|
||||
#if HAVE_STRUCT_TM_TM_ZONE || HAVE_TZNAME
|
||||
+ /* coverity[uninit_use_in_call : FALSE] */
|
||||
ok = ok && save_abbr (tz, &tm_1);
|
||||
#endif
|
||||
if (revert_tz (old_tz) && ok)
|
||||
{
|
||||
+ /* coverity[uninit_use : FALSE] */
|
||||
*tm = tm_1;
|
||||
return t;
|
||||
}
|
||||
diff -up diffutils-3.10/src/analyze.c.orig diffutils-3.10/src/analyze.c
|
||||
--- diffutils-3.10/src/analyze.c.orig 2023-05-20 11:17:26.000000000 +0200
|
||||
+++ diffutils-3.10/src/analyze.c 2024-07-30 16:36:42.915438987 +0200
|
||||
@@ -689,6 +689,7 @@ diff_2_files (struct comparison *cmp)
|
||||
for (f = 0; f < 2; f++)
|
||||
{
|
||||
free (cmp->file[f].equivs);
|
||||
+ /* coverity[offset_free : FALSE] */
|
||||
free (cmp->file[f].linbuf + cmp->file[f].linbuf_base);
|
||||
}
|
||||
|
||||
diff -up diffutils-3.10/src/diff3.c.orig diffutils-3.10/src/diff3.c
|
||||
--- diffutils-3.10/src/diff3.c.orig 2023-05-20 11:17:26.000000000 +0200
|
||||
+++ diffutils-3.10/src/diff3.c 2024-07-30 16:36:42.915438987 +0200
|
||||
@@ -798,6 +798,8 @@ using_to_diff3_block (struct diff_block
|
||||
D_LINEARRAY (result, FILEC) + result_offset,
|
||||
D_LENARRAY (result, FILEC) + result_offset,
|
||||
D_NUMLINES (ptr, FC)))
|
||||
+ /* There is a potential resource leak here, but it is not important */
|
||||
+ /* coverity[leaked_storage : FALSE] */
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -827,6 +829,8 @@ using_to_diff3_block (struct diff_block
|
||||
D_LINEARRAY (result, FILE0 + d) + result_offset,
|
||||
D_LENARRAY (result, FILE0 + d) + result_offset,
|
||||
D_NUMLINES (ptr, FO)))
|
||||
+ /* There is a potential resource leak here, but it is not important */
|
||||
+ /* coverity[leaked_storage : FALSE] */
|
||||
return 0;
|
||||
|
||||
/* Catch the lines between here and the next diff */
|
||||
diff -up diffutils-3.10/src/diff.c.orig diffutils-3.10/src/diff.c
|
||||
--- diffutils-3.10/src/diff.c.orig 2024-07-30 16:35:17.766783183 +0200
|
||||
+++ diffutils-3.10/src/diff.c 2024-07-30 16:36:42.915438987 +0200
|
||||
@@ -429,6 +429,7 @@ main (int argc, char **argv)
|
||||
sizeof C_ifdef_group_formats - 7 /* 7*"@" */,
|
||||
&alloc))
|
||||
xalloc_die ();
|
||||
+ /* coverity[alloc_strlen : FALSE] */
|
||||
char *b = xmalloc (alloc);
|
||||
char *base = b;
|
||||
int changes = 0;
|
||||
diff -up diffutils-3.10/src/ifdef.c.orig diffutils-3.10/src/ifdef.c
|
||||
--- diffutils-3.10/src/ifdef.c.orig 2023-02-19 19:04:39.000000000 +0100
|
||||
+++ diffutils-3.10/src/ifdef.c 2024-07-30 16:36:42.915438987 +0200
|
||||
@@ -361,6 +361,7 @@ do_printf_spec (FILE *out, char const *s
|
||||
format spec "%3lx". Here the spec prefix is "%3". */
|
||||
size_t spec_prefix_len = f - spec - 2;
|
||||
size_t pI_len = sizeof pI - 1;
|
||||
+ /* coverity[bad_alloc_arithmetic : FALSE] */
|
||||
char *format = xmalloca (spec_prefix_len + pI_len + 2);
|
||||
char *p = mempcpy (format, spec, spec_prefix_len);
|
||||
p = stpcpy (p, pI);
|
||||
@ -0,0 +1,315 @@
|
||||
diff -up diffutils-3.7/lib/careadlinkat.c.me diffutils-3.7/lib/careadlinkat.c
|
||||
--- diffutils-3.7/lib/careadlinkat.c.me 2021-03-23 23:19:06.957542021 +0100
|
||||
+++ diffutils-3.7/lib/careadlinkat.c 2021-03-23 23:22:29.309145314 +0100
|
||||
@@ -1,6 +1,6 @@
|
||||
/* Read symbolic links into a buffer without size limitation, relative to fd.
|
||||
|
||||
- Copyright (C) 2001, 2003-2004, 2007, 2009-2018 Free Software Foundation,
|
||||
+ Copyright (C) 2001, 2003-2004, 2007, 2009-2021 Free Software Foundation,
|
||||
Inc.
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
@@ -38,75 +38,64 @@
|
||||
|
||||
#include "allocator.h"
|
||||
|
||||
-/* Assuming the current directory is FD, get the symbolic link value
|
||||
- of FILENAME as a null-terminated string and put it into a buffer.
|
||||
- If FD is AT_FDCWD, FILENAME is interpreted relative to the current
|
||||
- working directory, as in openat.
|
||||
-
|
||||
- If the link is small enough to fit into BUFFER put it there.
|
||||
- BUFFER's size is BUFFER_SIZE, and BUFFER can be null
|
||||
- if BUFFER_SIZE is zero.
|
||||
-
|
||||
- If the link is not small, put it into a dynamically allocated
|
||||
- buffer managed by ALLOC. It is the caller's responsibility to free
|
||||
- the returned value if it is nonnull and is not BUFFER. A null
|
||||
- ALLOC stands for the standard allocator.
|
||||
-
|
||||
- The PREADLINKAT function specifies how to read links. It operates
|
||||
- like POSIX readlinkat()
|
||||
- <http://pubs.opengroup.org/onlinepubs/9699919799/functions/readlink.html>
|
||||
- but can assume that its first argument is the same as FD.
|
||||
+enum { STACK_BUF_SIZE = 1024 };
|
||||
|
||||
- If successful, return the buffer address; otherwise return NULL and
|
||||
- set errno. */
|
||||
+/* Act like careadlinkat (see below), with an additional argument
|
||||
+ STACK_BUF that can be used as temporary storage.
|
||||
|
||||
-char *
|
||||
-careadlinkat (int fd, char const *filename,
|
||||
+ If GCC_LINT is defined, do not inline this function with GCC 10.1
|
||||
+ and later, to avoid creating a pointer to the stack that GCC
|
||||
+ -Wreturn-local-addr incorrectly complains about. See:
|
||||
+ https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93644
|
||||
+ Although the noinline attribute can hurt performance a bit, no better way
|
||||
+ to pacify GCC is known; even an explicit #pragma does not pacify GCC.
|
||||
+ When the GCC bug is fixed this workaround should be limited to the
|
||||
+ broken GCC versions. */
|
||||
+#if __GNUC_PREREQ (10, 1)
|
||||
+# if defined GCC_LINT || defined lint
|
||||
+__attribute__ ((__noinline__))
|
||||
+# elif __OPTIMIZE__ && !__NO_INLINE__
|
||||
+# define GCC_BOGUS_WRETURN_LOCAL_ADDR
|
||||
+# endif
|
||||
+#endif
|
||||
+static char *
|
||||
+readlink_stk (int fd, char const *filename,
|
||||
char *buffer, size_t buffer_size,
|
||||
struct allocator const *alloc,
|
||||
- ssize_t (*preadlinkat) (int, char const *, char *, size_t))
|
||||
+ ssize_t (*preadlinkat) (int, char const *, char *, size_t),
|
||||
+ char stack_buf[STACK_BUF_SIZE])
|
||||
{
|
||||
char *buf;
|
||||
size_t buf_size;
|
||||
size_t buf_size_max =
|
||||
SSIZE_MAX < SIZE_MAX ? (size_t) SSIZE_MAX + 1 : SIZE_MAX;
|
||||
- char stack_buf[1024];
|
||||
|
||||
if (! alloc)
|
||||
alloc = &stdlib_allocator;
|
||||
|
||||
- if (! buffer_size)
|
||||
+ if (!buffer)
|
||||
{
|
||||
- /* Allocate the initial buffer on the stack. This way, in the
|
||||
- common case of a symlink of small size, we get away with a
|
||||
- single small malloc() instead of a big malloc() followed by a
|
||||
- shrinking realloc(). */
|
||||
buffer = stack_buf;
|
||||
- buffer_size = sizeof stack_buf;
|
||||
+ buffer_size = STACK_BUF_SIZE;
|
||||
}
|
||||
|
||||
buf = buffer;
|
||||
buf_size = buffer_size;
|
||||
|
||||
- do
|
||||
+ while (buf)
|
||||
{
|
||||
/* Attempt to read the link into the current buffer. */
|
||||
ssize_t link_length = preadlinkat (fd, filename, buf, buf_size);
|
||||
size_t link_size;
|
||||
if (link_length < 0)
|
||||
{
|
||||
- /* On AIX 5L v5.3 and HP-UX 11i v2 04/09, readlink returns -1
|
||||
- with errno == ERANGE if the buffer is too small. */
|
||||
- int readlinkat_errno = errno;
|
||||
- if (readlinkat_errno != ERANGE)
|
||||
+ if (buf != buffer)
|
||||
{
|
||||
- if (buf != buffer)
|
||||
- {
|
||||
- alloc->free (buf);
|
||||
- errno = readlinkat_errno;
|
||||
- }
|
||||
- return NULL;
|
||||
+ int readlinkat_errno = errno;
|
||||
+ alloc->free (buf);
|
||||
+ errno = readlinkat_errno;
|
||||
}
|
||||
+ return NULL;
|
||||
}
|
||||
|
||||
link_size = link_length;
|
||||
@@ -117,19 +106,19 @@ careadlinkat (int fd, char const *filena
|
||||
|
||||
if (buf == stack_buf)
|
||||
{
|
||||
- char *b = (char *) alloc->allocate (link_size);
|
||||
+ char *b = alloc->allocate (link_size);
|
||||
buf_size = link_size;
|
||||
if (! b)
|
||||
break;
|
||||
- memcpy (b, buf, link_size);
|
||||
- buf = b;
|
||||
+ return memcpy (b, buf, link_size);
|
||||
}
|
||||
- else if (link_size < buf_size && buf != buffer && alloc->reallocate)
|
||||
+
|
||||
+ if (link_size < buf_size && buf != buffer && alloc->reallocate)
|
||||
{
|
||||
/* Shrink BUF before returning it. */
|
||||
- char *b = (char *) alloc->reallocate (buf, link_size);
|
||||
+ char *b = alloc->reallocate (buf, link_size);
|
||||
if (b)
|
||||
- buf = b;
|
||||
+ return b;
|
||||
}
|
||||
|
||||
return buf;
|
||||
@@ -138,8 +127,8 @@ careadlinkat (int fd, char const *filena
|
||||
if (buf != buffer)
|
||||
alloc->free (buf);
|
||||
|
||||
- if (buf_size <= buf_size_max / 2)
|
||||
- buf_size *= 2;
|
||||
+ if (buf_size < buf_size_max / 2)
|
||||
+ buf_size = 2 * buf_size + 1;
|
||||
else if (buf_size < buf_size_max)
|
||||
buf_size = buf_size_max;
|
||||
else if (buf_size_max < SIZE_MAX)
|
||||
@@ -149,12 +138,53 @@ careadlinkat (int fd, char const *filena
|
||||
}
|
||||
else
|
||||
break;
|
||||
- buf = (char *) alloc->allocate (buf_size);
|
||||
+ buf = alloc->allocate (buf_size);
|
||||
}
|
||||
- while (buf);
|
||||
|
||||
if (alloc->die)
|
||||
alloc->die (buf_size);
|
||||
errno = ENOMEM;
|
||||
return NULL;
|
||||
}
|
||||
+
|
||||
+
|
||||
+/* Assuming the current directory is FD, get the symbolic link value
|
||||
+ of FILENAME as a null-terminated string and put it into a buffer.
|
||||
+ If FD is AT_FDCWD, FILENAME is interpreted relative to the current
|
||||
+ working directory, as in openat.
|
||||
+
|
||||
+ If the link is small enough to fit into BUFFER put it there.
|
||||
+ BUFFER's size is BUFFER_SIZE, and BUFFER can be null
|
||||
+ if BUFFER_SIZE is zero.
|
||||
+
|
||||
+ If the link is not small, put it into a dynamically allocated
|
||||
+ buffer managed by ALLOC. It is the caller's responsibility to free
|
||||
+ the returned value if it is nonnull and is not BUFFER. A null
|
||||
+ ALLOC stands for the standard allocator.
|
||||
+
|
||||
+ The PREADLINKAT function specifies how to read links. It operates
|
||||
+ like POSIX readlinkat()
|
||||
+ <https://pubs.opengroup.org/onlinepubs/9699919799/functions/readlink.html>
|
||||
+ but can assume that its first argument is the same as FD.
|
||||
+
|
||||
+ If successful, return the buffer address; otherwise return NULL and
|
||||
+ set errno. */
|
||||
+
|
||||
+char *
|
||||
+careadlinkat (int fd, char const *filename,
|
||||
+ char *buffer, size_t buffer_size,
|
||||
+ struct allocator const *alloc,
|
||||
+ ssize_t (*preadlinkat) (int, char const *, char *, size_t))
|
||||
+{
|
||||
+ /* Allocate the initial buffer on the stack. This way, in the
|
||||
+ common case of a symlink of small size, we get away with a
|
||||
+ single small malloc instead of a big malloc followed by a
|
||||
+ shrinking realloc. */
|
||||
+ #ifdef GCC_BOGUS_WRETURN_LOCAL_ADDR
|
||||
+ #warning "GCC might issue a bogus -Wreturn-local-addr warning here."
|
||||
+ #warning "See <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93644>."
|
||||
+ #endif
|
||||
+ char stack_buf[STACK_BUF_SIZE];
|
||||
+ return readlink_stk (fd, filename, buffer, buffer_size, alloc,
|
||||
+ preadlinkat, stack_buf);
|
||||
+}
|
||||
diff -up diffutils-3.7/src/diff.c.me diffutils-3.7/src/diff.c
|
||||
diff -up diffutils-3.7/src/diff.h.me diffutils-3.7/src/diff.h
|
||||
--- diffutils-3.7/src/diff.h.me 2021-03-23 22:47:04.509390138 +0100
|
||||
+++ diffutils-3.7/src/diff.h 2021-03-23 22:58:35.022552755 +0100
|
||||
@@ -392,7 +392,7 @@ extern void print_sdiff_script (struct c
|
||||
extern char const change_letter[4];
|
||||
extern char const pr_program[];
|
||||
extern char *concat (char const *, char const *, char const *);
|
||||
-extern bool (*lines_differ) (char const *, size_t, char const *, size_t) _GL_ATTRIBUTE_PURE;
|
||||
+extern bool (*lines_differ) (char const *, size_t, char const *, size_t);
|
||||
extern bool lines_differ_singlebyte (char const *, size_t, char const *, size_t) _GL_ATTRIBUTE_PURE;
|
||||
#ifdef HANDLE_MULTIBYTE
|
||||
extern bool lines_differ_multibyte (char const *, size_t, char const *, size_t) _GL_ATTRIBUTE_PURE;
|
||||
diff -up diffutils-3.7/src/util.c.me diffutils-3.7/src/util.c
|
||||
--- diffutils-3.7/src/util.c.me 2021-03-23 23:01:58.105168496 +0100
|
||||
+++ diffutils-3.7/src/util.c 2021-03-23 23:18:18.833918967 +0100
|
||||
@@ -1144,6 +1144,7 @@ lines_differ_singlebyte (char const *s1,
|
||||
}
|
||||
|
||||
#ifdef HANDLE_MULTIBYTE
|
||||
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
|
||||
# define MBC2WC(T, END, MBLENGTH, WC, STATE, CONVFAIL) \
|
||||
do \
|
||||
{ \
|
||||
diff -up diffutils-3.7/lib/regcomp.c.me diffutils-3.7/lib/regcomp.c
|
||||
--- diffutils-3.7/lib/regcomp.c.me 2021-03-24 09:01:20.582271604 +0100
|
||||
+++ diffutils-3.7/lib/regcomp.c 2021-03-24 09:03:54.125287605 +0100
|
||||
@@ -3674,7 +3674,6 @@ build_charclass_op (re_dfa_t *dfa, RE_TR
|
||||
Idx alloc = 0;
|
||||
#endif /* not RE_ENABLE_I18N */
|
||||
reg_errcode_t ret;
|
||||
- re_token_t br_token;
|
||||
bin_tree_t *tree;
|
||||
|
||||
sbcset = (re_bitset_ptr_t) calloc (sizeof (bitset_t), 1);
|
||||
@@ -3725,11 +3724,7 @@ build_charclass_op (re_dfa_t *dfa, RE_TR
|
||||
#endif
|
||||
|
||||
/* Build a tree for simple bracket. */
|
||||
-#if defined GCC_LINT || defined lint
|
||||
- memset (&br_token, 0, sizeof br_token);
|
||||
-#endif
|
||||
- br_token.type = SIMPLE_BRACKET;
|
||||
- br_token.opr.sbcset = sbcset;
|
||||
+ re_token_t br_token = { .type = SIMPLE_BRACKET, .opr.sbcset = sbcset };
|
||||
tree = create_token_tree (dfa, NULL, NULL, &br_token);
|
||||
if (__glibc_unlikely (tree == NULL))
|
||||
goto build_word_op_espace;
|
||||
@@ -3820,11 +3815,7 @@ static bin_tree_t *
|
||||
create_tree (re_dfa_t *dfa, bin_tree_t *left, bin_tree_t *right,
|
||||
re_token_type_t type)
|
||||
{
|
||||
- re_token_t t;
|
||||
-#if defined GCC_LINT || defined lint
|
||||
- memset (&t, 0, sizeof t);
|
||||
-#endif
|
||||
- t.type = type;
|
||||
+ re_token_t t = { .type = type };
|
||||
return create_token_tree (dfa, left, right, &t);
|
||||
}
|
||||
|
||||
diff -up diffutils-3.7/lib/regexec.c.me diffutils-3.7/lib/regexec.c
|
||||
--- diffutils-3.7/lib/regexec.c.me 2021-03-24 08:50:16.101143023 +0100
|
||||
+++ diffutils-3.7/lib/regexec.c 2021-03-24 08:55:03.347246385 +0100
|
||||
@@ -828,7 +828,9 @@ re_search_internal (const regex_t *preg,
|
||||
break;
|
||||
if (__glibc_unlikely (err != REG_NOMATCH))
|
||||
goto free_return;
|
||||
+#ifdef DEBUG
|
||||
match_last = -1;
|
||||
+#endif
|
||||
}
|
||||
else
|
||||
break; /* We found a match. */
|
||||
@@ -3693,6 +3695,7 @@ group_nodes_into_DFAstates (const re_dfa
|
||||
bitset_empty (accepts);
|
||||
}
|
||||
}
|
||||
+ assume (ndests <= SBC_MAX);
|
||||
return ndests;
|
||||
error_return:
|
||||
for (j = 0; j < ndests; ++j)
|
||||
diff -up diffutils-3.7/lib/regex_internal.h.me diffutils-3.7/lib/regex_internal.h
|
||||
--- diffutils-3.7/lib/regex_internal.h.me 2021-03-24 08:54:03.464477733 +0100
|
||||
+++ diffutils-3.7/lib/regex_internal.h 2021-03-24 08:54:22.824728618 +0100
|
||||
@@ -34,6 +34,7 @@
|
||||
#include <stdint.h>
|
||||
|
||||
#include <intprops.h>
|
||||
+#include <verify.h>
|
||||
|
||||
#ifdef _LIBC
|
||||
# include <libc-lock.h>
|
||||
diff -up diffutils-3.7/src/ifdef.c.me diffutils-3.7/src/ifdef.c
|
||||
--- diffutils-3.7/src/ifdef.c.me 2021-03-24 18:10:43.265671781 +0100
|
||||
+++ diffutils-3.7/src/ifdef.c 2021-03-24 18:08:39.843320920 +0100
|
||||
@@ -362,7 +362,7 @@ do_printf_spec (FILE *out, char const *s
|
||||
printint print_value = value;
|
||||
size_t spec_prefix_len = f - spec - 2;
|
||||
size_t pI_len = sizeof pI - 1;
|
||||
-#if 0
|
||||
+#if HAVE_C_VARARRAYS
|
||||
char format[spec_prefix_len + pI_len + 2];
|
||||
#else
|
||||
char *format = xmalloc (spec_prefix_len + pI_len + 2);
|
||||
@ -0,0 +1,73 @@
|
||||
diff -up diffutils-3.7/lib/freopen-safer.c.me diffutils-3.7/lib/freopen-safer.c
|
||||
--- diffutils-3.7/lib/freopen-safer.c.me 2021-03-24 15:38:27.785170510 +0100
|
||||
+++ diffutils-3.7/lib/freopen-safer.c 2021-03-24 15:39:56.389523872 +0100
|
||||
@@ -49,6 +49,7 @@ protect_fd (int fd)
|
||||
}
|
||||
return false;
|
||||
}
|
||||
+ /* coverity[leaked_handle : FALSE] */
|
||||
return true;
|
||||
}
|
||||
|
||||
diff -up diffutils-3.7/lib/regex_internal.c.me diffutils-3.7/lib/regex_internal.c
|
||||
--- diffutils-3.7/lib/regex_internal.c.me 2021-03-24 15:45:12.934308141 +0100
|
||||
+++ diffutils-3.7/lib/regex_internal.c 2021-03-24 15:48:06.165592478 +0100
|
||||
@@ -1724,6 +1724,7 @@ create_cd_newstate (const re_dfa_t *dfa,
|
||||
}
|
||||
if (re_node_set_init_copy (newstate->entrance_nodes, nodes)
|
||||
!= REG_NOERROR)
|
||||
+ /* coverity[leaked_storage : FALSE] */
|
||||
return NULL;
|
||||
nctx_nodes = 0;
|
||||
newstate->has_constraint = 1;
|
||||
diff -up diffutils-3.7/src/analyze.c.me diffutils-3.7/src/analyze.c
|
||||
--- diffutils-3.7/src/analyze.c.me 2021-03-24 17:16:35.560137760 +0100
|
||||
+++ diffutils-3.7/src/analyze.c 2021-03-24 17:18:02.298846273 +0100
|
||||
@@ -688,6 +688,7 @@ diff_2_files (struct comparison *cmp)
|
||||
for (f = 0; f < 2; f++)
|
||||
{
|
||||
free (cmp->file[f].equivs);
|
||||
+ /* coverity[offset_free : FALSE] */
|
||||
free (cmp->file[f].linbuf + cmp->file[f].linbuf_base);
|
||||
}
|
||||
|
||||
diff -up diffutils-3.7/src/diff3.c.me diffutils-3.7/src/diff3.c
|
||||
--- diffutils-3.7/src/diff3.c.me 2021-03-24 17:18:21.317231331 +0100
|
||||
+++ diffutils-3.7/src/diff3.c 2021-03-24 17:22:54.217398657 +0100
|
||||
@@ -795,6 +795,7 @@ using_to_diff3_block (struct diff_block
|
||||
D_LINEARRAY (result, FILEC) + result_offset,
|
||||
D_LENARRAY (result, FILEC) + result_offset,
|
||||
D_NUMLINES (ptr, FC)))
|
||||
+ /* coverity[leaked_storage : FALSE] */
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -824,6 +825,7 @@ using_to_diff3_block (struct diff_block
|
||||
D_LINEARRAY (result, FILE0 + d) + result_offset,
|
||||
D_LENARRAY (result, FILE0 + d) + result_offset,
|
||||
D_NUMLINES (ptr, FO)))
|
||||
+ /* coverity[leaked_storage : FALSE] */
|
||||
return 0;
|
||||
|
||||
/* Catch the lines between here and the next diff */
|
||||
diff -up diffutils-3.7/src/sdiff.c.me diffutils-3.7/src/sdiff.c
|
||||
--- diffutils-3.7/src/sdiff.c.me 2021-03-24 17:24:37.022988328 +0100
|
||||
+++ diffutils-3.7/src/sdiff.c 2021-03-24 17:25:39.145495628 +0100
|
||||
@@ -1169,5 +1169,6 @@ temporary_file (void)
|
||||
fd = mkstemp (buf);
|
||||
if (0 <= fd)
|
||||
tmpname = buf;
|
||||
+ /* coverity[leaked_storage : FALSE] */
|
||||
return fd;
|
||||
}
|
||||
diff -up diffutils-3.7/src/util.c.me diffutils-3.7/src/util.c
|
||||
--- diffutils-3.7/src/util.c.me 2021-03-24 17:25:51.419067091 +0100
|
||||
+++ diffutils-3.7/src/util.c 2021-03-24 17:36:28.882404028 +0100
|
||||
@@ -699,6 +699,7 @@ parse_diff_color (void)
|
||||
}
|
||||
colors_enabled = false;
|
||||
}
|
||||
+/* coverity[leaked_storage : FALSE] */
|
||||
}
|
||||
|
||||
static void
|
||||
@ -0,0 +1,20 @@
|
||||
diff -up diffutils-3.6/src/cmp.c.cmp-s-empty diffutils-3.6/src/cmp.c
|
||||
--- diffutils-3.6/src/cmp.c.cmp-s-empty 2017-05-18 18:39:59.000000000 +0100
|
||||
+++ diffutils-3.6/src/cmp.c 2017-05-22 10:53:28.477147864 +0100
|
||||
@@ -330,12 +330,15 @@ main (int argc, char **argv)
|
||||
|
||||
/* If only a return code is needed,
|
||||
and if both input descriptors are associated with plain files,
|
||||
+ and if both files are larger than 0 bytes (procfs files are always 0),
|
||||
conclude that the files differ if they have different sizes
|
||||
and if more bytes will be compared than are in the smaller file. */
|
||||
|
||||
if (comparison_type == type_status
|
||||
&& S_ISREG (stat_buf[0].st_mode)
|
||||
- && S_ISREG (stat_buf[1].st_mode))
|
||||
+ && S_ISREG (stat_buf[1].st_mode)
|
||||
+ && stat_buf[0].st_size > 0
|
||||
+ && stat_buf[1].st_size > 0)
|
||||
{
|
||||
off_t s0 = stat_buf[0].st_size - file_position (0);
|
||||
off_t s1 = stat_buf[1].st_size - file_position (1);
|
||||
@ -0,0 +1,26 @@
|
||||
diff -up diffutils-3.7/gnulib-tests/test-perror2.c.fix-gnulib-tests diffutils-3.7/gnulib-tests/test-perror2.c
|
||||
--- diffutils-3.7/gnulib-tests/test-perror2.c.fix-gnulib-tests 2018-01-07 00:45:53.000000000 +0000
|
||||
+++ diffutils-3.7/gnulib-tests/test-perror2.c 2020-10-08 14:36:15.002040558 +0100
|
||||
@@ -79,9 +79,6 @@ main (void)
|
||||
errno = -5;
|
||||
perror ("");
|
||||
ASSERT (!ferror (stderr));
|
||||
- ASSERT (msg1 == msg2 || msg1 == msg4 || STREQ (msg1, str1));
|
||||
- ASSERT (msg2 == msg4 || STREQ (msg2, str2));
|
||||
- ASSERT (msg3 == msg4 || STREQ (msg3, str3));
|
||||
ASSERT (STREQ (msg4, str4));
|
||||
|
||||
free (str1);
|
||||
diff -up diffutils-3.7/gnulib-tests/test-strerror_r.c.fix-gnulib-tests diffutils-3.7/gnulib-tests/test-strerror_r.c
|
||||
--- diffutils-3.7/gnulib-tests/test-strerror_r.c.fix-gnulib-tests 2018-01-07 00:45:53.000000000 +0000
|
||||
+++ diffutils-3.7/gnulib-tests/test-strerror_r.c 2020-10-08 14:36:15.003040568 +0100
|
||||
@@ -165,9 +165,6 @@ main (void)
|
||||
|
||||
strerror_r (EACCES, buf, sizeof buf);
|
||||
strerror_r (-5, buf, sizeof buf);
|
||||
- ASSERT (msg1 == msg2 || msg1 == msg4 || STREQ (msg1, str1));
|
||||
- ASSERT (msg2 == msg4 || STREQ (msg2, str2));
|
||||
- ASSERT (msg3 == msg4 || STREQ (msg3, str3));
|
||||
ASSERT (STREQ (msg4, str4));
|
||||
|
||||
free (str1);
|
||||
@ -0,0 +1,25 @@
|
||||
diff -up diffutils-3.7/lib/c-stack.c.sigstksz diffutils-3.7/lib/c-stack.c
|
||||
--- diffutils-3.7/lib/c-stack.c.sigstksz 2021-04-12 10:58:48.892279388 +0100
|
||||
+++ diffutils-3.7/lib/c-stack.c 2021-04-12 11:04:59.488695551 +0100
|
||||
@@ -52,12 +52,18 @@ typedef struct sigaltstack stack_t;
|
||||
#endif
|
||||
#ifndef SIGSTKSZ
|
||||
# define SIGSTKSZ 16384
|
||||
-#elif HAVE_LIBSIGSEGV && SIGSTKSZ < 16384
|
||||
+#elif HAVE_LIBSIGSEGV
|
||||
/* libsigsegv 2.6 through 2.8 have a bug where some architectures use
|
||||
more than the Linux default of an 8k alternate stack when deciding
|
||||
if a fault was caused by stack overflow. */
|
||||
-# undef SIGSTKSZ
|
||||
-# define SIGSTKSZ 16384
|
||||
+# if defined _SC_SIGSTKSZ && _SC_SIGSTKSZ < 16384
|
||||
+ /* glibc 2.34 defines SIGSTKSZ to sysconf (_SC_SIGSTKSZ) */
|
||||
+# undef SIGSTKSZ
|
||||
+# define SIGSTKSZ 16384
|
||||
+# elif SIGSTKSZ < 16384
|
||||
+# undef SIGSTKSZ
|
||||
+# define SIGSTKSZ 16384
|
||||
+# endif
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
Loading…
Reference in new issue