missing.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
 */
 
/** Replacements for functions that are or can be missing on some platforms
 *
 * @file src/lib/util/missing.c
 *
 * @copyright 2000,2006 The FreeRADIUS server project
 */
RCSID("$Id: ee607a6353d2ba7e321866e8291ec9801d8e06a5 $")
 
#include <freeradius-devel/missing.h>
 
#include <ctype.h>
#include <pthread.h>
 
#if !defined(HAVE_CLOCK_GETTIME) && defined(__MACH__)
#  include <mach/mach_time.h>
#endif
 
#ifndef HAVE_STRNCASECMP
int strncasecmp(char *s1, char *s2, int n)
{
        int             dif;
        unsigned char   *p1, *p2;
        int             c1, c2;
 
        p1 = (unsigned char *)s1;
        p2 = (unsigned char *)s2;
        dif = 0;
 
        while (n != 0) {
                if (*p1 == 0 && *p2 == 0)
                        break;
                c1 = *p1;
                c2 = *p2;
 
                if (islower(c1)) c1 = toupper(c1);
                if (islower(c2)) c2 = toupper(c2);
 
                if ((dif = c1 - c2) != 0)
                        break;
                p1++;
                p2++;
                n--;
        }
        return dif;
}
#endif
 
#ifndef HAVE_STRCASECMP
int strcasecmp(char *s1, char *s2)
{
        int             l1, l2;
 
        l1 = strlen(s1);
        l2 = strlen(s2);
        if (l2 > l1) l1 = l2;
 
        return strncasecmp(s1, s2, l1);
}
#endif
 
 
#ifndef HAVE_MEMRCHR
/** GNU libc extension on some platforms
 *
 */
void *memrchr(void const *s, int c, size_t n)
{
        uint8_t *p;
 
        if (n == 0) return NULL;
 
        memcpy(&p, &s, sizeof(p));      /* defeat const */
        for (p += (n - 1); p >= (uint8_t const *)s; p--) if (*p == (uint8_t)c) return (void *)p;
 
        return NULL;
}
#endif
 
#ifndef HAVE_INET_ATON
int inet_aton(char const *cp, struct in_addr *inp)
{
        int     a1, a2, a3, a4;
 
        if (sscanf(cp, "%d.%d.%d.%d", &a1, &a2, &a3, &a4) != 4)
                return 0;
 
        inp->s_addr = htonl((a1 << 24) + (a2 << 16) + (a3 << 8) + a4);
        return 1;
}
#endif
 
#ifndef HAVE_STRSEP
/*
 *      Get next token from string *stringp, where tokens are
 *      possibly-empty strings separated by characters from delim.
 *
 *      Writes NULs into the string at *stringp to end tokens.
 *      delim need not remain constant from call to call.  On
 *      return, *stringp points past the last NUL written (if there
 *      might be further tokens), or is NULL (if there are
 *      definitely no more tokens).
 *
 *      If *stringp is NULL, strsep returns NULL.
 */
char *
strsep(char **stringp, char const *delim)
{
        char *s;
        char const *spanp;
        int c, sc;
        char *tok;
 
        if ((s = *stringp) == NULL)
                return (NULL);
 
        for (tok = s;;) {
                c = *s++;
                spanp = delim;
                do {
                        if ((sc = *spanp++) == c) {
                                if (c == 0)
                                        s = NULL;
                                else
                                        s[-1] = 0;
                                *stringp = s;
                                return (tok);
                        }
                } while (sc != 0);
        }
 
        return NULL;            /* NOTREACHED, but the compiler complains */
}
#endif
 
#ifndef HAVE_LOCALTIME_R
/*
 *      We use localtime_r() by default in the server.
 *
 *      For systems which do NOT have localtime_r(), we make the
 *      assumption that localtime() is re-entrant, and returns a
 *      per-thread data structure.
 *
 *      Even if localtime is NOT re-entrant, this function will
 *      lower the possibility of race conditions.
 */
struct tm *localtime_r(time_t const *l_clock, struct tm *result)
{
  memcpy(result, localtime(l_clock), sizeof(*result));
 
  return result;
}
#endif
 
