4 * Home page of code is: http://smartmontools.sourceforge.net
6 * Copyright (C) 2002-9 Bruce Allen <smartmontools-support@lists.sourceforge.net>
7 * Copyright (C) 2008-9 Christian Franke <smartmontools-support@lists.sourceforge.net>
8 * Copyright (C) 2000 Michael Cornwell <cornwell@acm.org>
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)
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.
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/
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,
40 #include <mbstring.h> // _mbsinc()
46 #include "svnversion.h"
51 #include "dev_interface.h"
53 const char * utility_cpp_cvsid
= "$Id: utility.cpp 2991 2009-12-03 19:53:21Z chrfranke $"
54 UTILITY_H_CVSID INT64_H_CVSID
;
56 const char * packet_types
[] = {
57 "Direct-access (disk)",
58 "Sequential-access (tape)",
61 "Write-once (optical disk)",
64 "Optical memory (optical disk)",
67 "Graphic arts pre-press (10)",
68 "Graphic arts pre-press (11)",
71 "Reduced block command (simplified disk)",
72 "Optical card reader/writer"
75 // Whenever exit() status is EXIT_BADCODE, please print this message
76 const char *reportbug
="Please report this bug to the Smartmontools developers at " PACKAGE_BUGREPORT
".\n";
79 // command-line argument: are we running in debug mode?.
80 unsigned char debugmode
= 0;
82 // BUILD_INFO can be provided by package maintainers
84 #define BUILD_INFO "(local build)"
87 // Make version information string
88 std::string
format_version_info(const char * prog_name
, bool full
/*= false*/)
90 std::string info
= strprintf(
91 "%s "PACKAGE_VERSION
" "SMARTMONTOOLS_SVN_DATE
" r"SMARTMONTOOLS_SVN_REV
92 " [%s] "BUILD_INFO
"\n"
93 "Copyright (C) 2002-9 by Bruce Allen, http://smartmontools.sourceforge.net\n",
94 prog_name
, smi()->get_os_version_str().c_str()
101 "%s comes with ABSOLUTELY NO WARRANTY. This is free\n"
102 "software, and you are welcome to redistribute it under\n"
103 "the terms of the GNU General Public License Version 2.\n"
104 "See http://www.gnu.org for further details.\n"
109 "smartmontools release "PACKAGE_VERSION
110 " dated "SMARTMONTOOLS_RELEASE_DATE
" at "SMARTMONTOOLS_RELEASE_TIME
"\n"
111 "smartmontools SVN rev "SMARTMONTOOLS_SVN_REV
112 " dated "SMARTMONTOOLS_SVN_DATE
" at "SMARTMONTOOLS_SVN_TIME
"\n"
113 "smartmontools build host: "SMARTMONTOOLS_BUILD_HOST
"\n"
114 "smartmontools build configured: "SMARTMONTOOLS_CONFIGURE_DATE
"\n"
115 "%s compile dated "__DATE__
" at "__TIME__
"\n"
116 "smartmontools configure arguments: ",
119 info
+= (sizeof(SMARTMONTOOLS_CONFIGURE_ARGS
) > 1 ?
120 SMARTMONTOOLS_CONFIGURE_ARGS
: "[no arguments given]");
126 // Solaris only: Get site-default timezone. This is called from
127 // UpdateTimezone() when TZ environment variable is unset at startup.
128 #if defined (__SVR4) && defined (__sun)
129 static const char *TIMEZONE_FILE
= "/etc/TIMEZONE";
131 static char *ReadSiteDefaultTimezone(){
137 fp
= fopen(TIMEZONE_FILE
, "r");
138 if(fp
== NULL
) return NULL
;
139 while(fgets(buf
, sizeof(buf
), fp
)) {
140 if (strncmp(buf
, "TZ=", 3)) // searches last "TZ=" line
143 if (buf
[n
] == '\n') buf
[n
] = 0;
152 // Make sure that this executable is aware if the user has changed the
153 // time-zone since the last time we polled devices. The cannonical
154 // example is a user who starts smartd on a laptop, then flies across
155 // time-zones with a laptop, and then changes the timezone, WITHOUT
156 // restarting smartd. This is a work-around for a bug in
157 // GLIBC. Yuk. See bug number 48184 at http://bugs.debian.org and
158 // thanks to Ian Redfern for posting a workaround.
160 // Please refer to the smartd manual page, in the section labeled LOG
161 // TIMESTAMP TIMEZONE.
162 void FixGlibcTimeZoneBug(){
165 putenv((char *)"TZ=GMT"); // POSIX prototype is 'int putenv(char *)'
167 putenv((char *)"TZ");
174 putenv("TZ="); // empty value removes TZ, putenv("TZ") does nothing
177 #elif defined (__SVR4) && defined (__sun)
178 // In Solaris, putenv("TZ=") sets null string and invalid timezone.
179 // putenv("TZ") does nothing. With invalid TZ, tzset() do as if
180 // TZ=GMT. With TZ unset, /etc/TIMEZONE will be read only _once_ at
181 // first tzset() call. Conclusion: Unlike glibc, dynamic
182 // configuration of timezone can be done only by changing actual
183 // value of TZ environment value.
184 enum tzstate
{ NOT_CALLED_YET
, USER_TIMEZONE
, TRACK_TIMEZONE
};
185 static enum tzstate state
= NOT_CALLED_YET
;
187 static struct stat prev_stat
;
188 static char *prev_tz
;
189 struct stat curr_stat
;
192 if(state
== NOT_CALLED_YET
) {
194 state
= USER_TIMEZONE
; // use supplied timezone
196 state
= TRACK_TIMEZONE
;
197 if(stat(TIMEZONE_FILE
, &prev_stat
)) {
198 state
= USER_TIMEZONE
; // no TZ, no timezone file; use GMT forever
200 prev_tz
= ReadSiteDefaultTimezone(); // track timezone file change
201 if(prev_tz
) putenv(prev_tz
);
205 } else if(state
== TRACK_TIMEZONE
) {
206 if(stat(TIMEZONE_FILE
, &curr_stat
) == 0
207 && (curr_stat
.st_ctime
!= prev_stat
.st_ctime
208 || curr_stat
.st_mtime
!= prev_stat
.st_mtime
)) {
209 // timezone file changed
210 curr_tz
= ReadSiteDefaultTimezone();
213 if(prev_tz
) free(prev_tz
);
214 prev_tz
= curr_tz
; prev_stat
= curr_stat
;
220 // OTHER OS/LIBRARY FIXES SHOULD GO HERE, IF DESIRED. PLEASE TRY TO
221 // KEEP THEM INDEPENDENT.
226 // Fix strings in tzname[] to avoid long names with non-ascii characters.
227 // If TZ is not set, tzset() in the MSVC runtime sets tzname[] to the
228 // national language timezone names returned by GetTimezoneInformation().
229 static char * fixtzname(char * dest
, int destsize
, const char * src
)
232 while (src
[i
] && j
< destsize
-1) {
233 int i2
= (const char *)_mbsinc((const unsigned char *)src
+i
) - src
;
235 i
= i2
; // Ignore multibyte chars
237 if ('A' <= src
[i
] && src
[i
] <= 'Z')
238 dest
[j
++] = src
[i
]; // "Pacific Standard Time" => "PST"
249 // This value follows the peripheral device type value as defined in
250 // SCSI Primary Commands, ANSI INCITS 301:1997. It is also used in
251 // the ATA standard for packet devices to define the device type.
252 const char *packetdevicetype(int type
){
254 return packet_types
[type
];
263 // Returns 1 if machine is big endian, else zero. This is a run-time
264 // rather than a compile-time function. We could do it at
265 // compile-time but in principle there are architectures that can run
266 // with either byte-ordering.
269 char *tmp
=(char *)&i
;
273 // Utility function prints date and time and timezone into a character
274 // buffer of length>=64. All the fuss is needed to get the right
275 // timezone info (sigh).
276 void dateandtimezoneepoch(char *buffer
, time_t tval
){
278 const char *timezonename
;
279 char datebuffer
[DATEANDEPOCHLEN
];
285 FixGlibcTimeZoneBug();
287 // Get the time structure. We need this to determine if we are in
288 // daylight savings time or not.
289 tmval
=localtime(&tval
);
291 // Convert to an ASCII string, put in datebuffer
292 // same as: asctime_r(tmval, datebuffer);
293 strncpy(datebuffer
, asctime(tmval
), DATEANDEPOCHLEN
);
294 datebuffer
[DATEANDEPOCHLEN
-1]='\0';
297 lenm1
=strlen(datebuffer
)-1;
298 datebuffer
[lenm1
>=0?lenm1
:0]='\0';
300 // correct timezone name
301 if (tmval
->tm_isdst
==0)
302 // standard time zone
303 timezonename
=tzname
[0];
304 else if (tmval
->tm_isdst
>0)
305 // daylight savings in effect
306 timezonename
=tzname
[1];
308 // unable to determine if daylight savings in effect
312 // Fix long non-ascii timezone names
314 timezonename
=fixtzname(tzfixbuf
, sizeof(tzfixbuf
), timezonename
);
317 // Finally put the information into the buffer as needed.
318 snprintf(buffer
, DATEANDEPOCHLEN
, "%s %s", datebuffer
, timezonename
);
323 // Date and timezone gets printed into string pointed to by buffer
324 void dateandtimezone(char *buffer
){
326 // Get the epoch (time in seconds since Jan 1 1970)
327 time_t tval
=time(NULL
);
329 dateandtimezoneepoch(buffer
, tval
);
333 // A replacement for perror() that sends output to our choice of
334 // printing. If errno not set then just print message.
335 void syserror(const char *message
){
338 // Get the correct system error message:
339 const char *errormessage
=strerror(errno
);
341 // Check that caller has handed a sensible string, and provide
342 // appropriate output. See perrror(3) man page to understand better.
343 if (message
&& *message
)
344 pout("%s: %s\n",message
, errormessage
);
346 pout("%s\n",errormessage
);
348 else if (message
&& *message
)
349 pout("%s\n",message
);
354 // POSIX extended regular expressions interpret unmatched ')' ordinary:
355 // "The close-parenthesis shall be considered special in this context
356 // only if matched with a preceding open-parenthesis."
358 // Actual '(...)' nesting errors remain undetected on strict POSIX
359 // implementations (glibc) but an error is reported on others (Cygwin).
361 // The check below is rather incomplete because it does not handle
363 // But it should work for the regex subset used in drive database
364 // and smartd '-s' directives.
365 static int check_regex_nesting(const char * pattern
)
368 for (i
= 0; pattern
[i
] && level
>= 0; i
++) {
369 switch (pattern
[i
]) {
370 case '(': level
++; break;
371 case ')': level
--; break;
377 // Wrapper class for regex(3)
379 regular_expression::regular_expression()
382 memset(&m_regex_buf
, 0, sizeof(m_regex_buf
));
385 regular_expression::regular_expression(const char * pattern
, int flags
)
387 memset(&m_regex_buf
, 0, sizeof(m_regex_buf
));
388 compile(pattern
, flags
);
391 regular_expression::~regular_expression()
396 regular_expression::regular_expression(const regular_expression
& x
)
398 memset(&m_regex_buf
, 0, sizeof(m_regex_buf
));
402 regular_expression
& regular_expression::operator=(const regular_expression
& x
)
409 void regular_expression::free_buf()
411 if (nonempty(&m_regex_buf
, sizeof(m_regex_buf
))) {
412 regfree(&m_regex_buf
);
413 memset(&m_regex_buf
, 0, sizeof(m_regex_buf
));
417 void regular_expression::copy(const regular_expression
& x
)
419 m_pattern
= x
.m_pattern
;
421 m_errmsg
= x
.m_errmsg
;
423 if (!m_pattern
.empty() && m_errmsg
.empty()) {
424 // There is no POSIX compiled-regex-copy command.
426 throw std::runtime_error(strprintf(
427 "Unable to recompile regular expression \"%s\": %s",
428 m_pattern
.c_str(), m_errmsg
.c_str()));
432 bool regular_expression::compile(const char * pattern
, int flags
)
440 bool regular_expression::compile()
442 int errcode
= regcomp(&m_regex_buf
, m_pattern
.c_str(), m_flags
);
445 regerror(errcode
, &m_regex_buf
, errmsg
, sizeof(errmsg
));
451 if (check_regex_nesting(m_pattern
.c_str()) < 0) {
452 m_errmsg
= "Unmatched ')'";
461 // Splits an argument to the -r option into a name part and an (optional)
462 // positive integer part. s is a pointer to a string containing the
463 // argument. After the call, s will point to the name part and *i the
464 // integer part if there is one or 1 otherwise. Note that the string s may
465 // be changed by this function. Returns zero if successful and non-zero
467 int split_report_arg(char *s
, int *i
)
469 if ((s
= strchr(s
, ','))) {
470 // Looks like there's a name part and an integer part.
474 if (*s
== '0' || !isdigit((int)*s
)) // The integer part must be positive
477 *i
= (int) strtol(s
, &tailptr
, 10);
478 if (errno
|| *tailptr
!= '\0')
481 // There's no integer part.
488 // same as above but sets *i to -1 if missing , argument
489 int split_report_arg2(char *s
, int *i
){
493 if (*s
=='\0' || !isdigit((int)*s
)) {
494 // What's left must be integer
500 *i
= (int) strtol(s
, &tailptr
, 10);
501 if (errno
|| *tailptr
!= '\0') {
509 #ifndef HAVE_STRTOULL
510 // Replacement for missing strtoull() (Linux with libc < 6, MSVC)
511 // Functionality reduced to requirements of smartd and split_selective_arg().
513 uint64_t strtoull(const char * p
, char * * endp
, int base
)
515 uint64_t result
, maxres
;
521 if (p
[i
] == 'x' || p
[i
] == 'X') {
533 maxres
= ~(uint64_t)0 / (unsigned)base
;
536 if ('0' <= c
&& c
<= '9')
538 else if ('A' <= c
&& c
<= 'Z')
539 digit
= c
- 'A' + 10;
540 else if ('a' <= c
&& c
<= 'z')
541 digit
= c
- 'a' + 10;
544 if (digit
>= (unsigned)base
)
546 if (!( result
< maxres
547 || (result
== maxres
&& digit
<= ~(uint64_t)0 % (unsigned)base
))) {
548 result
= ~(uint64_t)0; errno
= ERANGE
; // return on overflow
551 result
= result
* (unsigned)base
+ digit
;
555 *endp
= (char *)p
+ i
- 1;
558 #endif // HAVE_STRTOLL
560 // Splits an argument to the -t option that is assumed to be of the form
561 // "selective,%lld-%lld" (prefixes of "0" (for octal) and "0x"/"0X" (for hex)
562 // are allowed). The first long long int is assigned to *start and the second
563 // to *stop. Returns zero if successful and non-zero otherwise.
564 int split_selective_arg(char *s
, uint64_t *start
,
565 uint64_t *stop
, int *mode
)
568 if (!(s
= strchr(s
, ',')))
571 if (!isdigit((int)(*++s
))) {
573 if (!strncmp(s
, "redo", 4))
575 else if (!strncmp(s
, "next", 4))
577 else if (!strncmp(s
, "cont", 4))
590 // Last argument to strtoull (the base) is 0 meaning that decimal is assumed
591 // unless prefixes of "0" (for octal) or "0x"/"0X" (for hex) are used.
592 *start
= strtoull(s
, &tailptr
, 0);
595 if (!(!errno
&& (add
|| *s
== '-')))
597 if (!strcmp(s
, "-max")) {
598 *stop
= ~(uint64_t)0; // replaced by max LBA later
602 *stop
= strtoull(s
+1, &tailptr
, 0);
603 if (errno
|| *tailptr
!= '\0')
608 *stop
+= *start
; // -t select,N+M => -t select,N,(N+M-1)
616 #define EXIT_NOMEM 8 // out of memory
617 #define EXIT_BADCODE 10 // internal error - should NEVER happen
621 // Helps debugging. If the second argument is non-negative, then
622 // decrement bytes by that amount. Else decrement bytes by (one plus)
623 // length of null terminated string.
624 void *FreeNonZero1(void *address
, int size
, int line
, const char* file
){
627 bytes
-=1+strlen((char*)address
);
630 return CheckFree1(address
, line
, file
);
635 // To help with memory checking. Use when it is known that address is
637 void *CheckFree1(void *address
, int whatline
, const char* file
){
643 PrintOut(LOG_CRIT
, "Internal error in CheckFree() at line %d of file %s\n%s",
644 whatline
, file
, reportbug
);
648 // A custom version of calloc() that tracks memory use
649 void *Calloc(size_t nmemb
, size_t size
) {
650 void *ptr
=calloc(nmemb
, size
);
658 // A custom version of strdup() that keeps track of how much memory is
659 // being allocated. If mustexist is set, it also throws an error if we
660 // try to duplicate a NULL string.
661 char *CustomStrDup(const char *ptr
, int mustexist
, int whatline
, const char* file
){
664 // report error if ptr is NULL and mustexist is set
667 PrintOut(LOG_CRIT
, "Internal error in CustomStrDup() at line %d of file %s\n%s",
668 whatline
, file
, reportbug
);
675 // make a copy of the string...
679 PrintOut(LOG_CRIT
, "No memory to duplicate string %s at line %d of file %s\n", ptr
, whatline
, file
);
683 // and track memory usage
684 bytes
+=1+strlen(ptr
);
689 #endif // OLD_INTERFACE
692 // Returns true if region of memory contains non-zero entries
693 bool nonempty(const void * data
, int size
)
695 for (int i
= 0; i
< size
; i
++)
696 if (((const unsigned char *)data
)[i
])
702 // This routine converts an integer number of milliseconds into a test
703 // string of the form Xd+Yh+Zm+Ts.msec. The resulting text string is
704 // written to the array.
705 void MsecToText(unsigned int msec
, char *txt
){
707 unsigned int days
, hours
, min
, sec
;
709 days
= msec
/86400000U;
710 msec
-= days
*86400000U;
712 hours
= msec
/3600000U;
713 msec
-= hours
*3600000U;
722 txt
+= sprintf(txt
, "%2dd+", (int)days
);
726 sprintf(txt
, "%02d:%02d:%02d.%03d", (int)hours
, (int)min
, (int)sec
, (int)msec
);
730 // return (v)sprintf() formatted std::string
732 std::string
vstrprintf(const char * fmt
, va_list ap
)
735 vsnprintf(buf
, sizeof(buf
), fmt
, ap
);
736 buf
[sizeof(buf
)-1] = 0;
740 std::string
strprintf(const char * fmt
, ...)
742 va_list ap
; va_start(ap
, fmt
);
743 std::string str
= vstrprintf(fmt
, ap
);
749 #ifndef HAVE_WORKING_SNPRINTF
750 // Some versions of (v)snprintf() don't append null char on overflow (MSVCRT.DLL),
751 // and/or return -1 on overflow (old Linux).
752 // Below are sane replacements substituted by #define in utility.h.
755 #if defined(_WIN32) && defined(_MSC_VER)
756 #define vsnprintf _vsnprintf
759 int safe_vsnprintf(char *buf
, int size
, const char *fmt
, va_list ap
)
764 i
= vsnprintf(buf
, size
, fmt
, ap
);
765 if (0 <= i
&& i
< size
)
768 return strlen(buf
); // Note: cannot detect for overflow, not necessary here.
771 int safe_snprintf(char *buf
, int size
, const char *fmt
, ...)
775 i
= safe_vsnprintf(buf
, size
, fmt
, ap
);