Avoid using the non-thread-safe strerror() function

https://bugzilla.redhat.com/show_bug.cgi?id=985481

diff --git a/common/compat.c b/common/compat.c
index 3b1361c9bf72181a258c3e0d36a10b6b97d12a3e..e7bee3ccc78a1ee8977fa9b1869e0e0707ac5f78 100644 (file)
--- a/common/compat.c
+++ b/common/compat.c
@@ -807,3 +807,19 @@ getauxval (unsigned long type)
 }
 
 #endif /* HAVE_GETAUXVAL */
+
+#ifndef HAVE_STRERROR_R
+
+int
+strerror_r (int errnum,
+            char *buf,
+            size_t buflen)
+{
+#ifdef OS_WIN32
+       return strerror_s (buf, buflen, errnum);
+#else
+       #error no strerror_r implementation
+#endif
+}
+
+#endif /* HAVE_STRERROR_R */

diff --git a/common/compat.h b/common/compat.h
index 1cedc3515baadc43e3c6cf3a688c177f2f2e02c4..5b76d0069f4efded1f859daa349775545f7ef079 100644 (file)
--- a/common/compat.h
+++ b/common/compat.h
@@ -310,4 +310,12 @@ unsigned long     getauxval (unsigned long type);
 
 #endif /* !HAVE_GETAUXVAL */
 
+#ifndef HAVE_STRERROR_R
+
+int         strerror_r      (int errnum,
+                             char *buf,
+                             size_t buflen);
+
+#endif /* HAVE_STRERROR_R */
+
 #endif /* __COMPAT_H__ */

diff --git a/common/message.c b/common/message.c
index 8b54ad17b1babc22a1135e370c43d33d41ec0656..e68dfac561c8d2ca0b9991e90f3d426150fd15f1 100644 (file)
--- a/common/message.c
+++ b/common/message.c
@@ -85,6 +85,32 @@ p11_message_store (const char* msg,
        }
 }
 
+void
+p11_message_err (int errnum,
+                 const char* msg,
+                 ...)
+{
+       char buffer[P11_MESSAGE_MAX];
+       char strerr[P11_MESSAGE_MAX];
+       va_list va;
+       size_t length;
+
+       va_start (va, msg);
+       length = vsnprintf (buffer, P11_MESSAGE_MAX - 1, msg, va);
+       va_end (va);
+
+       /* Was it truncated? */
+       if (length > P11_MESSAGE_MAX - 1)
+               length = P11_MESSAGE_MAX - 1;
+       buffer[length] = 0;
+
+       strncpy (strerr, "Unknown error", sizeof (strerr));
+       strerror_r (errnum, strerr, sizeof (strerr));
+       strerr[P11_MESSAGE_MAX - 1] = 0;
+
+       p11_message ("%s: %s", buffer, strerr);
+}
+
 void
 p11_message (const char* msg,
              ...)

diff --git a/common/message.h b/common/message.h
index 60a7f81a1d4be5f95336f4f42adb53c0352fc448..3fe86df4473bdc3a64473bca36efa57a15e97939 100644 (file)
--- a/common/message.h
+++ b/common/message.h
@@ -48,6 +48,10 @@ extern char * (* p11_message_storage)      (void);
 void          p11_message                  (const char* msg,
                                             ...) GNUC_PRINTF (1, 2);
 
+void          p11_message_err              (int errnum,
+                                            const char* msg,
+                                            ...) GNUC_PRINTF (2, 3);
+
 void          p11_message_store            (const char* msg,
                                             size_t length);
 

diff --git a/common/path.c b/common/path.c
index 2f976a865e415a1f07247f01c157d9c996e283cf..f7bd2b97b5074f9c1a987dd430a42a4e4d72bcaa 100644 (file)
--- a/common/path.c
+++ b/common/path.c
@@ -137,8 +137,7 @@ expand_homedir (const char *remainder)
                pwd = getpwuid (getuid ());
                if (!pwd) {
                        error = errno;
-                       p11_message ("couldn't lookup home directory for user %d: %s",
-                                    getuid (), strerror (errno));
+                       p11_message_err (errno, "couldn't lookup home directory for user %d", getuid ());
                        errno = error;
                        return NULL;
                }