#ifndef HAVE_CTIME_R
/*
 *      We use ctime_r() by default in the server.
 *
 *      For systems which do NOT have ctime_r(), we make the
 *      assumption that ctime() is re-entrant, and returns a
 *      per-thread data structure.
 *
 *      Even if ctime is NOT re-entrant, this function will
 *      lower the possibility of race conditions.
 */
char *ctime_r(time_t const *l_clock, char *l_buf)
{
        char *p;
 
        p = ctime(l_clock);
        if (!p) return NULL;
 
        strcpy(l_buf, p);
 
        return l_buf;
}
#endif
 
#ifndef HAVE_GMTIME_R
/*
 *      We use gmtime_r() by default in the server.
 *
 *      For systems which do NOT have gmtime_r(), we make the
 *      assumption that gmtime() is re-entrant, and returns a
 *      per-thread data structure.
 *
 *      Even if gmtime is NOT re-entrant, this function will
 *      lower the possibility of race conditions.
 */
struct tm *gmtime_r(time_t const *l_clock, struct tm *result)
{
  memcpy(result, gmtime(l_clock), sizeof(*result));
 
  return result;
}
#endif
 
#ifndef HAVE_VDPRINTF
int vdprintf(int fd, char const *format, va_list args)
{
        int     ret;
        FILE    *fp;
        int     dup_fd;
 
        dup_fd = dup(fd);
        if (dup_fd < 0) return -1;
 
        fp = fdopen(dup_fd, "w");
        if (!fp) {
                close(dup_fd);
                return -1;
        }
 
        ret = vfprintf(fp, format, args);
        fclose(fp);     /* Also closes dup_fd */
 
        return ret;
}
#endif
 
 
#if !defined(HAVE_CLOCK_GETTIME) && defined(__MACH__)
int clock_gettime(int clk_id, struct timespec *t)
{
        static mach_timebase_info_data_t timebase;
        static bool done_init = false;
 
        static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
 
        if (!done_init) {
                pthread_mutex_lock(&mutex);
                if (!done_init) {
                        mach_timebase_info(&timebase);
                        done_init = true;
                }
                pthread_mutex_unlock(&mutex);
        }
 
        switch (clk_id) {
        case CLOCK_REALTIME:
                return -1;
 
        case CLOCK_MONOTONIC:
        {
                uint64_t time;
                time = mach_absolute_time();
                double nanoseconds = ((double)time * (double)timebase.numer)/((double)timebase.denom);
                double seconds = ((double)time * (double)timebase.numer)/((double)timebase.denom * 1e9);
                t->tv_sec = seconds;
                t->tv_nsec = nanoseconds;
        }
                return 0;
 
        default:
                errno = EINVAL;
                return -1;
        }
}
#endif
 
/*
 *      Replacements in case we don't have inet_pton
 */
#ifndef HAVE_INET_PTON
static int inet_pton4(char const *src, struct in_addr *dst)
{
        int octet;
        unsigned int num;
        char const *p, *off;
        uint8_t tmp[4];
        static char const digits[] = "0123456789";
 
        octet = 0;
        p = src;
        while (1) {
                num = 0;
                while (*p && ((off = strchr(digits, *p)) != NULL)) {
                        num *= 10;
                        num += (off - digits);
 
                        if (num > 255) return 0;
 
                        p++;
                }
                if (!*p) break;
 
                /*
                 *      Not a digit, MUST be a dot, else we
                 *      die.
                 */
                if (*p != '.') {
                        return 0;
                }
 
                tmp[octet++] = num;
                p++;
        }
 
        /*
         *      End of the string.  At the fourth
         *      octet is OK, anything else is an
         *      error.
         */
        if (octet != 3) {
                return 0;
        }
        tmp[3] = num;
 
        memcpy(dst, &tmp, sizeof(tmp));
        return 1;
}
 
 
#  ifdef HAVE_STRUCT_SOCKADDR_IN6
/** Convert presentation level address to network order binary form
 *
 * @note Does not touch dst unless it's returning 1.
 * @note :: in a full address is silently ignored.
 * @note Inspired by Mark Andrews.
 * @author Paul Vixie, 1996.
 *
 * @param src presentation level address.
 * @param dst where to write output address.
 * @return
 *      - 1 if `src' is a valid [RFC1884 2.2] address.
 *      - 0 if `src' in not a valid [RFC1884 2.2] address.
 */
