log.h
上传用户:uncom666
上传日期:2020-03-30
资源大小:1426k
文件大小:12k
源码类别:

SNMP编程

开发平台:

Visual C++

  1. /*_############################################################################
  2.   _## 
  3.   _##  log.h  
  4.   _##
  5.   _##  SNMP++v3.2.24
  6.   _##  -----------------------------------------------
  7.   _##  Copyright (c) 2001-2009 Jochen Katz, Frank Fock
  8.   _##
  9.   _##  This software is based on SNMP++2.6 from Hewlett Packard:
  10.   _##  
  11.   _##    Copyright (c) 1996
  12.   _##    Hewlett-Packard Company
  13.   _##  
  14.   _##  ATTENTION: USE OF THIS SOFTWARE IS SUBJECT TO THE FOLLOWING TERMS.
  15.   _##  Permission to use, copy, modify, distribute and/or sell this software 
  16.   _##  and/or its documentation is hereby granted without fee. User agrees 
  17.   _##  to display the above copyright notice and this license notice in all 
  18.   _##  copies of the software and any documentation of the software. User 
  19.   _##  agrees to assume all liability for the use of the software; 
  20.   _##  Hewlett-Packard and Jochen Katz make no representations about the 
  21.   _##  suitability of this software for any purpose. It is provided 
  22.   _##  "AS-IS" without warranty of any kind, either express or implied. User 
  23.   _##  hereby grants a royalty-free license to any and all derivatives based
  24.   _##  upon this software code base. 
  25.   _##  
  26.   _##  Stuttgart, Germany, Fri May 29 22:35:14 CEST 2009 
  27.   _##  
  28.   _##########################################################################*/
  29. #ifndef _log_h_
  30. #define _log_h_
  31. #include <snmp_pp/config_snmp_pp.h>
  32. #include <snmp_pp/reentrant.h>
  33. #ifndef WIN32
  34. #include <sys/types.h>
  35. #endif
  36. #include <stdio.h>
  37. #include <string.h>
  38. #ifdef SNMP_PP_NAMESPACE
  39. namespace Snmp_pp {
  40. #endif
  41. // Log entry class
  42. #define ERROR_LOG 0x10
  43. #define WARNING_LOG 0x20
  44. #define EVENT_LOG 0x30
  45. #define INFO_LOG 0x40
  46. #define DEBUG_LOG 0x50
  47. #define USER_LOG 0x60
  48. #define LOG_TYPES       6
  49. #ifdef _NO_LOGGING
  50.  
  51. #define LOG_BEGIN(x)
  52. #define LOG(x)
  53. #define LOG_END
  54. #else
  55. #define LOG_BEGIN(x)
  56. {
  57. if (DefaultLog::log()->log_needed(x))
  58. {
  59. DefaultLog::log()->lock();
  60. DefaultLog::create_log_entry(x);
  61. #define LOG(x) *DefaultLog::log_entry() += x
  62. #define LOG_END
  63. *DefaultLog::log() += DefaultLog::log_entry();
  64. DefaultLog::delete_log_entry();
  65. DefaultLog::log()->unlock();
  66. }
  67. }
  68. #endif
  69. /*--------------------------- class LogEntry --------------------------*/
  70. /**
  71.  * The LogEntry class represents log entries. An instance of LogEntry can be
  72.  * added to a Log. Each LogEntry can be classified into the log classes
  73.  * ERROR_LOG, WARNING_LOG, EVENT_LOG, INFO_LOG, DEBUG_LOG and USER_LOG with up
  74.  * to 16 severity levels. A log entry consists of a descriptor string and
  75.  * optional several string or numeric values.
  76.  *
  77.  * The log class USER_LOG can be used for applications, it is not used
  78.  * within snmp++ and agent++.
  79.  *
  80.  * @note A error log of level 0 will stop program execution!
  81.  *
  82.  * @see Log
  83.  * 
  84.  * @author Frank Fock
  85.  * @author Marty Janzen
  86.  * @version 3.5f
  87.  */
  88. class DLLOPT LogEntry {
  89. public:
  90. /**
  91.  * Constructor with log class and severity level
  92.  * 
  93.  * @param t - The type of the log entry. The type is composed 
  94.  *            by a logical OR of the log entry class with a level
  95.  *            of 0 up to 15. 
  96.  * @note A error log of level 0 will stop program execution!
  97.  */  
  98. LogEntry(unsigned char t) : type(t), count(0) {}
  99. /**
  100.  * Virtual destructor.
  101.  */  
  102. virtual ~LogEntry() {}
  103. /**
  104.  * Initialize a new log entry, showing timestamp, class, and level.
  105.  */ 
  106. virtual void init(void);
  107. /**
  108.  * Add a numeric value to the log entry.
  109.  *
  110.  * @param l - A numeric value.
  111.  */
  112. virtual LogEntry& operator+=(const long);
  113. /**
  114.  * Add a string value to the log entry.
  115.  *
  116.  * @param l - A numeric value.
  117.  */
  118. virtual LogEntry& operator+=(const char*);
  119. /**
  120.  * Get the contents of this log entry.
  121.          *
  122.  * @return Current contents of this log entry.
  123.  */ 
  124. virtual const char* get_value(void) const { return ""; }
  125. /**
  126.  * Get the class of this log entry.
  127.          *
  128.  * @return Log entry class.
  129.  */ 
  130. unsigned char get_class(void) const { return type & 0xF0; }
  131. /**
  132.  * Get the level of this log entry.
  133.          *
  134.  * @return Log entry level.
  135.  */ 
  136. unsigned char get_level(void) const { return type & 0x0F; }
  137. protected:
  138. /**
  139.  * Add a string to the log.
  140.  *
  141.  * @param s - A string value.
  142.  * @return TRUE if the value has been added and FALSE if the log
  143.  *         entry is full.
  144.  */
  145. virtual bool add_string(const char*) = 0;
  146. /**
  147.  * Add an integer to the log.
  148.  *
  149.  * @param s - An integer value.
  150.  * @return TRUE if the value has been added and FALSE if the log
  151.  *         entry is full.
  152.  */
  153. virtual bool add_integer(long);
  154. /**
  155.  * Add the current time to the log.
  156.  */
  157. virtual bool add_timestamp(void);
  158. protected:
  159. unsigned char   type;
  160. int count;
  161. };
  162. /*------------------------- class LogEntryImpl ------------------------*/
  163. #define MAX_LOG_SIZE 2550 // increased until debugprintf is not used!
  164. /**
  165.  * The LogEntryImpl class implements a log entry using a dynamically
  166.  * allocated, but fixed-size buffer.
  167.  * @see Log
  168.  * 
  169.  * @author Marty Janzen
  170.  * @version 3.5f
  171.  */
  172. class DLLOPT LogEntryImpl : public LogEntry {
  173. public:
  174. /**
  175.  * Constructor with log class and severity level
  176.  * 
  177.  * @param t - The type of the log entry. The type is composed 
  178.  *            by logical or the log entry class with a level
  179.  *            of 0 up to 15. 
  180.  * @note A error log of level 0 will stop program execution!
  181.  */  
  182. LogEntryImpl(unsigned char);
  183. /**
  184.  * Destructor.
  185.  */  
  186. ~LogEntryImpl();
  187. /**
  188.  * Get the contents of this log entry.
  189.          *
  190.  * @return Current contents of this log entry.
  191.  */ 
  192. virtual const char* get_value(void) const { return value; }
  193. protected:
  194. /**
  195.  * Count the bytes left for additional values.
  196.  *
  197.  * @return The number of bytes left in this log entry.
  198.  */  
  199. unsigned int bytes_left() 
  200.     { return (unsigned int)(MAX_LOG_SIZE-(ptr-value)-1); }
  201. /**
  202.  * Add a string to the log.
  203.  *
  204.  * @param s - A string value.
  205.  * @return TRUE if the value has been added and FALSE if the log
  206.  *         entry is full.
  207.  */
  208. bool add_string(const char*);
  209. private:
  210.         char* value;
  211. char* ptr;
  212. bool output_stopped;
  213. };
  214. /*--------------------------- class AgentLog --------------------------*/
  215. /**
  216.  * The AgentLog class is an abstract base class representing a log for
  217.  * information that is generated during the run time of an AGENT++
  218.  * SNMP agent.  A derived class only needs to provide appropriate
  219.  * create_log_entry() and operator+= methods.
  220.  * @see LogEntry
  221.  *
  222.  * @author Frank Fock
  223.  * @version 3.5.14
  224.  */
  225.  
  226. class DLLOPT AgentLog {
  227. public:
  228. /**
  229.  * Default constructor.
  230.  */ 
  231. AgentLog();
  232. /**
  233.  * Virtual destructor.
  234.  */
  235. virtual ~AgentLog() {}
  236. /**
  237.  * Lock the receiver.  Default action is to perform no locking.
  238.  */
  239. virtual void lock() {}
  240. /**
  241.  * Unlock the receiver.  Default action is to perform no locking.
  242.  */
  243. virtual void unlock() {}
  244. /**
  245.  * Set a filter on a specified log class. Only log entries with
  246.  * a level less or equal than the specified level will be logged.
  247.  *
  248.  * @param logclass - A log entry class. @see LogEntry
  249.  * @param filter - A value between 0 and 15.
  250.  */ 
  251. virtual void set_filter(int logclass, unsigned char filter);
  252. /**
  253.  * Gets the log level for the given log class.
  254.  * @return
  255.  *    a unsigned char value between 0 and 15 
  256.  */
  257. virtual unsigned char get_filter(int logclass) const; 
  258. /**
  259.  * Create a new LogEntry.
  260.  *
  261.  * @param t - The type of the log entry.
  262.  * @return A new instance of LogEntry (or of a derived class).
  263.  */
  264. virtual LogEntry* create_log_entry(unsigned char) const = 0;
  265. /**
  266.  * Add a LogEntry to the receiver Log.
  267.  *
  268.  * @param log - A log entry.
  269.  * @return The receiver log itself.
  270.  */
  271. virtual AgentLog& operator+=(const LogEntry*) = 0;
  272. /**
  273.  * Check whether a logging for the given type of LogEntry
  274.  * has to be done or not.
  275.  *
  276.  * @param type
  277.  *    the type of the log entry. The type is composed 
  278.  *    by logical or the log entry class with a level
  279.  *    of 0 up to 15.
  280.  * @return
  281.  *    TRUE if logging is needed, FALSE otherwise.
  282.  */
  283. virtual bool log_needed(unsigned char t) 
  284.   { return ((t & 0x0F) <= logfilter[(t / 16) - 1]); }
  285. /**
  286.  * Return the current time as a string.
  287.  * 
  288.  * @param
  289.  *    a buffer (of at least 18 characters, for the default method)
  290.          *    into which to place a string containg the current time.
  291.          *    If no buffer is supplied, a static area is used.
  292.  * @return
  293.  *    a string containing the current time. Either the supplied
  294.  *    buffer or the static area.
  295.  */
  296. virtual const char* now(char* = 0);
  297. /**
  298.  * Return the current time as a string, using the current
  299.          * default log object.  (For backward compatibility.)
  300.  * @note that the user is responsible for deleting the returned
  301.  * string, using delete [].
  302.  * 
  303.  * @return
  304.  *    a string containg the current time.
  305.  */
  306. static const char* get_current_time();
  307. protected:
  308. unsigned char logfilter[LOG_TYPES];
  309. char static_buf[18];
  310. };
  311. /*------------------------- class AgentLogImpl ------------------------*/
  312. /**
  313.  * The AgentLogImpl class is an implementation of AgentLog which writes
  314.  * log messages to a file, or to stdout or stderr.
  315.  * @see LogEntry 
  316.  *
  317.  * @author Frank Fock
  318.  * @version 3.5f
  319.  */
  320.  
  321. class DLLOPT AgentLogImpl : public AgentLog {
  322. public:
  323. /**
  324.  * Default constructor, with optional pointer to an open log file.
  325.          * Log is directed to the file if given, otherwise to stdout
  326.  *
  327.  * @param fp - An open log file.  0 implies stdout.
  328.  */ 
  329. AgentLogImpl(FILE* = stdout);
  330. /**
  331.  * Constructor with file name of a log file. Log is directed
  332.  * to the given file.
  333.  *
  334.  * @param fname - The file name of a log file.
  335.  */ 
  336. AgentLogImpl(const char*);
  337. /**
  338.  * Destructor.
  339.  */
  340. ~AgentLogImpl();
  341. /**
  342.  * Set destination of logs to a given file.
  343.  * 
  344.  * @param fname - A file name. "" directs logs to stdout.
  345.  */
  346. void set_dest(const char*);
  347. /**
  348.  * Set destination of logs to a given file.
  349.  * 
  350.  * @param fp - A pointer to an open file.  0 directs logs to stdout.
  351.  */
  352. void set_dest(FILE*);
  353. /**
  354.  * Lock the receiver.
  355.  */
  356. void lock()
  357. {
  358. #ifdef _THREADS
  359. logLock.lock();
  360. #endif
  361. }
  362. /**
  363.  * Unlock the receiver.
  364.  */
  365.  void unlock()
  366. {
  367. #ifdef _THREADS
  368. logLock.unlock();
  369. #endif
  370. }
  371. /**
  372.  * Create a new LogEntry.
  373.  *
  374.  * @param t - The type of the log entry.
  375.  * @return A new instance of LogEntry (or of a derived class).
  376.  */
  377. virtual LogEntry* create_log_entry(unsigned char) const;
  378. /**
  379.  * Add a LogEntry to the receiver Log.
  380.  *
  381.  * @param log - A log entry.
  382.  * @return The receiver log itself.
  383.  */
  384. virtual AgentLog& operator+=(const LogEntry*);
  385. protected:
  386. SnmpSynchronized logLock;
  387. FILE* logfile;
  388. bool close_needed;
  389. };
  390. /*--------------------------- class DefaultLog --------------------------*/
  391. /**
  392.  * The DefaultLog class has a static Log member, that is used by the
  393.  * AGENT++ API for logging.
  394.  *
  395.  * @version 3.5.4
  396.  * @author Frank Fock (singlton pattern -> Philippe Roger)
  397.  */  
  398. class DLLOPT DefaultLog {
  399. public:
  400. DefaultLog() { }
  401. ~DefaultLog() { }
  402. /** 
  403.  * Initialize the default logger with the given logging implementation.
  404.  *
  405.  * @param logger
  406.  *    an AgentLog instance to be used as default logger. A previously
  407.  *    set logger will be deleted.
  408.  */
  409. static void init(AgentLog* logger) 
  410.   { if (instance) delete instance; instance = logger; }
  411. /**
  412.  * Return the default logger. 
  413.  *
  414.  * @return
  415.  *    a pointer to an AgentLog instance.
  416.  */
  417. static AgentLog* log() 
  418.   { if (!instance) init(new AgentLogImpl()); return instance; }
  419. /**
  420.  * Create a new log entry or reuse an existing one.
  421.  *
  422.  * @param type
  423.  *    the type of the log entry as bitwise or of log class and level. 
  424.  */
  425. static void create_log_entry(unsigned char t)
  426.   { if (!entry) { entry = log()->create_log_entry(t); entry->init();} }
  427. /**
  428.  * Return the current log entry. If there is none, an ERROR_LOG entry
  429.  * with level 1 will be created.
  430.  *
  431.  * @return
  432.  *    a pointer to a LogEntry instance.
  433.  */
  434. static LogEntry* log_entry() 
  435.   { if (!entry) create_log_entry(ERROR_LOG | 1); return entry; } 
  436. /**
  437.  * Delete current log entry.
  438.  */
  439. static void delete_log_entry() 
  440.   { if (entry) delete entry; entry = 0; }
  441. protected:
  442. static AgentLog* instance;
  443. static LogEntry* entry;
  444. };
  445. #ifdef SNMP_PP_NAMESPACE
  446. }
  447. #endif
  448. #endif // _log_h_