diff --git a/configure.ac b/configure.ac
index 445bd4fbe4a55a7a40a34b28127b77023e393170..282fee841b8f87226b2fe1e749cf7f2c2d063d9f 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -80,7 +80,7 @@ if test "$os_unix" = "yes"; then
        AC_CHECK_MEMBERS([struct dirent.d_type],,,[#include <dirent.h>])
        AC_CHECK_FUNCS([getprogname getexecname basename mkstemp mkdtemp])
        AC_CHECK_FUNCS([getauxval issetugid getresuid])
-       AC_CHECK_FUNCS([strnstr memdup strndup])
+       AC_CHECK_FUNCS([strnstr memdup strndup strerror_r])
        AC_CHECK_FUNCS([asprintf vasprintf vsnprintf])
        AC_CHECK_FUNCS([timegm])
 

diff --git a/p11-kit/conf.c b/p11-kit/conf.c
index 83ee7ca43a35b1eed0b797bea1ff1b1774c4eecd..0ecb40ad6c0ffa28410218ee4e525cebe4e66462 100644 (file)
--- a/p11-kit/conf.c
+++ b/p11-kit/conf.c
@@ -118,8 +118,7 @@ _p11_conf_parse_file (const char* filename, int flags)
                        p11_debug ("config file is inaccessible");
 
                } else {
-                       p11_message ("couldn't open config file: %s: %s", filename,
-                                    strerror (error));
+                       p11_message_err (error, "couldn't open config file: %s", filename);
                        errno = error;
                        return NULL;
                }
@@ -400,8 +399,7 @@ load_configs_from_directory (const char *directory,
                        p11_debug ("couldn't list inacessible module configs");
                        return true;
                }
-               p11_message ("couldn't list directory: %s: %s", directory,
-                            strerror (error));
+               p11_message_err (error, "couldn't list directory: %s", directory);
                errno = error;
                return false;
        }

