Adding upstream version 7.4.upstream/7.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 920 insertions, 0 deletions

diff --git a/utility.cpp b/utility.cpp
new file mode 100644
index 0000000..505e4f0
--- /dev/null
+++ b/utility.cpp
@@ -0,0 +1,920 @@
+/*
+ * utility.cpp
+ *
+ * Home page of code is: https://www.smartmontools.org
+ *
+ * Copyright (C) 2002-12 Bruce Allen
+ * Copyright (C) 2008-23 Christian Franke
+ * Copyright (C) 2000 Michael Cornwell <cornwell@acm.org>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+// THIS FILE IS INTENDED FOR UTILITY ROUTINES THAT ARE APPLICABLE TO
+// BOTH SCSI AND ATA DEVICES, AND THAT MAY BE USED IN SMARTD,
+// SMARTCTL, OR BOTH.
+
+#include "config.h"
+#define __STDC_FORMAT_MACROS 1 // enable PRI* for C++
+
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <stdarg.h>
+#include <sys/stat.h>
+#ifdef HAVE_LOCALE_H
+#include <locale.h>
+#endif
+#ifdef _WIN32
+#include <mbstring.h> // _mbsinc()
+#endif
+
+#include <stdexcept>
+
+#include "svnversion.h"
+#include "utility.h"
+
+#include "atacmds.h"
+#include "dev_interface.h"
+#include "sg_unaligned.h"
+
+#ifndef USE_CLOCK_MONOTONIC
+#ifdef __MINGW32__
+// If MinGW-w64 < 9.0.0 or Windows < 8, GetSystemTimeAsFileTime() is used for
+// std::chrono::high_resolution_clock.  This provides only 1/64s (>15ms) resolution.
+// CLOCK_MONOTONIC uses QueryPerformanceCounter() which provides <1us resolution.
+#define USE_CLOCK_MONOTONIC 1
+#else
+// Use std::chrono::high_resolution_clock.
+#include <chrono>
+#define USE_CLOCK_MONOTONIC 0
+#endif
+#endif // USE_CLOCK_MONOTONIC
+
+const char * utility_cpp_cvsid = "$Id: utility.cpp 5519 2023-07-24 15:57:54Z chrfranke $"
+  UTILITY_H_CVSID;
+
+const char * packet_types[] = {
+        "Direct-access (disk)",
+        "Sequential-access (tape)",
+        "Printer",
+        "Processor",
+        "Write-once (optical disk)",
+        "CD/DVD",
+        "Scanner",
+        "Optical memory (optical disk)",
+        "Medium changer",
+        "Communications",
+        "Graphic arts pre-press (10)",
+        "Graphic arts pre-press (11)",
+        "Array controller",
+        "Enclosure services",
+        "Reduced block command (simplified disk)",
+        "Optical card reader/writer"
+};
+
+// BUILD_INFO can be provided by package maintainers
+#ifndef BUILD_INFO
+#define BUILD_INFO "(local build)"
+#endif
+
+// Make version information string
+// lines: 1: version only, 2: version+copyright, >=3: full information
+std::string format_version_info(const char * prog_name, int lines /* = 2 */)
+{
+  std::string info = strprintf(
+    "%s "
+#ifndef SMARTMONTOOLS_RELEASE_DATE
+      "pre-"
+#endif
+      PACKAGE_VERSION " "
+#ifdef SMARTMONTOOLS_SVN_REV
+      SMARTMONTOOLS_SVN_DATE " r" SMARTMONTOOLS_SVN_REV
+#else
+      "(build date " __DATE__ ")" // checkout without expansion of Id keywords
+#endif
+      " [%s] " BUILD_INFO "\n",
+    prog_name, smi()->get_os_version_str().c_str()
+  );
+  if (lines <= 1)
+    return info;
+
+  info += "Copyright (C) 2002-23, Bruce Allen, Christian Franke, www.smartmontools.org\n";
+  if (lines == 2)
+    return info;
+
+  info += "\n";
+  info += prog_name;
+  info += " comes with ABSOLUTELY NO WARRANTY. This is free\n"
+    "software, and you are welcome to redistribute it under\n"
+    "the terms of the GNU General Public License; either\n"
+    "version 2, or (at your option) any later version.\n"
+    "See https://www.gnu.org for further details.\n"
+    "\n"
+#ifndef SMARTMONTOOLS_RELEASE_DATE
+    "smartmontools pre-release " PACKAGE_VERSION "\n"
+#else
+    "smartmontools release " PACKAGE_VERSION
+      " dated " SMARTMONTOOLS_RELEASE_DATE " at " SMARTMONTOOLS_RELEASE_TIME "\n"
+#endif
+#ifdef SMARTMONTOOLS_SVN_REV
+    "smartmontools SVN rev " SMARTMONTOOLS_SVN_REV
+      " dated " SMARTMONTOOLS_SVN_DATE " at " SMARTMONTOOLS_SVN_TIME "\n"
+#else
+    "smartmontools SVN rev is unknown\n"
+#endif
+    "smartmontools build host: " SMARTMONTOOLS_BUILD_HOST "\n"
+    "smartmontools build with: "
+
+#define N2S_(s) #s
+#define N2S(s) N2S_(s)
+#if   __cplusplus == 202002
+                               "C++20"
+#elif __cplusplus == 201703
+                               "C++17"
+#elif __cplusplus == 201402
+                               "C++14"
+#elif __cplusplus == 201103
+                               "C++11"
+#else
+                               "C++(" N2S(__cplusplus) ")"
+#endif
+#undef N2S
+#undef N2S_
+
+#if defined(__GNUC__) && defined(__VERSION__) // works also with CLang
+                                     ", GCC " __VERSION__
+#endif
+#ifdef __MINGW64_VERSION_STR
+                                     ", MinGW-w64 " __MINGW64_VERSION_STR
+#endif
+                                                          "\n"
+    "smartmontools configure arguments:"
+#ifdef SOURCE_DATE_EPOCH
+                                      " [hidden in reproducible builds]\n"
+    "reproducible build SOURCE_DATE_EPOCH: "
+#endif
+  ;
+#ifdef SOURCE_DATE_EPOCH
+  char ts[32]; struct tm tmbuf;
+  strftime(ts, sizeof(ts), "%Y-%m-%d %H:%M:%S", time_to_tm_local(&tmbuf, SOURCE_DATE_EPOCH));
+  info += strprintf("%u (%s)", (unsigned)SOURCE_DATE_EPOCH, ts);
+#else
+  info += (sizeof(SMARTMONTOOLS_CONFIGURE_ARGS) > 1 ?
+           SMARTMONTOOLS_CONFIGURE_ARGS : " [no arguments given]");
+#endif
+  info += '\n';
+
+  return info;
+}
+
+// Solaris only: Get site-default timezone. This is called from
+// UpdateTimezone() when TZ environment variable is unset at startup.
+#if defined (__SVR4) && defined (__sun)
+static const char *TIMEZONE_FILE = "/etc/TIMEZONE";
+
+static char *ReadSiteDefaultTimezone(){
+  FILE *fp;
+  char buf[512], *tz;
+  int n;
+
+  tz = NULL;
+  fp = fopen(TIMEZONE_FILE, "r");
+  if(fp == NULL) return NULL;
+  while(fgets(buf, sizeof(buf), fp)) {
+    if (strncmp(buf, "TZ=", 3))    // searches last "TZ=" line
+      continue;
+    n = strlen(buf) - 1;
+    if (buf[n] == '\n') buf[n] = 0;
+    if (tz) free(tz);
+    tz = strdup(buf);
+  }
+  fclose(fp);
+  return tz;
+}
+#endif
+
+// Make sure that this executable is aware if the user has changed the
+// time-zone since the last time we polled devices. The canonical
+// example is a user who starts smartd on a laptop, then flies across
+// time-zones with a laptop, and then changes the timezone, WITHOUT
+// restarting smartd. This is a work-around for a bug in
+// GLIBC. Yuk. See bug number 48184 at http://bugs.debian.org and
+// thanks to Ian Redfern for posting a workaround.
+
+// Please refer to the smartd manual page, in the section labeled LOG
+// TIMESTAMP TIMEZONE.
+void FixGlibcTimeZoneBug(){
+#if __GLIBC__  
+  if (!getenv("TZ")) {
+    putenv((char *)"TZ=GMT"); // POSIX prototype is 'int putenv(char *)'
+    tzset();
+    putenv((char *)"TZ");
+    tzset();
+  }
+#elif _WIN32
+  const char * tz = getenv("TZ");
+  if (!tz) {
+    putenv("TZ=GMT");
+    tzset();
+    putenv("TZ=");  // empty value removes TZ, putenv("TZ") does nothing
+    tzset();
+  }
+  else {
+    static const regular_expression tzrex("[A-Z]{3}[-+]?[0-9]+([A-Z]{3,4})?");
+    // tzset() from MSVCRT only supports the above basic syntax of TZ.
+    // Otherwise the timezone settings are set to bogus values.
+    // Unset TZ and revert to system default timezone in these cases.
+    if (!tzrex.full_match(tz)) {
+      putenv("TZ=");
+      tzset();
+    }
+  }
+#elif defined (__SVR4) && defined (__sun)
+  // In Solaris, putenv("TZ=") sets null string and invalid timezone.
+  // putenv("TZ") does nothing.  With invalid TZ, tzset() do as if
+  // TZ=GMT.  With TZ unset, /etc/TIMEZONE will be read only _once_ at
+  // first tzset() call.  Conclusion: Unlike glibc, dynamic
+  // configuration of timezone can be done only by changing actual
+  // value of TZ environment value.
+  enum tzstate { NOT_CALLED_YET, USER_TIMEZONE, TRACK_TIMEZONE };
+  static enum tzstate state = NOT_CALLED_YET;
+
+  static struct stat prev_stat;
+  static char *prev_tz;
+  struct stat curr_stat;
+  char *curr_tz;
+
+  if(state == NOT_CALLED_YET) {
+    if(getenv("TZ")) {
+      state = USER_TIMEZONE; // use supplied timezone
+    } else {
+      state = TRACK_TIMEZONE;
+      if(stat(TIMEZONE_FILE, &prev_stat)) {
+	state = USER_TIMEZONE;	// no TZ, no timezone file; use GMT forever
+      } else {
+	prev_tz = ReadSiteDefaultTimezone(); // track timezone file change
+	if(prev_tz) putenv(prev_tz);
+      }
+    }
+    tzset();
+  } else if(state == TRACK_TIMEZONE) {
+    if(stat(TIMEZONE_FILE, &curr_stat) == 0
+       && (curr_stat.st_ctime != prev_stat.st_ctime
+	    || curr_stat.st_mtime != prev_stat.st_mtime)) {
+      // timezone file changed
+      curr_tz = ReadSiteDefaultTimezone();
+      if(curr_tz) {
+	putenv(curr_tz);
+	if(prev_tz) free(prev_tz);
+	prev_tz = curr_tz; prev_stat = curr_stat; 
+      }
+    }
+    tzset();
+  }
+#endif
+  // OTHER OS/LIBRARY FIXES SHOULD GO HERE, IF DESIRED.  PLEASE TRY TO
+  // KEEP THEM INDEPENDENT.
+  return;
+}
+
+#ifdef _WIN32
+// Fix strings in tzname[] to avoid long names with non-ascii characters.
+// If TZ is not set, tzset() in the MSVC runtime sets tzname[] to the
+// national language timezone names returned by GetTimezoneInformation().
+static char * fixtzname(char * dest, int destsize, const char * src)
+{
+  int i = 0, j = 0;
+  while (src[i] && j < destsize-1) {
+    int i2 = (const char *)_mbsinc((const unsigned char *)src+i) - src;
+    if (i2 > i+1)
+      i = i2; // Ignore multibyte chars
+    else {
+      if ('A' <= src[i] && src[i] <= 'Z')
+        dest[j++] = src[i]; // "Pacific Standard Time" => "PST"
+      i++;
+    }
+  }
+  if (j < 2)
+    j = 0;
+  dest[j] = 0;
+  return dest;
+}
+#endif // _WIN32
+
+// This value follows the peripheral device type value as defined in
+// SCSI Primary Commands, ANSI INCITS 301:1997.  It is also used in
+// the ATA standard for packet devices to define the device type.
+const char *packetdevicetype(int type){
+  if (type<0x10)
+    return packet_types[type];
+  
+  if (type<0x20)
+    return "Reserved";
+  
+  return "Unknown";
+}
+
+// Convert time to broken-down local time, throw on error.
+struct tm * time_to_tm_local(struct tm * tp, time_t t)
+{
+#ifndef _WIN32
+  // POSIX, C23 - missing in MSVRCT, C++ and older C.
+  if (!localtime_r(&t, tp))
+    throw std::runtime_error("localtime_r() failed");
+#elif 0 // defined(__STDC_LIB_EXT1__)
+  // C11 - requires #define __STDC_WANT_LIB_EXT1__ before <time.h>.
+  // Missing in POSIX and C++, MSVCRT variant differs.
+  if (!localtime_s(&t, tp))
+    throw std::runtime_error("localtime_s() failed");
+#else
+  // MSVCRT - 64-bit variant avoids conflict with the above C11 variant.
+  __time64_t t64 = t;
+  if (_localtime64_s(tp, &t64))
+    throw std::runtime_error("_localtime64_s() failed");
+#endif
+  return tp;
+}
+
+// Utility function prints date and time and timezone into a character
+// buffer of length 64.  All the fuss is needed to get the right
+// timezone info (sigh).
+void dateandtimezoneepoch(char (& buffer)[DATEANDEPOCHLEN], time_t tval)
+{
+  FixGlibcTimeZoneBug();
+  
+  // Get the time structure.  We need this to determine if we are in
+  // daylight savings time or not.
+  struct tm tmbuf, * tmval = time_to_tm_local(&tmbuf, tval);
+  
+  // Convert to an ASCII string, put in datebuffer.
+  // Same as: strftime(datebuffer, sizeof(datebuffer), "%a %b %e %H:%M:%S %Y\n"),
+  // but always in "C" locale.
+  char datebuffer[32];
+  STATIC_ASSERT(sizeof(datebuffer) >= 26); // assumed by asctime_r()
+#ifndef _WIN32
+  // POSIX (missing in MSVRCT, C and C++)
+  if (!asctime_r(tmval, datebuffer))
+    throw std::runtime_error("asctime_r() failed");
+#else
+  // MSVCRT, C11 (missing in POSIX)
+  if (asctime_s(datebuffer, sizeof(datebuffer), tmval))
+    throw std::runtime_error("asctime_s() failed");
+#endif
+  
+  // Remove newline
+  int lenm1 = strlen(datebuffer) - 1;
+  datebuffer[lenm1>=0?lenm1:0]='\0';
+
+#if defined(_WIN32) && defined(_MSC_VER)
+  // tzname is missing in MSVC14
+  #define tzname _tzname
+#endif
+
+  // correct timezone name
+  const char * timezonename;
+  if (tmval->tm_isdst==0)
+    // standard time zone
+    timezonename=tzname[0];
+  else if (tmval->tm_isdst>0)
+    // daylight savings in effect
+    timezonename=tzname[1];
+  else
+    // unable to determine if daylight savings in effect
+    timezonename="";
+
+#ifdef _WIN32
+  // Fix long non-ascii timezone names
+    // cppcheck-suppress variableScope
+  char tzfixbuf[6+1] = "";
+  if (!getenv("TZ"))
+    timezonename=fixtzname(tzfixbuf, sizeof(tzfixbuf), timezonename);
+#endif
+  
+  // Finally put the information into the buffer as needed.
+  snprintf(buffer, DATEANDEPOCHLEN, "%s %s", datebuffer, timezonename);
+  
+  return;
+}
+
+// A replacement for perror() that sends output to our choice of
+// printing. If errno not set then just print message.
+void syserror(const char *message){
+  
+  if (errno) {
+    // Get the correct system error message:
+    const char *errormessage=strerror(errno);
+    
+    // Check that caller has handed a sensible string, and provide
+    // appropriate output. See perror(3) man page to understand better.
+    if (message && *message)
+      pout("%s: %s\n",message, errormessage);
+    else
+      pout("%s\n",errormessage);
+  }
+  else if (message && *message)
+    pout("%s\n",message);
+  
+  return;
+}
+
+// Check regular expression for non-portable features.
+//
+// POSIX extended regular expressions interpret unmatched ')' ordinary:
+// "The close-parenthesis shall be considered special in this context
+//  only if matched with a preceding open-parenthesis."
+//
+// GNU libc and BSD libc support unmatched ')', Cygwin reports an error.
+//
+// POSIX extended regular expressions do not define empty subexpressions:
+// "A vertical-line appearing first or last in an ERE, or immediately following
+//  a vertical-line or a left-parenthesis, or immediately preceding a
+//  right-parenthesis, produces undefined results."
+//
+// GNU libc and Cygwin support empty subexpressions, BSD libc reports an error.
+//
+static const char * check_regex(const char * pattern)
+{
+  int level = 0;
+  char c;
+
+  for (int i = 0; (c = pattern[i]); i++) {
+    // Skip "\x"
+    if (c == '\\') {
+      if (!pattern[++i])
+        break;
+      continue;
+    }
+
+    // Skip "[...]"
+    if (c == '[') {
+      if (pattern[++i] == '^')
+        i++;
+      if (!pattern[i++])
+        break;
+      while ((c = pattern[i]) && c != ']')
+        i++;
+      if (!c)
+        break;
+      continue;
+    }
+
+    // Check "(...)" nesting
+    if (c == '(')
+      level++;
+    else if (c == ')' && --level < 0)
+      return "Unmatched ')'";
+
+    // Check for leading/trailing '|' or "||", "|)", "|$", "(|", "^|"
+    char c1;
+    if (   (c == '|' && (   i == 0 || !(c1 = pattern[i+1])
+                          || c1 == '|' || c1 == ')' || c1 == '$'))
+        || ((c == '(' || c == '^') && pattern[i+1] == '|')       )
+      return "Empty '|' subexpression";
+  }
+
+  return (const char *)0;
+}
+
+// Wrapper class for POSIX regex(3) or std::regex
+
+#ifndef WITH_CXX11_REGEX
+
+regular_expression::regular_expression()
+{
+  memset(&m_regex_buf, 0, sizeof(m_regex_buf));
+}
+
+regular_expression::~regular_expression()
+{
+  free_buf();
+}
+
+regular_expression::regular_expression(const regular_expression & x)
+: m_pattern(x.m_pattern),
+  m_errmsg(x.m_errmsg)
+{
+  memset(&m_regex_buf, 0, sizeof(m_regex_buf));
+  copy_buf(x);
+}
+
+regular_expression & regular_expression::operator=(const regular_expression & x)
+{
+  m_pattern = x.m_pattern;
+  m_errmsg = x.m_errmsg;
+  free_buf();
+  copy_buf(x);
+  return *this;
+}
+
+void regular_expression::free_buf()
+{
+  if (nonempty(&m_regex_buf, sizeof(m_regex_buf))) {
+    regfree(&m_regex_buf);
+    memset(&m_regex_buf, 0, sizeof(m_regex_buf));
+  }
+}
+
+void regular_expression::copy_buf(const regular_expression & x)
+{
+  if (nonempty(&x.m_regex_buf, sizeof(x.m_regex_buf))) {
+    // There is no POSIX compiled-regex-copy command.
+    if (!compile())
+      throw std::runtime_error(strprintf(
+        "Unable to recompile regular expression \"%s\": %s",
+        m_pattern.c_str(), m_errmsg.c_str()));
+  }
+}
+
+#endif // !WITH_CXX11_REGEX
+
+regular_expression::regular_expression(const char * pattern)
+: m_pattern(pattern)
+{
+  if (!compile())
+    throw std::runtime_error(strprintf(
+      "error in regular expression \"%s\": %s",
+      m_pattern.c_str(), m_errmsg.c_str()));
+}
+
+bool regular_expression::compile(const char * pattern)
+{
+#ifndef WITH_CXX11_REGEX
+  free_buf();
+#endif
+  m_pattern = pattern;
+  return compile();
+}
+
+bool regular_expression::compile()
+{
+#ifdef WITH_CXX11_REGEX
+  try {
+    m_regex.assign(m_pattern, std::regex_constants::extended);
+  }
+  catch (std::regex_error & ex) {
+    m_errmsg = ex.what();
+    return false;
+  }
+
+#else
+  int errcode = regcomp(&m_regex_buf, m_pattern.c_str(), REG_EXTENDED);
+  if (errcode) {
+    char errmsg[512];
+    regerror(errcode, &m_regex_buf, errmsg, sizeof(errmsg));
+    m_errmsg = errmsg;
+    free_buf();
+    return false;
+  }
+#endif
+
+  const char * errmsg = check_regex(m_pattern.c_str());
+  if (errmsg) {
+    m_errmsg = errmsg;
+#ifdef WITH_CXX11_REGEX
+    m_regex = std::regex();
+#else
+    free_buf();
+#endif
+    return false;
+  }
+
+  m_errmsg.clear();
+  return true;
+}
+
+bool regular_expression::full_match(const char * str) const
+{
+#ifdef WITH_CXX11_REGEX
+  return std::regex_match(str, m_regex);
+#else
+  match_range range;
+  return (   !regexec(&m_regex_buf, str, 1, &range, 0)
+          && range.rm_so == 0 && range.rm_eo == (int)strlen(str));
+#endif
+}
+
+bool regular_expression::execute(const char * str, unsigned nmatch, match_range * pmatch) const
+{
+#ifdef WITH_CXX11_REGEX
+  std::cmatch m;
+  if (!std::regex_search(str, m, m_regex))
+    return false;
+  unsigned sz = m.size();
+  for (unsigned i = 0; i < nmatch; i++) {
+    if (i < sz && *m[i].first) {
+      pmatch[i].rm_so = m[i].first  - str;
+      pmatch[i].rm_eo = m[i].second - str;
+    }
+    else
+      pmatch[i].rm_so = pmatch[i].rm_eo = -1;
+  }
+  return true;
+
+#else
+  return !regexec(&m_regex_buf, str, nmatch, pmatch, 0);
+#endif
+}
+
+// Splits an argument to the -t option that is assumed to be of the form
+// "selective,%lld-%lld" (prefixes of "0" (for octal) and "0x"/"0X" (for hex)
+// are allowed).  The first long long int is assigned to *start and the second
+// to *stop.  Returns zero if successful and non-zero otherwise.
+int split_selective_arg(char *s, uint64_t *start,
+                        uint64_t *stop, int *mode)
+{
+  char *tailptr;
+  if (!(s = strchr(s, ',')))
+    return 1;
+  bool add = false;
+  if (!isdigit((int)(*++s))) {
+    *start = *stop = 0;
+    if (!strncmp(s, "redo", 4))
+      *mode = SEL_REDO;
+    else if (!strncmp(s, "next", 4))
+      *mode = SEL_NEXT;
+    else if (!strncmp(s, "cont", 4))
+      *mode = SEL_CONT;
+    else
+      return 1;
+    s += 4;
+    if (!*s)
+      return 0;
+    if (*s != '+')
+      return 1;
+  }
+  else {
+    *mode = SEL_RANGE;
+    errno = 0;
+    // Last argument to strtoull (the base) is 0 meaning that decimal is assumed
+    // unless prefixes of "0" (for octal) or "0x"/"0X" (for hex) are used.
+    *start = strtoull(s, &tailptr, 0);
+    s = tailptr;
+    add = (*s == '+');
+    if (!(!errno && (add || *s == '-')))
+      return 1;
+    if (!strcmp(s, "-max")) {
+      *stop = ~(uint64_t)0; // replaced by max LBA later
+      return 0;
+    }
+  }
+
+  errno = 0;
+  *stop = strtoull(s+1, &tailptr, 0);
+  if (errno || *tailptr != '\0')
+    return 1;
+  if (add) {
+    if (*stop > 0)
+      (*stop)--;
+    *stop += *start; // -t select,N+M => -t select,N,(N+M-1)
+  }
+  return 0;
+}
+
+// Returns true if region of memory contains non-zero entries
+bool nonempty(const void * data, int size)
+{
+  for (int i = 0; i < size; i++)
+    if (((const unsigned char *)data)[i])
+      return true;
+  return false;
+}
+
+// Copy not null terminated char array to null terminated string.
+// Replace non-ascii characters.  Remove leading and trailing blanks.
+const char * format_char_array(char * str, int strsize, const char * chr, int chrsize)
+{
+  int b = 0;
+  while (b < chrsize && chr[b] == ' ')
+    b++;
+  int n = 0;
+  while (b+n < chrsize && chr[b+n])
+    n++;
+  while (n > 0 && chr[b+n-1] == ' ')
+    n--;
+
+  if (n >= strsize)
+    n = strsize-1;
+
+  for (int i = 0; i < n; i++) {
+    char c = chr[b+i];
+    str[i] = (' ' <= c && c <= '~' ? c : '?');
+  }
+
+  str[n] = 0;
+  return str;
+}
+
+// Format integer with thousands separator
+const char * format_with_thousands_sep(char * str, int strsize, uint64_t val,
+                                       const char * thousands_sep /* = 0 */)
+{
+  if (!thousands_sep) {
+    thousands_sep = ",";
+#ifdef HAVE_LOCALE_H
+    setlocale(LC_ALL, "");
+    const struct lconv * currentlocale = localeconv();
+    if (*(currentlocale->thousands_sep))
+      thousands_sep = currentlocale->thousands_sep;
+#endif
+  }
+
+  char num[64];
+  snprintf(num, sizeof(num), "%" PRIu64, val);
+  int numlen = strlen(num);
+
+  int i = 0, j = 0;
+  do
+    str[j++] = num[i++];
+  while (i < numlen && (numlen - i) % 3 != 0 && j < strsize-1);
+  str[j] = 0;
+
+  while (i < numlen && j < strsize-1) {
+    j += snprintf(str+j, strsize-j, "%s%.3s", thousands_sep, num+i);
+    i += 3;
+  }
+
+  return str;
+}
+
+// Format capacity with SI prefixes
+const char * format_capacity(char * str, int strsize, uint64_t val,
+                             const char * decimal_point /* = 0 */)
+{
+  if (!decimal_point) {
+    decimal_point = ".";
+#ifdef HAVE_LOCALE_H
+    setlocale(LC_ALL, "");
+    const struct lconv * currentlocale = localeconv();
+    if (*(currentlocale->decimal_point))
+      decimal_point = currentlocale->decimal_point;
+#endif
+  }
+
+  const unsigned factor = 1000; // 1024 for KiB,MiB,...
+  static const char prefixes[] = " KMGTP";
+
+  // Find d with val in [d, d*factor)
+  unsigned i = 0;
+  uint64_t d = 1;
+  for (uint64_t d2 = d * factor; val >= d2; d2 *= factor) {
+    d = d2;
+    if (++i >= sizeof(prefixes)-2)
+      break;
+  }
+
+  // Print 3 digits
+  uint64_t n = val / d;
+  if (i == 0)
+    snprintf(str, strsize, "%u B", (unsigned)n);
+  else if (n >= 100) // "123 xB"
+    snprintf(str, strsize, "%" PRIu64 " %cB", n, prefixes[i]);
+  else if (n >= 10)  // "12.3 xB"
+    snprintf(str, strsize, "%" PRIu64 "%s%u %cB", n, decimal_point,
+        (unsigned)(((val % d) * 10) / d), prefixes[i]);
+  else               // "1.23 xB"
+    snprintf(str, strsize, "%" PRIu64 "%s%02u %cB", n, decimal_point,
+        (unsigned)(((val % d) * 100) / d), prefixes[i]);
+
+  return str;
+}
+
+// return (v)sprintf() formatted std::string
+__attribute_format_printf(1, 0)
+std::string vstrprintf(const char * fmt, va_list ap)
+{
+  char buf[512];
+  vsnprintf(buf, sizeof(buf), fmt, ap);
+  buf[sizeof(buf)-1] = 0;
+  return buf;
+}
+
+std::string strprintf(const char * fmt, ...)
+{
+  va_list ap; va_start(ap, fmt);
+  std::string str = vstrprintf(fmt, ap);
+  va_end(ap);
+  return str;
+}
+
+#if defined(HAVE___INT128)
+// Compiler supports '__int128'.
+
+// Recursive 128-bit to string conversion function
+static int snprint_uint128(char * str, int strsize, unsigned __int128 value)
+{
+  if (strsize <= 0)
+    return -1;
+
+  if (value <= 0xffffffffffffffffULL) {
+    // Print leading digits as 64-bit value
+    return snprintf(str, (size_t)strsize, "%" PRIu64, (uint64_t)value);
+  }
+  else {
+    // Recurse to print leading digits
+    const uint64_t e19 = 10000000000000000000ULL; // 2^63 < 10^19 < 2^64
+    int len1 = snprint_uint128(str, strsize, value / e19);
+    if (len1 < 0)
+      return -1;
+
+    // Print 19 digits remainder as 64-bit value
+    int len2 = snprintf(str + (len1 < strsize ? len1 : strsize - 1),
+                        (size_t)(len1 < strsize ? strsize - len1 : 1),
+                        "%019" PRIu64, (uint64_t)(value % e19)        );
+    if (len2 < 0)
+      return -1;
+    return len1 + len2;
+  }
+}
+
+// Convert 128-bit unsigned integer provided as two 64-bit halves to a string.
+const char * uint128_hilo_to_str(char * str, int strsize, uint64_t value_hi, uint64_t value_lo)
+{
+  snprint_uint128(str, strsize, ((unsigned __int128)value_hi << 64) | value_lo);
+  return str;
+}
+
+#elif defined(HAVE_LONG_DOUBLE_WIDER_PRINTF)
+// Compiler and *printf() support 'long double' which is wider than 'double'.
+
+const char * uint128_hilo_to_str(char * str, int strsize, uint64_t value_hi, uint64_t value_lo)
+{
+  snprintf(str, strsize, "%.0Lf", value_hi * (0xffffffffffffffffULL + 1.0L) + value_lo);
+  return str;
+}
+
+#else // !HAVE_LONG_DOUBLE_WIDER_PRINTF
+// No '__int128' or 'long double' support, use 'double'.
+
+const char * uint128_hilo_to_str(char * str, int strsize, uint64_t value_hi, uint64_t value_lo)
+{
+  snprintf(str, strsize, "%.0f", value_hi * (0xffffffffffffffffULL + 1.0) + value_lo);
+  return str;
+}
+
+#endif // HAVE___INT128
+
+// Get microseconds since some unspecified starting point.
+long long get_timer_usec()
+{
+#if USE_CLOCK_MONOTONIC
+  struct timespec ts;
+  if (clock_gettime(CLOCK_MONOTONIC, &ts))
+    return -1;
+  return ts.tv_sec * 1000000LL + ts.tv_nsec / 1000;
+#else
+  return std::chrono::duration_cast<std::chrono::microseconds>(
+    std::chrono::high_resolution_clock::now().time_since_epoch()
+  ).count();
+#endif
+}
+
+// Runtime check of byte ordering, throws on error.
+static void check_endianness()
+{
+  const union {
+    // Force compile error if int type is not 32bit.
+    unsigned char c[sizeof(int) == 4 ? 8 : -1];
+    uint64_t i;
+  } x = {{1, 2, 3, 4, 5, 6, 7, 8}};
+  const uint64_t le = 0x0807060504030201ULL;
+  const uint64_t be = 0x0102030405060708ULL;
+
+  if (!(   x.i == (isbigendian() ? be : le)
+        && sg_get_unaligned_le16(x.c)   == (uint16_t)le
+        && sg_get_unaligned_be16(x.c+6) == (uint16_t)be
+        && sg_get_unaligned_le32(x.c)   == (uint32_t)le
+        && sg_get_unaligned_be32(x.c+4) == (uint32_t)be
+        && sg_get_unaligned_le64(x.c)   == le
+        && sg_get_unaligned_be64(x.c)   == be          ))
+    throw std::logic_error("CPU endianness does not match compile time test");
+}
+
+#if defined(__GNUC__) && (__GNUC__ >= 7)
+
+// G++ 7+: Assume sane implementation and avoid -Wformat-truncation warning
+static void check_snprintf() {}
+
+#else
+
+static void check_snprintf()
+{
+  char buf[] =              "ABCDEFGHI";
+  int n1 = snprintf(buf, 8, "123456789");
+  int n2 = snprintf(buf, 0, "X");
+  if (!(!strcmp(buf, "1234567") && n1 == 9 && n2 == 1))
+    throw std::logic_error("Function snprintf() does not conform to C99");
+}
+
+#endif
+
+// Runtime check of ./configure result, throws on error.
+void check_config()
+{
+  check_endianness();
+  check_snprintf();
+}