Annotation of embedaddon/smartmontools/utility.cpp, revision 1.1.1.1
1.1 misho 1: /*
2: * utility.cpp
3: *
4: * Home page of code is: http://smartmontools.sourceforge.net
5: *
6: * Copyright (C) 2002-11 Bruce Allen <smartmontools-support@lists.sourceforge.net>
7: * Copyright (C) 2008-11 Christian Franke <smartmontools-support@lists.sourceforge.net>
8: * Copyright (C) 2000 Michael Cornwell <cornwell@acm.org>
9: *
10: * This program is free software; you can redistribute it and/or modify
11: * it under the terms of the GNU General Public License as published by
12: * the Free Software Foundation; either version 2, or (at your option)
13: * any later version.
14: *
15: * You should have received a copy of the GNU General Public License
16: * (for example COPYING); if not, write to the Free
17: * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18: *
19: * This code was originally developed as a Senior Thesis by Michael Cornwell
20: * at the Concurrent Systems Laboratory (now part of the Storage Systems
21: * Research Center), Jack Baskin School of Engineering, University of
22: * California, Santa Cruz. http://ssrc.soe.ucsc.edu/
23: *
24: */
25:
26: // THIS FILE IS INTENDED FOR UTILITY ROUTINES THAT ARE APPLICABLE TO
27: // BOTH SCSI AND ATA DEVICES, AND THAT MAY BE USED IN SMARTD,
28: // SMARTCTL, OR BOTH.
29:
30: #include "config.h"
31:
32: #include <stdio.h>
33: #include <string.h>
34: #include <time.h>
35: #include <errno.h>
36: #include <stdlib.h>
37: #include <ctype.h>
38: #include <stdarg.h>
39: #include <sys/stat.h>
40: #ifdef HAVE_LOCALE_H
41: #include <locale.h>
42: #endif
43: #ifdef _WIN32
44: #include <mbstring.h> // _mbsinc()
45: #endif
46:
47: #include <stdexcept>
48:
49: #include "svnversion.h"
50: #include "int64.h"
51: #include "utility.h"
52:
53: #include "atacmds.h"
54: #include "dev_interface.h"
55:
56: const char * utility_cpp_cvsid = "$Id: utility.cpp 3305 2011-03-30 21:32:05Z chrfranke $"
57: UTILITY_H_CVSID INT64_H_CVSID;
58:
59: const char * packet_types[] = {
60: "Direct-access (disk)",
61: "Sequential-access (tape)",
62: "Printer",
63: "Processor",
64: "Write-once (optical disk)",
65: "CD/DVD",
66: "Scanner",
67: "Optical memory (optical disk)",
68: "Medium changer",
69: "Communications",
70: "Graphic arts pre-press (10)",
71: "Graphic arts pre-press (11)",
72: "Array controller",
73: "Enclosure services",
74: "Reduced block command (simplified disk)",
75: "Optical card reader/writer"
76: };
77:
78: // BUILD_INFO can be provided by package maintainers
79: #ifndef BUILD_INFO
80: #define BUILD_INFO "(local build)"
81: #endif
82:
83: // Make version information string
84: std::string format_version_info(const char * prog_name, bool full /*= false*/)
85: {
86: std::string info = strprintf(
87: "%s "PACKAGE_VERSION" "
88: #ifdef SMARTMONTOOLS_SVN_REV
89: SMARTMONTOOLS_SVN_DATE" r"SMARTMONTOOLS_SVN_REV
90: #else
91: "(build date "__DATE__")" // checkout without expansion of Id keywords
92: #endif
93: " [%s] "BUILD_INFO"\n"
94: "Copyright (C) 2002-11 by Bruce Allen, http://smartmontools.sourceforge.net\n",
95: prog_name, smi()->get_os_version_str().c_str()
96: );
97: if (!full)
98: return info;
99:
100: info += strprintf(
101: "\n"
102: "%s comes with ABSOLUTELY NO WARRANTY. This is free\n"
103: "software, and you are welcome to redistribute it under\n"
104: "the terms of the GNU General Public License Version 2.\n"
105: "See http://www.gnu.org for further details.\n"
106: "\n",
107: prog_name
108: );
109: info += strprintf(
110: "smartmontools release "PACKAGE_VERSION
111: " dated "SMARTMONTOOLS_RELEASE_DATE" at "SMARTMONTOOLS_RELEASE_TIME"\n"
112: #ifdef SMARTMONTOOLS_SVN_REV
113: "smartmontools SVN rev "SMARTMONTOOLS_SVN_REV
114: " dated "SMARTMONTOOLS_SVN_DATE" at "SMARTMONTOOLS_SVN_TIME"\n"
115: #else
116: "smartmontools SVN rev is unknown\n"
117: #endif
118: "smartmontools build host: "SMARTMONTOOLS_BUILD_HOST"\n"
119: "smartmontools build configured: "SMARTMONTOOLS_CONFIGURE_DATE "\n"
120: "%s compile dated "__DATE__" at "__TIME__"\n"
121: "smartmontools configure arguments: ",
122: prog_name
123: );
124: info += (sizeof(SMARTMONTOOLS_CONFIGURE_ARGS) > 1 ?
125: SMARTMONTOOLS_CONFIGURE_ARGS : "[no arguments given]");
126: info += '\n';
127:
128: return info;
129: }
130:
131: // Solaris only: Get site-default timezone. This is called from
132: // UpdateTimezone() when TZ environment variable is unset at startup.
133: #if defined (__SVR4) && defined (__sun)
134: static const char *TIMEZONE_FILE = "/etc/TIMEZONE";
135:
136: static char *ReadSiteDefaultTimezone(){
137: FILE *fp;
138: char buf[512], *tz;
139: int n;
140:
141: tz = NULL;
142: fp = fopen(TIMEZONE_FILE, "r");
143: if(fp == NULL) return NULL;
144: while(fgets(buf, sizeof(buf), fp)) {
145: if (strncmp(buf, "TZ=", 3)) // searches last "TZ=" line
146: continue;
147: n = strlen(buf) - 1;
148: if (buf[n] == '\n') buf[n] = 0;
149: if (tz) free(tz);
150: tz = strdup(buf);
151: }
152: fclose(fp);
153: return tz;
154: }
155: #endif
156:
157: // Make sure that this executable is aware if the user has changed the
158: // time-zone since the last time we polled devices. The cannonical
159: // example is a user who starts smartd on a laptop, then flies across
160: // time-zones with a laptop, and then changes the timezone, WITHOUT
161: // restarting smartd. This is a work-around for a bug in
162: // GLIBC. Yuk. See bug number 48184 at http://bugs.debian.org and
163: // thanks to Ian Redfern for posting a workaround.
164:
165: // Please refer to the smartd manual page, in the section labeled LOG
166: // TIMESTAMP TIMEZONE.
167: void FixGlibcTimeZoneBug(){
168: #if __GLIBC__
169: if (!getenv("TZ")) {
170: putenv((char *)"TZ=GMT"); // POSIX prototype is 'int putenv(char *)'
171: tzset();
172: putenv((char *)"TZ");
173: tzset();
174: }
175: #elif _WIN32
176: if (!getenv("TZ")) {
177: putenv("TZ=GMT");
178: tzset();
179: putenv("TZ="); // empty value removes TZ, putenv("TZ") does nothing
180: tzset();
181: }
182: #elif defined (__SVR4) && defined (__sun)
183: // In Solaris, putenv("TZ=") sets null string and invalid timezone.
184: // putenv("TZ") does nothing. With invalid TZ, tzset() do as if
185: // TZ=GMT. With TZ unset, /etc/TIMEZONE will be read only _once_ at
186: // first tzset() call. Conclusion: Unlike glibc, dynamic
187: // configuration of timezone can be done only by changing actual
188: // value of TZ environment value.
189: enum tzstate { NOT_CALLED_YET, USER_TIMEZONE, TRACK_TIMEZONE };
190: static enum tzstate state = NOT_CALLED_YET;
191:
192: static struct stat prev_stat;
193: static char *prev_tz;
194: struct stat curr_stat;
195: char *curr_tz;
196:
197: if(state == NOT_CALLED_YET) {
198: if(getenv("TZ")) {
199: state = USER_TIMEZONE; // use supplied timezone
200: } else {
201: state = TRACK_TIMEZONE;
202: if(stat(TIMEZONE_FILE, &prev_stat)) {
203: state = USER_TIMEZONE; // no TZ, no timezone file; use GMT forever
204: } else {
205: prev_tz = ReadSiteDefaultTimezone(); // track timezone file change
206: if(prev_tz) putenv(prev_tz);
207: }
208: }
209: tzset();
210: } else if(state == TRACK_TIMEZONE) {
211: if(stat(TIMEZONE_FILE, &curr_stat) == 0
212: && (curr_stat.st_ctime != prev_stat.st_ctime
213: || curr_stat.st_mtime != prev_stat.st_mtime)) {
214: // timezone file changed
215: curr_tz = ReadSiteDefaultTimezone();
216: if(curr_tz) {
217: putenv(curr_tz);
218: if(prev_tz) free(prev_tz);
219: prev_tz = curr_tz; prev_stat = curr_stat;
220: }
221: }
222: tzset();
223: }
224: #endif
225: // OTHER OS/LIBRARY FIXES SHOULD GO HERE, IF DESIRED. PLEASE TRY TO
226: // KEEP THEM INDEPENDENT.
227: return;
228: }
229:
230: #ifdef _WIN32
231: // Fix strings in tzname[] to avoid long names with non-ascii characters.
232: // If TZ is not set, tzset() in the MSVC runtime sets tzname[] to the
233: // national language timezone names returned by GetTimezoneInformation().
234: static char * fixtzname(char * dest, int destsize, const char * src)
235: {
236: int i = 0, j = 0;
237: while (src[i] && j < destsize-1) {
238: int i2 = (const char *)_mbsinc((const unsigned char *)src+i) - src;
239: if (i2 > i+1)
240: i = i2; // Ignore multibyte chars
241: else {
242: if ('A' <= src[i] && src[i] <= 'Z')
243: dest[j++] = src[i]; // "Pacific Standard Time" => "PST"
244: i++;
245: }
246: }
247: if (j < 2)
248: j = 0;
249: dest[j] = 0;
250: return dest;
251: }
252: #endif // _WIN32
253:
254: // This value follows the peripheral device type value as defined in
255: // SCSI Primary Commands, ANSI INCITS 301:1997. It is also used in
256: // the ATA standard for packet devices to define the device type.
257: const char *packetdevicetype(int type){
258: if (type<0x10)
259: return packet_types[type];
260:
261: if (type<0x20)
262: return "Reserved";
263:
264: return "Unknown";
265: }
266:
267: // Runtime check of byte ordering, throws if different from isbigendian().
268: void check_endianness()
269: {
270: union {
271: // Force compile error if int type is not 32bit.
272: unsigned char c[sizeof(unsigned) == 4 ? 4 : -1];
273: unsigned i;
274: } x = {{1,2,3,4}};
275:
276: int big = -1;
277: switch (x.i) {
278: case 0x01020304: big = 1; break;
279: case 0x04030201: big = 0; break;
280: }
281:
282: if (big != (isbigendian() ? 1 : 0))
283: throw std::logic_error("CPU endianness does not match compile time test");
284: }
285:
286: // Utility function prints date and time and timezone into a character
287: // buffer of length>=64. All the fuss is needed to get the right
288: // timezone info (sigh).
289: void dateandtimezoneepoch(char *buffer, time_t tval){
290: struct tm *tmval;
291: const char *timezonename;
292: char datebuffer[DATEANDEPOCHLEN];
293: int lenm1;
294: #ifdef _WIN32
295: char tzfixbuf[6+1];
296: #endif
297:
298: FixGlibcTimeZoneBug();
299:
300: // Get the time structure. We need this to determine if we are in
301: // daylight savings time or not.
302: tmval=localtime(&tval);
303:
304: // Convert to an ASCII string, put in datebuffer
305: // same as: asctime_r(tmval, datebuffer);
306: strncpy(datebuffer, asctime(tmval), DATEANDEPOCHLEN);
307: datebuffer[DATEANDEPOCHLEN-1]='\0';
308:
309: // Remove newline
310: lenm1=strlen(datebuffer)-1;
311: datebuffer[lenm1>=0?lenm1:0]='\0';
312:
313: // correct timezone name
314: if (tmval->tm_isdst==0)
315: // standard time zone
316: timezonename=tzname[0];
317: else if (tmval->tm_isdst>0)
318: // daylight savings in effect
319: timezonename=tzname[1];
320: else
321: // unable to determine if daylight savings in effect
322: timezonename="";
323:
324: #ifdef _WIN32
325: // Fix long non-ascii timezone names
326: if (!getenv("TZ"))
327: timezonename=fixtzname(tzfixbuf, sizeof(tzfixbuf), timezonename);
328: #endif
329:
330: // Finally put the information into the buffer as needed.
331: snprintf(buffer, DATEANDEPOCHLEN, "%s %s", datebuffer, timezonename);
332:
333: return;
334: }
335:
336: // Date and timezone gets printed into string pointed to by buffer
337: void dateandtimezone(char *buffer){
338:
339: // Get the epoch (time in seconds since Jan 1 1970)
340: time_t tval=time(NULL);
341:
342: dateandtimezoneepoch(buffer, tval);
343: return;
344: }
345:
346: // A replacement for perror() that sends output to our choice of
347: // printing. If errno not set then just print message.
348: void syserror(const char *message){
349:
350: if (errno) {
351: // Get the correct system error message:
352: const char *errormessage=strerror(errno);
353:
354: // Check that caller has handed a sensible string, and provide
355: // appropriate output. See perrror(3) man page to understand better.
356: if (message && *message)
357: pout("%s: %s\n",message, errormessage);
358: else
359: pout("%s\n",errormessage);
360: }
361: else if (message && *message)
362: pout("%s\n",message);
363:
364: return;
365: }
366:
367: // POSIX extended regular expressions interpret unmatched ')' ordinary:
368: // "The close-parenthesis shall be considered special in this context
369: // only if matched with a preceding open-parenthesis."
370: //
371: // Actual '(...)' nesting errors remain undetected on strict POSIX
372: // implementations (glibc) but an error is reported on others (Cygwin).
373: //
374: // The check below is rather incomplete because it does not handle
375: // e.g. '\)' '[)]'.
376: // But it should work for the regex subset used in drive database
377: // and smartd '-s' directives.
378: static int check_regex_nesting(const char * pattern)
379: {
380: int level = 0, i;
381: for (i = 0; pattern[i] && level >= 0; i++) {
382: switch (pattern[i]) {
383: case '(': level++; break;
384: case ')': level--; break;
385: }
386: }
387: return level;
388: }
389:
390: // Wrapper class for regex(3)
391:
392: regular_expression::regular_expression()
393: : m_flags(0)
394: {
395: memset(&m_regex_buf, 0, sizeof(m_regex_buf));
396: }
397:
398: regular_expression::regular_expression(const char * pattern, int flags,
399: bool throw_on_error /*= true*/)
400: {
401: memset(&m_regex_buf, 0, sizeof(m_regex_buf));
402: if (!compile(pattern, flags) && throw_on_error)
403: throw std::runtime_error(strprintf(
404: "error in regular expression \"%s\": %s",
405: m_pattern.c_str(), m_errmsg.c_str()));
406: }
407:
408: regular_expression::~regular_expression()
409: {
410: free_buf();
411: }
412:
413: regular_expression::regular_expression(const regular_expression & x)
414: {
415: memset(&m_regex_buf, 0, sizeof(m_regex_buf));
416: copy(x);
417: }
418:
419: regular_expression & regular_expression::operator=(const regular_expression & x)
420: {
421: free_buf();
422: copy(x);
423: return *this;
424: }
425:
426: void regular_expression::free_buf()
427: {
428: if (nonempty(&m_regex_buf, sizeof(m_regex_buf))) {
429: regfree(&m_regex_buf);
430: memset(&m_regex_buf, 0, sizeof(m_regex_buf));
431: }
432: }
433:
434: void regular_expression::copy(const regular_expression & x)
435: {
436: m_pattern = x.m_pattern;
437: m_flags = x.m_flags;
438: m_errmsg = x.m_errmsg;
439:
440: if (!m_pattern.empty() && m_errmsg.empty()) {
441: // There is no POSIX compiled-regex-copy command.
442: if (!compile())
443: throw std::runtime_error(strprintf(
444: "Unable to recompile regular expression \"%s\": %s",
445: m_pattern.c_str(), m_errmsg.c_str()));
446: }
447: }
448:
449: bool regular_expression::compile(const char * pattern, int flags)
450: {
451: free_buf();
452: m_pattern = pattern;
453: m_flags = flags;
454: return compile();
455: }
456:
457: bool regular_expression::compile()
458: {
459: int errcode = regcomp(&m_regex_buf, m_pattern.c_str(), m_flags);
460: if (errcode) {
461: char errmsg[512];
462: regerror(errcode, &m_regex_buf, errmsg, sizeof(errmsg));
463: m_errmsg = errmsg;
464: free_buf();
465: return false;
466: }
467:
468: if (check_regex_nesting(m_pattern.c_str()) < 0) {
469: m_errmsg = "Unmatched ')'";
470: free_buf();
471: return false;
472: }
473:
474: m_errmsg.clear();
475: return true;
476: }
477:
478: // Splits an argument to the -r option into a name part and an (optional)
479: // positive integer part. s is a pointer to a string containing the
480: // argument. After the call, s will point to the name part and *i the
481: // integer part if there is one or 1 otherwise. Note that the string s may
482: // be changed by this function. Returns zero if successful and non-zero
483: // otherwise.
484: int split_report_arg(char *s, int *i)
485: {
486: if ((s = strchr(s, ','))) {
487: // Looks like there's a name part and an integer part.
488: char *tailptr;
489:
490: *s++ = '\0';
491: if (*s == '0' || !isdigit((int)*s)) // The integer part must be positive
492: return 1;
493: errno = 0;
494: *i = (int) strtol(s, &tailptr, 10);
495: if (errno || *tailptr != '\0')
496: return 1;
497: } else {
498: // There's no integer part.
499: *i = 1;
500: }
501:
502: return 0;
503: }
504:
505: // same as above but sets *i to -1 if missing , argument
506: int split_report_arg2(char *s, int *i){
507: char *tailptr;
508: s+=6;
509:
510: if (*s=='\0' || !isdigit((int)*s)) {
511: // What's left must be integer
512: *i=-1;
513: return 1;
514: }
515:
516: errno = 0;
517: *i = (int) strtol(s, &tailptr, 10);
518: if (errno || *tailptr != '\0') {
519: *i=-1;
520: return 1;
521: }
522:
523: return 0;
524: }
525:
526: #ifndef HAVE_STRTOULL
527: // Replacement for missing strtoull() (Linux with libc < 6, MSVC)
528: // Functionality reduced to requirements of smartd and split_selective_arg().
529:
530: uint64_t strtoull(const char * p, char * * endp, int base)
531: {
532: uint64_t result, maxres;
533: int i = 0;
534: char c = p[i++];
535:
536: if (!base) {
537: if (c == '0') {
538: if (p[i] == 'x' || p[i] == 'X') {
539: base = 16; i++;
540: }
541: else
542: base = 8;
543: c = p[i++];
544: }
545: else
546: base = 10;
547: }
548:
549: result = 0;
550: maxres = ~(uint64_t)0 / (unsigned)base;
551: for (;;) {
552: unsigned digit;
553: if ('0' <= c && c <= '9')
554: digit = c - '0';
555: else if ('A' <= c && c <= 'Z')
556: digit = c - 'A' + 10;
557: else if ('a' <= c && c <= 'z')
558: digit = c - 'a' + 10;
559: else
560: break;
561: if (digit >= (unsigned)base)
562: break;
563: if (!( result < maxres
564: || (result == maxres && digit <= ~(uint64_t)0 % (unsigned)base))) {
565: result = ~(uint64_t)0; errno = ERANGE; // return on overflow
566: break;
567: }
568: result = result * (unsigned)base + digit;
569: c = p[i++];
570: }
571: if (endp)
572: *endp = (char *)p + i - 1;
573: return result;
574: }
575: #endif // HAVE_STRTOLL
576:
577: // Splits an argument to the -t option that is assumed to be of the form
578: // "selective,%lld-%lld" (prefixes of "0" (for octal) and "0x"/"0X" (for hex)
579: // are allowed). The first long long int is assigned to *start and the second
580: // to *stop. Returns zero if successful and non-zero otherwise.
581: int split_selective_arg(char *s, uint64_t *start,
582: uint64_t *stop, int *mode)
583: {
584: char *tailptr;
585: if (!(s = strchr(s, ',')))
586: return 1;
587: bool add = false;
588: if (!isdigit((int)(*++s))) {
589: *start = *stop = 0;
590: if (!strncmp(s, "redo", 4))
591: *mode = SEL_REDO;
592: else if (!strncmp(s, "next", 4))
593: *mode = SEL_NEXT;
594: else if (!strncmp(s, "cont", 4))
595: *mode = SEL_CONT;
596: else
597: return 1;
598: s += 4;
599: if (!*s)
600: return 0;
601: if (*s != '+')
602: return 1;
603: }
604: else {
605: *mode = SEL_RANGE;
606: errno = 0;
607: // Last argument to strtoull (the base) is 0 meaning that decimal is assumed
608: // unless prefixes of "0" (for octal) or "0x"/"0X" (for hex) are used.
609: *start = strtoull(s, &tailptr, 0);
610: s = tailptr;
611: add = (*s == '+');
612: if (!(!errno && (add || *s == '-')))
613: return 1;
614: if (!strcmp(s, "-max")) {
615: *stop = ~(uint64_t)0; // replaced by max LBA later
616: return 0;
617: }
618: }
619: *stop = strtoull(s+1, &tailptr, 0);
620: if (errno || *tailptr != '\0')
621: return 1;
622: if (add) {
623: if (*stop > 0)
624: (*stop)--;
625: *stop += *start; // -t select,N+M => -t select,N,(N+M-1)
626: }
627: return 0;
628: }
629:
630: #ifdef OLD_INTERFACE
631:
632: int64_t bytes = 0;
633:
634: // Helps debugging. If the second argument is non-negative, then
635: // decrement bytes by that amount. Else decrement bytes by (one plus)
636: // length of null terminated string.
637: void *FreeNonZero1(void *address, int size, int line, const char* file){
638: if (address) {
639: if (size<0)
640: bytes-=1+strlen((char*)address);
641: else
642: bytes-=size;
643: return CheckFree1(address, line, file);
644: }
645: return NULL;
646: }
647:
648: // To help with memory checking. Use when it is known that address is
649: // NOT null.
650: void *CheckFree1(void *address, int /*whatline*/, const char* /*file*/){
651: if (address){
652: free(address);
653: return NULL;
654: }
655: throw std::runtime_error("Internal error in CheckFree()");
656: }
657:
658: // A custom version of calloc() that tracks memory use
659: void *Calloc(size_t nmemb, size_t size) {
660: void *ptr=calloc(nmemb, size);
661:
662: if (ptr)
663: bytes+=nmemb*size;
664:
665: return ptr;
666: }
667:
668: // A custom version of strdup() that keeps track of how much memory is
669: // being allocated. If mustexist is set, it also throws an error if we
670: // try to duplicate a NULL string.
671: char *CustomStrDup(const char *ptr, int mustexist, int /*whatline*/, const char* /*file*/){
672: char *tmp;
673:
674: // report error if ptr is NULL and mustexist is set
675: if (ptr==NULL){
676: if (mustexist)
677: throw std::runtime_error("Internal error in CustomStrDup()");
678: else
679: return NULL;
680: }
681:
682: // make a copy of the string...
683: tmp=strdup(ptr);
684:
685: if (!tmp)
686: throw std::bad_alloc();
687:
688: // and track memory usage
689: bytes+=1+strlen(ptr);
690:
691: return tmp;
692: }
693:
694: #endif // OLD_INTERFACE
695:
696:
697: // Returns true if region of memory contains non-zero entries
698: bool nonempty(const void * data, int size)
699: {
700: for (int i = 0; i < size; i++)
701: if (((const unsigned char *)data)[i])
702: return true;
703: return false;
704: }
705:
706:
707: // This routine converts an integer number of milliseconds into a test
708: // string of the form Xd+Yh+Zm+Ts.msec. The resulting text string is
709: // written to the array.
710: void MsecToText(unsigned int msec, char *txt){
711: unsigned int days, hours, min, sec;
712:
713: days = msec/86400000U;
714: msec -= days*86400000U;
715:
716: hours = msec/3600000U;
717: msec -= hours*3600000U;
718:
719: min = msec/60000U;
720: msec -= min*60000U;
721:
722: sec = msec/1000U;
723: msec -= sec*1000U;
724:
725: if (days) {
726: txt += sprintf(txt, "%2dd+", (int)days);
727: }
728:
729: sprintf(txt, "%02d:%02d:%02d.%03d", (int)hours, (int)min, (int)sec, (int)msec);
730: return;
731: }
732:
733: // Format integer with thousands separator
734: const char * format_with_thousands_sep(char * str, int strsize, uint64_t val,
735: const char * thousands_sep /* = 0 */)
736: {
737: if (!thousands_sep) {
738: thousands_sep = ",";
739: #ifdef HAVE_LOCALE_H
740: setlocale(LC_ALL, "");
741: const struct lconv * currentlocale = localeconv();
742: if (*(currentlocale->thousands_sep))
743: thousands_sep = currentlocale->thousands_sep;
744: #endif
745: }
746:
747: char num[64];
748: snprintf(num, sizeof(num), "%"PRIu64, val);
749: int numlen = strlen(num);
750:
751: int i = 0, j = 0;
752: do
753: str[j++] = num[i++];
754: while (i < numlen && (numlen - i) % 3 != 0 && j < strsize-1);
755: str[j] = 0;
756:
757: while (i < numlen && j < strsize-1) {
758: j += snprintf(str+j, strsize-j, "%s%.3s", thousands_sep, num+i);
759: i += 3;
760: }
761:
762: return str;
763: }
764:
765: // Format capacity with SI prefixes
766: const char * format_capacity(char * str, int strsize, uint64_t val,
767: const char * decimal_point /* = 0 */)
768: {
769: if (!decimal_point) {
770: decimal_point = ".";
771: #ifdef HAVE_LOCALE_H
772: setlocale(LC_ALL, "");
773: const struct lconv * currentlocale = localeconv();
774: if (*(currentlocale->decimal_point))
775: decimal_point = currentlocale->decimal_point;
776: #endif
777: }
778:
779: const unsigned factor = 1000; // 1024 for KiB,MiB,...
780: static const char prefixes[] = " KMGTP";
781:
782: // Find d with val in [d, d*factor)
783: unsigned i = 0;
784: uint64_t d = 1;
785: for (uint64_t d2 = d * factor; val >= d2; d2 *= factor) {
786: d = d2;
787: if (++i >= sizeof(prefixes)-2)
788: break;
789: }
790:
791: // Print 3 digits
792: uint64_t n = val / d;
793: if (i == 0)
794: snprintf(str, strsize, "%u B", (unsigned)n);
795: else if (n >= 100) // "123 xB"
796: snprintf(str, strsize, "%"PRIu64" %cB", n, prefixes[i]);
797: else if (n >= 10) // "12.3 xB"
798: snprintf(str, strsize, "%"PRIu64"%s%u %cB", n, decimal_point,
799: (unsigned)(((val % d) * 10) / d), prefixes[i]);
800: else // "1.23 xB"
801: snprintf(str, strsize, "%"PRIu64"%s%02u %cB", n, decimal_point,
802: (unsigned)(((val % d) * 100) / d), prefixes[i]);
803:
804: return str;
805: }
806:
807: // return (v)sprintf() formatted std::string
808:
809: std::string vstrprintf(const char * fmt, va_list ap)
810: {
811: char buf[512];
812: vsnprintf(buf, sizeof(buf), fmt, ap);
813: buf[sizeof(buf)-1] = 0;
814: return buf;
815: }
816:
817: std::string strprintf(const char * fmt, ...)
818: {
819: va_list ap; va_start(ap, fmt);
820: std::string str = vstrprintf(fmt, ap);
821: va_end(ap);
822: return str;
823: }
824:
825:
826: #ifndef HAVE_WORKING_SNPRINTF
827: // Some versions of (v)snprintf() don't append null char on overflow (MSVCRT.DLL),
828: // and/or return -1 on overflow (old Linux).
829: // Below are sane replacements substituted by #define in utility.h.
830:
831: #undef vsnprintf
832: #if defined(_WIN32) && defined(_MSC_VER)
833: #define vsnprintf _vsnprintf
834: #endif
835:
836: int safe_vsnprintf(char *buf, int size, const char *fmt, va_list ap)
837: {
838: int i;
839: if (size <= 0)
840: return 0;
841: i = vsnprintf(buf, size, fmt, ap);
842: if (0 <= i && i < size)
843: return i;
844: buf[size-1] = 0;
845: return strlen(buf); // Note: cannot detect for overflow, not necessary here.
846: }
847:
848: int safe_snprintf(char *buf, int size, const char *fmt, ...)
849: {
850: int i; va_list ap;
851: va_start(ap, fmt);
852: i = safe_vsnprintf(buf, size, fmt, ap);
853: va_end(ap);
854: return i;
855: }
856:
857: #endif
858:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>