utils.cpp

Go to the documentation of this file.

#include <utils.h>

#ifdef _WIN32
#include <winsock2.h>
#include <windows.h>
#include <io.h>
#define O_RDWR _O_RDWR
#define O_BINARY _O_BINARY
#define O_CREAT _O_CREAT
#define O_EXCL _O_EXCL
#define S_IREAD _S_IREAD
#define S_IWRITE _S_IWRITE
#endif
#ifdef HAVE_LINUX
#include <arpa/inet.h>
#define O_BINARY (0)
#endif

#include <inttypes.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <limits.h>

#include <cstdlib>
#include <cstring>
#include <functional>
#include <sstream>

/*#include <portable_endian.h>*/
#include <endianness_config.h>


void cbWrapper(void * data, void * hint) {
    (void)data;
    std::function<void()>* f = reinterpret_cast<std::function<void()>*>(hint);
    (*f)();
    delete f;
}

void insertNetworkUInt32(void * buffer, uint32_t value) {
    uint32_t temp = htobe32(value);
    memcpy(buffer, &temp, sizeof(uint32_t));
}

void insertNetworkUInt64(void * buffer, uint64_t value) {
    uint64_t temp = htobe64(value);
    memcpy(buffer, &temp, sizeof(uint64_t));
}

uint32_t readNetworkUInt32(void * buffer) {
    uint32_t temp;
    memcpy(&temp, buffer, sizeof(uint32_t));
    return betoh32(temp);
}

uint64_t readNetworkUInt64(void * buffer) {
    uint64_t temp;
    memcpy(&temp, buffer, sizeof(uint64_t));
    return betoh64(temp);
}

void setThreadPriority(std::thread & th, thread_priority_t prio) {
#ifdef WIN32
    HANDLE h_th = (HANDLE)th.native_handle();

    switch (prio)
    {
    case REALTIME       : (void) SetThreadPriority(h_th, THREAD_PRIORITY_TIME_CRITICAL);        break;
    case HIGH           : (void) SetThreadPriority(h_th, THREAD_PRIORITY_HIGHEST);          break;
    case ABOVE_NORMAL   : (void) SetThreadPriority(h_th, THREAD_PRIORITY_ABOVE_NORMAL);     break;
    case NORMAL         : (void) SetThreadPriority(h_th, THREAD_PRIORITY_NORMAL);           break;
    case BELOW_NORMAL   : (void) SetThreadPriority(h_th, THREAD_PRIORITY_BELOW_NORMAL);     break;
    case IDLE           : (void) SetThreadPriority(h_th, THREAD_PRIORITY_LOWEST);           break;
    }
#else
#ifndef __APPLE__
    pthread_t thId = (pthread_t)th.native_handle();
    pthread_attr_t thAttr;
    int policy = 0;
    int minPrio = 0;
    int maxPrio = 0;
    int iprio;

    pthread_attr_init(&thAttr);
    pthread_attr_getschedpolicy(&thAttr, &policy);
    minPrio = sched_get_priority_min(policy);
    maxPrio = sched_get_priority_max(policy);

    switch (prio) {
        case REALTIME:
            iprio = maxPrio;
            break;
        case HIGH:
            iprio = (3 * maxPrio + minPrio) / 4;
            break;
        case ABOVE_NORMAL:
            iprio = (2 * maxPrio + minPrio) / 3;
            break;
        case BELOW_NORMAL:
            iprio = (maxPrio + 2 * minPrio) / 3;
            break;
        case IDLE:
            iprio = minPrio;
            break;
        case NORMAL:
        default:
            iprio = (maxPrio + minPrio) / 2;
            break;
    }
    pthread_setschedprio(thId, iprio);
    pthread_attr_destroy(&thAttr);
#endif
#endif
}

size_t fwriteString(FILE * stream, const std::string & str) {
    return fwrite(str.c_str(), 1, str.size(), stream);
}

