syserror.c

Go to the documentation of this file.

/*
 *   This library is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU Lesser General Public
 *   License as published by the Free Software Foundation; either
 *   version 2.1 of the License, or (at your option) any later version.
 *
 *   This library is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 *   Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
/** Support functions to allow libraries to get system errors in a threadsafe and easily debuggable way
 *
 * @file src/lib/util/syserror.c
 *
 * @copyright 2017 The FreeRADIUS server project
 * @copyright 2017 Arran Cudbard-Bell (a.cudbardb@freeradius.org)
 */
RCSID("$Id: 253b4d36a0657a0ba72bb31dea7fd462a637d718 $")
 
#include <freeradius-devel/util/log.h>
#include <freeradius-devel/util/strerror.h>
#include <freeradius-devel/util/syserror.h>
#include <freeradius-devel/util/atexit.h>
 
 
#define FR_SYSERROR_BUFSIZE (2048)
 
static _Thread_local char *fr_syserror_buffer;
static _Thread_local bool logging_stop; //!< Due to ordering issues we may get errors being
                                        ///< logged from within other thread local destructors
                                        ///< which cause a crash on exit if the logging buffer
                                        ///< has already been freed.
 
#define HAVE_DEFINITION(_errno) ((_errno) < (int)(NUM_ELEMENTS(fr_syserror_macro_names)))
 
/*
 *      Explicitly cleanup the memory allocated to the error buffer,
 *      just in case valgrind complains about it.
 */
static int _fr_logging_free(UNUSED void *arg)
{
        if (talloc_free(fr_syserror_buffer) < 0) return -1;
        fr_syserror_buffer = NULL;
        logging_stop = true;
        return 0;
}
 
/** POSIX-2008 errno macros
 *
 * Non-POSIX macros may be added, but you must check they're defined.
 */
static char const *fr_syserror_macro_names[] = {
        [E2BIG] = "E2BIG",
        [EACCES] = "EACCES",
        [EADDRINUSE] = "EADDRINUSE",
        [EADDRNOTAVAIL] = "EADDRNOTAVAIL",
        [EAFNOSUPPORT] = "EAFNOSUPPORT",
#if EWOULDBLOCK == EAGAIN
        [EWOULDBLOCK] = "EWOULDBLOCK or EAGAIN",
#else
        [EAGAIN] = "EAGAIN",
        [EWOULDBLOCK] = "EWOULDBLOCK",
#endif
        [EALREADY] = "EALREADY",
        [EBADF] = "EBADF",
        [EBADMSG] = "EBADMSG",
        [EBUSY] = "EBUSY",
        [ECANCELED] = "ECANCELED",
        [ECHILD] = "ECHILD",
        [ECONNABORTED] = "ECONNABORTED",
        [ECONNREFUSED] = "ECONNREFUSED",
        [ECONNRESET] = "ECONNRESET",
        [EDEADLK] = "EDEADLK",
        [EDESTADDRREQ] = "EDESTADDRREQ",
        [EDOM] = "EDOM",
        [EDQUOT] = "EDQUOT",
        [EEXIST] = "EEXIST",
        [EFAULT] = "EFAULT",
        [EFBIG] = "EFBIG",
        [EHOSTUNREACH] = "EHOSTUNREACH",
        [EIDRM] = "EIDRM",
        [EILSEQ] = "EILSEQ",
        [EINPROGRESS] = "EINPROGRESS",
        [EINTR] = "EINTR",
        [EINVAL] = "EINVAL",
        [EIO] = "EIO",
        [EISCONN] = "EISCONN",
        [EISDIR] = "EISDIR",
        [ELOOP] = "ELOOP",
        [EMFILE] = "EMFILE",
        [EMLINK] = "EMLINK",
        [EMSGSIZE] = "EMSGSIZE",
        [EMULTIHOP] = "EMULTIHOP",
        [ENAMETOOLONG] = "ENAMETOOLONG",
        [ENETDOWN] = "ENETDOWN",
        [ENETRESET] = "ENETRESET",
        [ENETUNREACH] = "ENETUNREACH",
        [ENFILE] = "ENFILE",
        [ENOBUFS] = "ENOBUFS",
#ifdef ENODATA
        [ENODATA] = "ENODATA",
#endif
        [ENODEV] = "ENODEV",
        [ENOENT] = "ENOENT",
        [ENOEXEC] = "ENOEXEC",
        [ENOLCK] = "ENOLCK",
        [ENOLINK] = "ENOLINK",
        [ENOMEM] = "ENOMEM",
        [ENOMSG] = "ENOMSG",
        [ENOPROTOOPT] = "ENOPROTOOPT",
        [ENOSPC] = "ENOSPC",
#ifdef ENOSR
        [ENOSR] = "ENOSR",
#endif
#ifdef ENOSTR
        [ENOSTR] = "ENOSTR",
#endif
        [ENOSYS] = "ENOSYS",
        [ENOTCONN] = "ENOTCONN",
        [ENOTDIR] = "ENOTDIR",
        [ENOTEMPTY] = "ENOTEMPTY",
#ifdef ENOTRECOVERABLE
        [ENOTRECOVERABLE] = "ENOTRECOVERABLE",
#endif
        [ENOTSOCK] = "ENOTSOCK",
#if ENOTSUP == EOPNOTSUPP
        [ENOTSUP] = "ENOTSUP or EOPNOTSUPP",
#else
        [ENOTSUP] = "ENOTSUP",
        [EOPNOTSUPP] = "EOPNOTSUPP",
#endif
        [ENOTTY] = "ENOTTY",
        [ENXIO] = "ENXIO",
        [EOVERFLOW] = "EOVERFLOW",
#ifdef EOWNERDEAD
        [EOWNERDEAD] = "EOWNERDEAD",
#endif
        [EPERM] = "EPERM",
        [EPIPE] = "EPIPE",
        [EPROTO] = "EPROTO",
        [EPROTONOSUPPORT] = "EPROTONOSUPPORT",
        [EPROTOTYPE] = "EPROTOTYPE",
        [ERANGE] = "ERANGE",
        [EROFS] = "EROFS",
        [ESPIPE] = "ESPIPE",
        [ESRCH] = "ESRCH",
        [ESTALE] = "ESTALE",
#ifdef ETIME
        [ETIME] = "ETIME",
#endif
        [ETIMEDOUT] = "ETIMEDOUT",
        [ETXTBSY] = "ETXTBSY",
        [EXDEV] = "EXDEV"
};
 