static int inet_pton6(char const *src, unsigned char *dst)
{
        static char const xdigits_l[] = "0123456789abcdef",
                          xdigits_u[] = "0123456789ABCDEF";
        uint8_t tmp[IN6ADDRSZ], *tp, *endp, *colonp;
        char const *xdigits, *curtok;
        int ch, saw_xdigit;
        u_int val;
 
        memset((tp = tmp), 0, IN6ADDRSZ);
        endp = tp + IN6ADDRSZ;
        colonp = NULL;
        /* Leading :: requires some special handling. */
        if (*src == ':')
                if (*++src != ':')
                        return (0);
        curtok = src;
        saw_xdigit = 0;
        val = 0;
        while ((ch = *src++) != '\0') {
                char const *pch;
 
                if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
                        pch = strchr((xdigits = xdigits_u), ch);
                if (pch != NULL) {
                        val <<= 4;
                        val |= (pch - xdigits);
                        if (val > 0xffff)
                                return (0);
                        saw_xdigit = 1;
                        continue;
                }
                if (ch == ':') {
                        curtok = src;
                        if (!saw_xdigit) {
                                if (colonp)
                                        return (0);
                                colonp = tp;
                                continue;
                        }
                        if (tp + INT16SZ > endp)
                                return (0);
                        *tp++ = (uint8_t) (val >> 8) & 0xff;
                        *tp++ = (uint8_t) val & 0xff;
                        saw_xdigit = 0;
                        val = 0;
                        continue;
                }
                if (ch == '.' && ((tp + INADDRSZ) <= endp) &&
                    inet_pton4(curtok, (struct in_addr *) tp) > 0) {
                        tp += INADDRSZ;
                        saw_xdigit = 0;
                        break;  /* '\0' was seen by inet_pton4(). */
                }
                return (0);
        }
        if (saw_xdigit) {
                if (tp + INT16SZ > endp)
                        return (0);
                *tp++ = (uint8_t) (val >> 8) & 0xff;
                *tp++ = (uint8_t) val & 0xff;
        }
        if (colonp != NULL) {
                /*
                 * Since some memmove()'s erroneously fail to handle
                 * overlapping regions, we'll do the shift by hand.
                 */
                int const n = tp - colonp;
                int i;
 
                for (i = 1; i <= n; i++) {
                        endp[- i] = colonp[n - i];
                        colonp[n - i] = 0;
                }
                tp = endp;
        }
        if (tp != endp)
                return (0);
        /* bcopy(tmp, dst, IN6ADDRSZ); */
        memcpy(dst, tmp, IN6ADDRSZ);
        return (1);
}
#  endif
 
/*
 *      Utility function, so that the rest of the server doesn't
 *      have ifdef's around IPv6 support
 */
int inet_pton(int af, char const *src, void *dst)
{
        if (af == AF_INET) return inet_pton4(src, dst);
 
#  ifdef HAVE_STRUCT_SOCKADDR_IN6
        if (af == AF_INET6) return inet_pton6(src, dst);
#  endif
        return -1;
}
#endif  /* HAVE_INET_PTON */
 
#ifndef HAVE_INET_NTOP
/*
 *      Utility function, so that the rest of the server doesn't
 *      have ifdef's around IPv6 support
 */
