Use malloc by default but allow bounded alloca

Signed-off-by: Mattias Andrée <maandree@kth.se>

4 files changed, 44 insertions, 1 deletions

diff --git a/common.h b/common.h
index e6e15d5..c053fac 100644
--- a/common.h
+++ b/common.h
@@ -5,10 +5,16 @@
 #include <alloca.h>
 #include <errno.h>
 #include <stddef.h>
+#include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 
+#ifndef ALLOCA_LIMIT
+# define ALLOCA_LIMIT 0
+#endif
+
+
 /**
  * Process a chunk using SHA-2
  * 
diff --git a/config.mk b/config.mk
index 2062ea6..66efe55 100644
--- a/config.mk
+++ b/config.mk
@@ -6,3 +6,9 @@ CC = c99
 CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_XOPEN_SOURCE=700
 CFLAGS   = -Wall -O3
 LDFLAGS  = -s
+
+# You can add -DALLOCA_LIMIT=# to CPPFLAGS, where # is a size_t
+# value, to put a limit on how large allocation the library is
+# allowed to make with alloca(3). For buffers that can have any
+# size this limit will be used if it wants to allocate a larger
+# buffer. Choose 0 to use malloc(3) instead of alloca(3).
diff --git a/sum_fd.c b/sum_fd.c
index fed3bed..196efe4 100644
--- a/sum_fd.c
+++ b/sum_fd.c
@@ -7,17 +7,42 @@ libsha2_sum_fd(int fd, enum libsha2_algorithm algorithm, void *restrict hashsum)
 {
 	struct libsha2_state state;
 	ssize_t r;
+#ifndef _WIN32
 	struct stat attr;
+#endif
 	size_t blksize = 4096;
 	char *restrict chunk;
 
 	if (libsha2_init(&state, algorithm) < 0)
 		return -1;
 
+#ifndef _WIN32
 	if (fstat(fd, &attr) == 0 && attr.st_blksize > 0)
 		blksize = (size_t)(attr.st_blksize);
+#endif
 
+#if ALLOCA_LIMIT > 0
+	if (blksize > (size_t)ALLOCA_LIMIT) {
+		blksize = (size_t)ALLOCA_LIMIT;
+		blksize -= blksize % sizeof(((struct libsha2_state)NULL)->chunk);
+		if (!blksize)
+			blksize = sizeof(((struct libsha2_state)NULL)->chunk);
+	}
+# if defined(__clang__)
+	/* We are using a limit so it's just like declaring an array
+	 * in a function, except we might use less of the stack. */
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Walloca"
+# endif
 	chunk = alloca(blksize);
+# if defined(__clang__)
+#  pragma clang diagnostic pop
+# endif
+#else
+	chunk = malloc(blksize);
+	if (!chunk)
+		return -1;
+#endif
 
 	for (;;) {
 		r = read(fd, chunk, blksize);
@@ -26,11 +51,17 @@ libsha2_sum_fd(int fd, enum libsha2_algorithm algorithm, void *restrict hashsum)
 				break;
 			if (errno == EINTR)
 				continue;
+#if ALLOCA_LIMIT <= 0
+			free(chunk);
+#endif
 			return -1;
 		}
 		libsha2_update(&state, chunk, (size_t)r * 8);
 	}
 
 	libsha2_digest(&state, NULL, 0, hashsum);
+#if ALLOCA_LIMIT <= 0
+       free(chunk);
+#endif
 	return 0;
 }
diff --git a/update.c b/update.c
index 8d0610d..4cf31a5 100644
--- a/update.c
+++ b/update.c
@@ -14,7 +14,7 @@ libsha2_update(struct libsha2_state *restrict state, const void *restrict messag
 
 	if (off) {
 		n = msglen < state->chunk_size - off ? msglen : state->chunk_size - off;
-		memcpy(state->chunk + off, message, n);
+		memcpy(&state->chunk[off], message, n);
 		if (off + n == state->chunk_size)
 			libsha2_process(state, state->chunk);
 		message += n;