util.c

// GK - Converter between Gauss-Krueger/TM and WGS84 coordinates for Slovenia
// Copyright (c) 2014-2019 Matjaz Rihtar <matjaz@eunet.si>
// All rights reserved.
//
// This program 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 program 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 program; if not, see http://www.gnu.org/licenses/
//
// util.c: Collection of utility functions for use in other parts of program
//
#include "common.h"

// Hex encoded disallowed URI characters
// See https://url.spec.whatwg.org/#percent-encoded-bytes
const char *hexc[] = {
  // simple encode set: space " # < > ? ` { }
  "%20",        // space
  "%22",        // "
  "%23",        // #
  "%3c", "%3C", // <
  "%3e", "%3E", // >
  "%3f", "%3F", // ?
  "%60",        // `
  "%7b", "%7B", // {
  "%7d", "%7D", // }
  "%25"         // %
  // default encode set: / : ; = @ [ \ ] ^ |
};

#ifdef __cplusplus
extern "C" {
#endif

// ----------------------------------------------------------------------------
// xtrunc
// Round towards zero
// (trunc is missing from Microsoft C)
// ----------------------------------------------------------------------------
double xtrunc(double d)
{
  double r;

  if (d > 0) r = floor(d + 0.00000000000001);
  else r = ceil(d - 0.00000000000001);
  return r;
} /* xtrunc */


// ----------------------------------------------------------------------------
// xround
// Round half up if positive, round half down if negative (= round to nearest)
// (round is missing from Microsoft C)
// ----------------------------------------------------------------------------
int xround(double d)
{
  int i;

  if (d > 0) i = (int)floor(d + 0.50000000000001);
  else i = (int)ceil(d - 0.50000000000001);
  return i;
} /* xround */


// ----------------------------------------------------------------------------
// xllround
// Round half up if positive, round half down if negative (= round to nearest)
// (llround is missing from Microsoft C)
// ----------------------------------------------------------------------------
long long int xllround(double d)
{
  long long int i64;

  if (d > 0) i64 = (long long int)floor(d + 0.50000000000001);
  else i64 = (long long int)ceil(d - 0.50000000000001);
  return i64;
} /* xllround */


// ----------------------------------------------------------------------------
// xfmin
// Return the lesser of two doubles
// (fmin is missing from Microsoft C)
// ----------------------------------------------------------------------------
double xfmin(double d1, double d2)
{
  if (d1 < d2)
    return d1;
  else
    return d2;
} /* xfmin */


// ----------------------------------------------------------------------------
// xfmax
// Return the larger of two doubles
// (fmax is missing from Microsoft C)
// ----------------------------------------------------------------------------
double xfmax(double d1, double d2)
{
  if (d1 > d2)
    return d1;
  else
    return d2;
} /* xfmax */


// ----------------------------------------------------------------------------
// xstrncpy
// Copy string s2 into string s1 until s1 is full (n = size of s1)
// s1 needs size + 1 char for terminating null.
// ----------------------------------------------------------------------------
TCHAR *xstrncpy(TCHAR *s1, const TCHAR *s2, size_t n)
{
  size_t ii;

  if (s1 != NULL && s2 != NULL) {
    // Copy until length of s1 == n or s2 is empty
    for (ii = 0; ii < n && *s2; ii++)
      *s1++ = *s2++;
    *s1 = T('\0');
  }

  return s1;
} /* xstrncpy */


// ----------------------------------------------------------------------------
// xstrncat
// Appends string s2 to string s1 until s1 is full (n = size of s1)
// s1 needs size + 1 char for terminating null.
// ----------------------------------------------------------------------------
TCHAR *xstrncat(TCHAR *s1, const TCHAR *s2, size_t n)
{
  size_t ii;

  if (s1 != NULL && s2 != NULL) {
    for (ii = 0; ii < n && *s1; ii++) s1++;
    // Copy until length of s1 == n or s2 is empty
    for ( ; ii < n && *s2; ii++)
      *s1++ = *s2++;
    *s1 = T('\0');
  }

  return s1;
} /* xstrncat */


// ----------------------------------------------------------------------------
// xstrtrim
// Trims white spaces (defined by "isspace") from the end of str
// Returns pointer to beginning of non-white space in str
// ----------------------------------------------------------------------------
TCHAR *xstrtrim(TCHAR *str)
{
  TCHAR *beg;
  int ii;

  if (str == NULL) return NULL;

  // Trim white spaces at the end
  ii = strlen(str) - 1;
  while (ii >= 0 && isspace(str[ii]))
    str[ii--] = T('\0');

  // Trim white spaces at the beginning
  beg = str;
  while (isspace(*beg)) beg++;

  return beg;
} /* xstrtrim */


// ----------------------------------------------------------------------------
// in_delim
// Returns true if character is in delimiter list.
// ----------------------------------------------------------------------------
int in_delim(TCHAR c, const TCHAR *delim)
{
  int found;
  TCHAR *s;

//if (delim == NULL) return 0;

  found = 0;
  for (s = (TCHAR *)delim; *s && !found; s++) {
    if (c == *s) found = 1;
  }
  return found;
} /* in_delim */


// ----------------------------------------------------------------------------
// xstrtok_r
// Extracts token from string str. Token delimiters are specified in string
// delim. Consecutive delimiters are ignored.
// (strtok_r is missing from Microsoft C & MinGW)
// ----------------------------------------------------------------------------
TCHAR *xstrtok_r(TCHAR *str, const TCHAR *delim, TCHAR **savep)
{
  TCHAR *ret;
  int dc, tc;

  if (str == NULL) {
    if (savep == NULL) return NULL;
    else str = *savep;
    if (str == NULL) return NULL;
  }
  if (delim == NULL) return str; // check this!

  // first clear all delimiters
  for (dc = 1; *str && dc; ) {
    dc = 0;
    if (in_delim(*str, delim)) {
      *str++ = T('\0'); dc = 1;
    }
  }

  ret = str;

  // token is until next delimiter, which is also cleared
  tc = 0;
  for (dc = 0; *str && !dc; str++) {
    if (in_delim(*str, delim)) {
      *str = T('\0'); dc = 1;
    }
    else tc++;
  }
  if (tc == 0) ret = NULL;
  *savep = str;

  return ret;
} /* xstrtok_r */


// ----------------------------------------------------------------------------
// xstrsep
// Extracts token from string *strp. Token delimiters are specified in string
// delim. Consecutive delimiters return empty tokens.
// Empty string *strp returns empty token (token after last delimiter).
// (strsep is missing from Microsoft C)
// ----------------------------------------------------------------------------
TCHAR *xstrsep(TCHAR **strp, const TCHAR *delim)
{
  TCHAR *ret;
  int dc;

  if (strp == NULL || *strp == NULL) return NULL;
  if (delim == NULL) return *strp; // check this!

  ret = *strp;

  for (dc = 0; **strp && !dc; (*strp)++) {
    if (in_delim(**strp, delim)) {
      **strp = T('\0'); dc = 1;
    }
  }
  if (!dc) *strp = NULL; // last token

  return ret;
} /* xstrsep */


// ----------------------------------------------------------------------------
// xstrstr (Boyer-Moore-Horspool)
// Finds the first occurrence of string s2 in string s1 using fast (aver. O(N))
// Boyer-Moore-Horspool algorithm.
// ----------------------------------------------------------------------------
TCHAR *xstrstr(TCHAR *s1, size_t n1, const TCHAR *s2, size_t n2)
{
  size_t ii, last;
  size_t skip[TSIZE];

  if (s1 == NULL || s2 == NULL || n2 > n1) return NULL;
  if (n2 == 0) return s1;

  for (ii = 0; ii < TSIZE; ii++)
    skip[ii] = n2;

  last = n2 - 1;

  for (ii = 0; ii < last; ii++)
    skip[s2[ii] & TSIZE] = last - ii;

  while (n1 >= n2) {
    for (ii = last; s1[ii] == s2[ii]; ii--)
      if (ii == 0) return s1;

    n1 -= skip[s1[last] & TSIZE];
    s1 += skip[s1[last] & TSIZE];
  }

  return NULL;
} /* xstrstr */


// ----------------------------------------------------------------------------
// xstrerror
// Returns string describing last occured error. Trims white spaces and dot
// from the end. Returned string must be freed after use outside the function.
// ----------------------------------------------------------------------------
TCHAR *xstrerror(void)
{
  TCHAR *msg;
  int error, len;

#ifdef _WIN32
  error = GetLastError();
  msg = (TCHAR *)calloc(MAXS+1, sizeof(TCHAR));
  if (msg == NULL) return NULL;
  FormatMessage(
    FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
    NULL, error,
    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),  // default language
    (LPTSTR)msg, MAXS, NULL);
#else //not _WIN32
  error = errno;
  msg = (TCHAR *)calloc(MAXS+1, sizeof(TCHAR));
  if (msg == NULL) return NULL;
  strerror_r(error, msg, MAXS);
#endif

  // Trim white spaces and dot from the end
  len = strlen(msg) - 1;
  while (len >= 0 && (isspace(msg[len]) || msg[len] == T('.')))
    msg[len--] = T('\0');

  return msg;
} /* xstrerror */


