snprintf: renamed and we now only use msnprintf()

The function does not return the same value as snprintf() normally does,
so readers may be mislead into thinking the code works differently than
it actually does. A different function name makes this easier to detect.

Reported-by: Tomas Hoger
Assisted-by: Daniel Gustafsson
Fixes #3296
Closes #3297

1 files changed, 32 insertions, 32 deletions

diff --git a/tests/libtest/lib518.c b/tests/libtest/lib518.c
index 81c5a5fad..1a3091fcc 100644
--- a/tests/libtest/lib518.c
+++ b/tests/libtest/lib518.c
@@ -5,7 +5,7 @@
  *                            | (__| |_| |  _ <| |___
  *                             \___|\___/|_| \_\_____|
  *
- * Copyright (C) 1998 - 2016, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2018, Daniel Stenberg, <daniel@haxx.se>, et al.
  *
  * This software is licensed as described in the file COPYING, which
  * you should have received as part of this distribution. The terms
@@ -55,10 +55,10 @@ static char msgbuff[256];
 static void store_errmsg(const char *msg, int err)
 {
   if(!err)
-    snprintf(msgbuff, sizeof(msgbuff), "%s", msg);
+    msnprintf(msgbuff, sizeof(msgbuff), "%s", msg);
   else
-    snprintf(msgbuff, sizeof(msgbuff), "%s, errno %d, %s", msg,
-             err, strerror(err));
+    msnprintf(msgbuff, sizeof(msgbuff), "%s, errno %d, %s", msg,
+              err, strerror(err));
 }
 
 static void close_file_descriptors(void)
@@ -132,7 +132,7 @@ static int rlimit(int keep_open)
     strcpy(strbuff, "INFINITY");
   else
 #endif
-    snprintf(strbuff, sizeof(strbuff), fmt, rl.rlim_cur);
+    msnprintf(strbuff, sizeof(strbuff), fmt, rl.rlim_cur);
   fprintf(stderr, "initial soft limit: %s\n", strbuff);
 
 #ifdef RLIM_INFINITY
@@ -140,7 +140,7 @@ static int rlimit(int keep_open)
     strcpy(strbuff, "INFINITY");
   else
 #endif
-    snprintf(strbuff, sizeof(strbuff), fmt, rl.rlim_max);
+    msnprintf(strbuff, sizeof(strbuff), fmt, rl.rlim_max);
   fprintf(stderr, "initial hard limit: %s\n", strbuff);
 
   /* show our constants */
@@ -198,7 +198,7 @@ static int rlimit(int keep_open)
       strcpy(strbuff, "INFINITY");
     else
 #endif
-      snprintf(strbuff, sizeof(strbuff), fmt, rl.rlim_cur);
+      msnprintf(strbuff, sizeof(strbuff), fmt, rl.rlim_cur);
     fprintf(stderr, "current soft limit: %s\n", strbuff);
 
 #ifdef RLIM_INFINITY
@@ -206,7 +206,7 @@ static int rlimit(int keep_open)
       strcpy(strbuff, "INFINITY");
     else
 #endif
-      snprintf(strbuff, sizeof(strbuff), fmt, rl.rlim_max);
+      msnprintf(strbuff, sizeof(strbuff), fmt, rl.rlim_max);
     fprintf(stderr, "current hard limit: %s\n", strbuff);
 
   } /* (rl.rlim_cur != rl.rlim_max) */
