utility.h

   1 /*
   2  * utility.h
   3  *
   4  * Home page of code is: http://smartmontools.sourceforge.net
   5  *
   6  * Copyright (C) 2002-10 Bruce Allen <smartmontools-support@lists.sourceforge.net>
   7  * Copyright (C) 2008-10 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 #ifndef UTILITY_H_
  27 #define UTILITY_H_
  28
  29 #define UTILITY_H_CVSID "$Id: utility.h 3093 2010-04-30 09:57:36Z chrfranke $"
  30
  31 #include <time.h>
  32 #include <sys/types.h> // for regex.h (according to POSIX)
  33 #include <regex.h>
  34 #include <stdarg.h>
  35 #include <stdio.h>
  36 #include <string.h>
  37 #include <string>
  38
  39 #if !defined(__GNUC__) && !defined(__attribute__)
  40 #define __attribute__(x)  /**/
  41 #endif
  42
  43 // Make version information string
  44 std::string format_version_info(const char * prog_name, bool full = false);
  45
  46 // return (v)sprintf() formated std::string
  47 std::string strprintf(const char * fmt, ...)
  48     __attribute__ ((format (printf, 1, 2)));
  49 std::string vstrprintf(const char * fmt, va_list ap);
  50
  51 #ifndef HAVE_WORKING_SNPRINTF
  52 // Substitute by safe replacement functions
  53 int safe_snprintf(char *buf, int size, const char *fmt, ...)
  54     __attribute__ ((format (printf, 3, 4)));
  55 int safe_vsnprintf(char *buf, int size, const char *fmt, va_list ap);
  56 #define snprintf  safe_snprintf
  57 #define vsnprintf safe_vsnprintf
  58 #endif
  59
  60 #ifndef HAVE_STRTOULL
  61 // Replacement for missing strtoull() (Linux with libc < 6, MSVC)
  62 uint64_t strtoull(const char * p, char * * endp, int base);
  63 #endif
  64
  65 // Utility function prints current date and time and timezone into a
  66 // character buffer of length>=64.  All the fuss is needed to get the
  67 // right timezone info (sigh).
  68 #define DATEANDEPOCHLEN 64
  69 void dateandtimezone(char *buffer);
  70 // Same, but for time defined by epoch tval
  71 void dateandtimezoneepoch(char *buffer, time_t tval);
  72
  73 // like printf() except that we can control it better. Note --
  74 // although the prototype is given here in utility.h, the function
  75 // itself is defined differently in smartctl and smartd.  So the
  76 // function definition(s) are in smartd.c and in smartctl.c.
  77 void pout(const char *fmt, ...)
  78      __attribute__ ((format (printf, 1, 2)));
  79
  80 // replacement for perror() with redirected output.
  81 void syserror(const char *message);
  82
  83 // Function for processing -r option in smartctl and smartd
  84 int split_report_arg(char *s, int *i);
  85 // Function for processing -c option in smartctl and smartd
  86 int split_report_arg2(char *s, int *i);
  87
  88 // Function for processing -t selective... option in smartctl
  89 int split_selective_arg(char *s, uint64_t *start, uint64_t *stop, int *mode);
  90
  91
  92 // Guess device type (ata or scsi) based on device name
  93 // Guessing will now use Controller Type defines below
  94
  95 // Moved to C++ interface
  96 //int guess_device_type(const char * dev_name);
  97
  98 // Create and return the list of devices to probe automatically
  99 // if the DEVICESCAN option is in the smartd config file
 100 // Moved to C++ interface
 101 //int make_device_names (char ***devlist, const char* name);
 102
 103 // Replacement for exit(status)
 104 // (exit is not compatible with C++ destructors)
 105 #define EXIT(status) { throw (int)(status); }
 106
 107
 108 #ifdef OLD_INTERFACE
 109
 110 // replacement for calloc() that tracks memory usage
 111 void *Calloc(size_t nmemb, size_t size);
 112
 113 // Utility function to free memory
 114 void *FreeNonZero1(void* address, int size, int whatline, const char* file);
 115
 116 // Typesafe version of above
 117 template <class T>
 118 inline T * FreeNonZero(T * address, int size, int whatline, const char* file)
 119   { return (T *)FreeNonZero1((void *)address, size, whatline, file); }
 120
 121 // A custom version of strdup() that keeps track of how much memory is
 122 // being allocated. If mustexist is set, it also throws an error if we
 123 // try to duplicate a NULL string.
 124 char *CustomStrDup(const char *ptr, int mustexist, int whatline, const char* file);
 125
 126 // To help with memory checking.  Use when it is known that address is
 127 // NOT null.
 128 void *CheckFree1(void *address, int whatline, const char* file);
 129
 130 // Typesafe version of above
 131 template <class T>
 132 inline T * CheckFree(T * address, int whatline, const char* file)
 133   { return (T *)CheckFree1((void *)address, whatline, file); }
 134
 135 #endif // OLD_INTERFACE
 136
 137 // This function prints either to stdout or to the syslog as needed
 138
 139 // [From GLIBC Manual: Since the prototype doesn't specify types for
 140 // optional arguments, in a call to a variadic function the default
 141 // argument promotions are performed on the optional argument
 142 // values. This means the objects of type char or short int (whether
 143 // signed or not) are promoted to either int or unsigned int, as
 144 // appropriate.]
 145 void PrintOut(int priority, const char *fmt, ...) __attribute__ ((format(printf, 2, 3)));
 146
 147 // Compile time check of byte ordering
 148 // (inline const function allows compiler to remove dead code)
 149 inline bool isbigendian()
 150 {
 151 #ifdef WORDS_BIGENDIAN
 152   return true;
 153 #else
 154   return false;
 155 #endif
 156 }
 157
 158 // Runtime check of byte ordering, throws if different from isbigendian().
 159 void check_endianness();
 160
 161 // This value follows the peripheral device type value as defined in
 162 // SCSI Primary Commands, ANSI INCITS 301:1997.  It is also used in
 163 // the ATA standard for packet devices to define the device type.
 164 const char *packetdevicetype(int type);
 165
 166 // Moved to C++ interface
 167 //int deviceopen(const char *pathname, char *type);
 168
 169 //int deviceclose(int fd);
 170
 171 // Optional functions of os_*.c
 172 #ifdef HAVE_GET_OS_VERSION_STR
 173 // Return build host and OS version as static string
 174 //const char * get_os_version_str(void);
 175 #endif
 176
 177 // returns true if any of the n bytes are nonzero, else zero.
 178 bool nonempty(const void * data, int size);
 179
 180 // needed to fix glibc bug
 181 void FixGlibcTimeZoneBug();
 182
 183 // convert time in msec to a text string
 184 void MsecToText(unsigned int msec, char *txt);
 185
 186 // Wrapper class for a raw data buffer
 187 class raw_buffer
 188 {
 189 public:
 190   explicit raw_buffer(unsigned sz, unsigned char val = 0)
 191     : m_data(new unsigned char[sz]),
 192       m_size(sz)
 193     { memset(m_data, val, m_size); }
 194
 195   ~raw_buffer()
 196     { delete [] m_data; }
 197
 198   unsigned size() const
 199     { return m_size; }
 200
 201   unsigned char * data()
 202     { return m_data; }
 203   const unsigned char * data() const
 204     { return m_data; }
 205
 206 private:
 207   unsigned char * m_data;
 208   unsigned m_size;
 209
 210   raw_buffer(const raw_buffer &);
 211   void operator=(const raw_buffer &);
 212 };
 213
 214 /// Wrapper class for FILE *.
 215 class stdio_file
 216 {
 217 public:
 218   explicit stdio_file(FILE * f = 0, bool owner = false)
 219     : m_file(f), m_owner(owner) { }
 220
 221   stdio_file(const char * name, const char * mode)
 222     : m_file(fopen(name, mode)), m_owner(true) { }
 223
 224   ~stdio_file()
 225     {
 226       if (m_file && m_owner)
 227         fclose(m_file);
 228     }
 229
 230   bool open(const char * name, const char * mode)
 231     {
 232       m_file = fopen(name, mode);
 233       m_owner = true;
 234       return !!m_file;
 235     }
 236
 237   void open(FILE * f, bool owner = false)
 238     {
 239       m_file = f;
 240       m_owner = owner;
 241     }
 242
 243   bool close()
 244     {
 245       if (!m_file)
 246         return true;
 247       bool ok = !ferror(m_file);
 248       if (fclose(m_file))
 249         ok = false;
 250       m_file = 0;
 251       return ok;
 252     }
 253
 254   operator FILE * ()
 255     { return m_file; }
 256
 257   bool operator!() const
 258     { return !m_file; }
 259
 260 private:
 261   FILE * m_file;
 262   bool m_owner;
 263
 264   stdio_file(const stdio_file &);
 265   void operator=(const stdio_file &);
 266 };
 267
 268 /// Wrapper class for regex(3).
 269 /// Supports copy & assignment and is compatible with STL containers.
 270 class regular_expression
 271 {
 272 public:
 273   // Construction & assignment
 274   regular_expression();
 275
 276   regular_expression(const char * pattern, int flags);
 277
 278   ~regular_expression();
 279
 280   regular_expression(const regular_expression & x);
 281
 282   regular_expression & operator=(const regular_expression & x);
 283
 284   /// Set and compile new pattern, return false on error.
 285   bool compile(const char * pattern, int flags);
 286
 287   // Get pattern from last compile().
 288   const char * get_pattern() const
 289     { return m_pattern.c_str(); }
 290
 291   /// Get error message from last compile().
 292   const char * get_errmsg() const
 293     { return m_errmsg.c_str(); }
 294
 295   // Return true if pattern is not set or bad.
 296   bool empty() const
 297     { return (m_pattern.empty() || !m_errmsg.empty()); }
 298
 299   /// Return true if substring matches pattern
 300   bool match(const char * str, int flags = 0) const
 301     { return !regexec(&m_regex_buf, str, 0, (regmatch_t*)0, flags); }
 302
 303   /// Return true if full string matches pattern
 304   bool full_match(const char * str, int flags = 0) const
 305     {
 306       regmatch_t range;
 307       return (   !regexec(&m_regex_buf, str, 1, &range, flags)
 308               && range.rm_so == 0 && range.rm_eo == (int)strlen(str));
 309     }
 310
 311   /// Return true if substring matches pattern, fill regmatch_t array.
 312   bool execute(const char * str, unsigned nmatch, regmatch_t * pmatch, int flags = 0) const
 313     { return !regexec(&m_regex_buf, str, nmatch, pmatch, flags); }
 314
 315 private:
 316   std::string m_pattern;
 317   int m_flags;
 318   regex_t m_regex_buf;
 319   std::string m_errmsg;
 320
 321   void free_buf();
 322   void copy(const regular_expression & x);
 323   bool compile();
 324 };
 325
 326 // macros to control printing
 327 #define PRINT_ON(control)  {if (control->printing_switchable) control->dont_print=false;}
 328 #define PRINT_OFF(control) {if (control->printing_switchable) control->dont_print=true;}
 329
 330 #ifdef _WIN32
 331 // Get exe directory
 332 //(implemented in os_win32.cpp)
 333 std::string get_exe_dir();
 334 #endif
 335
 336
 337 #ifdef OLD_INTERFACE
 338 // possible values for controller_type in extern.h
 339 #define CONTROLLER_UNKNOWN              0x00
 340 #define CONTROLLER_ATA                  0x01
 341 #define CONTROLLER_SCSI                 0x02
 342 #define CONTROLLER_3WARE                0x03  // set by -d option, but converted to one of three types below
 343 #define CONTROLLER_3WARE_678K           0x04  // NOT set by guess_device_type()
 344 #define CONTROLLER_3WARE_9000_CHAR      0x05  // set by guess_device_type()
 345 #define CONTROLLER_3WARE_678K_CHAR      0x06  // set by guess_device_type()
 346 #define CONTROLLER_MARVELL_SATA         0x07  // SATA drives behind Marvell controllers
 347 #define CONTROLLER_SAT                  0x08  // SATA device behind a SCSI ATA Translation (SAT) layer
 348 #define CONTROLLER_HPT                  0x09  // SATA drives behind HighPoint Raid controllers
 349 #define CONTROLLER_CCISS                0x10  // CCISS controller
 350 #define CONTROLLER_PARSEDEV             0x11  // "smartctl -r ataioctl,2 ..." output parser pseudo-device
 351 #define CONTROLLER_USBCYPRESS           0x12  // ATA device behind Cypress USB bridge
 352 #define CONTROLLER_ARECA                0x13  // Areca controller
 353 #endif
 354
 355 #endif
 356