diff --git a/tools/tests/test.c b/tools/tests/test.c
new file mode 100644 (file)
index 0000000..2aaf2c7
--- /dev/null
+++ b/tools/tests/test.c
@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) 2013, Red Hat Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *     * Redistributions of source code must retain the above
+ *       copyright notice, this list of conditions and the
+ *       following disclaimer.
+ *     * Redistributions in binary form must reproduce the
+ *       above copyright notice, this list of conditions and
+ *       the following disclaimer in the documentation and/or
+ *       other materials provided with the distribution.
+ *     * The names of contributors to this software may not be
+ *       used to endorse or promote products derived from this
+ *       software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+ * DAMAGE.
+ *
+ * Author: Stef Walter <stefw@collabora.co.uk>
+ */
+
+#include "config.h"
+#include "CuTest.h"
+
+#include "debug.h"
+#include "message.h"
+#include "path.h"
+#include "test.h"
+
+#include <sys/stat.h>
+
+#include <assert.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#ifdef OS_UNIX
+#include <paths.h>
+#endif
+
+static char *
+read_file (CuTest *tc,
+           const char *file,
+           int line,
+           const char *filename,
+           long *len)
+{
+       struct stat sb;
+       FILE *f = NULL;
+       char *data;
+
+       f = fopen (filename, "rb");
+       if (f == NULL)
+               CuFail_Line (tc, file, line, "Couldn't open file", filename);
+
+       /* Figure out size */
+       if (stat (filename, &sb) < 0)
+               CuFail_Line (tc, file, line, "Couldn't stat file", filename);
+
+       *len = sb.st_size;
+       data = malloc (*len ? *len : 1);
+       assert (data != NULL);
+
+       /* And read in one block */
+       if (fread (data, 1, *len, f) != *len)
+               CuFail_Line (tc, file, line, "Couldn't read file", filename);
+
+       fclose (f);
+
+       return data;
+}
+
+void
+test_check_file_msg (CuTest *tc,
+                     const char *file,
+                     int line,
+                     const char *directory,
+                     const char *name,
+                     const char *reference)
+{
+       char *refdata;
+       long reflen;
+
+       refdata = read_file (tc, file, line, reference, &reflen);
+       test_check_data_msg (tc, file, line, directory, name, refdata, reflen);
+       free (refdata);
+}
+
+void
+test_check_data_msg (CuTest *tc,
+                     const char *file,
+                     int line,
+                     const char *directory,
+                     const char *name,
+                     const void *refdata,
+                     long reflen)
+{
+       char *filedata;
+       char *filename;
+       long filelen;
+
+       if (asprintf (&filename, "%s/%s", directory, name) < 0)
+               CuFail_Line (tc, file, line, "asprintf() failed", NULL);
+
+       filedata = read_file (tc, file, line, filename, &filelen);
+
+       if (filelen != reflen || memcmp (filedata, refdata, reflen) != 0)
+               CuFail_Line (tc, file, line, "File contents not as expected", filename);
+
+       CuAssert_Line (tc, file, line, "couldn't remove file", unlink (filename) >= 0);
+       free (filename);
+       free (filedata);
+}
+
+#ifdef OS_UNIX
+
+void
+test_check_symlink_msg (CuTest *tc,
+                        const char *file,
+                        int line,
+                        const char *directory,
+                        const char *name,
+                        const char *destination)
+{
+       char buf[1024] = { 0, };
+       char *filename;
+
+       if (asprintf (&filename, "%s/%s", directory, name) < 0)
+               CuFail_Line (tc, file, line, "asprintf() failed", NULL);
+
+       if (readlink (filename, buf, sizeof (buf)) < 0)
+               CuFail_Line (tc, file, line, "Couldn't read symlink", filename);
+
+       CuAssertStrEquals_LineMsg (tc, file, line, "symlink contents wrong", destination, buf);
+
+       CuAssert_Line (tc, file, line, "couldn't remove symlink", unlink (filename) >= 0);
+       free (filename);
+}
+
+#endif /* OS_UNIX */
+
+p11_dict *
+test_check_directory_files (const char *file,
+                            ...)
+{
+       p11_dict *files;
+       va_list va;
+
+       files = p11_dict_new (p11_dict_str_hash, p11_dict_str_equal, NULL, NULL);
+
+       va_start (va, file);
+
+       while (file != NULL) {
+               if (!p11_dict_set (files, (void *)file, (void *)file))
+                       return_val_if_reached (NULL);
+               file = va_arg (va, const char *);
+       }
+
+       va_end (va);
+
+       return files;
+}
+
+void
+test_check_directory_msg (CuTest *tc,
+                          const char *file,
+                          int line,
+                          const char *directory,
+                          p11_dict *files)
+{
+       p11_dictiter iter;
+       struct dirent *dp;
+       const char *name;
+       DIR *dir;
+
+       dir = opendir (directory);
+       if (dir == NULL)
+               CuFail_Line (tc, file ,line, "Couldn't open directory", directory);
+
+       while ((dp = readdir (dir)) != NULL) {
+               if (strcmp (dp->d_name, ".") == 0 ||
+                   strcmp (dp->d_name, "..") == 0)
+                       continue;
+
+               if (!p11_dict_remove (files, dp->d_name))
+                       CuFail_Line (tc, file, line, "Unexpected file in directory", dp->d_name);
+       }
+
+       closedir (dir);
+
+#ifdef OS_UNIX
+       CuAssert_Line (tc, file, line, "couldn't chown directory", chmod (directory, S_IRWXU) >= 0);
+#endif
+
+       p11_dict_iterate (files, &iter);
+       while (p11_dict_next (&iter, (void **)&name, NULL))
+               CuFail_Line (tc, file, line, "Couldn't find file in directory", name);
+
+       p11_dict_free (files);
+}
+
+static char *
+expand_tempdir (const char *name)
+{
+       const char *env;
+
+       env = getenv ("TMPDIR");
+       if (env && env[0]) {
+               return p11_path_build (env, name, NULL);
+
+       } else {
+#ifdef OS_UNIX
+#ifdef _PATH_TMP
+               return p11_path_build (_PATH_TMP, name, NULL);
+#else
+               return p11_path_build ("/tmp", name, NULL);
+#endif
+
+#else /* OS_WIN32 */
+               char directory[MAX_PATH + 1];
+
+               if (!GetTempPathA (MAX_PATH + 1, directory)) {
+                       p11_message ("couldn't lookup temp directory");
+                       errno = ENOTDIR;
+                       return NULL;
+               }
+
+               return p11_path_build (directory, name, NULL);
+
+#endif /* OS_WIN32 */
+       }
+}
+
+char *
+test_temp_directory (const char *templ)
+{
+       char *directory;
+
+       directory = expand_tempdir (templ);
+       if (directory == NULL)
+               return NULL;
+
+       if (!mkdtemp (directory)) {
+               p11_message_err (errno, "couldn't create temp directory: %s", directory);
+               free (directory);
+               assert (0 && "not reached");
+       }
+
+       return directory;
+}

