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