// ----------------------------------------------------------------------------
// xprintf
// Writes an entry in previously opened log file, prepended by time of entry.
// ----------------------------------------------------------------------------
int xprintf(FILE *out, TCHAR *fmt, ...)
{
  va_list ap;
  time_t now;
  struct tm *tmnow;
  TCHAR ftime[MAXS+1];
  TCHAR *msg;

  now = time(NULL);
  tmnow = localtime(&now);
//strftime(ftime, MAXS, T("%y-%m-%d %H:%M:%S"), tmnow);
  strftime(ftime, MAXS, T("%H:%M:%S"), tmnow);

  msg = (TCHAR *)calloc(MAXL+1, sizeof(TCHAR));

  va_start(ap, fmt);
  vsnprintf(msg, MAXL, fmt, ap);
  va_end(ap);

  fprintf(out, T("%s %s"), ftime, msg);
//fflush(NULL);

  free(msg);
  return 0;
} /* xprintf */


// ----------------------------------------------------------------------------
// fefind
// Tries to find first free file name with specified extension (adding numbers
// to the name until 15).
// ----------------------------------------------------------------------------
TCHAR *fefind(TCHAR *fname, TCHAR *ext, TCHAR *newname)
{
  TCHAR name[MAXS+1], newext[MAXS+1], *s;
  struct _stat fst;
  int ii;

  xstrncpy(name, fname, MAXS);
  if ((s = strrchr(name, T('.'))) != NULL) *s = T('\0');

  xstrncpy(newname, name, MAXS);
  xstrncat(newname, ext, MAXS);
  for (ii = 0; ii <= 15; ii++) { // append 1..15 to output file name
    if (utf8_stat(newname, &fst) < 0) break; // file not found
    snprintf(newext, MAXS, T("-%d%s"), ii+1, ext);
    xstrncpy(newname, name, MAXS);
    xstrncat(newname, newext, MAXS);
  }
  if (ii > 15) {
    xstrncpy(newname, name, MAXS);
    xstrncat(newname, ext, MAXS);
    return NULL;
  }
  return newname;
} /* fefind */


