utils.cpp

/**************************************************************
* Copyright (c) 2010-2013, Dynamic Network Services, Inc.
* Jake Montgomery (jmontgomery@dyn.com) & Tom Daly (tom@dyn.com)
* Distributed under the FreeBSD License - see LICENSE
***************************************************************/
// Base header for the beacon and control
#include "common.h"
#include "utils.h"
#include "compat.h"
#include <errno.h>
#include <string.h>
#include <stdarg.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <sys/socket.h>

using namespace std;

static const size_t formatShortBuffersSize = 256;
static const size_t formatShortBuffersCount = 12;

static const size_t formatMediumBuffersSize = 1024;  // must be big enough for full, escaped, domain name.
static const size_t formatMediumBuffersCount = 4;
static pthread_key_t gUtilsTLSKey;
static bool gHasUtilsTLSKey = false;
static const size_t bigBufferMaxSize = 4096;

namespace openbfdd
{

  struct UtilsTLSData
  {
    UtilsTLSData() :
       nextFormatShortBuffer(0),
       nextFormatMediumBuffer(0),
       bigBuffer(NULL),
       bigBufferSize(0)
    { }

    ~UtilsTLSData()
    {
      delete[] bigBuffer;
    }

    char formatShortBuffers[formatShortBuffersCount][formatShortBuffersSize];   // For "human readable" numbers. Big enough for a signed int64_t with commas.
    uint32_t nextFormatShortBuffer;

    char formatMediumBuffers[formatMediumBuffersCount][formatMediumBuffersSize]; // Big Enough for domain name as text
    uint32_t nextFormatMediumBuffer;

    char *bigBuffer;
    size_t bigBufferSize;

  };


  static void deleteUtilsTLS(void *data)
  {
    if (data)
    {
      delete (reinterpret_cast<UtilsTLSData *>(data));
    }
  }

  static UtilsTLSData* getUtilsTLS()
  {
    if (!gHasUtilsTLSKey)
      return NULL;
    void *data = pthread_getspecific(gUtilsTLSKey);
    if (data != NULL)
      return reinterpret_cast<UtilsTLSData *>(data);

    UtilsTLSData *tlsData = new(std::nothrow) UtilsTLSData;
    if (!tlsData)
      return NULL;

    if (0 != pthread_setspecific(gUtilsTLSKey, tlsData))
    {
      delete tlsData;
      return NULL;
    }

    return tlsData;
  }



  bool UtilsInit()
  {
    if (gHasUtilsTLSKey)
      return true;

    int ret = pthread_key_create(&gUtilsTLSKey, deleteUtilsTLS);
    if (ret != 0)
      return false;
    gHasUtilsTLSKey = true;

    // This is a 'kludgy' attempt to detect when the pthread libraries have been
    // 'stubbed', as there are on FreeBSD without the -pthread flag.

    if (0 != pthread_setspecific(gUtilsTLSKey, (void *)(uintptr_t)(0xbefed)))
      return false;

    void *data = pthread_getspecific(gUtilsTLSKey);
    if ((uintptr_t)data != (uintptr_t)(0xbefed))
      return false;

    if (0 != pthread_setspecific(gUtilsTLSKey, NULL))
      return false;

    return true;
  }

  static char* nextFormatShortBuffer()
  {
    UtilsTLSData *tls = getUtilsTLS();
    if (!tls)
      return NULL;

    char *nextBuf = tls->formatShortBuffers[tls->nextFormatShortBuffer++];
    if (tls->nextFormatShortBuffer >= countof(tls->formatShortBuffers))
      tls->nextFormatShortBuffer = 0;
    return nextBuf;
  }


  static char* nextFormatMeduimBuffer()
  {
    UtilsTLSData *tls = getUtilsTLS();
    if (!tls)
      return NULL;

    char *nextBuf = tls->formatMediumBuffers[tls->nextFormatMediumBuffer++];
    if (tls->nextFormatMediumBuffer >= countof(tls->formatMediumBuffers))
      tls->nextFormatMediumBuffer = 0;
    return nextBuf;
  }




