gprofng/src/util.cc

/* Copyright (C) 2021-2023 Free Software Foundation, Inc.
   Contributed by Oracle.

   This file is part of GNU Binutils.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, 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 General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */

#include "config.h"
#include <sys/param.h>
#include <stdarg.h>
#include <unistd.h>
#include <dirent.h>    // readdir()
#include <sys/param.h> // MAXPATHLEN
#include <pthread.h>   // mutex
#include <libgen.h>    // dirname
#include <sys/types.h> // open
#include <sys/stat.h>  // open
#include <errno.h>     // errno
#include <fcntl.h>     // open

#include "util.h"
#include "dbe_structs.h"
#include "StringBuilder.h"
#include "StringMap.h"      // For directory names
#include "Application.h"    // Only for get_prog_name
#include "vec.h"

void
tsadd (timestruc_t *result, timestruc_t *time)
{
  // This routine will add "time" to "result".
  result->tv_sec += time->tv_sec;
  result->tv_nsec += time->tv_nsec;
  if (result->tv_nsec >= NANOSEC)
    {
      result->tv_nsec -= NANOSEC;
      result->tv_sec++;
    }
}

void
tssub (timestruc_t *result, timestruc_t *time1, timestruc_t *time2)
{
  // This routine will store "time1" - "time2" in "result".

  if (time1->tv_nsec >= time2->tv_nsec)
    {
      result->tv_nsec = time1->tv_nsec - time2->tv_nsec;
      if (time1->tv_sec >= time2->tv_sec)
	result->tv_sec = time1->tv_sec - time2->tv_sec;
      else
	{
	  result->tv_sec = -1;
	  result->tv_nsec = 0;
	}
    }
  else
    {
      result->tv_nsec = time1->tv_nsec + NANOSEC - time2->tv_nsec;
      if (time1->tv_sec - 1 >= time2->tv_sec)
	result->tv_sec = time1->tv_sec - 1 - time2->tv_sec;
      else
	{
	  result->tv_sec = -1;
	  result->tv_nsec = 0;
	}
    }
}

int
tscmp (timestruc_t *time1, timestruc_t *time2)
{
  // This routine will return 1 if "time1" is greater than "time2"
  // and 0 if "time1" is equal to "time2" and -1 otherwise.
  if (time1->tv_sec == time2->tv_sec)
    return time1->tv_nsec > time2->tv_nsec ? 1 :
	  time1->tv_nsec == time2->tv_nsec ? 0 : -1;
  else
    return time1->tv_sec > time2->tv_sec ? 1 : -1;
}

void
int_max (int *maximum, int count)
{
  if (count > *maximum)
    *maximum = count;
}

double
TValue::to_double ()
{
  switch (tag)
    {
    case VT_DOUBLE:
      return (double) d;
    case VT_INT:
      return (double) i;
    case VT_ULLONG:
      return (double) ull;
    case VT_LLONG:
    case VT_ADDRESS:
      return (double) ll;
    case VT_FLOAT:
      return (double) f;
    case VT_SHORT:
      return (double) s;
    default:
      return 0.0;
    }
}

int
TValue::to_int ()
{
  switch (tag)
    {
    case VT_DOUBLE:
      return (int) d;
    case VT_INT:
      return (int) i;
    case VT_ULLONG:
      return (int) ull;
    case VT_LLONG:
    case VT_ADDRESS:
      return (int) ll;
    case VT_FLOAT:
      return (int) f;
    case VT_SHORT:
      return (int) s;
    default:
      return 0;
    }
}

size_t
TValue::get_len ()
{
  char buf[256];
  return strlen (to_str (buf, sizeof (buf)));
}

char *
TValue::to_str (char *str, size_t strsz)
{
  switch (tag)
    {
    case VT_DOUBLE:
      if (d == 0.)
	{
	  if (sign)
	    snprintf (str, strsz, NTXT ("+0.   "));
	  else
	    snprintf (str, strsz, NTXT ("0.   "));
	}
      else if (sign)
	snprintf (str, strsz, NTXT ("%+.3lf"), d);
      else
	snprintf (str, strsz, NTXT ("%.3lf"), d);
      break;
    case VT_INT:
      snprintf (str, strsz, NTXT ("%u"), i);
      break;
    case VT_LLONG:
      if (sign)
	snprintf (str, strsz, NTXT ("%+lld"), ll);
      else
	snprintf (str, strsz, NTXT ("%lld"), ll);
      break;
    case VT_ULLONG:
      snprintf (str, strsz, NTXT ("%llu"), ll);
      break;
    case VT_ADDRESS:
      snprintf (str, strsz, NTXT ("%u:0x%08x"), ADDRESS_SEG (ll), ADDRESS_OFF (ll));
      break;
    case VT_FLOAT:
      snprintf (str, strsz, NTXT ("%.3f"), f);
      break;
    case VT_SHORT:
      snprintf (str, strsz, NTXT ("%hu"), s);
      break;
    case VT_LABEL:
      return l; // 'str' is not used !!!
    default:
      *str = '\0';
      break;
    }

  return str;
}

void
TValue::make_delta (TValue *v1, TValue *v2)
{
  assert (v1->tag == v2->tag);
  tag = v1->tag;
  sign = true;
  switch (v1->tag)
    {
    case VT_INT:
      i = v1->i - v2->i;
      break;
    case VT_LLONG:
      ll = v1->ll - v2->ll;
      break;
    case VT_ULLONG:
    case VT_ADDRESS:
      tag = VT_LLONG;
      ll = (long long) (v1->ull - v2->ull);
      break;
    case VT_FLOAT:
      f = v1->f - v2->f;
      break;
    case VT_DOUBLE:
      d = v1->d - v2->d;
      break;
    default:
      assert (0);
      break;
    }
}

void
TValue::make_ratio (TValue *v1, TValue *v2)
{
  assert (v1->tag == v2->tag);
  double x1 = v1->to_double ();
  double x2 = v2->to_double ();
  sign = false;
  if (x1 == 0.)
    {
      // if the numerator is 0, the ratio is 1. or 0. only
      d = (x2 == 0.) ? 1. : 0.;
      tag = VT_DOUBLE;
    }
  else
    {
      // EUGENE replace 99.999 with a variable that is known by both DBE and GUI
      if (x1 > 99.999 * x2)
	{
	  l = dbe_strdup (">99.999");
	  tag = VT_LABEL;
	}
      else if (x1 < -99.999 * x2)
	{
	  l = dbe_strdup ("<-99.999");
	  tag = VT_LABEL;
	}
      else
	{
	  d = x1 / x2;
	  tag = VT_DOUBLE;
	}
    }
}