#ifdef _WIN32
// ----------------------------------------------------------------------------
// getFILETIMEoffset
// Get time offset since January 1, 1970 for conversion to Unix epoch.
// ----------------------------------------------------------------------------
LARGE_INTEGER getFILETIMEoffset()
{
  SYSTEMTIME s;
  FILETIME f;
  LARGE_INTEGER t;

  s.wYear = 1970;
  s.wMonth = 1;
  s.wDay = 1;
  s.wHour = 0;
  s.wMinute = 0;
  s.wSecond = 0;
  s.wMilliseconds = 0;
  SystemTimeToFileTime(&s, &f);
  t.QuadPart = f.dwHighDateTime;
  t.QuadPart <<= 32;
  t.QuadPart |= f.dwLowDateTime;
  return t;
} /* getFILETIMEoffset */


// ----------------------------------------------------------------------------
// clock_gettime
// Returns the time of the specified clock clk_id in nanoseconds precision.
// (clock_gettime is missing from Microsoft C)
// ----------------------------------------------------------------------------
int clock_gettime(int clk_id, struct timespec *tv)
{
  LARGE_INTEGER t;
  FILETIME f;
//double microseconds;
  double nanoseconds;
  static LARGE_INTEGER offset;
//static double frequencyToMicroseconds;
  static double frequencyToNanoseconds;
  static int initialized = 0;
  static int usePerformanceCounter = 0;

  if (!initialized) {
    LARGE_INTEGER performanceFrequency;
    initialized = 1;
    usePerformanceCounter = QueryPerformanceFrequency(&performanceFrequency);
    if (usePerformanceCounter) {
      QueryPerformanceCounter(&offset);
   // frequencyToMicroseconds = (double)performanceFrequency.QuadPart / MICROSEC;
      frequencyToNanoseconds = (double)performanceFrequency.QuadPart / NANOSEC;
    }
    else {
      offset = getFILETIMEoffset();
   // frequencyToMicroseconds = 10.0;
      frequencyToNanoseconds = 0.01;
    }
  }
  if (usePerformanceCounter) QueryPerformanceCounter(&t);
  else {
    GetSystemTimeAsFileTime(&f);
    t.QuadPart = f.dwHighDateTime;
    t.QuadPart <<= 32;
    t.QuadPart |= f.dwLowDateTime;
  }

  t.QuadPart -= offset.QuadPart;
//microseconds = (double)t.QuadPart / frequencyToMicroseconds;
  nanoseconds = (double)t.QuadPart / frequencyToNanoseconds;
//t.QuadPart = (LONGLONG)microseconds;
  t.QuadPart = (LONGLONG)nanoseconds;
//tv->tv_sec = t.QuadPart / MICROSEC;
  tv->tv_sec = t.QuadPart / NANOSEC;
//tv->tv_usec = t.QuadPart % MICROSEC;
  tv->tv_nsec = t.QuadPart % NANOSEC;

  return 0;
} /* clock_gettime */