  /**
   * Gets the "big" buffer from tls.
   *
   * @param outBuf  [out] - Set to the buffer. Set to NULL on failure.
   *
   * @return size_t - The size of the buffer. 0 on failure.
   */
  static size_t getBigBuffer(char **outBuf)
  {
    if (!outBuf)
      return 0;
    *outBuf = NULL;

    UtilsTLSData *tls = getUtilsTLS();
    if (!tls)
      return 0;

    if (tls->bigBufferSize == 0)
    {
      tls->bigBuffer = new(std::nothrow) char[bigBufferMaxSize];
      if (!tls->bigBuffer)
        return 0;

      tls->bigBufferSize = bigBufferMaxSize;
    }

    *outBuf = tls->bigBuffer;
    return tls->bigBufferSize;
  }

  bool UtilsInitThread()
  {
    char *unusedBuf;

    if (!getBigBuffer(&unusedBuf))
      return false;

    return true;
  }

  size_t GetBigTLSBuffer(char **outBuf)
  {
    return getBigBuffer(outBuf);
  }

  size_t GetMediumTLSBuffer(char **outBuf)
  {
    if (!outBuf)
      return 0;

    *outBuf = nextFormatMeduimBuffer();
    if (*outBuf == NULL)
      return 0;
    return formatMediumBuffersSize;
  }

  size_t GetSmallTLSBuffer(char **outBuf)
  {
    if (!outBuf)
      return 0;

    *outBuf = nextFormatShortBuffer();
    if (*outBuf == NULL)
      return 0;
    return formatShortBuffersSize;
  }


  bool StringToInt(const char *arg, int64_t &value)
  {
    const char *next;
    if (!StringToInt(arg, value, &next))
      return false;

    next = SkipWhite(next);

    return (*next == '\0');
  }

  bool StringToInt(const char *arg, int64_t &value, const char **outNext)
  {
    int64_t val = 0;
    bool negative = false;
    const char *next;

    value = 0;
    if (!arg)
    {
      if (outNext)
        *outNext = NULL;
      return false;
    }

    next = SkipWhite(arg);

    if (*next == '+')
    {
      negative = false;
      next++;
    }
    else if (*next == '-')
    {
      negative = true;
      next++;
    }

    if (!isdigit(*next))
    {
      if (outNext)
        *outNext = next;
      return false;
    }

    for (; isdigit(*next); next++)
      val = val * 10 + *next - '0';

    if (outNext)
      *outNext = next;

    if (negative)
      val *= -1;
    value = val;

    if (!::isspace(*next) && *next != '\0')
      return false;

    return true;
  }


  bool StringToInt(const char *arg, uint64_t &value)
  {
    const char *next;
    if (!StringToInt(arg, value, &next))
      return false;

    next = SkipWhite(next);

    return (*next == '\0');
  }

  bool StringToInt(const char *arg, uint64_t &value, const char **outNext)
  {
    uint64_t val = 0;
    const char *next;

    value = 0;
    if (!arg)
    {
      if (outNext)
        *outNext = NULL;
      return false;
    }

    next = SkipWhite(arg);

    if (*next == '+')
      next++;
    else if (*next == '-')
    {
      if (outNext)
        *outNext = next;
      return false;
    }

    if (!isdigit(*next))
    {
      if (outNext)
        *outNext = next;
      return false;
    }

    for (; isdigit(*next); next++)
      val = val * 10 + *next - '0';

    if (outNext)
      *outNext = next;

    value = val;

    if (!::isspace(*next) && *next != '\0')
      return false;


    return true;
  }

  bool PartialStringToInt(const char *arg, uint64_t &value, const char **outNext)
  {
    const char *next;
    bool ret = StringToInt(arg, value, &next);
    if (outNext)
      *outNext = next;
    if (ret)
      return true;
    // We may have failed due to non-number characters after a number, which is ok for this function.
    if (!next || *next == '\0' || next == arg)
      return false;
    // We have consumed at least one character. We want to return true if any numbers were read.
    if (isdigit(*(next - 1)))
      return true;
    return false;
  }



  const char*  SkipWhite(const char *str)
  {
    /* EOS \0 is not a space */
    while (::isspace(*str))
      str++;
    return str;
  }

  char*  SkipWhite(char *str)
  {
    return const_cast<char *>(SkipWhite((const char *)str));
  }

  const char*  SkipNonWhite(const char *str)
  {
    /* EOS \0 is not a space */
    while (*str != '\0' && !::isspace(*str))
      str++;
    return str;
  }

  char*  SkipNonWhite(char *str)
  {
    return const_cast<char *>(SkipNonWhite((const char *)str));
  }