int
TValue::compare (TValue *v)
{
  if (tag != v->tag)
    { // Only for comparison (Ratio)
      if (tag == VT_LABEL)
	{
	  if (v->tag == VT_LABEL)
	    return strcoll (l, v->l);
	  return 1;
	}
      if (v->tag == VT_LABEL)
	return -1;
      return ll < v->ll ? -1 : (ll == v->ll ? 0 : 1);
    }
  switch (tag)
    {
    case VT_SHORT:
      return s < v->s ? -1 : (s == v->s ? 0 : 1);
    case VT_INT:
      return i < v->i ? -1 : (i == v->i ? 0 : 1);
    case VT_FLOAT:
      return f < v->f ? -1 : (f == v->f ? 0 : 1);
    case VT_DOUBLE:
      return d < v->d ? -1 : (d == v->d ? 0 : 1);
    case VT_LABEL:
      return strcoll (l, v->l);
    case VT_LLONG:
    case VT_ULLONG:
    case VT_ADDRESS:
    case VT_HRTIME:
    default:
      return (ll < v->ll) ? -1 : ((ll == v->ll) ? 0 : 1);
    }
}

char *
strstr_r (char *s1, const char *s2)
{
  char *str = NULL;
  for (char *s = s1; s;)
    {
      s = strstr (s, s2);
      if (s)
	{
	  str = s;
	  s++;
	}
    }
  return str;
}

// reversal order of strpbrk

char *
strrpbrk (const char *string, const char *brkset)
{
  const char *p;
  const char *s;
  for (s = string + strlen (string) - 1; s >= string; s--)
    {
      for (p = brkset; *p != '\0' && *p != *s; ++p)
	;
      if (*p != '\0')
	return ((char *) s);
    }
  return NULL;
}

char *
read_line (FILE *fptr)
{
  // get an input line, no size limit
  int line_sz = 128; // starting size
  char *line = (char *) malloc (line_sz);

  // read as much of the line as will fit in memory
  line[0] = 0;
  int len = 0;
  for (;;)
    {
      while (fgets (line + len, line_sz - len, fptr) != NULL)
	{
	  len = (int) strlen (line);
	  if (len == 0 || line[len - 1] == '\n')
	    break;
	  // increase the buffer
	  char *lineNew = (char *) malloc (2 * line_sz);
	  strncpy (lineNew, line, line_sz);
	  lineNew[line_sz] = '\0';
	  free (line);
	  line = lineNew;
	  line_sz *= 2;
	  if (line == NULL)
	    {
	      fprintf (stderr, GTXT ("   Line too long -- out of memory; exiting\n"));
	      exit (1);
	    }
	}
      if (len == 0)
	{
	  free (line);
	  return NULL;
	}
      // see if there's a continuation line
      if ((len >= 2) && (line[len - 1] == '\n') && (line[len - 2] == '\\'))
	{
	  // remove the trailing \ and the \n, and keep going
	  line[len - 2] = 0;
	  len -= 2;
	}
      else
	break;
    }
  return line; // expecting the caller to free it
}

Vector<char *> *
split_str (char *str, char delimiter)
{
  Vector<char *> *v = new Vector<char *>;
  for (char *s = str; s;)
    {
      if (*s == '"')
	{
	  char *next_s = NULL;
	  char *tok = parse_qstring (s, &next_s);
	  if (tok && *tok != '\0')
	    v->append (tok);
	  if (*next_s)
	    s = next_s + 1;
	  else
	    s = NULL;
	}
      else
	{
	  char *next_s = strchr (s, delimiter);
	  if (next_s)
	    {
	      if (next_s != s)
		v->append (dbe_strndup (s, next_s - s));
	      s = next_s + 1;
	    }
	  else
	    {
	      if (*s != '\0')
		v->append (dbe_strdup (s));
	      s = NULL;
	    }
	}
    }
  return v;
}

// get quoted string
char *
parse_qstring (char *in_str, char **endptr)
{
  int i;
  char c, c2;
  char term;
  char csnum[2 * MAXPATHLEN];

  // Skip any leading blanks or tabs
  while (*in_str == '\t' || *in_str == ' ')
    in_str++;

  int gtxt = 0;
  if (*in_str == 'G' && *(in_str + 1) == 'T' && *(in_str + 2) == 'X'
      && *(in_str + 3) == 'T' && *(in_str + 4) == '(')
    {
      gtxt = 1;
      in_str += 5;
    }
  // non-quoted string
  if (*in_str == '"')
    term = '"';
  else if (*in_str == '\'')
    term = '\'';
  else
    return strtok_r (in_str, NTXT (" "), endptr);

  StringBuilder sb;
  while ((c = *(++in_str)) != '\0')
    {
      if (c == term) // the closing quote
	break;
      if (c == '\\')
	{ // handle any escaped characters
	  c2 = *(++in_str);
	  switch (c2)
	    {
	    case '\"':
	      sb.append ('\"');
	      break;
	    case '\'':
	      sb.append ('\'');
	      break;
	    case '\\':
	      sb.append ('\\');
	      break;
	    case 't':
	      sb.append ('\t');
	      break;
	    case 'r':
	      sb.append ('\r');
	      break;
	    case 'b':
	      sb.append ('\b');
	      break;
	    case 'f':
	      sb.append ('\f');
	      break;
	    case 'n':
	      sb.append ('\n');
	      break;
	    default:
	      if ((c2 >= '0') && (c2 <= '9'))
		{
		  for (i = 0; i < MAXPATHLEN; i++)
		    {
		      if (((c2 < '0') || (c2 > '9')) && (c2 != 'x') &&
			  ((c2 < 'a') || (c2 > 'f')) &&
			  ((c2 < 'A') || (c2 > 'F')))
			{
			  csnum[i] = '\0';
			  --in_str;
			  break;
			}
		      else
			{
			  csnum[i] = c2;
			  c2 = *(++in_str);
			}
		    }
		  sb.append ((char) strtoul (csnum, endptr, 0));
		}
	      else
		sb.append (c2);
	      break;
	    }
	}
      else
	sb.append (c);
    }
  if (c == term && gtxt && *in_str == ')')
    in_str++;
  if (*in_str == '\0')
    *endptr = in_str;
  else
    *endptr = in_str + 1;
  return sb.toString ();
}