// ----------------------------------------------------------------------------
// utf82wchar
// Converts UTF-8 encoded string to a wide character (UTF-16) string.
// ----------------------------------------------------------------------------
wchar_t *utf82wchar(const char *str)
{
  int wlen;
  wchar_t *wstr;

  wlen = MultiByteToWideChar(CP_UTF8, 0, str, -1, 0, 0);
  if (wlen == 0) return NULL;

  wstr = (wchar_t *)calloc(wlen, sizeof(wchar_t));
  if (wstr == NULL) return NULL;

  if (MultiByteToWideChar(CP_UTF8, 0, str, -1, wstr, wlen) == 0) {
    free(wstr);
    return NULL;
  }

  return wstr;
} /* utf82wchar */


// ----------------------------------------------------------------------------
// wchar2utf8
// Converts wide character (UTF-16) string to an UTF-8 encoded string.
// ----------------------------------------------------------------------------
char *wchar2utf8(const wchar_t *wstr)
{
  int len;
  char *str;

  len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, 0, 0, NULL, NULL);
  if (len == 0) return NULL;

  str = (char *)calloc(len, sizeof(char));
  if (str == NULL) return NULL;

  if (WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, len, NULL, NULL) == 0) {
    free(str);
    return NULL;
  }

  return str;
} /* wchar2utf8 */


#ifndef _WCHAR
// ----------------------------------------------------------------------------
// utf8_fopen
// Open UTF-8 encoded file name.
// ----------------------------------------------------------------------------
FILE *utf8_fopen(const char *fname, const char *mode)
{
  wchar_t *wfname, *wmode;
  FILE *file;
  int error;

  wfname = utf82wchar(fname);
  wmode = utf82wchar(mode);
  if (wfname == NULL || wmode == NULL) {
    if (wfname != NULL) free(wfname);
    if (wmode != NULL) free(wmode);
    SetLastError(ENOMEM);
    return NULL;
  }

  file = _wfopen(wfname, wmode);

  error = GetLastError();
  free(wfname);
  free(wmode);
  SetLastError(error);

  return file;
} /* utf8_fopen */


// ----------------------------------------------------------------------------
// utf8_stat
// Get status information for UTF-8 encoded file name.
// ----------------------------------------------------------------------------
int utf8_stat(const char *fname, struct _stat *fst)
{
  wchar_t *wfname;
  int rc, error;

  wfname = utf82wchar(fname);
  if (wfname == NULL) {
    SetLastError(ENOMEM);
    return -1;
  }

  rc = _wstat(wfname, fst);

  error = GetLastError();
  free(wfname);
  SetLastError(error);

  return rc;
} /* utf8_stat */
#endif //not _WHCAR
#endif //_WIN32


// ----------------------------------------------------------------------------
// search_path
// Input:  exe (just exe name)
// Output: path or NULL, if not found
// ----------------------------------------------------------------------------
TCHAR *search_path(const TCHAR *exe, TCHAR *path, int len)
{
  TCHAR *envp, *sysdir, *sp;
  TCHAR syspath[MAXS+1], cwd[MAXS+1];
  struct _stat fst;

  envp = getenv(T("PATH"));
#ifdef _WIN32
  strncpy(syspath, PATHSEP_S, MAXS);
  if (envp != NULL) strncat(syspath, envp, MAXS);
#else
  if (envp == NULL) return NULL;
  strncpy(syspath, envp, MAXS);
#endif

  sp = syspath;
  sysdir = xstrsep(&sp, PATHSEP_S);
  while (sysdir != NULL) {
    if (strlen(sysdir) > 0) {
      xstrncpy(path, sysdir, len-1);
      xstrncat(path, DIRSEP_S, len-1);
      xstrncat(path, exe, len-1);
    }
    else { // empty token = current dir
      if (getcwd(cwd, MAXS) != NULL)
        xstrncpy(path, cwd, len-1);
      else
        xstrncpy(path, T("."), len-1);
      xstrncat(path, DIRSEP_S, len-1);
      xstrncat(path, exe, len-1);
    }

    if (utf8_stat(path, &fst) == 0) // file found
      return path;

    sysdir = xstrsep(&sp, PATHSEP_S);
  }

  *path = T('\0');
  return NULL;
} /* search_path */