  void TrimTrailingWhite(char *str)
  {
    char *lastNonWhite = NULL;
    while (*str != '\0')
    {
      /* EOS \0 is not a space */
      if (!::isspace(*str))
        lastNonWhite = str;
      str++;
    }
    if (lastNonWhite != NULL && *lastNonWhite != '\0')
      lastNonWhite[1] = '\0';
  }

#define NSEC_PER_SEC 1000000000L

  static inline void timespecNormalize(struct timespec &ts)
  {
    if (ts.tv_nsec >= NSEC_PER_SEC)
    {
      ts.tv_sec += ts.tv_nsec / (NSEC_PER_SEC);
      ts.tv_nsec = ts.tv_nsec % NSEC_PER_SEC;
    }
    else if (ts.tv_nsec <= -NSEC_PER_SEC)
    {
      ts.tv_sec += ts.tv_nsec / (NSEC_PER_SEC);
      ts.tv_nsec = -((-ts.tv_nsec) % NSEC_PER_SEC); // not sure if % is yet standardized for negatives.
    }

    // make sure both have same sign
    if (ts.tv_sec > 0 && ts.tv_nsec < 0)
    {
      ts.tv_sec--;
      ts.tv_nsec = NSEC_PER_SEC + ts.tv_nsec;
    }
    else if (ts.tv_sec < 0 && ts.tv_nsec > 0)
    {
      ts.tv_sec++;
      ts.tv_nsec = NSEC_PER_SEC - ts.tv_nsec;
    }

  }

  void timespecAddMs(struct timespec &ts, uint32_t ms)
  {
    ts.tv_sec += ms / 1000;
    ts.tv_nsec += (ms % 1000) * 1000L * 1000;
    timespecNormalize(ts);
  }

  void timespecAddMicro(struct timespec &ts, uint64_t micro)
  {
    ts.tv_sec += time_t(micro / 1000000);
    ts.tv_nsec += (micro % 1000000) * 1000L;
    timespecNormalize(ts);
  }

  int timespecCompare(const struct timespec &tsl, const struct timespec &tsr)
  {
    if (tsl.tv_sec == tsr.tv_sec)
      return(tsl.tv_nsec > tsr.tv_nsec) ? 1 : (tsl.tv_nsec == tsr.tv_nsec) ? 0 : -1;

    return(tsl.tv_sec > tsr.tv_sec) ? 1 : -1;
  }

  void timespecSubtract(struct timespec &result, const struct timespec &tsl, const struct timespec &tsr)
  {
    result.tv_sec = tsl.tv_sec - tsr.tv_sec;
    result.tv_nsec = tsl.tv_nsec - tsr.tv_nsec;
    timespecNormalize(result);
  }

  struct timespec timespecSubtract(const struct timespec &tsl, const struct timespec &tsr)
  {
    struct timespec result;
    timespecSubtract(result, tsl, tsr);
    return result;
  }


  bool timespecIsNegative(const struct timespec &check)
  {
    return (check.tv_sec < 0 || (check.tv_sec == 0 && check.tv_nsec < 0));
  }

  void timespecToTimeval(const struct timespec &src, struct timeval &dst)
  {
    dst.tv_sec = src.tv_sec;
    dst.tv_usec = src.tv_nsec / 1000L;
  }

  struct timeval timespecToTimeval(const struct timespec &src)
  {
    struct timeval dst;

    timespecToTimeval(src, dst);
    return dst;
  }


  void timevalToTimespec(const struct timeval &src, struct timespec &dst)
  {
    dst.tv_sec = src.tv_sec;
    dst.tv_nsec = src.tv_usec * 1000L;
  }

  bool isTimespecEmpty(const struct timespec &src)
  {
    return src.tv_sec == 0 && src.tv_nsec == 0;
  }

  void MilliSleep(uint32_t ms)
  {
    struct timespec sleepTime;

    sleepTime.tv_sec = ms / 1000;
    sleepTime.tv_nsec = (ms % 1000) * 1000 * 1000;

    nanosleep(&sleepTime, NULL);
  }

  double timespecToSeconds(struct timespec time)
  {
    return (double(time.tv_sec) + double(time.tv_nsec) / NSEC_PER_SEC);
  }

  const char* Ip4ToString(const in_addr &address)
  {
    char *buf = nextFormatShortBuffer();
    if (!buf)
      return "<memerror>";

    sprintf(buf, "%hhu.%hhu.%hhu.%hhu",
            (uint8_t)((uint8_t *)&address)[0],
            (uint8_t)((uint8_t *)&address)[1],
            (uint8_t)((uint8_t *)&address)[2],
            (uint8_t)((uint8_t *)&address)[3]
            );

    return buf;
  }