// parse a file name of the form name`name2`
// returns name
// stores the pointer to named in fcontext
// returns NULL if the string is not properly formatted
char *
parse_fname (char *in_str, char **fcontext)
{
  *fcontext = NULL;
  int ch = '`';
  if (in_str == NULL)
    return NULL;
  char *copy = strdup (in_str);
  char *p = strchr (copy, ch);
  if (p != NULL)
    {
      // yes, there's an embedded file name
      *p = '\0';
      p++;
      // now find the terminating single quote
      char *p1 = strchr (p, ch);
      if (p1 == NULL)
	{
	  // if we don't have the closing `, the format is incorrect
	  free (copy);
	  return NULL;
	}
      //remove the closing quote
      *p1 = '\0';
      // see if there's anything following it
      if (*(p1 + 1) != 0)
	{
	  // error in format
	  free (copy);
	  return NULL;
	}
      free (*fcontext);
      *fcontext = strdup (p);
    }
  return copy;
}

int
get_paren (const char *name)
{
  char buf[8192];
  char *ptr;
  int temp_level1, temp_level2;

  temp_level1 = temp_level2 = 0;
  snprintf (buf, sizeof (buf), NTXT ("%s"), name);
  while ((ptr = strrpbrk (buf, "><)(")) != NULL)
    {
      if (*ptr == '>')
	temp_level1++;
      else if (*ptr == '<')
	temp_level1--;
      else if (*ptr == ')')
	temp_level2++;
      else
	{
	  temp_level2--;
	  if (temp_level1 <= 0 && temp_level2 <= 0)
	    return (int) (ptr - buf);
	}
      *ptr = '\0';
    }
  return -1;
}

// CRC-64 based on x^64 + x^11 + x^2 + x + 1 polynomial.
// This algorithm doesn't perform well but is short and
// readable. We currently use it for a small amount of
// short strings. Should this change, another algorithm
// with better performance is to be used instead.
static uint64_t masks[256] = {
  /*   0 */ 0x000000, 0x000807, 0x00100e, 0x001809, 0x00201c, 0x00281b,
  /*   6 */ 0x003012, 0x003815, 0x004038, 0x00483f, 0x005036, 0x005831,
  /*  12 */ 0x006024, 0x006823, 0x00702a, 0x00782d, 0x008070, 0x008877,
  /*  18 */ 0x00907e, 0x009879, 0x00a06c, 0x00a86b, 0x00b062, 0x00b865,
  /*  24 */ 0x00c048, 0x00c84f, 0x00d046, 0x00d841, 0x00e054, 0x00e853,
  /*  30 */ 0x00f05a, 0x00f85d, 0x0100e0, 0x0108e7, 0x0110ee, 0x0118e9,
  /*  36 */ 0x0120fc, 0x0128fb, 0x0130f2, 0x0138f5, 0x0140d8, 0x0148df,
  /*  42 */ 0x0150d6, 0x0158d1, 0x0160c4, 0x0168c3, 0x0170ca, 0x0178cd,
  /*  48 */ 0x018090, 0x018897, 0x01909e, 0x019899, 0x01a08c, 0x01a88b,
  /*  54 */ 0x01b082, 0x01b885, 0x01c0a8, 0x01c8af, 0x01d0a6, 0x01d8a1,
  /*  60 */ 0x01e0b4, 0x01e8b3, 0x01f0ba, 0x01f8bd, 0x0201c0, 0x0209c7,
  /*  66 */ 0x0211ce, 0x0219c9, 0x0221dc, 0x0229db, 0x0231d2, 0x0239d5,
  /*  72 */ 0x0241f8, 0x0249ff, 0x0251f6, 0x0259f1, 0x0261e4, 0x0269e3,
  /*  78 */ 0x0271ea, 0x0279ed, 0x0281b0, 0x0289b7, 0x0291be, 0x0299b9,
  /*  84 */ 0x02a1ac, 0x02a9ab, 0x02b1a2, 0x02b9a5, 0x02c188, 0x02c98f,
  /*  90 */ 0x02d186, 0x02d981, 0x02e194, 0x02e993, 0x02f19a, 0x02f99d,
  /*  96 */ 0x030120, 0x030927, 0x03112e, 0x031929, 0x03213c, 0x03293b,
  /* 102 */ 0x033132, 0x033935, 0x034118, 0x03491f, 0x035116, 0x035911,
  /* 108 */ 0x036104, 0x036903, 0x03710a, 0x03790d, 0x038150, 0x038957,
  /* 114 */ 0x03915e, 0x039959, 0x03a14c, 0x03a94b, 0x03b142, 0x03b945,
  /* 120 */ 0x03c168, 0x03c96f, 0x03d166, 0x03d961, 0x03e174, 0x03e973,
  /* 126 */ 0x03f17a, 0x03f97d, 0x040380, 0x040b87, 0x04138e, 0x041b89,
  /* 132 */ 0x04239c, 0x042b9b, 0x043392, 0x043b95, 0x0443b8, 0x044bbf,
  /* 138 */ 0x0453b6, 0x045bb1, 0x0463a4, 0x046ba3, 0x0473aa, 0x047bad,
  /* 144 */ 0x0483f0, 0x048bf7, 0x0493fe, 0x049bf9, 0x04a3ec, 0x04abeb,
  /* 150 */ 0x04b3e2, 0x04bbe5, 0x04c3c8, 0x04cbcf, 0x04d3c6, 0x04dbc1,
  /* 156 */ 0x04e3d4, 0x04ebd3, 0x04f3da, 0x04fbdd, 0x050360, 0x050b67,
  /* 162 */ 0x05136e, 0x051b69, 0x05237c, 0x052b7b, 0x053372, 0x053b75,
  /* 168 */ 0x054358, 0x054b5f, 0x055356, 0x055b51, 0x056344, 0x056b43,
  /* 174 */ 0x05734a, 0x057b4d, 0x058310, 0x058b17, 0x05931e, 0x059b19,
  /* 180 */ 0x05a30c, 0x05ab0b, 0x05b302, 0x05bb05, 0x05c328, 0x05cb2f,
  /* 186 */ 0x05d326, 0x05db21, 0x05e334, 0x05eb33, 0x05f33a, 0x05fb3d,
  /* 192 */ 0x060240, 0x060a47, 0x06124e, 0x061a49, 0x06225c, 0x062a5b,
  /* 198 */ 0x063252, 0x063a55, 0x064278, 0x064a7f, 0x065276, 0x065a71,
  /* 204 */ 0x066264, 0x066a63, 0x06726a, 0x067a6d, 0x068230, 0x068a37,
  /* 210 */ 0x06923e, 0x069a39, 0x06a22c, 0x06aa2b, 0x06b222, 0x06ba25,
  /* 216 */ 0x06c208, 0x06ca0f, 0x06d206, 0x06da01, 0x06e214, 0x06ea13,
  /* 222 */ 0x06f21a, 0x06fa1d, 0x0702a0, 0x070aa7, 0x0712ae, 0x071aa9,
  /* 228 */ 0x0722bc, 0x072abb, 0x0732b2, 0x073ab5, 0x074298, 0x074a9f,
  /* 234 */ 0x075296, 0x075a91, 0x076284, 0x076a83, 0x07728a, 0x077a8d,
  /* 240 */ 0x0782d0, 0x078ad7, 0x0792de, 0x079ad9, 0x07a2cc, 0x07aacb,
  /* 246 */ 0x07b2c2, 0x07bac5, 0x07c2e8, 0x07caef, 0x07d2e6, 0x07dae1,
  /* 252 */ 0x07e2f4, 0x07eaf3, 0x07f2fa, 0x07fafd
};