char const *inet_ntop(int af, void const *src, char *dst, size_t cnt)
{
        if (af == AF_INET) {
                uint8_t const *ipaddr = src;
 
                if (cnt <= INET_ADDRSTRLEN) return NULL;
 
                snprintf(dst, cnt, "%d.%d.%d.%d",
                         ipaddr[0], ipaddr[1],
                         ipaddr[2], ipaddr[3]);
                return dst;
        }
 
        /*
         *      If the system doesn't define this, we define it
         *      in missing.h
         */
        if (af == AF_INET6) {
                struct in6_addr const *ipaddr = src;
 
                if (cnt <= INET6_ADDRSTRLEN) return NULL;
 
                snprintf(dst, cnt, "%x:%x:%x:%x:%x:%x:%x:%x",
                         fr_nbo_to_uint16(ipaddr->a6_addr),
                         fr_nbo_to_uint16(ipaddr->a6_addr + 2),
                         fr_nbo_to_uint16(ipaddr->a6_addr + 4),
                         fr_nbo_to_uint16(ipaddr->a6_addr + 6),
                         fr_nbo_to_uint16(ipaddr->a6_addr + 8),
                         fr_nbo_to_uint16(ipaddr->a6_addr + 10),
                         fr_nbo_to_uint16(ipaddr->a6_addr + 12),
                         fr_nbo_to_uint16(ipaddr->a6_addr + 14));
                return dst;
        }
 
        return NULL;            /* don't support IPv6 */
}
#endif
 
#ifndef HAVE_SENDMMSG
/** Emulates the real sendmmsg in userland
 *
 * The idea behind the proper sendmmsg in FreeBSD and Linux is that multiple
 * datagram messages can be sent using a single system call.
 *
 * This function doesn't achieve that, but it does reduce ifdefs elsewhere
 * and means we can batch encoding/sending operations.
 *
 * @param[in] sockfd    to write packets to.
 * @param[in] msgvec    a pointer to an array of mmsghdr structures.
 *                      The size of this array is specified in vlen.
 * @param[in] vlen      Length of msgvec.
 * @param[in] flags     same as for sendmsg(2).
 * @return
 *      - >= 0 The number of messages sent.  Check against vlen to determine
 *        if overall operation was successful.
 *      - < 0 on error.  Only returned if first operation errors.
 */
int sendmmsg(int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags)
{
        unsigned int i;
 
        for (i = 0; i < vlen; i++) {
                ssize_t slen;
 
                slen = sendmsg(sockfd, &msgvec[i].msg_hdr, flags);
                if (slen < 0) {
                        msgvec[i].msg_len = 0;
 
                        /*
                         * man sendmmsg - Errors are as for sendmsg(2).
                         * An error is returned only if no datagrams could
                         * be sent.  See also BUGS.
                         */
                        if (i == 0) return -1;
                        return i;
                }
                msgvec[i].msg_len = (unsigned int)slen; /* Number of bytes sent */
        }
 
        return i;
}
#endif
 
#ifndef HAVE_RECVMMSG
/** Emulates the real recvmmsg in userland
 *
 * The proper recvmmsg in FreeBSD and Linux receives multiple datagram
 * messages using a single system call.
 *
 * This function doesn't achieve that, but it does reduce ifdefs elsewhere
 * and means we can batch receiving/decoding operations.
 *
 * @param[in] sockfd    to read packets from.
 * @param[in] msgvec    a pointer to an array of mmsghdr structures.
 *                      The size of this array is specified in vlen.
 * @param[in] vlen      Length of msgvec.
 * @param[in] flags     same as for recvmsg(2).
 * @param[in] timeout   ignored.  Each recvmsg blocks or not as the socket
 *                      does, so only use this on a non-blocking socket.
 * @return
 *      - >= 0 The number of messages received.  Check against vlen to determine
 *        if overall operation was successful.
 *      - < 0 on error.  Only returned if first operation errors.
 */
int recvmmsg(int sockfd, struct mmsghdr *msgvec, unsigned int vlen, int flags, UNUSED struct timespec *timeout)
{
        unsigned int i;
 
        for (i = 0; i < vlen; i++) {
                ssize_t slen;
 
                slen = recvmsg(sockfd, &msgvec[i].msg_hdr, flags);
                if (slen < 0) {
                        msgvec[i].msg_len = 0;
 
                        /*
                         * man recvmmsg - An error is returned only if no
                         * datagrams could be received.  See also BUGS.
                         */
                        if (i == 0) return -1;
                        return i;
                }
                msgvec[i].msg_len = (unsigned int)slen; /* Number of bytes received */
        }
 
        return i;
}
#endif
 
#ifndef HAVE_MEMFD_CREATE
#include <fcntl.h>
#include <stdio.h>
#include <sys/mman.h>
#include <freeradius-devel/util/rand.h>
 