static inline CC_HINT(always_inline)
ssize_t _fr_syserror(int num, char *buffer, size_t buff_len)
{
        /*
         *      XSI-Compliant version
         */
#if !defined(HAVE_FEATURES_H) || !defined(__GLIBC__) || ((_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 500) && ! _GNU_SOURCE)
        {
                int ret;
 
                ret = strerror_r(num, buffer, buff_len);
                if (ret != 0) {
#  ifndef NDEBUG
                        fprintf(stderr, "strerror_r() failed to write error for errno %i to buffer %p (%zu bytes), "
                                "returned %i: %s\n", num, buffer, (size_t)FR_SYSERROR_BUFSIZE, ret, strerror(ret));
#  endif
                        buffer[0] = '\0';
                        return -1;
                }
        }
        return strlen(buffer);
#else
        /*
         *      GNU Specific version
         *
         *      The GNU Specific version returns a char pointer. That pointer may point
         *      the buffer you just passed in, or to an immutable static string.
         */
        {
                char *q;
 
                q = strerror_r(num, buffer, buff_len);
                if (!q) {
#  ifndef NDEBUG
                        fprintf(stderr, "strerror_r() failed to write error for errno %i to buffer %p "
                                "(%zu bytes): %s\n", num, buffer, (size_t)FR_SYSERROR_BUFSIZE, strerror(errno));
#  endif
                        buffer[0] = '\0';
                        return -1;
                }
 
                /*
                 *      If strerror_r used a static string, copy it to the buffer
                 */
                if (q != buffer) {
                        size_t len;
 
                        len = strlen(q) + 1;
                        if (len >= buff_len) len = buff_len;    /* Truncate */
                        return strlcpy(buffer, q, len);
                }
 
                return strlen(q);
        }
#endif
}
 
static inline CC_HINT(always_inline)
char *_fr_syserror_buffer(void)
{
        char *buffer;
 
        buffer = fr_syserror_buffer;
        if (!buffer) {
                buffer = talloc_array(NULL, char, FR_SYSERROR_BUFSIZE);
                if (!buffer) {
                        fr_perror("Failed allocating memory for system error buffer");
                        return NULL;
                }
                fr_atexit_thread_local(fr_syserror_buffer, _fr_logging_free, buffer);
        }
        return buffer;
}
 
/** Guaranteed to be thread-safe version of strerror
 *
 * @param num   errno as returned by function or from global errno.
 * @return Error string relating to errno, with the macro name added as a prefix.
 *
 * @hidecallergraph
 */
char const *fr_syserror(int num)
{
        char *buffer, *p, *end;
 
        /*
         *      Try and produce something useful,
         *      even if the thread is exiting.
         */
        if (logging_stop) {
        error:
                if (HAVE_DEFINITION(num)) return fr_syserror_macro_names[num];
                return "";
        }
 
        if (num == 0) return "No additional error information";
 
        /*
         *      Grab our thread local buffer
         */
        buffer = _fr_syserror_buffer();
        if (!buffer) goto error;
 
        p = buffer;
        end = p + FR_SYSERROR_BUFSIZE;
 
        /*
         *      Prefix system errors with the macro name and number
         *      if we're debugging.
         */
        if (HAVE_DEFINITION(num)) {
                p += snprintf(p, end - p, "%s: ", fr_syserror_macro_names[num]);
        } else {
                p += snprintf(p, end - p, "errno %i: ", num);
        }
        if (p >= end) return p;
 
        if (_fr_syserror(num, p, end - p) < 0) goto error;
 
        return buffer;
}
 
/** Guaranteed to be thread-safe version of strerror
 *
 * @param num   errno as returned by function or from global errno.
 * @return Error string relating to errno with no decoration.
 *
 * @hidecallergraph
 */
char const *fr_syserror_simple(int num)
{
        char *buffer;
 
        if (logging_stop) return "";
 
        /*
         *      Grab our thread local buffer
         */
        buffer = _fr_syserror_buffer();
        if (!buffer || (_fr_syserror(num, buffer, FR_SYSERROR_BUFSIZE) < 0)) return "Failed retrieving error";
 
        return buffer;
}