uint64_t
crc64 (const char *str, size_t len)
{
  uint64_t res = 0LL;
  for (size_t i = 0; i < len; i++)
    {
      unsigned char b = (unsigned char) ((res >> 56) ^ *str++);
      res = res << 8;
      res ^= masks [b];
    }
  return res;
}

/**
 * Canonize path inside the string provided by the argument
 * @param path
 * @return path
 */
char *
canonical_path (char *path)
{
  char *s1, *s2;
  if (!path)
    return path;
  s1 = path;
  s2 = path;
  while (*s1)
    {
      if (*s1 == '.' && s1[1] == '/')
	{ // remove .///
	  for (s1++; *s1; s1++)
	    if (*s1 != '/')
	      break;
	}
      else if (*s1 == '/')
	{ // replace /// with /
	  *(s2++) = *s1;
	  for (s1++; *s1; s1++)
	    if (*s1 != '/')
	      break;
	}
      else
	{
	  while (*s1)
	    { // copy file or directory name
	      if (*s1 == '/')
		break;
	      *(s2++) = *(s1++);
	    }
	}
    }
  *s2 = 0;
  if (s2 != path && (s2 - 1) != path && s2[-1] == '/')  // remove last /
    *(s2 - 1) = 0;
  return path;
}

char *
get_relative_path (char *name)
{
  if (*name == '/' && theApplication)
    {
      char *cwd = theApplication->get_cur_dir ();
      if (cwd)
	{
	  size_t len = strlen (cwd);
	  if (len > 0 && len < strlen (name) && name[len] == '/'
	      && strncmp (cwd, name, len) == 0)
	    {
	      for (name += len + 1; *name == '/'; name++)
		;
	      return name;
	    }
	}
    }
  return name;
}

/**
 * Generate a relative link name from path_from to path_to
 * Example:
 * path_from=a/b/c/d
 * path_to=a/b/e/f/g
 * lname=../../e/f/g
 * @param path_to
 * @param path_from
 * @return lname - relative link
 */
char *
get_relative_link (const char *path_from, const char *path_to)
{
  if (!path_to)
    path_to = ".";
  if (!path_from)
    path_from = ".";
  char *s1 = dbe_strdup (path_to);
  s1 = canonical_path (s1);
  char *s2 = dbe_strdup (path_from);
  s2 = canonical_path (s2);
  long l = dbe_sstrlen (s1);
  // try to find common directories
  int common_slashes = 0;
  int last_common_slash = -1;
  for (int i = 0; i < l; i++)
    {
      if (s1[i] != s2[i]) break;
      if (s1[i] == 0) break;
      if (s1[i] == '/')
	{
	  common_slashes++;
	  last_common_slash = i;
	}
    }
  // find slashes in remaining path_to
  int slashes = 0;
  for (int i = last_common_slash + 1; i < l; i++)
    {
      if (s1[i] == '/')
	{
	  // Exclude "/./" case
	  if (i > last_common_slash + 2)
	    {
	      if (s1[i - 1] == '.' && s1[i - 2] == '/')
		continue;
	    }
	  else if (i > 0 && s1[i - 1] == '.')
	    continue;
	  slashes++;
	}
    }
  // generate relative path
  StringBuilder sb;
  for (int i = 0; i < slashes; i++)
    sb.append ("../");
  sb.append (s2 + last_common_slash + 1);
  char *lname = sb.toString ();
  free (s1);
  free (s2);
  return lname;
}

char *
get_prog_name (int basename)
{
  char *nm = NULL;
  if (theApplication)
    {
      nm = theApplication->get_name ();
      if (nm && basename)
	nm = get_basename (nm);
    }
  return nm;
}

char *
dbe_strndup (const char *str, size_t len)
{
  if (str == NULL)
    return NULL;
  char *s = (char *) malloc (len + 1);
  strncpy (s, str, len);
  s[len] = '\0';
  return s;
}

char *
dbe_sprintf (const char *fmt, ...)
{
  char buffer[256];
  int buf_size;
  va_list vp;

  va_start (vp, fmt);
  buf_size = vsnprintf (buffer, sizeof (buffer), fmt, vp) + 1;
  va_end (vp);
  if (buf_size < (int) sizeof (buffer))
    {
      if (buf_size <= 1)
	buffer[0] = 0;
      return strdup (buffer);
    }

  va_start (vp, fmt);
  char *buf = (char *) malloc (buf_size);
  vsnprintf (buf, buf_size, fmt, vp);
  va_end (vp);
  return buf;
}

ssize_t
dbe_write (int f, const char *fmt, ...)
{
  char buffer[256];
  int buf_size;
  va_list vp;

  va_start (vp, fmt);
  buf_size = vsnprintf (buffer, sizeof (buffer), fmt, vp) + 1;
  va_end (vp);
  if (buf_size < (int) sizeof (buffer))
    {
      if (buf_size <= 1)
	buffer[0] = 0;
      return write (f, buffer, strlen (buffer));
    }

  va_start (vp, fmt);
  char *buf = (char *) malloc (buf_size);
  vsnprintf (buf, buf_size, fmt, vp);
  va_end (vp);
  ssize_t val = write (f, buf, strlen (buf));
  free (buf);
  return val;
}

/* Worker Threads to avoid hanging on file servers */

/*
 * Thread states
 */
enum
{
  THREAD_START,
  THREAD_STARTED,
  THREAD_CANCEL,
  THREAD_CANCELED,
  THREAD_CREATE,
  THREAD_NOT_CREATED,
  THREAD_FINISHED
};

/*
 * Communication structure
 */
struct worker_thread_info
{
  pthread_t thread_id;      /* ID returned by pthread_create() */
  int thread_num;           /* Application-defined thread # */
  volatile int control;     /* Thread state */
  volatile int result;      /* Return status */
  struct stat64 statbuf;    /* File info from stat64() */
  const char *path;         /* File */
};

static pthread_mutex_t worker_thread_lock = PTHREAD_MUTEX_INITIALIZER;
static int worker_thread_number = 0;
/**
 * Call stat64() on current worker thread
 * Check if control is not THREAD_CANCEL
 * If control is THREAD_CANCEL return (exit thread)
 * @param *wt_info
 */