  const char* Ip4ToString(in_addr_t address)
  {
    in_addr temp;
    temp.s_addr = address;
    return Ip4ToString(temp);
  }

  const char* Ip4ToString(const in_addr &address, uint16_t port)
  {
    return Ip4ToString(address.s_addr,  port);
  }


  const char* Ip4ToString(in_addr_t address, uint16_t port)
  {
    char *buf = nextFormatShortBuffer();
    if (!buf)
      return "<memerror>";

    uint8_t *data = (uint8_t *)&address;


    sprintf(buf, "%hhu.%hhu.%hhu.%hhu:%hu",
            (uint8_t)data[0],
            (uint8_t)data[1],
            (uint8_t)data[2],
            (uint8_t)data[3],
            (unsigned int)port
            );

    return buf;

  }




  static const char *g_byteToString[] =
  {
    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19",
    "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39",
    "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59",
    "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79",
    "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99",
    "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119",
    "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139",
    "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159",
    "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175", "176", "177", "178", "179",
    "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197", "198", "199",
    "200", "201", "202", "203", "204", "205", "206", "207", "208", "209", "210", "211", "212", "213", "214", "215", "216", "217", "218", "219",
    "220", "221", "222", "223", "224", "225", "226", "227", "228", "229", "230", "231", "232", "233", "234", "235", "236", "237", "238", "239",
    "240", "241", "242", "243", "244", "245", "246", "247", "248", "249", "250", "251", "252", "253", "254", "255",
  };

  const char* ByteToString(uint8_t val)
  {
    return  g_byteToString[val];
  }


  char* FormatStr(char *buffer, size_t size, const char *format, ...)
  {
    va_list args;
    va_start(args, format);
    vsnprintf(buffer, size, format, args);
    va_end(args);
    return buffer;
  }

  const char* FormatShortStr(const char *format, ...)
  {
    char *buf = nextFormatShortBuffer();
    if (!buf)
      return "tls_error";

    va_list args;
    va_start(args, format);
    vsnprintf(buf, formatShortBuffersSize, format, args);
    va_end(args);
    return buf;
  }

  const char* FormatMediumStr(const char *format, ...)
  {
    char *buf = nextFormatMeduimBuffer();
    if (!buf)
      return "tls_error";

    va_list args;
    va_start(args, format);
    vsnprintf(buf, formatMediumBuffersSize, format, args);
    va_end(args);
    return buf;
  }

  const char* FormatMediumStrVa(const char *format, va_list args)
  {
    char *buf = nextFormatMeduimBuffer();
    if (!buf)
      return "tls_error";

    vsnprintf(buf, formatMediumBuffersSize, format, args);
    return buf;
  }

  const char* FormatBigStr(const char *format, ...)
  {
    char *buf;
    size_t bufsize = getBigBuffer(&buf);
    if (bufsize == 0)
      return "tls_error";

    va_list args;
    va_start(args, format);
    vsnprintf(buf, bufsize, format, args);
    va_end(args);
    return buf;
  }

  bool GetMonolithicTime(struct timespec &now)
  {
    if (0 == clock_gettime(CLOCK_MONOTONIC, &now))
      return true;

    LogAssertFalse("clock_gettime failed");
    gLog.Optional(Log::Critical, "clock_gettime failed.%s", ErrnoToString());
    now.tv_sec = 0;
    now.tv_nsec = 0;
    return false;
  }

  bool GetRealTime(struct timespec &now)
  {
    if (0 == clock_gettime(CLOCK_REALTIME, &now))
      return true;

    LogAssertFalse("clock_gettime failed");
    gLog.Optional(Log::Critical, "clock_gettime failed.%s", ErrnoToString());
    now.tv_sec = 0;
    now.tv_nsec = 0;
    return false;
  }



  /**
   * Helper for number format routines. buf is assumes to be big enough.
   *
   * @param val
   * @param buf - must be big enough for result. May not be null.
   * @param useCommas
   */
  static void addUnsignedInt(char *buf, uint64_t val, bool useCommas)
  {
    int index = 0, digits = 0;

    char c;
    char *buf2;

    // do in reverse, since that is easiest
    do
    {
      if (useCommas && digits != 0 && (digits % 3 == 0))
        buf[index++] = ',';

      buf[index++] = val % 10 + '0';
      digits++;
    }
    while ((val /= 10) > 0);

    buf[index] = '\0';

    // Reverse the string.
    buf2 = buf + index - 1;

    if (index > 1)
    {
      while (buf < buf2)
      {
        c = *buf2;
        *buf2 = *buf;
        *buf = c;
        buf++;
        buf2--;
      }
    }

  }