// ----------------------------------------------------------------------------
// locate_self
// Input:  argv0 (full exe path)
// Output: path0 (always)
// ----------------------------------------------------------------------------
TCHAR *locate_self(const TCHAR *argv0, TCHAR *path0, int len)
{
  TCHAR cwd[MAXS+1], *s;

  *path0 = T('\0');
#ifdef _WIN32
  GetModuleFileName(NULL, path0, len);
#else
  if (readlink(T("/proc/self/exe"), path0, len) < 0) { // Linux
    if (readlink(T("/proc/curproc/file"), path0, len) < 0) { // FreeBSD
      if (argv0[0] == DIRSEP) { // absolute path
        xstrncpy(path0, argv0, len-1);
      }
      else if (strchr(argv0, DIRSEP) != NULL) { // relative path
        if (realpath(argv0, path0) == NULL) {
          if (getcwd(cwd, MAXS) != NULL)
            xstrncpy(path0, cwd, len-1);
          else
            xstrncpy(path0, T("."), len-1);
          xstrncat(path0, DIRSEP_S, len-1);
          xstrncat(path0, argv0, len-1);
          // this will include ./ or ../
        }
      }
      else { // just exe name
        if (search_path(argv0, path0, len) == NULL) { // search PATH
          if (getcwd(cwd, MAXS) != NULL)
            xstrncpy(path0, cwd, len-1);
          else
            xstrncpy(path0, T("."), len-1);
          xstrncat(path0, DIRSEP_S, len-1);
          xstrncat(path0, argv0, len-1);
          // this is probably wrong
        }
      }
    }
  }
#endif
  path0[len-1] = T('\0');

  if ((s = strrchr(path0, DIRSEP)) != NULL) *s = T('\0');

  return path0;
} /* locate_self */


// ----------------------------------------------------------------------------
// locate_exe
// Works on UNIX only!
// ----------------------------------------------------------------------------
TCHAR *locate_exe(const TCHAR *exe, TCHAR *path, int len)
{
  FILE *fd;
  int ii;
  TCHAR *rv = NULL;

#ifndef _WIN32
  snprintf(path, len, T("which \"%s\" 2>/dev/null"), exe);

  fd = popen(path, T("r"));
  if (fd != NULL) {
    *path = T('\0');
    fgets(path, len, fd);
    pclose(fd);

    ii = strlen(path) - 1;
    while (ii >= 0 && isspace(path[ii]))
      path[ii--] = T('\0');

    if (strlen(path)) rv = path;
  }
  else *path = T('\0');
#endif

  return rv;
} /* locate_exe */


// ----------------------------------------------------------------------------
// uri2path
// ----------------------------------------------------------------------------
TCHAR *uri2path(const TCHAR *uri)
{
  int len, hclen, ii, v;
  TCHAR *path, *tmp, *s, *p;

  len = strlen(uri);
  path = (TCHAR *)calloc(len+1, sizeof(TCHAR));
  if (path == NULL) return NULL;
  tmp = (TCHAR *)calloc(len+1, sizeof(TCHAR));
  if (tmp == NULL) return NULL;

  // strip URI part
  while ((s = strstr(uri, T("://"))) != NULL) {
    uri = s+3;
    if (*uri != T('/')) uri--;
  }
  xstrncpy(path, uri, len);

  // replace hex encoded disallowed URI characters
  hclen = sizeof(hexc)/sizeof(*hexc);
  for (ii = 0; ii < hclen; ii++) {
    while ((s = strstr(path, hexc[ii])) != NULL) {
      *s = T('\0');
      xstrncpy(tmp, s+1, 2);
      errno = 0; v = strtol(tmp, &p, 16);
      if (errno || *p) v = T('?');
      snprintf(tmp, len, T("%s%c%s"), path, v, s+3);
      xstrncpy(path, tmp, len);
    }
  }

  free(tmp);
  return path;
} /* uri2path */

#ifdef __cplusplus
}
#endif