static void *
dbe_stat_on_thread (void *arg)
{
  struct worker_thread_info *wt_info = (struct worker_thread_info *) arg;
  pthread_mutex_lock (&worker_thread_lock);
  {
    if (wt_info->control != THREAD_START)
      {
	// Already too late
	pthread_mutex_unlock (&worker_thread_lock);
	return 0;
      }
    wt_info->control = THREAD_STARTED;
  }
  pthread_mutex_unlock (&worker_thread_lock);
  const char * path = wt_info->path;
  int st = stat64 (path, &(wt_info->statbuf));
  pthread_mutex_lock (&worker_thread_lock);
  {
    if (wt_info->control == THREAD_CANCEL)
      {
	// Too late.
	pthread_mutex_unlock (&worker_thread_lock);
	free (wt_info);
	return 0;
      }
    wt_info->result = st;
    wt_info->control = THREAD_FINISHED;
  }
  pthread_mutex_unlock (&worker_thread_lock);
  return 0;
}

/**
 * Create a worker thread to call specified function
 * Wait for its result, but not longer than 5 seconds
 * If the timeout happens, tell the thread to cancel
 * @param path
 * @param wt_info
 * @return thread state
 */
static int
dbe_dispatch_on_thread (const char *path, struct worker_thread_info *wt_info)
{
  wt_info->result = 0;
  wt_info->control = THREAD_START;
  pthread_attr_t attr;
  /* Initialize thread creation attributes */
  int res = pthread_attr_init (&attr);
  if (res != 0)
    {
      wt_info->control = THREAD_NOT_CREATED;
      return THREAD_NOT_CREATED;
    }
  wt_info->thread_id = 0;
  wt_info->path = path;
  // Lock
  pthread_mutex_lock (&worker_thread_lock);
  worker_thread_number++;
  wt_info->thread_num = worker_thread_number;
  // Unlock
  pthread_mutex_unlock (&worker_thread_lock);
  // Create thread
  res = pthread_create (&wt_info->thread_id, &attr, &dbe_stat_on_thread, wt_info);
  if (res != 0)
    {
      wt_info->control = THREAD_NOT_CREATED;
      pthread_attr_destroy (&attr);
      return THREAD_NOT_CREATED;
    }
  // Wait for the thread to finish
  res = 0;
  useconds_t maxusec = 5000000; // 5 seconds
  useconds_t deltausec = 1000; // 1 millisecond
  int max = maxusec / deltausec;
  for (int i = 0; i < max; i++)
    {
      if (THREAD_FINISHED == wt_info->control)
	break; // We are done
      usleep (deltausec);
    }
  // Lock
  pthread_mutex_lock (&worker_thread_lock);
  if (THREAD_FINISHED != wt_info->control)
    {
      // Cancel thread
      wt_info->control = THREAD_CANCEL; // Cannot use wt_info after that!
      res = THREAD_CANCEL;
    }
  // Unlock
  pthread_mutex_unlock (&worker_thread_lock);
  // Destroy the thread attributes object, since it is no longer needed
  pthread_attr_destroy (&attr);
  // Report that thread was canceled
  if (THREAD_CANCEL == res)
    return res; /* Cannot free memory allocated by thread */
  // Free all thread resources
  void *resources = 0;
  res = pthread_join (wt_info->thread_id, &resources);
  free (resources); /* Free memory allocated by thread */
  return THREAD_FINISHED;
}

static pthread_mutex_t dirnames_lock = PTHREAD_MUTEX_INITIALIZER;
static Map<const char*, int> *dirnamesMap = NULL;

#define DIR_STATUS_EXISTS 0
#define DIR_STATUS_UNKNOWN 2

/**
 * Check if this directory name is known
 * Return:
 * @param path
 *  0 - known, exists
 *  1 - known, does not exist
 *  2 - not known
 */
static int
check_dirname (const char *path)
{
  pthread_mutex_lock (&dirnames_lock);
  if (NULL == dirnamesMap)
    dirnamesMap = new StringMap<int>(128, 128);
  pthread_mutex_unlock (&dirnames_lock);
  int res = DIR_STATUS_UNKNOWN;
  if (path && *path)
    {
      char *fn = dbe_strdup (path);
      char *dn = dirname (fn);
      if (dn && *dn)
	res = dirnamesMap->get (dn);
      free (fn);
    }
  return res;
}

/**
 * Save directory name and its status
 * @param path
 * @param status
 * @return
 */
static void
extract_and_save_dirname (const char *path, int status)
{
  pthread_mutex_lock (&dirnames_lock);
  if (NULL == dirnamesMap)
    dirnamesMap = new StringMap<int>(128, 128);
  pthread_mutex_unlock (&dirnames_lock);
  char *fn = dbe_strdup (path);
  if (fn && *fn != 0)
    {
      char *dn = dirname (fn);
      if (dn && (*dn != 0))
	{
	  int st = 0; // exists
	  if (0 != status)
	    st = 1; // does not exist
	  dirnamesMap->put (dn, st);
	}
    }
  free (fn);
}

// get status for specified file
static int
dbe_stat_internal (const char *path, struct stat64 *sbuf, bool file_only)
{
  struct stat64 statbuf;
  int dir_status = check_dirname (path);
  if (dir_status == DIR_STATUS_UNKNOWN)
    {
      // Try to use a worker thread
      if (theApplication->get_number_of_worker_threads () > 0)
	{
	  struct worker_thread_info *wt_info;
	  wt_info = (worker_thread_info *) calloc (1, sizeof (worker_thread_info));
	  if (wt_info != NULL)
	    {
	      int res = dbe_dispatch_on_thread (path, wt_info);
	      if (THREAD_FINISHED == res)
		{
		  int st = wt_info->result;
		  extract_and_save_dirname (path, st);
		  if (st == 0 && file_only)
		    if (S_ISREG ((wt_info->statbuf).st_mode) == 0)
		      st = -1; // It is not a regular file
		  if (sbuf != NULL)
		    *sbuf = wt_info->statbuf;
		  free (wt_info);
		  return st;
		}
	      else
		{
		  if (THREAD_CANCEL == res)
		    {
		      // Worker thread hung. Cannot free wt_info.
		      // Allocated memory will be freed by worker thread.
		      // save directory
		      extract_and_save_dirname (path, 1);
		      return 1; // stat64 failed
		    }
		  else  // THREAD_NOT_CREATED - continue on current thread
		    free (wt_info);
		}
	    }
	}
    }
  else if (dir_status != DIR_STATUS_EXISTS)
    return -1; // does not exist
  if (sbuf == NULL)
    sbuf = &statbuf;
  int st = stat64 (path, sbuf);
  Dprintf (DEBUG_DBE_FILE, NTXT ("dbe_stat %d '%s'\n"), st, path);
  if (st == -1)
    return -1;
  else if (file_only && S_ISREG (sbuf->st_mode) == 0)
    return -1; // It is not ordinary file
  return st;
}