  const char* FormatInteger(uint64_t val, bool useCommas)
  {
    char *buf = nextFormatShortBuffer();
    if (!buf)
      return "error";
    addUnsignedInt(buf, val, useCommas);
    return buf;
  }

  const char* FormatInteger(int64_t val, bool useCommas)
  {
    char *buf = nextFormatShortBuffer();
    char *useBuf = buf;
    if (!buf)
      return "error";

    if (val < 0)
    {
      if (val == INT64_MIN)
      {
        // Special case since the positive of this is an overflow.
        if (useCommas)
          return "-9,223,372,036,854,775,808";
        else
          return "-9223372036854775808";
      }
      *(useBuf++) = '-';
      val = -val;
    }
    addUnsignedInt(useBuf, val, useCommas);
    return buf;
  }

  bool CheckArg(const char *check, const char *arg, const char **outParam)
  {
    size_t len = strlen(check);

    *outParam = NULL;

    if (0 != strncmp(check, arg, len))
      return false;
    if (arg[len] == '\0')
      return true;
    if (::isspace(arg[len]))
      return (*SkipWhite(&arg[len]) == '\0');
    if (arg[len] != '=')
      return false;
    *outParam = &arg[len] + 1;

    return true;
  }

  /**
   * Parses a dotted quad and stops on first non-number.
   *
   * @param next [out] - On success, this will point to the character after the
   *        last ip address character.
   *
   * @param str
   * @param out_addr
   * @param next
   *
   * @return bool - false on parsing error.
   */
  static bool parseIPv4Start(const char *str, uint32_t *out_addr, const char **next)
  {
    uint32_t realAddr;
    uint8_t *addr = (uint8_t *)&realAddr;
    int saw_digit, octets, ch;
    uint8_t *tp;

    saw_digit = 0;
    octets = 0;
    *(tp = addr) = 0;
    while ((ch = *str++) != '\0')
    {
      if (ch >= '0' && ch <= '9')
      {
        u_int next = *tp * 10 + (ch  - '0');
        if (saw_digit && *tp == 0)
          return (0);
        if (next > 255)
          return (0);
        *tp = next;
        if (!saw_digit)
        {
          if (++octets > 4)
            return (false);
          saw_digit = 1;
        }
      }
      else if (ch == '.' && saw_digit)
      {
        if (octets == 4)
          return (false);
        *++tp = 0;
        saw_digit = 0;
      }
      else
      {
        break;
      }
    }
    if (octets < 4)
      return (false);

    *out_addr = realAddr;

    if (next)
      *next = str - 1;

    return (true);
  }


  bool ParseIPv4Part(const char *str, uint32_t *out_addr, const char **next /*NULL*/)
  {
    const char *localNext;

    if (!parseIPv4Start(str, out_addr, &localNext))
      return false;
    if (next)
      *next = localNext;
    return true;
  }

  bool ParseIPv4Part(char *str, uint32_t *out_addr, char **next /*NULL*/)
  {
    return ParseIPv4Part(const_cast<const char *>(str),
                         out_addr,
                         const_cast<const char **>(next)
                         );
  }


  bool ParseIPv4(const char *str, uint32_t *out_addr, const char **next /*NULL*/)
  {
    const char *localNext;

    if (!parseIPv4Start(str, out_addr, &localNext))
      return false;
    if (localNext[0] != '\0' && !::isspace(localNext[0]))
      return false;
    if (next)
      *next = localNext;
    return true;
  }

  bool ParseIPv4(char *str, uint32_t *out_addr, char **next /*NULL*/)
  {
    return ParseIPv4(const_cast<const char *>(str),
                     out_addr,
                     const_cast<const char **>(next)
                     );
  }

  bool ParseIPv4Port(const char *str, uint32_t *out_addr, uint16_t *outPort)
  {
    const char *localNext;
    uint64_t port;

    if (!parseIPv4Start(str, out_addr, &localNext))
      return false;
    if (localNext[0] != ':' || ::isspace(localNext[1]))
      return false;
    localNext++;
    if (!StringToInt(localNext, port))
      return false;
    if (port > UINT16_MAX)
      return false;
    *outPort = (uint16_t)port;
    return true;
  }