/** Emulates memfd_create with a named shared memory object
 *
 * A memfd is an anonymous shared memory object which lives as long as a
 * descriptor or mapping refers to it.  The nearest portable thing is a
 * named object which is unlinked as soon as it has been opened.  The
 * name is only there to create it, so it is the caller's name with a
 * random suffix, and only its first characters are kept as macOS limits
 * the whole name to 31 characters.
 *
 * @param[in] name      for debugging, as for the real call.
 * @param[in] flags     only MFD_CLOEXEC is honoured.
 * @return
 *      - The descriptor.
 *      - -1 on error, with errno set as for shm_open.
 */
int memfd_create(char const *name, unsigned int flags)
{
        char    path[32];
        int     fd;
 
        snprintf(path, sizeof(path), "/%.6s_%08" PRIx32 "%08" PRIx32, name, fr_rand(), fr_rand());
 
        fd = shm_open(path, O_RDWR | O_CREAT | O_EXCL, 0600);
        if (fd < 0) return -1;
 
        (void) shm_unlink(path);
        if (flags & MFD_CLOEXEC) (void) fcntl(fd, F_SETFD, FD_CLOEXEC);
 
        return fd;
}
#endif
 
/*
 *      So we don't have ifdef's in the rest of the code
 */
#ifndef HAVE_CLOSEFROM
 #include <stdlib.h>
#ifdef HAVE_DIRENT_H
#  include <dirent.h>
/*
 *      Some versions of Linux don't have closefrom(), but they will
 *      have /proc.
 *
 *      BSD systems will generally have closefrom(), but not proc.
 *
 *      OSX doesn't have closefrom() or /proc/self/fd, but it does
 *      have /dev/fd
 */
#  ifdef __linux__
#    define CLOSEFROM_DIR "/proc/self/fd"
#  elif defined(__APPLE__)
#    define CLOSEFROM_DIR "/dev/fd"
#  else
#    undef HAVE_DIRENT_H
#  endif
#endif
 
void closefrom(int fd)
{
        int i;
        int maxfd = 256;
#  ifdef HAVE_DIRENT_H
        DIR *dir;
#  endif
 
#ifdef F_CLOSEM
        if (fcntl(fd, F_CLOSEM) == 0) return;
#  endif
 
#  ifdef F_MAXFD
        maxfd = fcntl(fd, F_F_MAXFD);
        if (maxfd >= 0) goto do_close;
#  endif
 
#  ifdef _SC_OPEN_MAX
        maxfd = sysconf(_SC_OPEN_MAX);
        if (maxfd < 0) {
                maxfd = 256;
        }
#  endif
 
#  ifdef HAVE_DIRENT_H
        /*
         *      Use /proc/self/fd directory if it exists.
         */
        dir = opendir(CLOSEFROM_DIR);
        if (dir != NULL) {
                long my_fd;
                char *endp;
                struct dirent *dp;
 
                while ((dp = readdir(dir)) != NULL) {
                        my_fd = strtol(dp->d_name, &endp, 10);
                        if (my_fd <= 0) continue;
 
                        if (*endp) continue;
 
                        if (my_fd == dirfd(dir)) continue;
 
                        if ((my_fd >= fd) && (my_fd <= maxfd)) {
                                (void) close((int) my_fd);
                        }
                }
                (void) closedir(dir);
                return;
        }
#  endif
 
#  ifdef F_MAXFD
do_close:
#  endif
 
        if (fd > maxfd) return;
 
        /*
         *      FIXME: return EINTR?
         */
        for (i = fd; i < maxfd; i++) {
                close(i);
        }
 
        return;
}
#endif
 
#ifndef HAVE_MEMSET_EXPLICIT
void *memset_explicit(void *ptr,
#ifdef HAVE_EXPLICIT_BZERO
                      UNUSED
#endif
                      int ch,
                      size_t len)
{
        if (!len) return ptr;
 
#ifdef HAVE_EXPLICIT_BZERO
        explicit_bzero(ptr, len);
#else
        {
                volatile unsigned char *volatile p =  (volatile unsigned char *volatile) ptr;
                size_t i = len;
 
                while (i--) {
                        *(p++) = ch;
                }
        }
#endif
 
        return ptr;
}
#endif