tests/test-strerror_r.c

   1 /* Test of strerror_r() function.
   2    Copyright (C) 2007-2011 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software Foundation,
  16    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  17
  18 #include <config.h>
  19
  20 #include <string.h>
  21
  22 #include "signature.h"
  23 SIGNATURE_CHECK (strerror_r, int, (int, char *, size_t));
  24
  25 #include <errno.h>
  26
  27 #include "macros.h"
  28
  29 int
  30 main (void)
  31 {
  32   char buf[100];
  33   int ret;
  34
  35   /* Test results with valid errnum and enough room.  */
  36
  37   errno = 0;
  38   buf[0] = '\0';
  39   ASSERT (strerror_r (EACCES, buf, sizeof buf) == 0);
  40   ASSERT (buf[0] != '\0');
  41   ASSERT (errno == 0);
  42   ASSERT (strlen (buf) < sizeof buf);
  43
  44   errno = 0;
  45   buf[0] = '\0';
  46   ASSERT (strerror_r (ETIMEDOUT, buf, sizeof buf) == 0);
  47   ASSERT (buf[0] != '\0');
  48   ASSERT (errno == 0);
  49   ASSERT (strlen (buf) < sizeof buf);
  50
  51   errno = 0;
  52   buf[0] = '\0';
  53   ASSERT (strerror_r (EOVERFLOW, buf, sizeof buf) == 0);
  54   ASSERT (buf[0] != '\0');
  55   ASSERT (errno == 0);
  56   ASSERT (strlen (buf) < sizeof buf);
  57
  58   /* POSIX requires strerror (0) to succeed.  Reject use of "Unknown
  59      error", but allow "Success", "No error", or even Solaris' "Error
  60      0" which are distinct patterns from true out-of-range strings.
  61      http://austingroupbugs.net/view.php?id=382  */
  62   errno = 0;
  63   buf[0] = '\0';
  64   ret = strerror_r (0, buf, sizeof buf);
  65   ASSERT (ret == 0);
  66   ASSERT (buf[0]);
  67   ASSERT (errno == 0);
  68   ASSERT (strstr (buf, "nknown") == NULL);
  69   ASSERT (strstr (buf, "ndefined") == NULL);
  70
  71   /* Test results with out-of-range errnum and enough room.  POSIX
  72      allows an empty string on success, and allows an unchanged buf on
  73      error, but these are not useful, so we guarantee contents.  */
  74   errno = 0;
  75   buf[0] = '^';
  76   ret = strerror_r (-3, buf, sizeof buf);
  77   ASSERT (ret == 0 || ret == EINVAL);
  78   ASSERT (buf[0] != '^');
  79   ASSERT (*buf);
  80   ASSERT (errno == 0);
  81   ASSERT (strlen (buf) < sizeof buf);
  82
  83   /* Test results with a too small buffer.  POSIX requires an error;
  84      only ERANGE for 0 and valid errors, and a choice of ERANGE or
  85      EINVAL for out-of-range values.  On error, POSIX permits buf to
  86      be empty, unchanged, or unterminated, but these are not useful,
  87      so we guarantee NUL-terminated truncated contents for all but
  88      size 0.  http://austingroupbugs.net/view.php?id=398.  Also ensure
  89      that no out-of-bounds writes occur.  */
  90   {
  91     int errs[] = { EACCES, 0, -3, };
  92     int j;
  93
  94     buf[sizeof buf - 1] = '\0';
  95     for (j = 0; j < SIZEOF (errs); j++)
  96       {
  97         int err = errs[j];
  98         char buf2[sizeof buf] = "";
  99         size_t len;
 100         size_t i;
 101
 102         strerror_r (err, buf2, sizeof buf2);
 103         len = strlen (buf2);
 104         ASSERT (len < sizeof buf);
 105
 106         for (i = 0; i <= len; i++)
 107           {
 108             memset (buf, '^', sizeof buf - 1);
 109             errno = 0;
 110             ret = strerror_r (err, buf, i);
 111             ASSERT (errno == 0);
 112             if (err < 0)
 113               ASSERT (ret == ERANGE || ret == EINVAL);
 114             else
 115               ASSERT (ret == ERANGE);
 116             if (i)
 117               {
 118                 ASSERT (strncmp (buf, buf2, i - 1) == 0);
 119                 ASSERT (buf[i - 1] == '\0');
 120               }
 121             ASSERT (strspn (buf + i, "^") == sizeof buf - 1 - i);
 122           }
 123
 124         strcpy (buf, "BADFACE");
 125         errno = 0;
 126         ret = strerror_r (err, buf, len + 1);
 127         ASSERT (ret != ERANGE);
 128         ASSERT (errno == 0);
 129         ASSERT (strcmp (buf, buf2) == 0);
 130       }
 131   }
 132
 133 #if GNULIB_STRERROR
 134   /* Test that strerror_r does not clobber strerror buffer.  On some
 135      platforms, this test can only succeed if gnulib also replaces
 136      strerror.  */
 137   {
 138     const char *msg1;
 139     const char *msg2;
 140     const char *msg3;
 141     const char *msg4;
 142     char *str1;
 143     char *str2;
 144     char *str3;
 145     char *str4;
 146
 147     msg1 = strerror (ENOENT);
 148     ASSERT (msg1);
 149     str1 = strdup (msg1);
 150     ASSERT (str1);
 151
 152     msg2 = strerror (ERANGE);
 153     ASSERT (msg2);
 154     str2 = strdup (msg2);
 155     ASSERT (str2);
 156
 157     msg3 = strerror (-4);
 158     ASSERT (msg3);
 159     str3 = strdup (msg3);
 160     ASSERT (str3);
 161
 162     msg4 = strerror (1729576);
 163     ASSERT (msg4);
 164     str4 = strdup (msg4);
 165     ASSERT (str4);
 166
 167     strerror_r (EACCES, buf, sizeof buf);
 168     strerror_r (-5, buf, sizeof buf);
 169     ASSERT (msg1 == msg2 || msg1 == msg4 || STREQ (msg1, str1));
 170     ASSERT (msg2 == msg4 || STREQ (msg2, str2));
 171     ASSERT (msg3 == msg4 || STREQ (msg3, str3));
 172     ASSERT (STREQ (msg4, str4));
 173
 174     free (str1);
 175     free (str2);
 176     free (str3);
 177     free (str4);
 178   }
 179 #endif
 180
 181   return 0;
 182 }