#ifdef HAVE_WINDOWS
/* mkstemp extracted from libc/sysdeps/posix/tempname.c.  Copyright
   (C) 1991-1999, 2000, 2001, 2006 Free Software Foundation, Inc.

   The GNU C 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.  */

static const char letters[] =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

/* Generate a temporary file name based on TMPL.  TMPL must match the
   rules for mk[s]temp (i.e. end in "XXXXXX").  The name constructed
   does not exist at the time of the call to mkstemp.  TMPL is
   overwritten with the result.  */
int mkstemp (char *tmpl) {
  size_t len;
  char *XXXXXX;
  static unsigned long long value;
  unsigned long long random_time_bits;
  unsigned int count;
  int fd = -1;
  int save_errno = errno;

  /* A lower bound on the number of temporary files to attempt to
     generate.  The maximum total number of temporary file names that
     can exist for a given template is 62**6.  It should never be
     necessary to try all these combinations.  Instead if a reasonable
     number of names is tried (we define reasonable as 62**3) fail to
     give the system administrator the chance to remove the problems.  */
#define ATTEMPTS_MIN (62 * 62 * 62)

  /* The number of times to attempt to generate a temporary file.  To
     conform to POSIX, this must be no smaller than TMP_MAX.  */
#if ATTEMPTS_MIN < TMP_MAX
  unsigned int attempts = TMP_MAX;
#else
  unsigned int attempts = ATTEMPTS_MIN;
#endif

  len = strlen (tmpl);
  if (len < 6 || strcmp (&tmpl[len - 6], "XXXXXX"))
    {
      errno = EINVAL;
      return -1;
    }

/* This is where the Xs start.  */
  XXXXXX = &tmpl[len - 6];

  /* Get some more or less random data.  */
  {
    SYSTEMTIME      stNow;
    FILETIME ftNow;

    // get system time
    GetSystemTime(&stNow);
    stNow.wMilliseconds = 500;
    if (!SystemTimeToFileTime(&stNow, &ftNow))
    {
        errno = -1;
        return -1;
    }

    random_time_bits = (((unsigned long long)ftNow.dwHighDateTime << 32)
                        | (unsigned long long)ftNow.dwLowDateTime);
  }
  value += random_time_bits ^ (unsigned long long)GetCurrentThreadId ();

  for (count = 0; count < attempts; value += 7777, ++count)
    {
      unsigned long long v = value;

      /* Fill in the random bits.  */
      XXXXXX[0] = letters[v % 62];
      v /= 62;
      XXXXXX[1] = letters[v % 62];
      v /= 62;
      XXXXXX[2] = letters[v % 62];
      v /= 62;
      XXXXXX[3] = letters[v % 62];
      v /= 62;
      XXXXXX[4] = letters[v % 62];
      v /= 62;
      XXXXXX[5] = letters[v % 62];

#ifdef HAVE_WINDOWS
      _sopen_s(&fd, tmpl, _O_RDWR | _O_BINARY | _O_CREAT | _O_EXCL, _SH_DENYRW, _S_IREAD | _S_IWRITE);
#else
      fd = open (tmpl, O_RDWR | O_BINARY | O_CREAT | O_EXCL, S_IREAD | S_IWRITE);
#endif
      if (fd >= 0)
    {
      errno = save_errno;
      return fd;
    }
      else if (errno != EEXIST)
    return -1;
    }

  /* We got out of the loop because we ran out of combinations to try.  */
  errno = EEXIST;
  return -1;
}
#endif

std::string getHome() {
    std::stringstream home;
#ifdef _WIN32
    char * temp;
    size_t size;
    _dupenv_s(&temp, &size, "HOMEDRIVE");
    home << temp;
    free(temp);
    _dupenv_s(&temp, &size, "HOMEPATH");
    home << temp;
    free(temp);
#else
    home << getenv("HOME");
#endif
    return home.str();
}