Annotation of embedaddon/smartmontools/utility.h, revision 1.1
1.1 ! misho 1: /*
! 2: * utility.h
! 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: #ifndef UTILITY_H_
! 27: #define UTILITY_H_
! 28:
! 29: #define UTILITY_H_CVSID "$Id: utility.h 3305 2011-03-30 21:32:05Z 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: // Compile time check of byte ordering
! 138: // (inline const function allows compiler to remove dead code)
! 139: inline bool isbigendian()
! 140: {
! 141: #ifdef WORDS_BIGENDIAN
! 142: return true;
! 143: #else
! 144: return false;
! 145: #endif
! 146: }
! 147:
! 148: // Runtime check of byte ordering, throws if different from isbigendian().
! 149: void check_endianness();
! 150:
! 151: // This value follows the peripheral device type value as defined in
! 152: // SCSI Primary Commands, ANSI INCITS 301:1997. It is also used in
! 153: // the ATA standard for packet devices to define the device type.
! 154: const char *packetdevicetype(int type);
! 155:
! 156: // Moved to C++ interface
! 157: //int deviceopen(const char *pathname, char *type);
! 158:
! 159: //int deviceclose(int fd);
! 160:
! 161: // Optional functions of os_*.c
! 162: #ifdef HAVE_GET_OS_VERSION_STR
! 163: // Return build host and OS version as static string
! 164: //const char * get_os_version_str(void);
! 165: #endif
! 166:
! 167: // returns true if any of the n bytes are nonzero, else zero.
! 168: bool nonempty(const void * data, int size);
! 169:
! 170: // needed to fix glibc bug
! 171: void FixGlibcTimeZoneBug();
! 172:
! 173: // convert time in msec to a text string
! 174: void MsecToText(unsigned int msec, char *txt);
! 175:
! 176: // Format integer with thousands separator
! 177: const char * format_with_thousands_sep(char * str, int strsize, uint64_t val,
! 178: const char * thousands_sep = 0);
! 179:
! 180: // Format capacity with SI prefixes
! 181: const char * format_capacity(char * str, int strsize, uint64_t val,
! 182: const char * decimal_point = 0);
! 183:
! 184: // Wrapper class for a raw data buffer
! 185: class raw_buffer
! 186: {
! 187: public:
! 188: explicit raw_buffer(unsigned sz, unsigned char val = 0)
! 189: : m_data(new unsigned char[sz]),
! 190: m_size(sz)
! 191: { memset(m_data, val, m_size); }
! 192:
! 193: ~raw_buffer()
! 194: { delete [] m_data; }
! 195:
! 196: unsigned size() const
! 197: { return m_size; }
! 198:
! 199: unsigned char * data()
! 200: { return m_data; }
! 201: const unsigned char * data() const
! 202: { return m_data; }
! 203:
! 204: private:
! 205: unsigned char * m_data;
! 206: unsigned m_size;
! 207:
! 208: raw_buffer(const raw_buffer &);
! 209: void operator=(const raw_buffer &);
! 210: };
! 211:
! 212: /// Wrapper class for FILE *.
! 213: class stdio_file
! 214: {
! 215: public:
! 216: explicit stdio_file(FILE * f = 0, bool owner = false)
! 217: : m_file(f), m_owner(owner) { }
! 218:
! 219: stdio_file(const char * name, const char * mode)
! 220: : m_file(fopen(name, mode)), m_owner(true) { }
! 221:
! 222: ~stdio_file()
! 223: {
! 224: if (m_file && m_owner)
! 225: fclose(m_file);
! 226: }
! 227:
! 228: bool open(const char * name, const char * mode)
! 229: {
! 230: m_file = fopen(name, mode);
! 231: m_owner = true;
! 232: return !!m_file;
! 233: }
! 234:
! 235: void open(FILE * f, bool owner = false)
! 236: {
! 237: m_file = f;
! 238: m_owner = owner;
! 239: }
! 240:
! 241: bool close()
! 242: {
! 243: if (!m_file)
! 244: return true;
! 245: bool ok = !ferror(m_file);
! 246: if (fclose(m_file))
! 247: ok = false;
! 248: m_file = 0;
! 249: return ok;
! 250: }
! 251:
! 252: operator FILE * ()
! 253: { return m_file; }
! 254:
! 255: bool operator!() const
! 256: { return !m_file; }
! 257:
! 258: private:
! 259: FILE * m_file;
! 260: bool m_owner;
! 261:
! 262: stdio_file(const stdio_file &);
! 263: void operator=(const stdio_file &);
! 264: };
! 265:
! 266: /// Wrapper class for regex(3).
! 267: /// Supports copy & assignment and is compatible with STL containers.
! 268: class regular_expression
! 269: {
! 270: public:
! 271: // Construction & assignment
! 272: regular_expression();
! 273:
! 274: regular_expression(const char * pattern, int flags,
! 275: bool throw_on_error = true);
! 276:
! 277: ~regular_expression();
! 278:
! 279: regular_expression(const regular_expression & x);
! 280:
! 281: regular_expression & operator=(const regular_expression & x);
! 282:
! 283: /// Set and compile new pattern, return false on error.
! 284: bool compile(const char * pattern, int flags);
! 285:
! 286: // Get pattern from last compile().
! 287: const char * get_pattern() const
! 288: { return m_pattern.c_str(); }
! 289:
! 290: /// Get error message from last compile().
! 291: const char * get_errmsg() const
! 292: { return m_errmsg.c_str(); }
! 293:
! 294: // Return true if pattern is not set or bad.
! 295: bool empty() const
! 296: { return (m_pattern.empty() || !m_errmsg.empty()); }
! 297:
! 298: /// Return true if substring matches pattern
! 299: bool match(const char * str, int flags = 0) const
! 300: { return !regexec(&m_regex_buf, str, 0, (regmatch_t*)0, flags); }
! 301:
! 302: /// Return true if full string matches pattern
! 303: bool full_match(const char * str, int flags = 0) const
! 304: {
! 305: regmatch_t range;
! 306: return ( !regexec(&m_regex_buf, str, 1, &range, flags)
! 307: && range.rm_so == 0 && range.rm_eo == (int)strlen(str));
! 308: }
! 309:
! 310: /// Return true if substring matches pattern, fill regmatch_t array.
! 311: bool execute(const char * str, unsigned nmatch, regmatch_t * pmatch, int flags = 0) const
! 312: { return !regexec(&m_regex_buf, str, nmatch, pmatch, flags); }
! 313:
! 314: private:
! 315: std::string m_pattern;
! 316: int m_flags;
! 317: regex_t m_regex_buf;
! 318: std::string m_errmsg;
! 319:
! 320: void free_buf();
! 321: void copy(const regular_expression & x);
! 322: bool compile();
! 323: };
! 324:
! 325: #ifdef _WIN32
! 326: // Get exe directory
! 327: //(implemented in os_win32.cpp)
! 328: std::string get_exe_dir();
! 329: #endif
! 330:
! 331:
! 332: #ifdef OLD_INTERFACE
! 333: // remaining controller types in old interface modules
! 334: #define CONTROLLER_UNKNOWN 0x00
! 335: #define CONTROLLER_ATA 0x01
! 336: #define CONTROLLER_SCSI 0x02
! 337: #endif
! 338:
! 339: #endif
! 340:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to utility.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / smartmontools