/*
* utility.cpp
*
- * Home page of code is: http://smartmontools.sourceforge.net
+ * Home page of code is: http://www.smartmontools.org
*
- * Copyright (C) 2002-6 Bruce Allen <smartmontools-support@lists.sourceforge.net>
+ * Copyright (C) 2002-12 Bruce Allen
+ * Copyright (C) 2008-18 Christian Franke
* Copyright (C) 2000 Michael Cornwell <cornwell@acm.org>
*
- * 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 2, or (at your option)
- * any later version.
- *
- * You should have received a copy of the GNU General Public License
- * (for example COPYING); if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * This code was originally developed as a Senior Thesis by Michael Cornwell
- * at the Concurrent Systems Laboratory (now part of the Storage Systems
- * Research Center), Jack Baskin School of Engineering, University of
- * California, Santa Cruz. http://ssrc.soe.ucsc.edu/
- *
+ * 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 <syslog.h>
#include <stdarg.h>
#include <sys/stat.h>
+#ifdef HAVE_LOCALE_H
+#include <locale.h>
+#endif
#ifdef _WIN32
#include <mbstring.h> // _mbsinc()
#endif
-#include "config.h"
-#include "int64.h"
+#include <stdexcept>
+
+#include "svnversion.h"
#include "utility.h"
-// Any local header files should be represented by a CVSIDX just below.
-const char* utility_c_cvsid="$Id: utility.cpp,v 1.62 2006/08/09 20:40:20 chrfranke Exp $"
-CONFIG_H_CVSID INT64_H_CVSID UTILITY_H_CVSID;
+#include "atacmds.h"
+#include "dev_interface.h"
+#include "sg_unaligned.h"
+
+const char * utility_cpp_cvsid = "$Id: utility.cpp 4842 2018-12-02 16:07:26Z chrfranke $"
+ UTILITY_H_CVSID;
const char * packet_types[] = {
"Direct-access (disk)",
"Optical card reader/writer"
};
-// Whenever exit() status is EXIT_BADCODE, please print this message
-const char *reportbug="Please report this bug to the Smartmontools developers at " PACKAGE_BUGREPORT ".\n";
-
-
-// hang on to exit code, so we can make use of more generic 'atexit()'
-// functionality and still check our exit code
-int exitstatus = 0;
+// BUILD_INFO can be provided by package maintainers
+#ifndef BUILD_INFO
+#define BUILD_INFO "(local build)"
+#endif
-// command-line argument: are we running in debug mode?.
-unsigned char debugmode = 0;
+// Make version information string
+std::string format_version_info(const char * prog_name, bool full /*= false*/)
+{
+ std::string info = strprintf(
+ "%s " 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"
+ "Copyright (C) 2002-18, Bruce Allen, Christian Franke, www.smartmontools.org\n",
+ prog_name, smi()->get_os_version_str().c_str()
+ );
+ if (!full)
+ 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 http://www.gnu.org for further details.\n"
+ "\n"
+ "smartmontools release " PACKAGE_VERSION
+ " dated " SMARTMONTOOLS_RELEASE_DATE " at " SMARTMONTOOLS_RELEASE_TIME "\n"
+#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 > 201703
+ "C++2x" N2S(__cplusplus)
+#elif __cplusplus == 201703
+ "C++17"
+#elif __cplusplus > 201402
+ "C++14" N2S(__cplusplus)
+#elif __cplusplus == 201402
+ "C++14"
+#elif __cplusplus > 201103
+ "C++11" N2S(__cplusplus)
+#elif __cplusplus == 201103
+ "C++11"
+#elif __cplusplus > 199711
+ "C++98" N2S(__cplusplus)
+#elif __cplusplus == 199711
+ "C++98"
+#else
+ "C++" N2S(__cplusplus)
+#endif
+#undef N2S
+#undef N2S_
+#if defined(__GNUC__) && defined(__VERSION__) // works also with CLang
+ ", GCC " __VERSION__
+#endif
+ "\n"
+ "smartmontools configure arguments:"
+ ;
+ info += (sizeof(SMARTMONTOOLS_CONFIGURE_ARGS) > 1 ?
+ SMARTMONTOOLS_CONFIGURE_ARGS : " [no arguments given]");
+ info += '\n';
+
+ return info;
+}
// Solaris only: Get site-default timezone. This is called from
// UpdateTimezone() when TZ environment variable is unset at startup.
#endif
// Make sure that this executable is aware if the user has changed the
-// time-zone since the last time we polled devices. The cannonical
+// 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
void FixGlibcTimeZoneBug(){
#if __GLIBC__
if (!getenv("TZ")) {
- putenv("TZ=GMT");
+ putenv((char *)"TZ=GMT"); // POSIX prototype is 'int putenv(char *)'
tzset();
- putenv("TZ");
+ putenv((char *)"TZ");
tzset();
}
#elif _WIN32
return "Unknown";
}
-
-// Returns 1 if machine is big endian, else zero. This is a run-time
-// rather than a compile-time function. We could do it at
-// compile-time but in principle there are architectures that can run
-// with either byte-ordering.
-int isbigendian(){
- short i=0x0100;
- char *tmp=(char *)&i;
- return *tmp;
-}
-
// Utility function prints date and time and timezone into a character
-// buffer of length>=64. All the fuss is needed to get the right
+// buffer of length 64. All the fuss is needed to get the right
// timezone info (sigh).
-void dateandtimezoneepoch(char *buffer, time_t tval){
+void dateandtimezoneepoch(char (& buffer)[DATEANDEPOCHLEN], time_t tval)
+{
struct tm *tmval;
- char *timezonename;
+ const char *timezonename;
char datebuffer[DATEANDEPOCHLEN];
int lenm1;
-#ifdef _WIN32
- char tzfixbuf[6+1];
-#endif
FixGlibcTimeZoneBug();
// Remove newline
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
if (tmval->tm_isdst==0)
// standard time zone
#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
return;
}
-// Date and timezone gets printed into string pointed to by buffer
-void dateandtimezone(char *buffer){
-
- // Get the epoch (time in seconds since Jan 1 1970)
- time_t tval=time(NULL);
-
- dateandtimezoneepoch(buffer, tval);
- return;
-}
-
-// These are two utility functions for printing CVS IDs. Massagecvs()
-// returns distance that it has moved ahead in the input string
-int massagecvs(char *out, const char *cvsid){
- char *copy,*filename,*date,*version;
- int retVal=0;
- const char delimiters[] = " ,$";
-
- // make a copy on the heap, go to first token,
- if (!(copy=strdup(cvsid)))
- return 0;
-
- if (!(filename=strtok(copy, delimiters)))
- goto endmassage;
-
- // move to first instance of "Id:"
- while (strcmp(filename,"Id:"))
- if (!(filename=strtok(NULL, delimiters)))
- goto endmassage;
-
- // get filename, skip "v", get version and date
- if (!( filename=strtok(NULL, delimiters) ) ||
- !( strtok(NULL, delimiters) ) ||
- !( version=strtok(NULL, delimiters) ) ||
- !( date=strtok(NULL, delimiters) ) )
- goto endmassage;
-
- sprintf(out,"%-16s revision: %-5s date: %-15s", filename, version, date);
- retVal = (date-copy)+strlen(date);
-
- endmassage:
- free(copy);
- return retVal;
-}
-
-// prints a single set of CVS ids
-void printone(char *block, const char *cvsid){
- char strings[CVSMAXLEN];
- const char *here=cvsid;
- int bi=0, len=strlen(cvsid)+1;
-
- // check that the size of the output block is sufficient
- if (len>=CVSMAXLEN) {
- pout("CVSMAXLEN=%d must be at least %d\n",CVSMAXLEN,len+1);
- EXIT(1);
- }
-
- // loop through the different strings
- while (bi<CVSMAXLEN && (len=massagecvs(strings,here))){
- bi+=snprintf(block+bi,CVSMAXLEN-bi,"%s %s\n",(bi==0?"Module:":" uses:"),strings);
- here+=len;
- }
- 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){
return;
}
-// Prints a warning message for a failed regular expression compilation from
-// regcomp().
-void printregexwarning(int errcode, regex_t *compiled){
- size_t length = regerror(errcode, compiled, NULL, 0);
- char *buffer = (char*)malloc(length);
- if (!buffer){
- pout("Out of memory in printregexwarning()\n");
- return;
- }
- regerror(errcode, compiled, buffer, length);
- pout("%s\n", buffer);
- free(buffer);
- 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."
//
-// Actual '(...)' nesting errors remain undetected on strict POSIX
-// implementations (glibc) but an error is reported on others (Cygwin).
-//
-// The check below is rather incomplete because it does not handle
-// e.g. '\)' '[)]'.
-// But it should work for the regex subset used in drive database.
-static int check_regex_nesting(const char * pattern)
+// 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, i;
- for (i = 0; pattern[i] && level >= 0; i++) {
- switch (pattern[i]) {
- case '(': level++; break;
- case ')': level--; break;
+ 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 level;
+
+ return (const char *)0;
}
-// A wrapper for regcomp(). Returns zero for success, non-zero otherwise.
-int compileregex(regex_t *compiled, const char *pattern, int cflags)
-{
- int errorcode;
+// Wrapper class for POSIX regex(3) or std::regex
- if ( (errorcode = regcomp(compiled, pattern, cflags))
- || check_regex_nesting(pattern) < 0 ) {
- pout("Internal error: unable to compile regular expression \"%s\" ", pattern);
- if (errorcode)
- printregexwarning(errorcode, compiled);
- else
- pout("Unmatched ')'\n");
- pout("Please inform smartmontools developers at " PACKAGE_BUGREPORT "\n");
- return 1;
- }
- return 0;
+#ifndef WITH_CXX11_REGEX
+
+regular_expression::regular_expression()
+{
+ memset(&m_regex_buf, 0, sizeof(m_regex_buf));
}
-// Splits an argument to the -r option into a name part and an (optional)
-// positive integer part. s is a pointer to a string containing the
-// argument. After the call, s will point to the name part and *i the
-// integer part if there is one or 1 otherwise. Note that the string s may
-// be changed by this function. Returns zero if successful and non-zero
-// otherwise.
-int split_report_arg(char *s, int *i)
+regular_expression::~regular_expression()
{
- if ((s = strchr(s, ','))) {
- // Looks like there's a name part and an integer part.
- char *tailptr;
+ free_buf();
+}
- *s++ = '\0';
- if (*s == '0' || !isdigit((int)*s)) // The integer part must be positive
- return 1;
- errno = 0;
- *i = (int) strtol(s, &tailptr, 10);
- if (errno || *tailptr != '\0')
- return 1;
- } else {
- // There's no integer part.
- *i = 1;
+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));
}
+}
- return 0;
+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()));
+ }
}
-// same as above but sets *i to -1 if missing , argument
-int split_report_arg2(char *s, int *i){
- char *tailptr;
- s+=6;
+#endif // !WITH_CXX11_REGEX
- if (*s=='\0' || !isdigit((int)*s)) {
- // What's left must be integer
- *i=-1;
- return 1;
+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;
}
- errno = 0;
- *i = (int) strtol(s, &tailptr, 10);
- if (errno || *tailptr != '\0') {
- *i=-1;
- return 1;
+#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;
}
- return 0;
+ m_errmsg.clear();
+ return true;
}
-#ifndef HAVE_STRTOULL
-// Replacement for missing strtoull() (Linux with libc < 6, MSVC 6.0)
-// Functionality reduced to split_selective_arg()'s requirements.
+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
+}
-static uint64_t strtoull(const char * p, char * * endp, int base)
+bool regular_expression::execute(const char * str, unsigned nmatch, match_range * pmatch) const
{
- uint64_t result, maxres;
- int i = 0;
- char c = p[i++];
- // assume base == 0
- if (c == '0') {
- if (p[i] == 'x' || p[i] == 'X') {
- base = 16; i++;
+#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
- base = 8;
- c = p[i++];
- }
- else
- base = 10;
-
- result = 0;
- maxres = ~(uint64_t)0 / (unsigned)base;
- for (;;) {
- unsigned digit;
- if ('0' <= c && c <= '9')
- digit = c - '0';
- else if ('A' <= c && c <= 'Z')
- digit = c - 'A' + 10;
- else if ('a' <= c && c <= 'z')
- digit = c - 'a' + 10;
- else
- break;
- if (digit >= (unsigned)base)
- break;
- if (!( result < maxres
- || (result == maxres && digit <= ~(uint64_t)0 % (unsigned)base))) {
- result = ~(uint64_t)0; errno = ERANGE; // return on overflow
- break;
- }
- result = result * (unsigned)base + digit;
- c = p[i++];
+ pmatch[i].rm_so = pmatch[i].rm_eo = -1;
}
- *endp = (char *)p + i - 1;
- return result;
+ return true;
+
+#else
+ return !regexec(&m_regex_buf, str, nmatch, pmatch, 0);
+#endif
}
-#endif // HAVE_STRTOLL
// 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)
+ uint64_t *stop, int *mode)
{
char *tailptr;
-
if (!(s = strchr(s, ',')))
return 1;
- if (!isdigit((int)(*++s)))
- return 1;
- 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);
+ 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;
+ }
+ }
- s = tailptr;
- if (errno || *s++ != '-')
- return 1;
- *stop = strtoull(s, &tailptr, 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;
}
-int64_t bytes = 0;
-// Helps debugging. If the second argument is non-negative, then
-// decrement bytes by that amount. Else decrement bytes by (one plus)
-// length of null terminated string.
-void *FreeNonZero1(void *address, int size, int line, const char* file){
- if (address) {
- if (size<0)
- bytes-=1+strlen((char*)address);
- else
- bytes-=size;
- return CheckFree1(address, line, file);
- }
- return NULL;
+// 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;
}
-// To help with memory checking. Use when it is known that address is
-// NOT null.
-void *CheckFree1(void *address, int whatline, const char* file){
- if (address){
- free(address);
- return NULL;
+// 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 : '?');
}
-
- PrintOut(LOG_CRIT, "Internal error in CheckFree() at line %d of file %s\n%s",
- whatline, file, reportbug);
- EXIT(EXIT_BADCODE);
+
+ str[n] = 0;
+ return str;
}
-// A custom version of calloc() that tracks memory use
-void *Calloc(size_t nmemb, size_t size) {
- void *ptr=calloc(nmemb, size);
-
- if (ptr)
- bytes+=nmemb*size;
+// 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
+ }
- return ptr;
-}
+ char num[64];
+ snprintf(num, sizeof(num), "%" PRIu64, val);
+ int numlen = strlen(num);
-// A custom version of strdup() that keeps track of how much memory is
-// being allocated. If mustexist is set, it also throws an error if we
-// try to duplicate a NULL string.
-char *CustomStrDup(char *ptr, int mustexist, int whatline, const char* file){
- char *tmp;
+ 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;
+ }
- // report error if ptr is NULL and mustexist is set
- if (ptr==NULL){
- if (mustexist) {
- PrintOut(LOG_CRIT, "Internal error in CustomStrDup() at line %d of file %s\n%s",
- whatline, file, reportbug);
- EXIT(EXIT_BADCODE);
- }
- else
- return NULL;
+ 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
}
- // make a copy of the string...
- tmp=strdup(ptr);
-
- if (!tmp) {
- PrintOut(LOG_CRIT, "No memory to duplicate string %s at line %d of file %s\n", ptr, whatline, file);
- EXIT(EXIT_NOMEM);
+ 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;
}
-
- // and track memory usage
- bytes+=1+strlen(ptr);
-
- return tmp;
+
+ // 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;
}
-// Returns nonzero if region of memory contains non-zero entries
-int nonempty(unsigned char *testarea,int n){
- int i;
- for (i=0;i<n;i++)
- if (testarea[i])
- return 1;
- return 0;
+// 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;
+}
-// This routine converts an integer number of milliseconds into a test
-// string of the form Xd+Yh+Zm+Ts.msec. The resulting text string is
-// written to the array.
-void MsecToText(unsigned int msec, char *txt){
- int start=0;
- unsigned int days, hours, min, sec;
+#if defined(HAVE___INT128)
+// Compiler supports '__int128'.
- days = msec/86400000U;
- msec -= days*86400000U;
+// Recursive 128-bit to string conversion function
+static int snprint_uint128(char * str, int strsize, unsigned __int128 value)
+{
+ if (strsize <= 0)
+ return -1;
- hours = msec/3600000U;
- msec -= hours*3600000U;
+ 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;
+ }
+}
- min = msec/60000U;
- msec -= min*60000U;
+// 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;
+}
- sec = msec/1000U;
- msec -= sec*1000U;
+#elif defined(HAVE_LONG_DOUBLE_WIDER_PRINTF)
+// Compiler and *printf() support 'long double' which is wider than 'double'.
- if (days) {
- txt += sprintf(txt, "%2dd+", (int)days);
- start=1;
- }
+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;
+}
- sprintf(txt, "%02d:%02d:%02d.%03d", (int)hours, (int)min, (int)sec, (int)msec);
- return;
+#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
+
+// 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");
+}
#ifndef HAVE_WORKING_SNPRINTF
-// Some versions of (v)snprintf() don't append null char on overflow (MSVCRT.DLL),
-// and/or return -1 on overflow (old Linux).
+// Some versions of (v)snprintf() don't append null char (MSVCRT.DLL),
+// and/or return -1 on output truncation (glibc <= 2.0.6).
// Below are sane replacements substituted by #define in utility.h.
#undef vsnprintf
return i;
}
-#endif
+static void check_snprintf() {}
+
+#elif 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 // HAVE_WORKING_SNPRINTF
+
+// Runtime check of ./configure result, throws on error.
+void check_config()
+{
+ check_endianness();
+ check_snprintf();
+}
projects / mirror_smartmontools-debian.git / blobdiff