Add compile-time checks as well

1 files changed, 38 insertions, 0 deletions

diff --git a/include/string.h b/include/string.h
index 107df9b..e464eab 100644
--- a/include/string.h
+++ b/include/string.h
@@ -6,6 +6,9 @@
 
 #if defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE > 0 && defined(__OPTIMIZE__) && __OPTIMIZE__ > 0
 
+#define __errordecl(name, msg) extern void name(void) __attribute__((__error__(msg)))
+
+__errordecl(__memcpy_error, "memcpy: buffer overflow detected");
 static inline __attribute__ ((always_inline))
 void *
 __fortify_memcpy(void *__restrict dest, const void *__restrict src, size_t n)
@@ -14,6 +17,9 @@ __fortify_memcpy(void *__restrict dest, const void *__restrict src, size_t n)
         char *d = dest;
         const char *s = src;
 
+        if (__builtin_constant_p(n) && n > bos)
+                __memcpy_error();
+
         /* trap if pointers are overlapping */
         if ((d <= s && d + n > s) ||
             (s <= d && s + n > d))
@@ -23,23 +29,31 @@ __fortify_memcpy(void *__restrict dest, const void *__restrict src, size_t n)
         return memcpy(dest, src, n);
 }
 
+__errordecl(__memmove_error, "memmove: buffer overflow detected");
 static inline __attribute__ ((always_inline))
 void *
 __fortify_memmove(void *__restrict dest, const void *__restrict src, size_t n)
 {
         size_t bos = __builtin_object_size(dest, 0);
 
+        if (__builtin_constant_p(n) && n > bos)
+                __memmove_error();
+
         if (n > bos)
                 __builtin_trap();
         return memmove(dest, src, n);
 }
 
+__errordecl(__memset_error, "memset: buffer overflow detected");
 static inline __attribute__ ((always_inline))
 void *
 __fortify_memset(void *dest, int c, size_t n)
 {
         size_t bos = __builtin_object_size(dest, 0);
 
+        if (__builtin_constant_p(n) && n > bos)
+                __memset_error();
+
         if (n > bos)
                 __builtin_trap();
         return memset(dest, c, n);
@@ -56,12 +70,16 @@ __fortify_stpcpy(char *__restrict dest, const char *__restrict src)
         return stpcpy(dest, src);
 }
 
+__errordecl(__stpncpy_error, "stpncpy: buffer overflow detected");
 static inline __attribute__ ((always_inline))
 char *
 __fortify_stpncpy(char *__restrict dest, const char *__restrict src, size_t n)
 {
         size_t bos = __builtin_object_size(dest, 0);
 
+        if (__builtin_costant_p(n) && n > bos)
+                __stpncpy_error();
+
         if (n > bos)
                 __builtin_trap();
         return stpncpy(dest, src, n);
@@ -89,6 +107,7 @@ __fortify_strcpy(char *__restrict dest, const char *__restrict src)
         return strcpy(dest, src);
 }
 
+__errordecl(__strncat_error, "strncat: buffer overflow detected");
 static inline __attribute__ ((always_inline))
 char *
 __fortify_strncat(char *__restrict dest, const char *__restrict src, size_t n)
@@ -96,6 +115,9 @@ __fortify_strncat(char *__restrict dest, const char *__restrict src, size_t n)
         size_t bos = __builtin_object_size(dest, 0);
         size_t slen, dlen;
 
+        if (__builtin_constant_p(n) && n > bos)
+                __strncat_error();
+
         if (n > bos) {
                 slen = strlen(src);
                 dlen = strlen(dest);
@@ -107,24 +129,32 @@ __fortify_strncat(char *__restrict dest, const char *__restrict src, size_t n)
         return strncat(dest, src, n);
 }
 
+__errordecl(__strncpy_error, "strncpy: buffer overflow detected");
 static inline __attribute__ ((always_inline))
 char *
 __fortify_strncpy(char *__restrict dest, const char *__restrict src, size_t n)
 {
         size_t bos = __builtin_object_size(dest, 0);
 
+        if (__builtin_constant_p(n) && n > bos)
+                __strncpy_error();
+
         if (n > bos)
                 __builtin_trap();
         return strncpy(dest, src, n);
 }
 
 #ifdef _GNU_SOURCE
+__errordecl(__mempcpy_error, "mempcpy: buffer overflow detected");
 static inline __attribute__ ((always_inline))
 void *
 __fortify_mempcpy(void *__restrict dest, const void *__restrict src, size_t n)
 {
         size_t bos = __builtin_object_size(dest, 0);
 
+        if (__builtin_constant_p(n) && n > bos)
+                __mempcpy_error();
+
         if (n > bos)
                 __builtin_trap();
         return mempcpy(dest, src, n);
@@ -132,23 +162,31 @@ __fortify_mempcpy(void *__restrict dest, const void *__restrict src, size_t n)
 #endif
 
 #if defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+__errordecl(__strlcat_error, "strlcat: buffer overflow detected");
 static inline __attribute__ ((always_inline))
 size_t
 __fortify_strlcat(char *__restrict dest, const char *__restrict src, size_t n)
 {
         size_t bos = __builtin_object_size(dest, 0);
 
+        if (__builtin_constant_p(n) && n > bos)
+                __strlcat_error();
+
         if (n > bos)
                 __builtin_trap();
         return strlcat(dest, src, n);
 }
 
+__errordecl(__strlcpy_error, "strlcpy: buffer overflow detected");
 static inline __attribute__ ((always_inline))
 size_t
 __fortify_strlcpy(char *__restrict dest, const char *__restrict src, size_t n)
 {
         size_t bos = __builtin_object_size(dest, 0);
 
+        if (__builtin_constant_p(n) && n > bos)
+                __strlcpy_error();
+
         if (n > bos)
                 __builtin_trap();
         return strlcpy(dest, src, n);