// get status for the regular file

int
dbe_stat_file (const char *path, struct stat64 *sbuf)
{
  int res = dbe_stat_internal (path, sbuf, true);
  return res;
}

// get status for specified file

int
dbe_stat (const char *path, struct stat64 *sbuf)
{
  int res = dbe_stat_internal (path, sbuf, false);
  return res;
}

/**
 * Reads directory and prepares list of files according to the specified format
 * Supported formats:
 * "/bin/ls -a" - see 'man ls' for details
 * "/bin/ls -aF" - see 'man ls' for details
 * @param path
 * @param format
 * @return char * files
 */
char *
dbe_read_dir (const char *path, const char *format)
{
  StringBuilder sb;
  DIR *dir = opendir (path);
  if (dir == NULL)
    return sb.toString ();
  int format_aF = 0;
  if (!strcmp (format, NTXT ("/bin/ls -aF")))
    format_aF = 1;
  struct dirent *entry = NULL;
  if (format != NULL)
    {
      while ((entry = readdir (dir)) != NULL)
	{
	  sb.append (entry->d_name);
	  if (format_aF)
	    {
	      const char *attr = NTXT ("@"); // Link
	      struct stat64 sbuf;
	      sbuf.st_mode = 0;
	      char filename[MAXPATHLEN + 1];
	      snprintf (filename, sizeof (filename), NTXT ("%s/%s"), path, entry->d_name);
	      dbe_stat (filename, &sbuf);
	      if (S_IREAD & sbuf.st_mode)
		{ // Readable
		  if (S_ISDIR (sbuf.st_mode) != 0)  // Directory
		    attr = NTXT ("/");
		  else if (S_ISREG (sbuf.st_mode) != 0) // Regular file
		    attr = NTXT ("");
		}
	      sb.append (attr);
	    }
	  sb.append (NTXT ("\n"));
	}
    }
  closedir (dir);
  return sb.toString ();
}

/**
 * Gets list of processes according to the specified format
 * Supported formats:
 * "/bin/ps -ef" - see 'man ps' for details
 * @param format
 * @return char * processes
 */
char *
dbe_get_processes (const char *format)
{
  StringBuilder sb;
  if (!strcmp (format, NTXT ("/bin/ps -ef")))
    {
      char buf[BUFSIZ];
      FILE *ptr = popen (format, "r");
      if (ptr != NULL)
	{
	  while (fgets (buf, BUFSIZ, ptr) != NULL)
	    sb.append (buf);
	  pclose (ptr);
	}
    }
  return sb.toString ();
}

/**
 * Creates the directory named by the specified path name, including any
 * necessary but nonexistent parent directories.
 * Uses system utility "/bin/mkdir -p"
 * Temporary limitation: path name should not contain spaces.
 * Returns message from "/bin/mkdir -p"
 * @param pathname
 * @return result
 */
char *
dbe_create_directories (const char *pathname)
{
  StringBuilder sb;
  char *makedir = dbe_sprintf (NTXT ("/bin/mkdir -p %s 2>&1"), pathname);
  char out[BUFSIZ];
  FILE *ptr = popen (makedir, "r");
  if (ptr != NULL)
    {
      while (fgets (out, BUFSIZ, ptr) != NULL)
	sb.append (out);
      pclose (ptr);
    }
  free (makedir);
  DIR *dir = opendir (pathname);
  if (dir != NULL)
    {
      closedir (dir);
      return NULL; // success
    }
  else
    sb.append (NTXT ("\nError: Cannot open directory\n")); // DEBUG
  return sb.toString (); // error
}

/**
 * Deletes the file or the directory named by the specified path name.
 * If this pathname denotes a directory, then the directory must be empty in order to be deleted.
 * Uses system utility "/bin/rm" or "/bin/rmdir"
 * Temporary limitation: path name should not contain spaces.
 * Returns error message from system utility
 * @param pathname
 * @return result
 */
char *
dbe_delete_file (const char *pathname)
{
  StringBuilder sb;
  char *cmd = NULL;
  struct stat64 sbuf;
  sbuf.st_mode = 0;
  int st = dbe_stat (pathname, &sbuf);
  if (st == 0)
    { // Exists
      if (S_ISDIR (sbuf.st_mode) != 0)      // Directory
	cmd = dbe_sprintf (NTXT ("/bin/rmdir %s 2>&1"), pathname);
      else if (S_ISREG (sbuf.st_mode) != 0)     // Regular file
	cmd = dbe_sprintf (NTXT ("/bin/rm %s 2>&1"), pathname);
    }
  else
    return NULL; // Nothing to remove
  if (cmd != NULL)
    {
      char out[BUFSIZ];
      FILE *ptr = popen (cmd, "r");
      if (ptr != NULL)
	{
	  while (fgets (out, BUFSIZ, ptr) != NULL)
	    sb.append (out);
	  pclose (ptr);
	}
      free (cmd);
    }
  else
    sb.sprintf (NTXT ("Error: cannot remove %s - not a regular file and not a directory\n"), pathname);
  return sb.toString ();
}

char *
dbe_xml2str (const char *s)
{
  if (s == NULL)
    return NULL;
  StringBuilder sb;
  while (*s)
    {
      if (*s == '&')
	{
	  if (strncmp (s, NTXT ("&nbsp;"), 6) == 0)
	    {
	      sb.append (' ');
	      s += 6;
	      continue;
	    }
	  else if (strncmp (s, NTXT ("&quot;"), 6) == 0)
	    {
	      sb.append ('"');
	      s += 6;
	      continue;
	    }
	  else if (strncmp (s, NTXT ("&amp;"), 5) == 0)
	    {
	      sb.append ('&');
	      s += 5;
	      continue;
	    }
	  else if (strncmp (s, NTXT ("&lt;"), 4) == 0)
	    {
	      sb.append ('<');
	      s += 4;
	      continue;
	    }
	  else if (strncmp (s, NTXT ("&gt;"), 4) == 0)
	    {
	      sb.append ('>');
	      s += 4;
	      continue;
	    }
	}
      sb.append (*s);
      s++;
    }
  return sb.toString ();
}