@@ -233,10 +233,10 @@ static int rlimit(int keep_open)
      (rl.rlim_cur != RLIM_INFINITY) &&
 #endif
      (rl.rlim_cur <= num_open.rlim_cur)) {
-    snprintf(strbuff2, sizeof(strbuff2), fmt, rl.rlim_cur);
-    snprintf(strbuff1, sizeof(strbuff1), fmt, num_open.rlim_cur);
-    snprintf(strbuff, sizeof(strbuff), "fds needed %s > system limit %s",
-             strbuff1, strbuff2);
+    msnprintf(strbuff2, sizeof(strbuff2), fmt, rl.rlim_cur);
+    msnprintf(strbuff1, sizeof(strbuff1), fmt, num_open.rlim_cur);
+    msnprintf(strbuff, sizeof(strbuff), "fds needed %s > system limit %s",
+              strbuff1, strbuff2);
     store_errmsg(strbuff, 0);
     fprintf(stderr, "%s\n", msgbuff);
     return -4;
@@ -257,7 +257,7 @@ static int rlimit(int keep_open)
     nitems = 0x40000;
   do {
     num_open.rlim_max = sizeof(*memchunk) * (size_t)nitems;
-    snprintf(strbuff, sizeof(strbuff), fmt, num_open.rlim_max);
+    msnprintf(strbuff, sizeof(strbuff), fmt, num_open.rlim_max);
     fprintf(stderr, "allocating memchunk %s byte array\n", strbuff);
     memchunk = malloc(sizeof(*memchunk) * (size_t)nitems);
     if(!memchunk) {
@@ -285,9 +285,9 @@ static int rlimit(int keep_open)
   /* verify that we won't overflow size_t in malloc() */
 
   if((size_t)(num_open.rlim_max) > ((size_t)-1) / sizeof(*fd)) {
-    snprintf(strbuff1, sizeof(strbuff1), fmt, num_open.rlim_max);
-    snprintf(strbuff, sizeof(strbuff), "unable to allocate an array for %s "
-             "file descriptors, would overflow size_t", strbuff1);
+    msnprintf(strbuff1, sizeof(strbuff1), fmt, num_open.rlim_max);
+    msnprintf(strbuff, sizeof(strbuff), "unable to allocate an array for %s "
+              "file descriptors, would overflow size_t", strbuff1);
     store_errmsg(strbuff, 0);
     fprintf(stderr, "%s\n", msgbuff);
     free(memchunk);
@@ -296,7 +296,7 @@ static int rlimit(int keep_open)
 
   /* allocate array for file descriptors */
 
-  snprintf(strbuff, sizeof(strbuff), fmt, num_open.rlim_max);
+  msnprintf(strbuff, sizeof(strbuff), fmt, num_open.rlim_max);
   fprintf(stderr, "allocating array for %s file descriptors\n", strbuff);
 
   fd = malloc(sizeof(*fd) * (size_t)(num_open.rlim_max));
@@ -316,14 +316,14 @@ static int rlimit(int keep_open)
       num_open.rlim_cur++)
     fd[num_open.rlim_cur] = -1;
 
-  snprintf(strbuff, sizeof(strbuff), fmt, num_open.rlim_max);
+  msnprintf(strbuff, sizeof(strbuff), fmt, num_open.rlim_max);
   fprintf(stderr, "trying to open %s file descriptors\n", strbuff);
 
   /* open a dummy descriptor */
 
   fd[0] = open(DEV_NULL, O_RDONLY);
   if(fd[0] < 0) {
-    snprintf(strbuff, sizeof(strbuff), "opening of %s failed", DEV_NULL);
+    msnprintf(strbuff, sizeof(strbuff), "opening of %s failed", DEV_NULL);
     store_errmsg(strbuff, errno);
     fprintf(stderr, "%s\n", msgbuff);
     free(fd);
@@ -344,20 +344,20 @@ static int rlimit(int keep_open)
 
       fd[num_open.rlim_cur] = -1;
 
-      snprintf(strbuff1, sizeof(strbuff1), fmt, num_open.rlim_cur);
-      snprintf(strbuff, sizeof(strbuff), "dup() attempt %s failed", strbuff1);
+      msnprintf(strbuff1, sizeof(strbuff1), fmt, num_open.rlim_cur);
+      msnprintf(strbuff, sizeof(strbuff), "dup() attempt %s failed", strbuff1);
       fprintf(stderr, "%s\n", strbuff);
 
-      snprintf(strbuff1, sizeof(strbuff), fmt, num_open.rlim_cur);
-      snprintf(strbuff, sizeof(strbuff), "fds system limit seems close to %s",
+      msnprintf(strbuff1, sizeof(strbuff), fmt, num_open.rlim_cur);
+      msnprintf(strbuff, sizeof(strbuff), "fds system limit seems close to %s",
                strbuff1);
       fprintf(stderr, "%s\n", strbuff);
 
       num_open.rlim_max = NUM_NEEDED;
 
-      snprintf(strbuff2, sizeof(strbuff2), fmt, num_open.rlim_max);
-      snprintf(strbuff1, sizeof(strbuff1), fmt, num_open.rlim_cur);
-      snprintf(strbuff, sizeof(strbuff), "fds needed %s > system limit %s",
+      msnprintf(strbuff2, sizeof(strbuff2), fmt, num_open.rlim_max);
+      msnprintf(strbuff1, sizeof(strbuff1), fmt, num_open.rlim_cur);
+      msnprintf(strbuff, sizeof(strbuff), "fds needed %s > system limit %s",
                strbuff2, strbuff1);
       store_errmsg(strbuff, 0);
       fprintf(stderr, "%s\n", msgbuff);
@@ -375,7 +375,7 @@ static int rlimit(int keep_open)
 
   }
 
-  snprintf(strbuff, sizeof(strbuff), fmt, num_open.rlim_max);
+  msnprintf(strbuff, sizeof(strbuff), fmt, num_open.rlim_max);
   fprintf(stderr, "%s file descriptors open\n", strbuff);
 
 #if !defined(HAVE_POLL_FINE)    && \
@@ -395,7 +395,7 @@ static int rlimit(int keep_open)
 
   num_open.rlim_cur = FD_SETSIZE - SAFETY_MARGIN;
   if(num_open.rlim_max > num_open.rlim_cur) {
-    snprintf(strbuff, sizeof(strbuff), "select limit is FD_SETSIZE %d",
+    msnprintf(strbuff, sizeof(strbuff), "select limit is FD_SETSIZE %d",
              FD_SETSIZE);
     store_errmsg(strbuff, 0);
     fprintf(stderr, "%s\n", msgbuff);
@@ -410,7 +410,7 @@ static int rlimit(int keep_open)
       rl.rlim_cur++) {
     if((fd[rl.rlim_cur] > 0) &&
        ((unsigned int)fd[rl.rlim_cur] > num_open.rlim_cur)) {
-      snprintf(strbuff, sizeof(strbuff), "select limit is FD_SETSIZE %d",
+      msnprintf(strbuff, sizeof(strbuff), "select limit is FD_SETSIZE %d",
                FD_SETSIZE);
       store_errmsg(strbuff, 0);
       fprintf(stderr, "%s\n", msgbuff);
@@ -432,12 +432,12 @@ static int rlimit(int keep_open)
    */
 
   if(!fopen_works()) {
-    snprintf(strbuff1, sizeof(strbuff1), fmt, num_open.rlim_max);
-    snprintf(strbuff, sizeof(strbuff),
+    msnprintf(strbuff1, sizeof(strbuff1), fmt, num_open.rlim_max);
+    msnprintf(strbuff, sizeof(strbuff),
              "fopen fails with %s fds open()",
              strbuff1);
     fprintf(stderr, "%s\n", msgbuff);
-    snprintf(strbuff, sizeof(strbuff),
+    msnprintf(strbuff, sizeof(strbuff),
              "fopen fails with lots of fds open()");
     store_errmsg(strbuff, 0);
     close_file_descriptors();