diff --git a/trust/parser.c b/trust/parser.c
index b4335085ceb43bea7c41f0bbf7104275c7adaddc..4129cc00f7047eef49eeecbc869f61bb587ba36d 100644 (file)
--- a/trust/parser.c
+++ b/trust/parser.c
@@ -760,7 +760,7 @@ p11_parse_file (p11_parser *parser,
 
        map = p11_mmap_open (filename, &data, &size);
        if (map == NULL) {
-               p11_message ("couldn't open and map file: %s: %s", filename, strerror (errno));
+               p11_message_err (errno, "couldn't open and map file: %s", filename);
                return P11_PARSE_FAILURE;
        }
 

diff --git a/trust/save.c b/trust/save.c
index 0f047fcda2778ee9584408f8968d10a6d515478f..a549d936d171d557c05c861ba7e0a0dfd1a60424 100644 (file)
--- a/trust/save.c
+++ b/trust/save.c
@@ -105,8 +105,7 @@ p11_save_open_file (const char *path,
 
        fd = mkstemp (temp);
        if (fd < 0) {
-               p11_message ("couldn't create file: %s%s: %s",
-                            path, extension, strerror (errno));
+               p11_message_err (errno, "couldn't create file: %s%s", path, extension);
                free (temp);
                return NULL;
        }
@@ -148,8 +147,7 @@ p11_save_write (p11_save_file *file,
                if (res <= 0) {
                        if (errno == EAGAIN && errno == EINTR)
                                continue;
-                       p11_message ("couldn't write to file: %s: %s",
-                                    file->temp, strerror (errno));
+                       p11_message_err (errno, "couldn't write to file: %s", file->temp);
                        return false;
                } else {
                        written += res;
@@ -179,8 +177,7 @@ on_unique_try_link (void *data,
        if (link (file->temp, path) < 0) {
                if (errno == EEXIST)
                        return 0; /* Continue trying other names */
-               p11_message ("couldn't complete writing of file: %s: %s",
-                            path, strerror (errno));
+               p11_message_err (errno, "couldn't complete writing of file: %s", path);
                return -1;
        }
 
@@ -198,8 +195,7 @@ on_unique_try_rename (void *data,
        if (rename (file->temp, path) < 0) {
                if (errno == EEXIST)
                        return 0; /* Continue trying other names */
-               p11_message ("couldn't complete writing of file: %s: %s",
-                            path, strerror (errno));
+               p11_message ("couldn't complete writing of file: %s", path);
                return -1;
        }
 
@@ -230,23 +226,20 @@ p11_save_finish_file (p11_save_file *file,
                return_val_if_reached (false);
 
        if (close (file->fd) < 0) {
-               p11_message ("couldn't write file: %s: %s",
-                            file->temp, strerror (errno));
+               p11_message_err (errno, "couldn't write file: %s", file->temp);
                ret = false;
 
 #ifdef OS_UNIX
        /* Set the mode of the file, readable by everyone, but not writable */
        } else if (chmod (file->temp, S_IRUSR | S_IRGRP | S_IROTH) < 0) {
-               p11_message ("couldn't set file permissions: %s: %s",
-                            file->temp, strerror (errno));
+               p11_message_err (errno, "couldn't set file permissions: %s", file->temp);
                close (file->fd);
                ret = false;
 
        /* Atomically rename the tempfile over the filename */
        } else if (file->flags & P11_SAVE_OVERWRITE) {
                if (rename (file->temp, path) < 0) {
-                       p11_message ("couldn't complete writing file: %s: %s",
-                                    path, strerror (errno));
+                       p11_message_err (errno, "couldn't complete writing file: %s", path);
                        ret = false;
                } else {
                        unlink (file->temp);
@@ -264,8 +257,7 @@ p11_save_finish_file (p11_save_file *file,
        /* When not overwriting, link will fail if filename exists. */
        } else {
                if (link (file->temp, path) < 0) {
-                       p11_message ("couldn't complete writing of file: %s: %s",
-                                    path, strerror (errno));
+                       p11_message_err (errno, "couldn't complete writing of file: %s", path);
                        ret = false;
                }
                unlink (file->temp);
@@ -284,15 +276,13 @@ p11_save_finish_file (p11_save_file *file,
 
                } else if ((file->flags & P11_SAVE_OVERWRITE) &&
                            unlink (path) < 0 && errno != ENOENT) {
-                       p11_message ("couldn't remove original file: %s: %s",
-                                    path, strerror (errno));
+                       p11_message_err (errno, "couldn't remove original file: %s", path);
                        ret = false;
                }
 
                if (ret == true &&
                    rename (file->temp, path) < 0) {
-                       p11_message ("couldn't complete writing file: %s: %s",
-                                    path, strerror (errno));
+                       p11_message_err (errno, "couldn't complete writing file: %s", path);
                        ret = false;
                }
 
@@ -330,7 +320,7 @@ p11_save_open_directory (const char *path,
 #endif
                /* Some random error, report it */
                if (errno != EEXIST) {
-                       p11_message ("couldn't create directory: %s: %s", path, strerror (errno));
+                       p11_message_err (errno, "couldn't create directory: %s", path);
 
                /* The directory exists and we're not overwriting */
                } else if (!(flags & P11_SAVE_OVERWRITE)) {
@@ -346,8 +336,7 @@ p11_save_open_directory (const char *path,
                if (stat (path, &sb) >= 0) {
                        if ((sb.st_mode & S_IRWXU) != S_IRWXU &&
                            chmod (path, S_IRWXU | sb.st_mode) < 0) {
-                               p11_message ("couldn't make directory writable: %s: %s",
-                                            path, strerror (errno));
+                               p11_message_err (errno, "couldn't make directory writable: %s", path);
                                return NULL;
                        }
                }
@@ -501,8 +490,7 @@ p11_save_symlink_in (p11_save_dir *dir,
        unlink (path);
 
        if (symlink (destination, path) < 0) {
-               p11_message ("couldn't create symlink: %s: %s",
-                            path, strerror (errno));
+               p11_message_err (errno, "couldn't create symlink: %s", path);
                ret = false;
        } else {
                if (!p11_dict_set (dir->cache, name, name))
@@ -534,8 +522,7 @@ cleanup_directory (const char *directory,
        /* First we load all the modules */
        dir = opendir (directory);
        if (!dir) {
-               p11_message ("couldn't list directory: %s: %s",
-                            directory, strerror (errno));
+               p11_message_err (errno, "couldn't list directory: %s", directory);
                return false;
        }
 
@@ -575,8 +562,7 @@ cleanup_directory (const char *directory,
        p11_dict_iterate (remove, &iter);
        while (p11_dict_next (&iter, (void **)&path, NULL)) {
                if (unlink (path) < 0 && errno != ENOENT) {
-                       p11_message ("couldn't remove file: %s: %s",
-                                    path, strerror (errno));
+                       p11_message_err (errno, "couldn't remove file: %s", path);
                        ret = false;
                        break;
                }
@@ -604,8 +590,7 @@ p11_save_finish_directory (p11_save_dir *dir,
                /* Try to set the mode of the directory to readable */
                if (ret && chmod (dir->path, S_IRUSR | S_IXUSR | S_IRGRP |
                                             S_IXGRP | S_IROTH | S_IXOTH) < 0) {
-                       p11_message ("couldn't set directory permissions: %s: %s",
-                                    dir->path, strerror (errno));
+                       p11_message_err (errno, "couldn't set directory permissions: %s", dir->path);
                        ret = false;
                }
 #endif /* OS_UNIX */

diff --git a/trust/token.c b/trust/token.c
index 12e9e4c2879797a41f3949af1b9fa2595253beda..d2a12d0c05b395087834f2b2335031299968aa35 100644 (file)
--- a/trust/token.c
+++ b/trust/token.c
@@ -226,8 +226,7 @@ loader_load_if_file (p11_token *token,
 
        if (stat (path, &sb) < 0) {
                if (errno == ENOENT) {
-                       p11_message ("couldn't stat path: %s: %s",
-                                    path, strerror (errno));
+                       p11_message_err (errno, "couldn't stat path: %s", path);
                }
 
        } else if (!S_ISDIR (sb.st_mode)) {
@@ -254,8 +253,7 @@ loader_load_directory (p11_token *token,
        /* First we load all the modules */
        dir = opendir (directory);
        if (!dir) {
-               p11_message ("couldn't list directory: %s: %s",
-                            directory, strerror (errno));
+               p11_message_err (errno, "couldn't list directory: %s", directory);
                loader_not_loaded (token, directory);
                return 0;
        }
@@ -297,10 +295,8 @@ loader_load_path (p11_token *token,
        int ret;
 
        if (stat (path, &sb) < 0) {
-               if (errno != ENOENT) {
-                       p11_message ("cannot access trust certificate path: %s: %s",
-                                    path, strerror (errno));
-               }
+               if (errno != ENOENT)
+                       p11_message_err (errno, "cannot access trust certificate path: %s", path);
                loader_gone_file (token, path);
                return 0;
        }
@@ -413,8 +409,7 @@ p11_token_reload (p11_token *token,
                if (errno == ENOENT) {
                        loader_gone_file (token, origin);
                } else {
-                       p11_message ("cannot access trust file: %s: %s",
-                                    origin, strerror (errno));
+                       p11_message_err (errno, "cannot access trust file: %s", origin);
                }
                return false;
        }
@@ -459,7 +454,7 @@ check_directory (const char *path,
                free (parent);
                return ret;
        default:
-               p11_message ("couldn't access: %s: %s", path, strerror (errno));
+               p11_message_err (errno, "couldn't access: %s", path);
                return false;
        }
 }
@@ -600,7 +595,7 @@ mkdir_with_parents (const char *path)
                }
                /* fall through */
        default:
-               p11_message ("couldn't create directory: %s: %s", path, strerror (errno));
+               p11_message_err (errno, "couldn't create directory: %s", path);
                return false;
        }
 }