void
swapByteOrder (void *p, size_t sz)
{
  if (sz == 8)
    {
      uint64_t *pv = (uint64_t *) p;
      uint64_t v = *pv;
      v = ((v & 0x00000000FF000000) << 8) | ((v >> 8) & 0x00000000FF000000) |
	      ((v & 0x0000000000FF0000) << 24) | ((v >> 24) & 0x0000000000FF0000) |
	      ((v & 0x000000000000FF00) << 40) | ((v >> 40) & 0x000000000000FF00) |
	      (v >> 56) | (v << 56);
      *pv = v;
    }
  else if (sz == 4)
    {
      uint32_t *pv = (uint32_t *) p;
      uint32_t v = *pv;
      v = (v >> 24) | (v << 24) | ((v & 0x0000FF00) << 8) | ((v >> 8) & 0x0000FF00);
      *pv = v;
    }
  else if (sz == 2)
    {
      uint16_t *pv = (uint16_t *) p;
      uint16_t v = *pv;
      v = (v >> 8) | (v << 8);
      *pv = v;
    }
}

void
destroy (void *vec)
{
  if (vec == NULL)
    return;
  Vector<void*> *array = (Vector<void*>*)vec;
  switch (array->type ())
    {
    case VEC_STRING:
      ((Vector<char *>*)array)->destroy ();
      break;
    case VEC_VOIDARR:
    case VEC_STRINGARR:
    case VEC_INTARR:
    case VEC_BOOLARR:
    case VEC_LLONGARR:
    case VEC_DOUBLEARR:
      for (long i = 0; i < array->size (); i++)
	destroy (array->fetch (i));
      break;
    case VEC_INTEGER:
    case VEC_CHAR:
    case VEC_BOOL:
    case VEC_DOUBLE:
    case VEC_LLONG:
    default:
      break;
    }
  delete array;
}

int64_t
read_from_file (int fd, void *buffer, int64_t nbyte)
{
  int64_t cnt = 0;
  char *buf = (char *) buffer;
  while (nbyte > 0)
    { // Sometimes system cannot read 'nbyte'
      ssize_t n = read (fd, (void *) (buf + cnt), (size_t) nbyte);
      if (n <= 0)
	break;
      nbyte -= n;
      cnt += n;
    }
  return cnt;
}

/**
 * Create symbolic link to the path
 * @param  path - path with spaces
 * @param  dir  - directory where the link should be created
 * @return symbolic link
 */
char *
dbe_create_symlink_to_path (const char *path, const char *dir)
{
  char *symbolic_link = NULL;
  if (NULL == path || NULL == dir)
    return NULL;
  int res = mkdir (dir, 0777);
  if (res != 0 && dbe_stat (dir, NULL) != 0)
    return NULL; // Cannot create directory
  long len = dbe_sstrlen (path);
  if (len <= 4)
    return NULL; // Unknown situation
  if (strcmp ((path + len - 4), "/bin") != 0)   // Unknown situation
    return NULL;
  int max = 99; // Just an arbitrary number
  for (int i = 1; i <= max; i++)
    {
      // Try to create symbolic link
      char *d = dbe_sprintf ("%s/%d", dir, i);
      if (NULL == d)
	return NULL;
      res = mkdir (d, 0777);
      symbolic_link = dbe_sprintf ("%s/%s", d, "bin");
      free (d);
      if (NULL == symbolic_link) // Not enough memory
	return NULL;
      res = symlink (path, symbolic_link);
      if (res == 0)     // Link is created - use it.
	break;
      // Check if such link already exists
      int e = errno;
      char buf[MAXPATHLEN + 1];
      memset (buf, 0, MAXPATHLEN + 1);
      ssize_t n = readlink (symbolic_link, buf, MAXPATHLEN);
      if (n == len && strcmp (path, buf) == 0) // Link is correct - use it.
	break;
      if (i == max)
	{ // report the error
	  fprintf (stderr, GTXT ("Error: symlink(%s, %s) returned error: %d\n"), path, symbolic_link, res);
	  fprintf (stderr, GTXT ("Error: errno=%d (%s)\n"), e, strerror (e));
	  fflush (stderr);
	}
      free (symbolic_link);
      symbolic_link = NULL;
    }
  return symbolic_link;
}

// Compute checksum for specified file.
// This code is from usr/src/cmd/cksum.c, adapted for us
// crcposix -- compute posix.2 compatable 32 bit CRC
//
// The POSIX.2 (draft 10) CRC algorithm.
// This is a 32 bit CRC with polynomial
//      x**32 + x**26 + x**23 + x**22 + x**16 + x**12 + x**11 + x**10 +
//      x**8  + x**7  + x**5  + x**4  + x**2  + x**1  + x**0
//
// layout is from the POSIX.2 Rationale