  bool ParseIPv4Block(const char *str, uint32_t *out_addr, uint8_t *out_bits)
  {
    const char *localNext;
    uint64_t bits;

    if (!parseIPv4Start(str, out_addr, &localNext))
      return false;
    if (localNext[0] != '/' || ::isspace(localNext[1]))
      return false;
    localNext++;
    if (!StringToInt(localNext, bits))
      return false;
    if (bits > 255)
      return false;
    *out_bits = (uint8_t)bits;
    return true;
  }


  bool ParseIPv6Part(const char *str, uint8_t *inOutStorage, const char **outNext /*NULL*/)
  {
    // First determine if it is IPv4 or IPv6
    str = SkipWhite(str);
    const char *firstColon = strchr(str, ':');
    const char *last, *next;

    if (!firstColon)
      return false;

    char addrStr[INET6_ADDRSTRLEN];

    if (*str == '[')
    {
      ++str;
      last = strchr(str,  ']');
      if (!last)
        return false;
      next = last + 1;
    }
    else
    {
      // walk to find first non numeric, and non ':' and non '.' character
      for (last = str; *last != '\0'; ++last)
      {
        if (*last != ':' && *last != '.' && !isxdigit(*last))
          break;
      }
      next = last;
    }

    if (last == str || size_t(last - str) >= sizeof(addrStr))
      return false;

    memcpy(addrStr, str, last - str);
    addrStr[last - str] = '\0';
    if (1 != inet_pton(AF_INET6, addrStr, inOutStorage))
      return false;

    if (outNext)
      *outNext = next;

    return true;

  }

  bool ParseIPv6Part(char *str, uint8_t *inOutStorage, char **outNext /*NULL*/)
  {
    return ParseIPv6Part(const_cast<const char *>(str),
                         inOutStorage,
                         const_cast<const char **>(outNext)
                         );

  }


  bool CheckDir(const char *dir,  int *outErrno)
  {
    if (!dir || dir[0] == '\0')
    {
      if (outErrno)
        *outErrno = ENOENT;
      return false;
    }

    struct stat st;

    if (0 != stat(dir,  &st))
    {
      if (outErrno)
        *outErrno = errno;
      return false;
    }

    if (!S_ISDIR(st.st_mode))
    {
      if (outErrno)
        *outErrno = ENOTDIR;
      return false;
    }
    return true;
  }

  bool FileExists(const char *path, int *outErrno)
  {
    if (!path || path[0] == '\0')
    {
      if (outErrno)
        *outErrno = ENOENT;
      return false;
    }

    struct stat st;

    if (0 != stat(path,  &st))
    {
      if (outErrno)
        *outErrno = errno;
      return false;
    }

    if (!S_ISREG(st.st_mode))
    {
      if (outErrno)
        *outErrno = ENOENT;
      return false;
    }
    return true;
  }


  bool IsExplicitRelativePath(const char *path)
  {
    if (!path || !*path || path[0] != '.')
      return false;
    return (path[1] == '/'
            || (path[1] == '.' && path[2] == '/'));
  }

  string StripFileName(const string &path)
  {
    size_t pos = path.find_last_of('/');
    if (pos == string::npos)
      return string();

    return path.substr(0, pos + 1);
  }

  std::string StripFilePath(const std::string &path)
  {
    size_t pos = path.find_last_of('/');
    if (pos == string::npos)
      return path;

    return path.substr(pos + 1);
  }

  string GetCwd()
  {
    // Using an allocated buffer avoids the huge stack hit, at the expense of an
    // allocation. Not sure if the tradeoff is worthwhile.
    const size_t bufSize = MAXPATHLEN;
    char *buffer = new char[bufSize];

    if (::getcwd(buffer, bufSize) == NULL)
    {
      delete[] buffer;
      return string();
    }

    string result = buffer;
    delete[] buffer;
    return result;
  }


  const char* SystemErrorToString(int errnum)
  {
    int olderr = errno;

    char *buf = nextFormatMeduimBuffer();
    if (!buf)
    {
      errno = olderr;
      return "tls_error";
    }

    compat_strerror_r(errnum, buf, formatMediumBuffersSize);
    errno = olderr;

    return buf;
  }

  const char* ErrnoToString()
  {
    return SystemErrorToString(errno);
  }

}