static uint32_t crctab_posix[256] = {
  0x00000000L,
  0x04C11DB7L, 0x09823B6EL, 0x0D4326D9L, 0x130476DCL, 0x17C56B6BL,
  0x1A864DB2L, 0x1E475005L, 0x2608EDB8L, 0x22C9F00FL, 0x2F8AD6D6L,
  0x2B4BCB61L, 0x350C9B64L, 0x31CD86D3L, 0x3C8EA00AL, 0x384FBDBDL,
  0x4C11DB70L, 0x48D0C6C7L, 0x4593E01EL, 0x4152FDA9L, 0x5F15ADACL,
  0x5BD4B01BL, 0x569796C2L, 0x52568B75L, 0x6A1936C8L, 0x6ED82B7FL,
  0x639B0DA6L, 0x675A1011L, 0x791D4014L, 0x7DDC5DA3L, 0x709F7B7AL,
  0x745E66CDL, 0x9823B6E0L, 0x9CE2AB57L, 0x91A18D8EL, 0x95609039L,
  0x8B27C03CL, 0x8FE6DD8BL, 0x82A5FB52L, 0x8664E6E5L, 0xBE2B5B58L,
  0xBAEA46EFL, 0xB7A96036L, 0xB3687D81L, 0xAD2F2D84L, 0xA9EE3033L,
  0xA4AD16EAL, 0xA06C0B5DL, 0xD4326D90L, 0xD0F37027L, 0xDDB056FEL,
  0xD9714B49L, 0xC7361B4CL, 0xC3F706FBL, 0xCEB42022L, 0xCA753D95L,
  0xF23A8028L, 0xF6FB9D9FL, 0xFBB8BB46L, 0xFF79A6F1L, 0xE13EF6F4L,
  0xE5FFEB43L, 0xE8BCCD9AL, 0xEC7DD02DL, 0x34867077L, 0x30476DC0L,
  0x3D044B19L, 0x39C556AEL, 0x278206ABL, 0x23431B1CL, 0x2E003DC5L,
  0x2AC12072L, 0x128E9DCFL, 0x164F8078L, 0x1B0CA6A1L, 0x1FCDBB16L,
  0x018AEB13L, 0x054BF6A4L, 0x0808D07DL, 0x0CC9CDCAL, 0x7897AB07L,
  0x7C56B6B0L, 0x71159069L, 0x75D48DDEL, 0x6B93DDDBL, 0x6F52C06CL,
  0x6211E6B5L, 0x66D0FB02L, 0x5E9F46BFL, 0x5A5E5B08L, 0x571D7DD1L,
  0x53DC6066L, 0x4D9B3063L, 0x495A2DD4L, 0x44190B0DL, 0x40D816BAL,
  0xACA5C697L, 0xA864DB20L, 0xA527FDF9L, 0xA1E6E04EL, 0xBFA1B04BL,
  0xBB60ADFCL, 0xB6238B25L, 0xB2E29692L, 0x8AAD2B2FL, 0x8E6C3698L,
  0x832F1041L, 0x87EE0DF6L, 0x99A95DF3L, 0x9D684044L, 0x902B669DL,
  0x94EA7B2AL, 0xE0B41DE7L, 0xE4750050L, 0xE9362689L, 0xEDF73B3EL,
  0xF3B06B3BL, 0xF771768CL, 0xFA325055L, 0xFEF34DE2L, 0xC6BCF05FL,
  0xC27DEDE8L, 0xCF3ECB31L, 0xCBFFD686L, 0xD5B88683L, 0xD1799B34L,
  0xDC3ABDEDL, 0xD8FBA05AL, 0x690CE0EEL, 0x6DCDFD59L, 0x608EDB80L,
  0x644FC637L, 0x7A089632L, 0x7EC98B85L, 0x738AAD5CL, 0x774BB0EBL,
  0x4F040D56L, 0x4BC510E1L, 0x46863638L, 0x42472B8FL, 0x5C007B8AL,
  0x58C1663DL, 0x558240E4L, 0x51435D53L, 0x251D3B9EL, 0x21DC2629L,
  0x2C9F00F0L, 0x285E1D47L, 0x36194D42L, 0x32D850F5L, 0x3F9B762CL,
  0x3B5A6B9BL, 0x0315D626L, 0x07D4CB91L, 0x0A97ED48L, 0x0E56F0FFL,
  0x1011A0FAL, 0x14D0BD4DL, 0x19939B94L, 0x1D528623L, 0xF12F560EL,
  0xF5EE4BB9L, 0xF8AD6D60L, 0xFC6C70D7L, 0xE22B20D2L, 0xE6EA3D65L,
  0xEBA91BBCL, 0xEF68060BL, 0xD727BBB6L, 0xD3E6A601L, 0xDEA580D8L,
  0xDA649D6FL, 0xC423CD6AL, 0xC0E2D0DDL, 0xCDA1F604L, 0xC960EBB3L,
  0xBD3E8D7EL, 0xB9FF90C9L, 0xB4BCB610L, 0xB07DABA7L, 0xAE3AFBA2L,
  0xAAFBE615L, 0xA7B8C0CCL, 0xA379DD7BL, 0x9B3660C6L, 0x9FF77D71L,
  0x92B45BA8L, 0x9675461FL, 0x8832161AL, 0x8CF30BADL, 0x81B02D74L,
  0x857130C3L, 0x5D8A9099L, 0x594B8D2EL, 0x5408ABF7L, 0x50C9B640L,
  0x4E8EE645L, 0x4A4FFBF2L, 0x470CDD2BL, 0x43CDC09CL, 0x7B827D21L,
  0x7F436096L, 0x7200464FL, 0x76C15BF8L, 0x68860BFDL, 0x6C47164AL,
  0x61043093L, 0x65C52D24L, 0x119B4BE9L, 0x155A565EL, 0x18197087L,
  0x1CD86D30L, 0x029F3D35L, 0x065E2082L, 0x0B1D065BL, 0x0FDC1BECL,
  0x3793A651L, 0x3352BBE6L, 0x3E119D3FL, 0x3AD08088L, 0x2497D08DL,
  0x2056CD3AL, 0x2D15EBE3L, 0x29D4F654L, 0xC5A92679L, 0xC1683BCEL,
  0xCC2B1D17L, 0xC8EA00A0L, 0xD6AD50A5L, 0xD26C4D12L, 0xDF2F6BCBL,
  0xDBEE767CL, 0xE3A1CBC1L, 0xE760D676L, 0xEA23F0AFL, 0xEEE2ED18L,
  0xF0A5BD1DL, 0xF464A0AAL, 0xF9278673L, 0xFDE69BC4L, 0x89B8FD09L,
  0x8D79E0BEL, 0x803AC667L, 0x84FBDBD0L, 0x9ABC8BD5L, 0x9E7D9662L,
  0x933EB0BBL, 0x97FFAD0CL, 0xAFB010B1L, 0xAB710D06L, 0xA6322BDFL,
  0xA2F33668L, 0xBCB4666DL, 0xB8757BDAL, 0xB5365D03L, 0xB1F740B4L
};

static void
m_crcposix (uint32_t *crcp, unsigned char *bp, uint32_t n)
{
  while (n-- > 0)
    *crcp = (*crcp << 8) ^ crctab_posix[(unsigned char) ((*crcp >> 24)^*bp++)];
}

// Do CRC-POSIX function by calling a library entry point that has a
// slightly different calling sequence.
static uint32_t
docrcposix (uint32_t crcval, unsigned char *bp, uint32_t n)
{
  m_crcposix (&crcval, bp, n);
  return (crcval);
}

// Sum algorithms require various kinds of post-processing.
// The 'S' and 'R' variables are from the POSIX.2 (Draft 8?) description
// of the "sum" utility.
static uint32_t
postprocess (uint32_t S, long long n)
{
  // POSIX tacks on significant bytes of the length so that
  // different length sequences of '\0' have different sums;
  // then it complements sum.
  unsigned char char_n[sizeof (n)];
  uint32_t i;
  for (i = 0; n != 0; n >>= 8, ++i)
    char_n[i] = (unsigned char) (n & 0xFF);
  return (~docrcposix (S, char_n, i));
}

uint32_t
get_cksum (const char * pathname, char ** errmsg)
{
  int fd = open (pathname, O_RDONLY);
  if (fd < 0)
    {
      if (errmsg)
	*errmsg = dbe_sprintf (GTXT ("*** Warning: Error opening file for reading: %s"), pathname);
      return 0; // error
    }
  uint32_t crcval = 0;
  long long bytes = 0;
  int64_t n;
  unsigned char buf[4096];
  while ((n = read_from_file (fd, (char *) buf, sizeof (buf))) > 0)
    {
      bytes += n;
      crcval = docrcposix (crcval, buf, n);
    }
  close (fd);
  crcval = postprocess (crcval, bytes);
  return crcval;
}