Changeset 7f9c823 in nscp for include


Ignore:
Timestamp:
11/08/09 23:24:31 (4 years ago)
Author:
Michael Medin <michael@…>
Branches:
master, 0.4.0, 0.4.1, 0.4.2
Children:
6672c56
Parents:
3b4097d
Message:

First attempt at serious boostification.
NOTICE! This is NOT a complete edition, it build and runs but many features are disabled and/or broken.
But we have working, sockets and mutexes and conversion functions from boost inside now and more to come...
Also started to build with CMake since it works better then boost.build

Location:
include
Files:
9 added
15 edited

Legend:

Unmodified
Added
Removed

  • include/NSCAPI.h

    r9567d4b r7f9c823  
    2222 
    2323 
    24 #include <tchar.h> 
     24#include <unicode_char.hpp> 
    2525 
    2626namespace NSCAPI { 
    … …  
    7979#endif 
    8080 
    81   const int xor = 1; 
     81  const int encryption_xor = 1; 
    8282 
    8383  // Settings types 
    … …  
    9696 
    9797  struct plugin_info { 
    98     TCHAR *dll; 
    99     TCHAR *name; 
    100     TCHAR *description; 
    101     TCHAR *version; 
     98    wchar_t *dll; 
     99    wchar_t *name; 
     100    wchar_t *description; 
     101    wchar_t *version; 
    102102  }; 
    103103  typedef plugin_info* plugin_info_list; 
    … …  
    105105 
    106106}; 
     107 
     108namespace NSCModuleHelper { 
     109  typedef void* (*lpNSAPILoader)(wchar_t*); 
     110} 

  • include/NSCHelper.cpp

    rf0eb62d r7f9c823  
    2121 
    2222#include <NSCHelper.h> 
     23#include <nsc_module_wrapper.hpp> 
    2324#include <msvc_wrappers.h> 
    24 #include <config.h> 
     25#include <settings/macros.h> 
     26#include <arrayBuffer.h> 
     27//#include <config.h> 
    2528#include <strEx.h> 
    2629 
    … …  
    6770* @return NSCAPI::success unless the buffer is to short then it will be NSCAPI::invalidBufferLen 
    6871*/ 
    69 int NSCHelper::wrapReturnString(TCHAR *buffer, unsigned int bufLen, std::wstring str, int defaultReturnCode ) { 
     72int NSCHelper::wrapReturnString(wchar_t *buffer, unsigned int bufLen, std::wstring str, int defaultReturnCode ) { 
    7073  // @todo deprecate this 
    7174  if (str.length() >= bufLen) { 
    … …  
    215218 * @return The returned status of the command 
    216219 */ 
    217 NSCAPI::nagiosReturn NSCModuleHelper::InjectCommandRAW(const TCHAR* command, const unsigned int argLen, TCHAR **argument, TCHAR *returnMessageBuffer, unsigned int returnMessageBufferLen, TCHAR *returnPerfBuffer, unsigned int returnPerfBufferLen)  
     220NSCAPI::nagiosReturn NSCModuleHelper::InjectCommandRAW(const wchar_t* command, const unsigned int argLen, TCHAR **argument, TCHAR *returnMessageBuffer, unsigned int returnMessageBufferLen, TCHAR *returnPerfBuffer, unsigned int returnPerfBufferLen)  
    218221{ 
    219222  if (!fNSAPIInject) 

  • include/NSCHelper.h

    rd5356c1 r7f9c823  
    2727#include <charEx.h> 
    2828#include <arrayBuffer.h> 
    29 #include <windows.h> 
     29#ifdef WIN32 
     30//#include <windows.h> 
     31#endif 
    3032 
    3133 
    … …  
    3335{ 
    3436#ifdef DEBUG 
    35   NSCAPI::nagiosReturn wrapReturnString(TCHAR *buffer, unsigned int bufLen, std::wstring str, NSCAPI::nagiosReturn defaultReturnCode); 
    36   NSCAPI::errorReturn wrapReturnString(TCHAR *buffer, unsigned int bufLen, std::wstring str, NSCAPI::errorReturn defaultReturnCode); 
     37  NSCAPI::nagiosReturn wrapReturnString(wchar_t *buffer, unsigned int bufLen, std::wstring str, NSCAPI::nagiosReturn defaultReturnCode); 
     38  NSCAPI::errorReturn wrapReturnString(wchar_t *buffer, unsigned int bufLen, std::wstring str, NSCAPI::errorReturn defaultReturnCode); 
    3739#else 
    38   int wrapReturnString(TCHAR *buffer, unsigned int bufLen, std::wstring str, int defaultReturnCode); 
     40  int wrapReturnString(wchar_t *buffer, unsigned int bufLen, std::wstring str, int defaultReturnCode); 
    3941#endif 
    4042  std::wstring translateMessageType(NSCAPI::messageTypes msgType); 
    … …  
    108110  typedef std::list<plugin_info_type> plugin_info_list; 
    109111  // Types for the Callbacks into the main program 
    110   typedef NSCAPI::errorReturn (*lpNSAPIGetBasePath)(TCHAR*,unsigned int); 
    111   typedef NSCAPI::errorReturn (*lpNSAPIGetApplicationName)(TCHAR*,unsigned int); 
    112   typedef NSCAPI::errorReturn (*lpNSAPIGetApplicationVersionStr)(TCHAR*,unsigned int); 
    113   typedef NSCAPI::errorReturn (*lpNSAPIGetSettingsString)(const TCHAR*,const TCHAR*,const TCHAR*,TCHAR*,unsigned int); 
    114   typedef NSCAPI::errorReturn (*lpNSAPIGetSettingsInt)(const TCHAR*, const TCHAR*, int); 
    115   typedef NSCAPI::errorReturn (*lpNSAPIGetSettingsSection)(const TCHAR*, arrayBuffer::arrayBuffer*, unsigned int *); 
     112   
     113  typedef NSCAPI::errorReturn (*lpNSAPIGetBasePath)(wchar_t*,unsigned int); 
     114  typedef NSCAPI::errorReturn (*lpNSAPIGetApplicationName)(wchar_t*,unsigned int); 
     115  typedef NSCAPI::errorReturn (*lpNSAPIGetApplicationVersionStr)(wchar_t*,unsigned int); 
     116  typedef NSCAPI::errorReturn (*lpNSAPIGetSettingsString)(const wchar_t*,const wchar_t*,const wchar_t*,wchar_t*,unsigned int); 
     117  typedef NSCAPI::errorReturn (*lpNSAPIGetSettingsInt)(const wchar_t*, const wchar_t*, int); 
     118  typedef NSCAPI::errorReturn (*lpNSAPIGetSettingsSection)(const wchar_t*, arrayBuffer::arrayBuffer*, unsigned int *); 
    116119  typedef NSCAPI::errorReturn (*lpNSAPIReleaseSettingsSectionBuffer)(arrayBuffer::arrayBuffer*, unsigned int *); 
    117   typedef void (*lpNSAPIMessage)(int, const TCHAR*, const int, const TCHAR*); 
     120  typedef void (*lpNSAPIMessage)(int, const wchar_t*, const int, const wchar_t*); 
    118121  typedef NSCAPI::errorReturn (*lpNSAPIStopServer)(void); 
    119122  typedef NSCAPI::errorReturn (*lpNSAPIExit)(void); 
    120   typedef NSCAPI::nagiosReturn (*lpNSAPIInject)(const TCHAR*, const unsigned int, TCHAR **, TCHAR *, unsigned int, TCHAR *, unsigned int); 
    121   typedef void* (*lpNSAPILoader)(TCHAR*); 
     123  typedef NSCAPI::nagiosReturn (*lpNSAPIInject)(const wchar_t*, const unsigned int, wchar_t **, wchar_t *, unsigned int, wchar_t *, unsigned int); 
     124   
    122125  typedef NSCAPI::boolReturn (*lpNSAPICheckLogMessages)(int); 
    123   typedef NSCAPI::errorReturn (*lpNSAPIEncrypt)(unsigned int, const TCHAR*, unsigned int, TCHAR*, unsigned int *); 
    124   typedef NSCAPI::errorReturn (*lpNSAPIDecrypt)(unsigned int, const TCHAR*, unsigned int, TCHAR*, unsigned int *); 
    125   typedef NSCAPI::errorReturn (*lpNSAPISetSettingsString)(const TCHAR*, const TCHAR*, const TCHAR*); 
    126   typedef NSCAPI::errorReturn (*lpNSAPISetSettingsInt)(const TCHAR*, const TCHAR*, int); 
     126  typedef NSCAPI::errorReturn (*lpNSAPIEncrypt)(unsigned int, const wchar_t*, unsigned int, wchar_t*, unsigned int *); 
     127  typedef NSCAPI::errorReturn (*lpNSAPIDecrypt)(unsigned int, const wchar_t*, unsigned int, wchar_t*, unsigned int *); 
     128  typedef NSCAPI::errorReturn (*lpNSAPISetSettingsString)(const wchar_t*, const wchar_t*, const wchar_t*); 
     129  typedef NSCAPI::errorReturn (*lpNSAPISetSettingsInt)(const wchar_t*, const wchar_t*, int); 
    127130  typedef NSCAPI::errorReturn (*lpNSAPIWriteSettings)(int); 
    128131  typedef NSCAPI::errorReturn (*lpNSAPIReadSettings)(int); 
    129132  typedef NSCAPI::errorReturn (*lpNSAPIRehash)(int); 
    130   typedef NSCAPI::errorReturn (*lpNSAPIDescribeCommand)(const TCHAR*,TCHAR*,unsigned int); 
     133  typedef NSCAPI::errorReturn (*lpNSAPIDescribeCommand)(const wchar_t*,wchar_t*,unsigned int); 
    131134  typedef NSCAPI::errorReturn (*lpNSAPIGetAllCommandNames)(arrayBuffer::arrayBuffer*, unsigned int *); 
    132135  typedef NSCAPI::errorReturn (*lpNSAPIReleaseAllCommandNamessBuffer)(arrayBuffer::arrayBuffer*, unsigned int *); 
    133   typedef NSCAPI::errorReturn (*lpNSAPIRegisterCommand)(const TCHAR*,const TCHAR*); 
    134   typedef NSCAPI::errorReturn (*lpNSAPISettingsRegKey)(const TCHAR*, const TCHAR*, int, const TCHAR*, const TCHAR*, const TCHAR*, int); 
    135   typedef NSCAPI::errorReturn (*lpNSAPISettingsRegPath)(const TCHAR*, const TCHAR*, const TCHAR*, int); 
     136  typedef NSCAPI::errorReturn (*lpNSAPIRegisterCommand)(const wchar_t*,const wchar_t*); 
     137  typedef NSCAPI::errorReturn (*lpNSAPISettingsRegKey)(const wchar_t*, const wchar_t*, int, const wchar_t*, const wchar_t*, const wchar_t*, int); 
     138  typedef NSCAPI::errorReturn (*lpNSAPISettingsRegPath)(const wchar_t*, const wchar_t*, const wchar_t*, int); 
    136139  typedef NSCAPI::errorReturn (*lpNSAPIGetPluginList)(int *len, NSCAPI::plugin_info *list[]); 
    137140  typedef NSCAPI::errorReturn (*lpNSAPIReleasePluginList)(int len, NSCAPI::plugin_info *list[]); 
    … …  
    150153 
    151154  void Message(int msgType, std::wstring file, int line, std::wstring message); 
    152   NSCAPI::nagiosReturn InjectCommandRAW(const TCHAR* command, const unsigned int argLen, TCHAR **argument, TCHAR *returnMessageBuffer, unsigned int returnMessageBufferLen, TCHAR *returnPerfBuffer, unsigned int returnPerfBufferLen); 
    153   NSCAPI::nagiosReturn InjectCommand(const TCHAR* command, const unsigned int argLen, TCHAR **argument, std::wstring & message, std::wstring & perf); 
    154   NSCAPI::nagiosReturn InjectCommand(const TCHAR* command, std::list<std::wstring> argument, std::wstring & message, std::wstring & perf); 
    155   NSCAPI::nagiosReturn InjectSplitAndCommand(const TCHAR* command, TCHAR* buffer, TCHAR splitChar, std::wstring & message, std::wstring & perf); 
    156   NSCAPI::nagiosReturn InjectSplitAndCommand(const std::wstring command, const std::wstring buffer, TCHAR splitChar, std::wstring & message, std::wstring & perf, bool escape = false); 
     155  NSCAPI::nagiosReturn InjectCommandRAW(const wchar_t* command, const unsigned int argLen, wchar_t **argument, wchar_t *returnMessageBuffer, unsigned int returnMessageBufferLen, wchar_t *returnPerfBuffer, unsigned int returnPerfBufferLen); 
     156  NSCAPI::nagiosReturn InjectCommand(const wchar_t* command, const unsigned int argLen, wchar_t **argument, std::wstring & message, std::wstring & perf); 
     157  NSCAPI::nagiosReturn InjectCommand(const wchar_t* command, std::list<std::wstring> argument, std::wstring & message, std::wstring & perf); 
     158  NSCAPI::nagiosReturn InjectSplitAndCommand(const wchar_t* command, wchar_t* buffer, wchar_t splitChar, std::wstring & message, std::wstring & perf); 
     159  NSCAPI::nagiosReturn InjectSplitAndCommand(const std::wstring command, const std::wstring buffer, wchar_t splitChar, std::wstring & message, std::wstring & perf, bool escape = false); 
    157160  void StopService(void); 
    158161  void Exit(void); 
    … …  
    160163  bool logDebug(); 
    161164  bool checkLogMessages(int type); 
    162   std::wstring Encrypt(std::wstring str, unsigned int algorithm = NSCAPI::xor); 
    163   std::wstring Decrypt(std::wstring str, unsigned int algorithm = NSCAPI::xor); 
     165  std::wstring Encrypt(std::wstring str, unsigned int algorithm = NSCAPI::encryption_xor); 
     166  std::wstring Decrypt(std::wstring str, unsigned int algorithm = NSCAPI::encryption_xor); 
    164167  NSCAPI::errorReturn SetSettingsString(std::wstring section, std::wstring key, std::wstring value); 
    165168  NSCAPI::errorReturn SetSettingsInt(std::wstring section, std::wstring key, int value); 
    … …  
    175178}; 
    176179 
    177 namespace NSCModuleWrapper { 
    178   struct module_version { 
    179     int major; 
    180     int minor; 
    181     int revision; 
    182   }; 
    183  
    184   BOOL wrapDllMain(HANDLE hModule, DWORD ul_reason_for_call); 
    185   HINSTANCE getModule(); 
    186  
    187   int wrapModuleHelperInit(NSCModuleHelper::lpNSAPILoader f);; 
    188   NSCAPI::errorReturn wrapGetModuleName(TCHAR* buf, unsigned int buflen, std::wstring str); 
    189   NSCAPI::errorReturn wrapGetConfigurationMeta(TCHAR* buf, unsigned int buflen, std::wstring str); 
    190   int wrapLoadModule(bool success); 
    191   NSCAPI::errorReturn wrapGetModuleVersion(int *major, int *minor, int *revision, module_version version); 
    192   NSCAPI::boolReturn wrapHasCommandHandler(bool has); 
    193   NSCAPI::boolReturn wrapHasMessageHandler(bool has); 
    194   int wrapUnloadModule(bool success); 
    195   NSCAPI::nagiosReturn wrapHandleCommand(NSCAPI::nagiosReturn retResult, const std::wstring retMessage, const std::wstring retPerformance, TCHAR *returnBufferMessage, unsigned int returnBufferMessageLen, TCHAR *returnBufferPerf, unsigned int returnBufferPerfLen); 
    196 } 
    197  
    198 ////////////////////////////////////////////////////////////////////////// 
    199 // Module wrappers (definitions) 
    200 #define NSC_WRAPPERS_MAIN() \ 
    201   extern "C" int NSModuleHelperInit(NSCModuleHelper::lpNSAPILoader f); \ 
    202   extern int NSLoadModule(int mode); \ 
    203   extern int NSGetModuleName(TCHAR* buf, int buflen); \ 
    204   extern int NSGetModuleDescription(TCHAR* buf, int buflen); \ 
    205   extern int NSGetModuleVersion(int *major, int *minor, int *revision); \ 
    206   extern NSCAPI::boolReturn NSHasCommandHandler(); \ 
    207   extern NSCAPI::boolReturn NSHasMessageHandler(); \ 
    208   extern void NSHandleMessage(int msgType, TCHAR* file, int line, TCHAR* message); \ 
    209   extern NSCAPI::nagiosReturn NSHandleCommand(const TCHAR* IN_cmd, const unsigned int IN_argsLen, TCHAR **IN_args, \ 
    210     TCHAR *OUT_retBufMessage, unsigned int IN_retBufMessageLen, TCHAR *OUT_retBufPerf, unsigned int IN_retBufPerfLen); \ 
    211   extern int NSUnloadModule(); \ 
    212   extern int NSGetConfigurationMeta(int IN_retBufLen, TCHAR *OUT_retBuf) 
    213  
    214 #define NSC_WRAPPERS_CLI() \ 
    215   extern int NSCommandLineExec(const TCHAR*,const unsigned int,TCHAR**) 
    216  
    217 #ifdef DEBUG 
    218 #define NSC_LOG_ERROR_STD_C(msg) NSC_LOG_ERROR(((std::wstring)msg).c_str()) 
    219 #define NSC_LOG_ERROR_C(msg) { \ 
    220   NSCModuleHelper::Message(NSCAPI::error, _T(__FILE__), __LINE__, msg) \ 
    221   std::wcerr << msg << std::endl; } 
    222 #else 
    223 #define NSC_LOG_ERROR_STD_C(msg) NSC_LOG_ERROR_STD(msg) 
    224 #define NSC_LOG_ERROR_C(msg) NSC_LOG_ERROR(msg) 
    225 #endif 
    226  
    227  
    228 #define NSC_LOG_ERROR_STD(msg) NSC_LOG_ERROR(((std::wstring)msg).c_str()) 
    229 #define NSC_LOG_ERROR(msg) \ 
    230   NSCModuleHelper::Message(NSCAPI::error, _T(__FILE__), __LINE__, msg) 
    231  
    232 #define NSC_LOG_CRITICAL_STD(msg) NSC_LOG_CRITICAL(((std::wstring)msg).c_str()) 
    233 #define NSC_LOG_CRITICAL(msg) \ 
    234   NSCModuleHelper::Message(NSCAPI::critical, _T(__FILE__), __LINE__, msg) 
    235  
    236 #define NSC_LOG_MESSAGE_STD(msg) NSC_LOG_MESSAGE(((std::wstring)msg).c_str()) 
    237 #define NSC_LOG_MESSAGE(msg) \ 
    238   NSCModuleHelper::Message(NSCAPI::log, _T(__FILE__), __LINE__, msg) 
    239  
    240 //#define NSC_DEBUG_MSG_STD(msg) NSC_DEBUG_MSG(((std::wstring)msg).c_str()) 
    241 #define NSC_DEBUG_MSG_STD(msg) NSC_DEBUG_MSG((std::wstring)msg) 
    242 #define NSC_DEBUG_MSG(msg) \ 
    243   NSCModuleHelper::Message(NSCAPI::debug, _T(__FILE__), __LINE__, msg) 
    244  
    245 /* 
    246 #define NSC_DEBUG_MSG_STD(msg) 
    247 #define NSC_DEBUG_MSG(msg) 
    248 */ 
    249 ////////////////////////////////////////////////////////////////////////// 
    250 // Message wrappers below this point 
    251  
    252 #define NSC_WRAPPERS_MAIN_DEF(toObject) \ 
    253   extern int NSModuleHelperInit(NSCModuleHelper::lpNSAPILoader f) { \ 
    254     try { \ 
    255       return NSCModuleWrapper::wrapModuleHelperInit(f); \ 
    256     } catch (...) { \ 
    257       NSC_LOG_CRITICAL(_T("Unknown exception in: wrapModuleHelperInit(...)")); \ 
    258       return NSCAPI::hasFailed; \ 
    259     } \ 
    260   } \ 
    261   extern int NSLoadModule(int mode) { \ 
    262     try { \ 
    263       return NSCModuleWrapper::wrapLoadModule(toObject.loadModule(mode)); \ 
    264     } catch (NSCModuleHelper::NSCMHExcpetion e) { \ 
    265       NSC_LOG_CRITICAL(_T("NSCMHE in: wrapLoadModule: " + e.msg_)); \ 
    266       return NSCAPI::hasFailed; \ 
    267     } catch (...) { \ 
    268       NSC_LOG_CRITICAL(_T("Unknown exception in: wrapLoadModule(...)")); \ 
    269       return NSCAPI::hasFailed; \ 
    270     } \ 
    271   } \ 
    272   extern int NSGetModuleName(TCHAR* buf, int buflen) { \ 
    273     try { \ 
    274       return NSCModuleWrapper::wrapGetModuleName(buf, buflen, toObject.getModuleName()); \ 
    275     } catch (...) { \ 
    276       NSC_LOG_CRITICAL(_T("Unknown exception in: wrapGetModuleName(...)")); \ 
    277       return NSCAPI::hasFailed; \ 
    278     } \ 
    279   } \ 
    280   extern int NSGetModuleDescription(TCHAR* buf, int buflen) { \ 
    281     try { \ 
    282       return NSCModuleWrapper::wrapGetModuleName(buf, buflen, toObject.getModuleDescription()); \ 
    283     } catch (...) { \ 
    284       NSC_LOG_CRITICAL(_T("Unknown exception in: wrapGetModuleName(...)")); \ 
    285       return NSCAPI::hasFailed; \ 
    286     } \ 
    287   } \ 
    288   extern int NSGetModuleVersion(int *major, int *minor, int *revision) { \ 
    289     try { \ 
    290       return NSCModuleWrapper::wrapGetModuleVersion(major, minor, revision, toObject.getModuleVersion()); \ 
    291     } catch (...) { \ 
    292       NSC_LOG_CRITICAL(_T("Unknown exception in: wrapGetModuleVersion(...)")); \ 
    293       return NSCAPI::hasFailed; \ 
    294     } \ 
    295   } \ 
    296   extern int NSUnloadModule() { \ 
    297     try { \ 
    298       return NSCModuleWrapper::wrapUnloadModule(toObject.unloadModule()); \ 
    299     } catch (...) { \ 
    300       NSC_LOG_CRITICAL(_T("Unknown exception in: wrapGetModuleVersion(...)")); \ 
    301       return NSCAPI::hasFailed; \ 
    302     } \ 
    303   } 
    304 #define NSC_WRAPPERS_HANDLE_MSG_DEF(toObject) \ 
    305   extern void NSHandleMessage(int msgType, TCHAR* file, int line, TCHAR* message) { \ 
    306     try { \ 
    307       toObject.handleMessage(msgType, file, line, message); \ 
    308     } catch (...) { \ 
    309       NSC_LOG_CRITICAL(_T("Unknown exception in: handleMessage(...)")); \ 
    310     } \ 
    311   } \ 
    312   extern NSCAPI::boolReturn NSHasMessageHandler() { \ 
    313     try { \ 
    314       return NSCModuleWrapper::wrapHasMessageHandler(toObject.hasMessageHandler()); \ 
    315     } catch (...) { \ 
    316       NSC_LOG_CRITICAL(_T("Unknown exception in: wrapHasMessageHandler(...)")); \ 
    317       return NSCAPI::isfalse; \ 
    318     } \ 
    319   } 
    320 #define NSC_WRAPPERS_IGNORE_MSG_DEF() \ 
    321   extern void NSHandleMessage(int msgType, TCHAR* file, int line, TCHAR* message) {} \ 
    322   extern NSCAPI::boolReturn NSHasMessageHandler() { return NSCAPI::isfalse; } 
    323 #define NSC_WRAPPERS_HANDLE_CMD_DEF(toObject) \ 
    324   extern NSCAPI::nagiosReturn NSHandleCommand(const TCHAR* IN_cmd, const unsigned int IN_argsLen, TCHAR **IN_args, \ 
    325                   TCHAR *OUT_retBufMessage, unsigned int IN_retBufMessageLen, TCHAR *OUT_retBufPerf, unsigned int IN_retBufPerfLen) \ 
    326   { \ 
    327     try { \ 
    328       std::wstring message, perf; \ 
    329       NSCAPI::nagiosReturn retCode = toObject.handleCommand(IN_cmd, IN_argsLen, IN_args, message, perf); \ 
    330       return NSCModuleWrapper::wrapHandleCommand(retCode, message, perf, OUT_retBufMessage, IN_retBufMessageLen, OUT_retBufPerf, IN_retBufPerfLen); \ 
    331     } catch (...) { \ 
    332       NSC_LOG_CRITICAL(_T("Unknown exception in: wrapHandleCommand(...)")); \ 
    333       return NSCAPI::returnIgnored; \ 
    334     } \ 
    335   } \ 
    336   extern NSCAPI::boolReturn NSHasCommandHandler() { \ 
    337     try { \ 
    338       return NSCModuleWrapper::wrapHasCommandHandler(toObject.hasCommandHandler()); \ 
    339     } catch (...) { \ 
    340       NSC_LOG_CRITICAL(_T("Unknown exception in: wrapHasCommandHandler(...)")); \ 
    341       return NSCAPI::isfalse; \ 
    342     } \ 
    343   } 
    344 #define NSC_WRAPPERS_IGNORE_CMD_DEF() \ 
    345   extern NSCAPI::nagiosReturn NSHandleCommand(const TCHAR* IN_cmd, const unsigned int IN_argsLen, TCHAR **IN_args, \ 
    346                   TCHAR *OUT_retBufMessage, unsigned int IN_retBufMessageLen, TCHAR *OUT_retBufPerf, unsigned int IN_retBufPerfLen) { \ 
    347     return NSCAPI::returnIgnored; \ 
    348   } \ 
    349   extern NSCAPI::boolReturn NSHasCommandHandler() { return NSCAPI::isfalse; } 
    350  
    351  
    352 #define NSC_WRAPPERS_HANDLE_CONFIGURATION(toObject) \ 
    353   extern int NSGetConfigurationMeta(int IN_retBufLen, TCHAR *OUT_retBuf) \ 
    354   { \ 
    355     try { \ 
    356       return NSCModuleWrapper::wrapGetConfigurationMeta(OUT_retBuf, IN_retBufLen, toObject.getConfigurationMeta()); \ 
    357     } catch (...) { \ 
    358       NSC_LOG_CRITICAL(_T("Unknown exception in: wrapGetConfigurationMeta(...)")); \ 
    359       return NSCAPI::hasFailed; \ 
    360     } \ 
    361   } 
    362  
    363 #define NSC_WRAPPERS_CLI_DEF(toObject) \ 
    364   extern int NSCommandLineExec(const TCHAR* command,const unsigned int argLen,TCHAR** args) { \ 
    365     try { \ 
    366       return toObject.commandLineExec(command, argLen, args); \ 
    367     } catch (...) { \ 
    368       NSC_LOG_CRITICAL(_T("Unknown exception in: commandLineExec(...)")); \ 
    369       std::wcerr << _T("Unknown exception in: commandLineExec(...)") << std::endl; \ 
    370       return NSCAPI::hasFailed; \ 
    371     } \ 
    372   } \ 
    373  
    374 ////////////////////////////////////////////////////////////////////////// 
    375 #define MODULE_SETTINGS_START(class, name, description) \ 
    376   std::wstring class::getConfigurationMeta() { \ 
    377   return (std::wstring)_T("<module name=\"") + name + _T("\" description=\"") + description + _T("\">") \ 
    378   _T("<pages>") 
    379  
    380  
    381 #define ADVANCED_PAGE(title) \ 
    382   _T("<page title=\"") title _T("\" advanced=\"true\">") \ 
    383   _T("<items>") 
    384  
    385 #define PAGE(title) \ 
    386   _T("<page title=\"") title _T("\">") \ 
    387   _T("<items>") 
    388  
    389 #define ITEM_EDIT_TEXT(caption, description) \ 
    390   _T("<item type=\"text\" caption=\"") caption _T("\" description=\"") description _T("\"><options>") 
    391  
    392 #define ITEM_EDIT_OPTIONAL_LIST(caption, description) \ 
    393   _T("<item type=\"optional_list\" caption=\"") caption _T("\" description=\"") description _T("\"><options>") 
    394  
    395 #define ITEM_CHECK_BOOL(caption, description) \ 
    396   _T("<item type=\"bool\" caption=\"") caption _T("\" description=\"") description _T("\"><options>") 
    397  
    398 #define ITEM_MAP_TO(type) \ 
    399   _T("</options><mapper type=\"") type _T("\">") \ 
    400   _T("<options>") 
    401  
    402 #define OPTION(key, value) \ 
    403   _T("<option key=\"") key _T("\" value=\"") value _T("\"/>") 
    404  
    405 #define ITEM_END() \ 
    406   _T("</options>") \ 
    407   _T("</mapper>") \ 
    408   _T("</item>") 
    409  
    410 #define PAGE_END() \ 
    411   _T("</items>") \ 
    412   _T("</page>") 
    413  
    414 #define MODULE_SETTINGS_END() \ 
    415       _T("</pages>") \ 
    416     _T("</module>"); \ 
    417   } 
    418180 
    419181#define SETTINGS_MAKE_NAME(key) \ 
    … …  
    437199  NSCModuleHelper::settings_register_key(setting_keys::key ## _PATH, setting_keys::key, NSCAPI::key_string, setting_keys::key ## _TITLE, setting_keys::key ## _DESC, setting_keys::key ## _DEFAULT, setting_keys::key ## _ADVANCED); 
    438200#define SETTINGS_REG_KEY_I(key) \ 
    439   NSCModuleHelper::settings_register_key(setting_keys::key ## _PATH, setting_keys::key, NSCAPI::key_integer, setting_keys::key ## _TITLE, setting_keys::key ## _DESC, strEx::itos(setting_keys::key ## _DEFAULT), setting_keys::key ## _ADVANCED); 
     201  NSCModuleHelper::settings_register_key(setting_keys::key ## _PATH, setting_keys::key, NSCAPI::key_integer, setting_keys::key ## _TITLE, setting_keys::key ## _DESC, boost::lexical_cast<std::wstring>(setting_keys::key ## _DEFAULT), setting_keys::key ## _ADVANCED); 
    440202#define SETTINGS_REG_KEY_B(key) \ 
    441203  NSCModuleHelper::settings_register_key(setting_keys::key ## _PATH, setting_keys::key, NSCAPI::key_integer, setting_keys::key ## _TITLE, setting_keys::key ## _DESC, setting_keys::key ## _DEFAULT==1?_T("1"):_T("0"), setting_keys::key ## _ADVANCED); 

  • include/NTService.h

    r739db5a r7f9c823  
    2424#include <sysinfo.h> 
    2525 
    26 namespace service_helper { 
     26namespace service_helper_impl { 
    2727  class service_exception { 
    2828    std::wstring what_; 

  • include/arrayBuffer.cpp

    r739db5a r7f9c823  
    2828 * @return Argument wrapped as a list 
    2929 */ 
    30 arrayBuffer::arrayList arrayBuffer::arrayBuffer2list(const unsigned int argLen, TCHAR *argument[]) { 
     30arrayBuffer::arrayList arrayBuffer::arrayBuffer2list(const unsigned int argLen, wchar_t *argument[]) { 
    3131  arrayList ret; 
    3232  int i=0; 
    … …  
    5353  for (i=0;it!=lst.end();++it,i++) { 
    5454    std::wstring::size_type alen = (*it).size(); 
    55     arrayBuffer[i] = new TCHAR[alen+2]; 
     55    arrayBuffer[i] = new wchar_t[alen+2]; 
    5656    wcsncpy_s(arrayBuffer[i], alen+2, (*it).c_str(), alen+1); 
    5757  } 
    … …  
    107107* @return The arrayBuffer 
    108108*/ 
    109 arrayBuffer::arrayBuffer arrayBuffer::split2arrayBuffer(const TCHAR* buffer, TCHAR splitChar, unsigned int &argLen) { 
     109arrayBuffer::arrayBuffer arrayBuffer::split2arrayBuffer(const wchar_t* buffer, wchar_t splitChar, unsigned int &argLen) { 
    110110  if (!buffer) 
    111111    throw ArrayBufferException(_T("Invalid buffer specified!")); 
    112112  argLen = 0; 
    113   const TCHAR *p = buffer; 
     113  const wchar_t *p = buffer; 
    114114  if (!p[0]) { 
    115115    return createEmptyArrayBuffer(argLen); 
    … …  
    121121  } 
    122122  argLen++; 
    123   TCHAR **arrayBuffer = new TCHAR*[argLen]; 
     123  wchar_t **arrayBuffer = new wchar_t*[argLen]; 
    124124  p = buffer; 
    125125  for (unsigned int i=0;i<argLen;i++) { 
    126     const TCHAR *q = wcschr(p, (i<argLen-1)?splitChar:0); 
     126    const wchar_t *q = wcschr(p, (i<argLen-1)?splitChar:0); 
    127127    unsigned int len = static_cast<int>(q-p); 
    128     arrayBuffer[i] = new TCHAR[len+1]; 
     128    arrayBuffer[i] = new wchar_t[len+1]; 
    129129    wcsncpy_s(arrayBuffer[i], len+1, p, len); 
    130130    arrayBuffer[i][len] = 0; 
    … …  
    140140  delete [] arrayBuffer[position]; 
    141141  size_t len = argument.length(); 
    142   arrayBuffer[position] = new TCHAR[len+2]; 
     142  arrayBuffer[position] = new wchar_t[len+2]; 
    143143  wcsncpy_s(arrayBuffer[position], len+1, argument.c_str(), len); 
    144144  arrayBuffer[position][len] = 0; 
    … …  
    153153 * @return The arrayBuffer 
    154154 */ 
    155 arrayBuffer::arrayBuffer arrayBuffer::split2arrayBuffer(const std::wstring inBuf, TCHAR splitChar, unsigned int &argLen, bool escape) { 
     155arrayBuffer::arrayBuffer arrayBuffer::split2arrayBuffer(const std::wstring inBuf, wchar_t splitChar, unsigned int &argLen, bool escape) { 
    156156  if (inBuf.empty()) 
    157157    return createEmptyArrayBuffer(argLen); 
    … …  
    197197  for (std::list<std::wstring>::const_iterator cit=token_list.begin();cit!=token_list.end();++cit) { 
    198198    size_t len = (*cit).size(); 
    199     TCHAR* token = new TCHAR[len+1]; 
     199    wchar_t* token = new wchar_t[len+1]; 
    200200    wcsncpy_s(token, len+1, (*cit).c_str(), len); 
    201201    arrayBuffer[argLen++] = token; 
    … …  
    289289  std::wcout << "arrayBuffer::test_createEmptyArrayBuffer() : "; 
    290290  unsigned int argLen; 
    291   TCHAR ** c = createEmptyArrayBuffer(argLen); 
     291  wchar_t ** c = createEmptyArrayBuffer(argLen); 
    292292  if ((c) && (argLen == 0)) 
    293293    std::wcout << "Succeeded" << std::endl; 
    … …  
    302302 * @param OUT_argLen  
    303303 */ 
    304 void arrayBuffer::test_split2arrayBuffer_str(std::wstring buffer, TCHAR splitter, int OUT_argLen) { 
     304void arrayBuffer::test_split2arrayBuffer_str(std::wstring buffer, wchar_t splitter, int OUT_argLen) { 
    305305  std::wcout << _T("arrayBuffer::test_split2arrayBuffer(") << buffer << _T(", ...) : "); 
    306306  unsigned int argLen = 0; 
    307   TCHAR ** c = split2arrayBuffer(buffer, splitter, argLen); 
     307  wchar_t ** c = split2arrayBuffer(buffer, splitter, argLen); 
    308308  if ((c) && (argLen == OUT_argLen)) 
    309309    std::wcout << _T("Succeeded") << std::endl; 
    … …  
    318318 * @param OUT_argLen  
    319319 */ 
    320 void arrayBuffer::test_split2arrayBuffer_char(TCHAR* buffer, TCHAR splitter, int OUT_argLen) { 
     320void arrayBuffer::test_split2arrayBuffer_char(wchar_t* buffer, wchar_t splitter, int OUT_argLen) { 
    321321  std::wcout << _T("arrayBuffer::test_split2arrayBuffer(") << buffer << _T(", ...) : "); 
    322322  unsigned int argLen = 0; 
    323   TCHAR ** c = split2arrayBuffer(buffer, splitter, argLen); 
     323  wchar_t ** c = split2arrayBuffer(buffer, splitter, argLen); 
    324324  if ((c) && (argLen == OUT_argLen)) 
    325325    std::wcout << _T("Succeeded") << std::endl; 

  • include/arrayBuffer.h

    r739db5a r7f9c823  
    2020***************************************************************************/ 
    2121#pragma once 
    22  
    23 #include <tchar.h> 
     22#include <unicode_char.hpp> 
    2423#include <string> 
    2524#include <list> 
    … …  
    5453    ArrayBufferException(std::wstring error) {} 
    5554  }; 
    56   typedef TCHAR* arrayBufferItem; 
     55  typedef wchar_t* arrayBufferItem; 
    5756  typedef arrayBufferItem* arrayBuffer; 
    5857  typedef std::list<std::wstring> arrayList; 
    5958  void set(arrayBuffer arrayBuffer, const unsigned int argLen, const unsigned int position, std::wstring argument); 
    60   arrayList arrayBuffer2list(const unsigned int argLen, TCHAR **argument); 
     59  arrayList arrayBuffer2list(const unsigned int argLen, wchar_t **argument); 
    6160  arrayBuffer list2arrayBuffer(const arrayList lst, unsigned int &argLen); 
    62   arrayBuffer split2arrayBuffer(const TCHAR* buffer, TCHAR splitChar, unsigned int &argLen); 
    63   arrayBuffer split2arrayBuffer(const std::wstring inBuf, TCHAR splitChar, unsigned int &argLen, bool escape = false); 
    64   std::wstring arrayBuffer2string(TCHAR **argument, const unsigned int argLen, std::wstring join); 
     61  arrayBuffer split2arrayBuffer(const wchar_t* buffer, wchar_t splitChar, unsigned int &argLen); 
     62  arrayBuffer split2arrayBuffer(const std::wstring inBuf, wchar_t splitChar, unsigned int &argLen, bool escape = false); 
     63  std::wstring arrayBuffer2string(wchar_t **argument, const unsigned int argLen, std::wstring join); 
    6564  arrayBuffer createEmptyArrayBuffer(unsigned int &argLen); 
    6665  arrayBuffer createArrayBuffer(unsigned int &argLen); 
    … …  
    7069    for (unsigned int i=0; i<argLen; i++) { 
    7170      size_t s = wcslen(other[i]); 
    72       ret[i] = new TCHAR[s+2]; 
     71      ret[i] = new wchar_t[s+2]; 
    7372      wcsncpy_s(ret[i], s+2, other[i], s); 
    7473    } 
    … …  
    7877#ifdef _DEBUG 
    7978  void test_createEmptyArrayBuffer(); 
    80   void test_split2arrayBuffer_str(std::wstring buffer, TCHAR splitter, int OUT_argLen); 
    81   void test_split2arrayBuffer_char(TCHAR* buffer, TCHAR splitter, int OUT_argLen); 
     79  void test_split2arrayBuffer_str(std::wstring buffer, wchar_t splitter, int OUT_argLen); 
     80  void test_split2arrayBuffer_char(wchar_t* buffer, wchar_t splitter, int OUT_argLen); 
    8281  void run_testArrayBuffer(); 
    8382#endif 

  • include/charEx.h

    r739db5a r7f9c823  
    2020***************************************************************************/ 
    2121#pragma once 
     22#ifdef WIN32 
    2223#include <windows.h> 
    2324#include <tchar.h> 
     25#endif 
    2426 
    2527namespace charEx { 
    … …  
    3032   * @return a list with strings 
    3133   */ 
    32   inline std::list<std::wstring> split(const TCHAR* buffer, TCHAR split) { 
     34  inline std::list<std::wstring> split(const wchar_t* buffer, wchar_t split) { 
    3335    std::list<std::wstring> ret; 
    34     const TCHAR *start = buffer; 
    35     for (const TCHAR *p = buffer;*p!='\0';p++) { 
     36    const wchar_t *start = buffer; 
     37    for (const wchar_t *p = buffer;*p!='\0';p++) { 
    3638      if (*p==split) { 
    3739        std::wstring str(start, p-start); 
    … …  
    4446  } 
    4547 
    46  
     48/* 
    4749  inline char* tchar_to_char( const wchar_t* pStr, int len, int &nChars) { 
    4850    if (pStr == NULL) 
    … …  
    7880      --nChars; 
    7981    if (nChars == 0) { 
    80       TCHAR *ret = new TCHAR[1]; 
     82      wchar_t *ret = new wchar_t[1]; 
    8183      ret[0] = 0; 
    8284      return ret; 
    … …  
    8486 
    8587    // convert the narrow string to a wide string  
    86     TCHAR *ret = new TCHAR[nChars+1]; 
     88    wchar_t *ret = new wchar_t[nChars+1]; 
    8789    MultiByteToWideChar(CP_ACP, 0 ,pStr ,len, const_cast<wchar_t*>(ret), nChars); 
    8890    return ret; 
    8991  } 
     92*/ 
    9093 
    9194 
    92  
    93   typedef std::pair<std::wstring,TCHAR*> token; 
    94   inline token getToken(TCHAR *buffer, TCHAR split) { 
     95  typedef std::pair<std::wstring,wchar_t*> token; 
     96  inline token getToken(wchar_t *buffer, wchar_t split) { 
    9597    if (buffer == NULL) 
    9698      throw std::exception(); 
    97     TCHAR *p = wcschr(buffer, split); 
     99    wchar_t *p = wcschr(buffer, split); 
    98100    if (!p) 
    99101      return token(buffer, NULL); 
    … …  
    104106  } 
    105107#ifdef _DEBUG 
    106   inline void test_getToken(TCHAR* in1, TCHAR in2, std::wstring out1, TCHAR * out2) { 
     108  inline void test_getToken(wchar_t* in1, wchar_t in2, std::wstring out1, wchar_t * out2) { 
    107109    token t = getToken(in1, in2); 
    108110    std::wcout << _T("charEx::test_getToken(") << in1 << _T(", ") << in2 << _T(") : "); 

  • include/checkHelpers.hpp

    rb1ac2fa r7f9c823  
    277277    } 
    278278    static std::wstring print(__int64 value) { 
    279       return strEx::itos(value); 
     279      return boost::lexical_cast<std::wstring>(value); 
    280280    } 
    281281    static std::wstring get_perf_unit(__int64 value) { 
    … …  
    283283    } 
    284284    static std::wstring print_perf(__int64 value, std::wstring unit) { 
    285       return strEx::itos(value); 
     285      return boost::lexical_cast<std::wstring>(value); 
    286286    } 
    287287    static std::wstring print_unformated(__int64 value) { 
    288       return strEx::itos(value); 
     288      return boost::lexical_cast<std::wstring>(value); 
    289289    } 
    290290    static std::wstring print_percent(__int64 value) { 
    291       return strEx::itos(value) + _T("%"); 
     291      return boost::lexical_cast<std::wstring>(value) + _T("%"); 
    292292    } 
    293293    static std::wstring key_prefix() { 

  • include/config.h

    rd5356c1 r7f9c823  
    2222 
    2323#include "../AutoBuild.h" 
     24/* 
    2425#include <tchar.h>  
     26*/ 
    2527#include <string> 
    2628#include <settings/macros.h> 
    … …  
    197199#define LUA_SCRIPT_SECTION_TITLE _T("LUA Scripts") 
    198200*/ 
    199  
    200 // Main Registry ROOT 
    201 #define NS_HKEY_ROOT HKEY_LOCAL_MACHINE 
    202 #define NS_REG_ROOT _T("SOFTWARE\\NSClient++") 

  • include/error.hpp

    rdcd5462 r7f9c823  
    11#pragma once 
    2 #include <tchar.h> 
     2#include <unicode_char.hpp> 
    33#include <string> 
    4 #include <windows.h> 
    54#include <strEx.h> 
    65#include <vector> 
    76 
    8 namespace error { 
    9   class format { 
    10   public: 
    11     static std::wstring from_system(unsigned long dwError) { 
    12       LPVOID lpMsgBuf = NULL; 
    13       unsigned long dwRet = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,NULL,dwError,MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),(LPTSTR)&lpMsgBuf,0,NULL); 
    14       if (dwRet == 0) { 
    15         return _T("failed to lookup error code: ") + strEx::itos(dwError) + _T("( reson: ") + strEx::itos(GetLastError()) + _T(")"); 
    16       } 
    17       TCHAR *szBuf = new TCHAR[dwRet + 100]; 
    18       wsprintf(szBuf, _T("%d: %s"), dwError, lpMsgBuf);  
    19       std::wstring str = szBuf; 
    20       delete [] szBuf; 
    21       LocalFree(lpMsgBuf); 
    22       return str; 
    23     } 
    24     static std::wstring from_module(std::wstring module, unsigned long dwError) { 
    25       LPVOID lpMsgBuf; 
    26       unsigned long dwRet = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_HMODULE|FORMAT_MESSAGE_IGNORE_INSERTS, 
    27         GetModuleHandle(module.c_str()),dwError,MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),(LPTSTR)&lpMsgBuf,0,NULL); 
    28       if (dwRet == 0) { 
    29         return _T("failed to lookup error code: ") + strEx::itos(dwError) + _T("( reson: ") + strEx::itos(GetLastError()) + _T(")"); 
    30       } 
    31       TCHAR *szBuf = new TCHAR[dwRet + 100]; 
    32       wsprintf(szBuf, _T("%d: %s"), dwError, lpMsgBuf);  
    33       std::wstring str = szBuf; 
    34       delete [] szBuf; 
    35       LocalFree(lpMsgBuf); 
    36       return str; 
    37     } 
    38     static std::wstring from_module(std::wstring module, unsigned long dwError, DWORD *arguments) { 
    39       LPVOID lpMsgBuf; 
    40       HMODULE hevt = LoadLibraryEx(module.c_str(), NULL, DONT_RESOLVE_DLL_REFERENCES); 
    41       if (hevt == NULL) { 
    42         return _T("failed to load: ") + module + _T("( reson: ") + strEx::itos(GetLastError()) + _T(")"); 
    43       } 
    44       unsigned long dwRet = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_HMODULE|FORMAT_MESSAGE_ARGUMENT_ARRAY,hevt, 
    45         dwError,MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),(LPTSTR)&lpMsgBuf,0,reinterpret_cast<va_list*>(arguments)); 
    46       if (dwRet == 0) { 
    47         FreeLibrary(hevt); 
    48         return _T("failed to lookup error code: ") + strEx::itos(dwError) + _T(" from DLL: ") + module + _T("( reson: ") + strEx::itos(GetLastError()) + _T(")"); 
    49       } 
    50       TCHAR *szBuf = new TCHAR[dwRet + 100]; 
    51       wsprintf(szBuf, _T("%d: %s"), dwError, lpMsgBuf);  
    52       std::wstring str = szBuf; 
    53       delete [] szBuf; 
    54       LocalFree(lpMsgBuf); 
    55       FreeLibrary(hevt); 
    56       return str; 
    57     } 
    58     class message { 
    59     public: 
    60       static std::wstring from_module(std::wstring module, unsigned long dwError) { 
    61         HMODULE hDLL = LoadLibraryEx(module.c_str(), NULL, DONT_RESOLVE_DLL_REFERENCES); 
    62         if (hDLL == NULL) { 
    63           return _T("failed to load: ") + module + _T("( reson: ") + strEx::itos(GetLastError()) + _T(")"); 
    64         } 
    65         LPVOID lpMsgBuf; 
    66         unsigned long dwRet = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_HMODULE|FORMAT_MESSAGE_IGNORE_INSERTS,hDLL, 
    67           dwError,MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),(LPTSTR)&lpMsgBuf,0,NULL); 
    68         if (dwRet == 0) { 
    69           FreeLibrary(hDLL); 
    70           DWORD err = GetLastError(); 
    71           if (err == 317) { 
    72             return _T(""); 
    73           } 
    74           return _T("failed to lookup error code: ") + strEx::itos(dwError) + _T(" from DLL: ") + module + _T("( reson: ") + strEx::itos(err) + _T(")"); 
    75         } 
    76         std::wstring str = reinterpret_cast<TCHAR*>(lpMsgBuf); 
    77         LocalFree(lpMsgBuf); 
    78         FreeLibrary(hDLL); 
    79         return str; 
    80       } 
    81  
    82       static std::wstring from_module_x64(std::wstring module, unsigned long dwError, TCHAR* argList[], DWORD argCount) { 
    83         if (argCount == 0) 
    84           return from_module_wrapper(module, dwError); 
    85         if (argCount == 1) 
    86           return from_module_wrapper(module, dwError, argList[0]); 
    87         if (argCount == 2) 
    88           return from_module_wrapper(module, dwError, argList[0], argList[1]); 
    89         if (argCount == 3) 
    90           return from_module_wrapper(module, dwError, argList[0], argList[1], argList[2]); 
    91         if (argCount == 4) 
    92           return from_module_wrapper(module, dwError, argList[0], argList[1], argList[2], argList[3]); 
    93         if (argCount == 5) 
    94           return from_module_wrapper(module, dwError, argList[0], argList[1], argList[2], argList[3], argList[4]); 
    95         if (argCount == 6) 
    96           return from_module_wrapper(module, dwError, argList[0], argList[1], argList[2], argList[3], argList[4], argList[5]); 
    97         if (argCount == 7) 
    98           return from_module_wrapper(module, dwError, argList[0], argList[1], argList[2], argList[3], argList[4], argList[5], argList[6]); 
    99         if (argCount == 8) 
    100           return from_module_wrapper(module, dwError, argList[0], argList[1], argList[2], argList[3], argList[4], argList[5], argList[6], argList[7]); 
    101         if (argCount == 9) 
    102           return from_module_wrapper(module, dwError, argList[0], argList[1], argList[2], argList[3], argList[4], argList[5], argList[6], argList[7], argList[8]); 
    103         if (argCount == 10) 
    104           return from_module_wrapper(module, dwError, argList[0], argList[1], argList[2], argList[3], argList[4], argList[5], argList[6], argList[7], argList[8], argList[9]); 
    105         if (argCount == 11) 
    106           return from_module_wrapper(module, dwError, argList[0], argList[1], argList[2], argList[3], argList[4], argList[5], argList[6], argList[7], argList[8], argList[9], argList[10]); 
    107         return _T("We cant handle ") + strEx::itos(argCount) + _T(" arguments so you wont get argList here"); 
    108       } 
    109     private: 
    110  
    111       static std::wstring from_module_wrapper(std::wstring module, unsigned long dwError, ...) { 
    112         va_list Ellipsis; 
    113         va_start(Ellipsis, dwError); 
    114         std::wstring ret = __from_module(module, dwError, &Ellipsis); 
    115         va_end(Ellipsis); 
    116         return ret; 
    117       } 
    118  
    119       static std::wstring __from_module(std::wstring module, unsigned long dwError, va_list *arguments) { 
    120         HMODULE hDLL = LoadLibraryEx(module.c_str(), NULL, DONT_RESOLVE_DLL_REFERENCES); 
    121         if (hDLL == NULL) { 
    122           return _T("failed to load: ") + module + _T("( reson: ") + strEx::itos(GetLastError()) + _T(")"); 
    123         } 
    124         LPVOID lpMsgBuf; 
    125  
    126         //unsigned long dwRet = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_HMODULE|FORMAT_MESSAGE_ARGUMENT_ARRAY,hDLL, 
    127         //  dwError,MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),(LPTSTR)&lpMsgBuf,0,reinterpret_cast<va_list*>(arguments)); 
    128         unsigned long dwRet = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_HMODULE,hDLL, 
    129           dwError,MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),(LPTSTR)&lpMsgBuf,0,reinterpret_cast<va_list*>(arguments)); 
    130         if (dwRet == 0) { 
    131           FreeLibrary(hDLL); 
    132           DWORD err = GetLastError(); 
    133           if (err == 317) { 
    134             return _T(""); 
    135           } 
    136           return _T("failed to lookup error code: ") + strEx::itos(dwError) + _T(" from DLL: ") + module + _T("( reson: ") + strEx::itos(err) + _T(")"); 
    137         } 
    138         std::wstring str = reinterpret_cast<TCHAR*>(lpMsgBuf); 
    139         LocalFree(lpMsgBuf); 
    140         FreeLibrary(hDLL); 
    141         return str; 
    142       } 
    143     public: 
    144       static std::wstring from_system(unsigned long dwError, DWORD *arguments) { 
    145         LPVOID lpMsgBuf; 
    146         unsigned long dwRet = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_ARGUMENT_ARRAY,NULL, 
    147           dwError,MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),(LPTSTR)&lpMsgBuf,0,reinterpret_cast<va_list*>(arguments)); 
    148         if (dwRet == 0) { 
    149           DWORD err = GetLastError(); 
    150           if (err == 317) { 
    151             return _T(""); 
    152           } 
    153           return _T("failed to lookup error code: ") + strEx::itos(dwError) + _T(" from system ( reson: ") + strEx::itos(err) + _T(")"); 
    154         } 
    155         std::wstring str = reinterpret_cast<TCHAR*>(lpMsgBuf); 
    156         LocalFree(lpMsgBuf); 
    157         return str; 
    158       } 
    159     }; 
    160   }; 
    161   class lookup { 
    162   public: 
    163     static std::wstring last_error(unsigned long dwLastError = -1) { 
    164       if (dwLastError == -1) { 
    165         dwLastError = GetLastError(); 
    166       } 
    167       return ::error::format::from_system(dwLastError); 
    168     } 
    169     static std::string last_error_ansi(unsigned long dwLastError = -1) { 
    170       if (dwLastError == -1) { 
    171         dwLastError = GetLastError(); 
    172       } 
    173       return strEx::wstring_to_string(::error::format::from_system(dwLastError)); 
    174     } 
    175   }; 
    176 } 
     7#ifdef WIN32 
     8#include <error_impl_w32.hpp> 
     9#else 
     10#include <error_impl_unix.hpp> 
     11#endif 

  • include/nrpe/nrpepacket.hpp

    r739db5a r7f9c823  
    148148  unsigned int getBufferLength() const { return getBufferLength(buffer_length_); } 
    149149  static unsigned int getBufferLength(unsigned int buffer_length) { return sizeof(packet)+buffer_length*sizeof(char); } 
     150  unsigned int getInternalBufferLength() const { return buffer_length_; } 
    150151 
    151152 

  • include/settings/macros.h

    rd5356c1 r7f9c823  
    11#pragma once 
    22 
    3  
     3#include <unicode_char.hpp> 
    44 
    55#define DEFINE_SETTING_S(name, path, key, value) \ 
    … …  
    3939  setting_keys::key ## _PATH, setting_keys::key, type, setting_keys::key ## _TITLE, setting_keys::key ## _DESC, setting_keys::key ## _DEFAULT, setting_keys::key ## _ADVANCED 
    4040#define SETTINGS_REG_KEY_I_GEN(key, type) \ 
    41   setting_keys::key ## _PATH, setting_keys::key, type, setting_keys::key ## _TITLE, setting_keys::key ## _DESC, strEx::itos(setting_keys::key ## _DEFAULT), setting_keys::key ## _ADVANCED 
     41  setting_keys::key ## _PATH, setting_keys::key, type, setting_keys::key ## _TITLE, setting_keys::key ## _DESC, boost::lexical_cast<std::wstring>(setting_keys::key ## _DEFAULT), setting_keys::key ## _ADVANCED 
    4242#define SETTINGS_REG_KEY_B_GEN(key, type) \ 
    4343  setting_keys::key ## _PATH, setting_keys::key, type, setting_keys::key ## _TITLE, setting_keys::key ## _DESC, setting_keys::key ## _DEFAULT==1?_T("1"):_T("0"), setting_keys::key ## _ADVANCED 
    … …  
    5757#define GENERIC_KEY_OBFUSCATED_PWD "obfuscated password" 
    5858#define GENERIC_KEY_USE_SSL "use ssl" 
     59 
     60 
     61// Main Registry ROOT 
     62#define NS_HKEY_ROOT HKEY_LOCAL_MACHINE 
     63#define NS_REG_ROOT _T("SOFTWARE\\NSClient++") 
    5964 
    6065 
    … …  
    217222    DESCRIBE_SETTING(SYNTAX, "SYNTAX", "Set this to use a specific syntax string for all commands (that don't specify one)."); 
    218223 
    219     DEFINE_SETTING_I(BUFFER_SIZE, EVENT_LOG_SECTION, "buffer_size", 4096); 
     224    DEFINE_SETTING_I(BUFFER_SIZE, EVENT_LOG_SECTION, "buffer_size", 65535); 
    220225    DESCRIBE_SETTING(BUFFER_SIZE, "BUFFER SIZE", "The size of the bugfer to use when getting messages this affects the speed and maximum size of messages you can recieve."); 
    221226  } 

  • include/settings/settings_old.hpp

    rd5356c1 r7f9c823  
    55#include <settings/Settings.h> 
    66#include <simpleini/SimpleIni.h> 
     7#include <settings/macros.h> 
    78 
    89#define MAIN_MODULES_SECTION_OLD _T("modules") 

  • include/settings/settings_registry.hpp

    rf0eb62d r7f9c823  
    66#include <msvc_wrappers.h> 
    77#include <error.hpp> 
     8#include <settings/macros.h> 
    89#define BUFF_LEN 4096 
    910 

  • include/strEx.h

    rd5356c1 r7f9c823  
    2020***************************************************************************/ 
    2121#pragma once 
    22  
    23 #include <tchar.h> 
    24 #include <windows.h> 
     22#include <unicode_char.hpp> 
    2523#include <sstream> 
    2624#include <iomanip> 
    … …  
    3230#include <algorithm> 
    3331#include <locale> 
     32#include <iostream> 
     33#include <string> 
     34#include <locale>  
     35#include <boost/lexical_cast.hpp> 
     36#include <boost/date_time.hpp> 
     37#include <boost/lexical_cast.hpp> 
     38//#include <boost/date_time/local_time/local_date_time.hpp> 
     39//#include <boost/date_time/gregorian/conversion.hpp> 
     40//boost::local_time::local_date_time  
    3441 
    3542 
    … …  
    3845#endif 
    3946 
     47 
     48 
     49 
     50#include <string> 
     51#include <locale> 
     52 
     53namespace boost 
     54{ 
     55  template<> 
     56  inline std::wstring lexical_cast<std::wstring, std::string>(const std::string& arg) 
     57  { 
     58    std::wstring result; 
     59    std::locale loc; 
     60    for(unsigned int i= 0; i < arg.size(); ++i) 
     61    { 
     62      result += std::use_facet<std::ctype<wchar_t> >(loc).widen(arg[i]); 
     63    } 
     64    return result; 
     65  } 
     66 
     67  template<> 
     68  inline std::string lexical_cast<std::string, std::wstring>(const std::wstring& arg) 
     69  { 
     70    std::string result; 
     71    std::locale loc; 
     72    for(unsigned int i= 0; i < arg.size(); ++i) 
     73    { 
     74      result += std::use_facet<std::ctype<wchar_t> >(loc).narrow(arg[i]); 
     75    } 
     76    return result; 
     77  } 
     78} 
    4079namespace strEx { 
    4180  class string_exception : public std::exception { 
    … …  
    4685      return _what; 
    4786    } 
     87    virtual ~string_exception() throw(); 
    4888  }; 
    4989  namespace s { 
    … …  
    72112    lst += append; 
    73113  } 
    74  
     114/* 
    75115  inline std::string wstring_to_string( const wchar_t* pStr, int len) { 
    76116    if (pStr == NULL) 
    … …  
    95135    return buf ;  
    96136  } 
     137  */ 
    97138  inline std::string wstring_to_string( const std::wstring& str ) { 
    98     return wstring_to_string(str.c_str(), static_cast<int>(str.length())); 
    99   } 
    100  
     139    return boost::lexical_cast<std::string>(str) ; 
     140    //return wstring_to_string(str.c_str(), static_cast<int>(str.length())); 
     141  } 
     142/* 
    101143  inline std::wstring string_to_wstring( const char* pStr , int len ) { 
    102144    if (pStr == NULL) 
    … …  
    120162    return buf ; 
    121163  } 
     164  */ 
    122165  inline std::wstring string_to_wstring( const std::string& str ) { 
    123     return string_to_wstring(str.c_str(), static_cast<int>(str.length())) ; 
     166    return boost::lexical_cast<std::wstring>(str) ; 
     167    //return string_to_wstring(str.c_str(), static_cast<int>(str.length())) ; 
    124168  } 
    125169 
    … …  
    164208    return ss.str(); 
    165209  } 
    166  
    167   inline std::wstring format_date(time_t time, std::wstring format = _T("%Y-%m-%d %H:%M:%S")) { 
    168     TCHAR buf[51]; 
     210  inline std::wstring format_date(boost::posix_time::ptime date, std::wstring format = _T("%Y-%m-%d %H:%M:%S")) { 
     211    std::locale locale_local (""); 
     212 
     213    boost::gregorian::wdate_facet *date_output = new boost::gregorian::wdate_facet(); 
     214    std::locale locale_adjusted (locale_local, date_output); 
     215 
     216    std::wstringstream date_ss; 
     217    date_ss.imbue(locale_adjusted); 
     218 
     219    date_output->format(format.c_str()); 
     220    date_ss << date; 
     221 
     222    std::wstring ss = date_ss.str(); 
     223    return ss; 
     224  } 
     225 
     226 
     227  inline std::wstring format_date(std::time_t time, std::wstring format = _T("%Y-%m-%d %H:%M:%S")) { 
     228    return format_date(boost::posix_time::from_time_t(time), format); 
     229    /* 
     230    wchar_t buf[51]; 
    169231    struct tm nt; // = new struct tm; 
    170232#if (_MSC_VER > 1300)  // 1300 == VC++ 7.0 
    … …  
    172234      return _T(""); 
    173235#else 
     236    struct tm nt; // = new struct tm; 
    174237    nt = gmtime(&time); 
    175238    if (nt == NULL) 
    … …  
    181244    buf[l] = 0; 
    182245    return buf; 
    183   } 
     246    */ 
     247  } 
     248  /* 
    184249  inline std::wstring format_date(const SYSTEMTIME &time, std::wstring format = _T("%Y-%m-%d %H:%M:%S")) { 
    185     TCHAR buf[51]; 
    186  
    187250    struct tm tmTime; 
    188251    memset(&tmTime, 0, sizeof(tmTime)); 
    … …  
    205268  static const __int64 SECS_BETWEEN_EPOCHS = 11644473600; 
    206269  static const __int64 SECS_TO_100NS = 10000000; 
     270  inline std::wstring format_filetime(unsigned long long filetime, std::wstring format = _T("%Y-%m-%d %H:%M:%S")) { 
     271    filetime -= (SECS_BETWEEN_EPOCHS * SECS_TO_100NS); 
     272    filetime /= SECS_TO_100NS; 
     273    return format_date(static_cast<time_t>(filetime), format); 
     274  } 
     275*/ 
     276  static const __int64 SECS_BETWEEN_EPOCHS = 11644473600; 
     277  static const __int64 SECS_TO_100NS = 10000000; 
     278 
    207279  inline std::wstring format_filetime(unsigned long long filetime, std::wstring format = _T("%Y-%m-%d %H:%M:%S")) { 
    208280    filetime -= (SECS_BETWEEN_EPOCHS * SECS_TO_100NS); 
    … …  
    222294    } 
    223295  } 
    224   inline std::wstring ctos(TCHAR c) { 
     296  inline std::wstring ctos(wchar_t c) { 
    225297    return std::wstring(1, c); 
    226298  } 
    227   inline TCHAR stoc(std::wstring str) { 
     299  inline wchar_t stoc(std::wstring str) { 
    228300    if (str.length() == 0) 
    229301      return L' '; 
    … …  
    245317    return ss.str(); 
    246318  } 
     319  /* 
    247320  inline std::wstring itos(__int64 i) { 
    248321    std::wstringstream ss; 
    … …  
    250323    return ss.str(); 
    251324  } 
     325  */ 
    252326  inline std::wstring itos(unsigned long i) { 
    253327    std::wstringstream ss; 
    … …  
    284358  } 
    285359  inline int stoi(std::wstring s) { 
    286     return _wtoi(s.c_str()); 
     360    return boost::lexical_cast<int>(s.c_str()); 
    287361  } 
    288362  inline double stod(std::wstring s) { 
    289     return _wtof(s.c_str()); 
     363    return boost::lexical_cast<double>(s.c_str()); 
    290364  } 
    291365  inline long long stoi64(std::wstring s) { 
    292     return _wtoi64(s.c_str()); 
     366    return boost::lexical_cast<long long>(s.c_str()); 
    293367  } 
    294368  inline unsigned stoui_as_time(std::wstring time, unsigned int smallest_unit = 1000) { 
    295369    std::wstring::size_type p = time.find_first_of(_T("sSmMhHdDwW")); 
    296     unsigned int value = _wtoi(time.c_str()); 
     370    unsigned int value = boost::lexical_cast<unsigned int>(time.c_str()); 
    297371    if (p == std::wstring::npos) 
    298372      return value * smallest_unit; 
    … …  
    312386  inline unsigned long long stoi64_as_time(std::wstring time, unsigned int smallest_unit = 1000) { 
    313387    std::wstring::size_type p = time.find_first_of(_T("sSmMhHdDwW")); 
    314     unsigned long long value = _wtoi64(time.c_str()); 
    315388    if (p == std::wstring::npos) 
    316       return value * smallest_unit; 
    317     else if ( (time[p] == 's') || (time[p] == 'S') ) 
     389      return boost::lexical_cast<long long>(time) * smallest_unit; 
     390    unsigned long long value = boost::lexical_cast<long long>(time.substr(0, p)); 
     391    if ( (time[p] == 's') || (time[p] == 'S') ) 
    318392      return value * 1000; 
    319393    else if ( (time[p] == 'm') || (time[p] == 'M') ) 
    … …  
    378452    std::wstring::size_type p = s.find_first_of(_T("BMKGT")); 
    379453    if (p == std::wstring::npos) 
    380       return _wtoi64(s.c_str()); 
     454      return boost::lexical_cast<long long>(s.c_str()); 
    381455    else if (s[p] == 'B')  
    382       return _wtoi64(s.c_str()); 
     456      return boost::lexical_cast<long long>(s.c_str()); 
    383457    else if (s[p] == 'K')  
    384       return _wtoi64(s.c_str())*1024; 
     458      return boost::lexical_cast<long long>(s.c_str())*1024; 
    385459    else if (s[p] == 'M')  
    386       return _wtoi64(s.c_str())*1024*1024; 
     460      return boost::lexical_cast<long long>(s.c_str())*1024*1024; 
    387461    else if (s[p] == 'G')  
    388       return _wtoi64(s.c_str())*1024*1024*1024; 
     462      return boost::lexical_cast<long long>(s.c_str())*1024*1024*1024; 
    389463    else if (s[p] == 'T')  
    390       return _wtoi64(s.c_str())*1024*1024*1024*1024; 
     464      return boost::lexical_cast<long long>(s.c_str())*1024*1024*1024*1024; 
    391465    else 
    392       return _wtoi64(s.c_str()); 
    393   } 
    394 #define BKMG_RANGE "BKMGTP" 
     466      return boost::lexical_cast<long long>(s.c_str()); 
     467  } 
     468#define BKMG_RANGE _T("BKMGTP") 
    395469#define BKMG_SIZE 5 
    396470 
    397   inline std::wstring itos_as_BKMG(unsigned __int64 i) { 
     471  inline std::wstring itos_as_BKMG(unsigned long long i) { 
    398472    double cpy = static_cast<double>(i); 
    399     TCHAR postfix[] = _T(BKMG_RANGE); 
     473    wchar_t postfix[] = BKMG_RANGE; 
    400474    int idx = 0; 
    401475    while ((cpy > 999)&&(idx<BKMG_SIZE)) { 
    … …  
    410484    return ret; 
    411485  } 
    412   inline std::wstring format_BKMG(unsigned __int64 i, std::wstring unit) { 
     486  inline std::wstring format_BKMG(unsigned long long i, std::wstring unit) { 
    413487    double cpy = static_cast<double>(i); 
    414     TCHAR postfix[] = _T(BKMG_RANGE); 
     488    wchar_t postfix[] = BKMG_RANGE; 
    415489    if (unit.length() != 1) 
    416490      return itos(cpy); 
    … …  
    430504    return itos(cpy); 
    431505  } 
    432   inline std::wstring find_proper_unit_BKMG(unsigned __int64 i) { 
     506  inline std::wstring find_proper_unit_BKMG(unsigned long long i) { 
    433507    double cpy = static_cast<double>(i); 
    434     TCHAR postfix[] = _T(BKMG_RANGE); 
     508    wchar_t postfix[] = BKMG_RANGE; 
    435509    int idx = 0; 
    436510    while ((cpy > 999)&&(idx<BKMG_SIZE)) { 
    … …  
    523597 
    524598    //  There's no memichr(), so we roll our own.  It ain't rocket science. 
    525     static const _E * __cdecl find(const _E *buf, size_t len, const _E& ch) { 
     599    static const _E * /*__cdecl*/ find(const _E *buf, size_t len, const _E& ch) { 
    526600      //  Jerry says that x86s have special mojo for memchr(), so the  
    527601      //  memchr() calls end up being reasonably efficient in practice. 
    … …  
    539613 
    540614    //  I'm reasonably sure that this is eq() for wide characters.  Maybe. 
    541     static bool eq_int_type(const int_type& ch1, const int_type& ch2) {  
    542       return char_traits<_E>::eq_int_type( tolower( ch1 ), tolower( ch2 ) );  
     615    static bool eq_int_type(const long& ch1, const long& ch2) {  
     616      return std::char_traits<_E>::eq_int_type( tolower( ch1 ), tolower( ch2 ) );  
    543617    } 
    544618  }; 
    … …  
    547621  //typedef std::basic_string<char, blind_traits<char>, std::allocator<char> >  blindstr; 
    548622  typedef std::basic_string<wchar_t, blind_traits<wchar_t>, std::allocator<wchar_t> >  blindstr; 
    549  
    550   struct case_blind_string_compare : public std::binary_function<std::wstring, std::wstring, bool> 
    551   { 
    552     bool operator() (const std::wstring& x, const std::wstring& y) const { 
    553       return _wcsicmp( x.c_str(), y.c_str() ) < 0; 
    554     } 
    555   }; 
    556  
    557  
    558623 
    559624  class StrICmp 
    … …  
    596661  } 
    597662 
     663  struct case_blind_string_compare : public std::binary_function<std::wstring, std::wstring, bool> 
     664  { 
     665    bool operator() (const std::wstring& x, const std::wstring& y) const { 
     666      return StrCmpI<std::wstring>(x,y); 
     667      //return _wcsicmp( x.c_str(), y.c_str() ) < 0; 
     668    } 
     669  }; 
    598670 
    599671#ifdef _DEBUG 
    … …  
    635707} 
    636708 
    637  
    638 #include <string> 
    639 #include <locale> 
    640  
    641 #include <boost/lexical_cast.hpp> 
    642  
    643 namespace boost 
    644 { 
    645   template<> 
    646   inline std::wstring lexical_cast<std::wstring, std::string>(const std::string& arg) 
    647   { 
    648     std::wstring result; 
    649     std::locale loc; 
    650     for(unsigned int i= 0; i < arg.size(); ++i) 
    651     { 
    652       result += std::use_facet<std::ctype<wchar_t> >(loc).widen(arg[i]); 
    653     } 
    654     return result; 
    655   } 
    656  
    657   template<> 
    658   inline std::string lexical_cast<std::string, std::wstring>(const std::wstring& arg) 
    659   { 
    660     std::string result; 
    661     std::locale loc; 
    662     for(unsigned int i= 0; i < arg.size(); ++i) 
    663     { 
    664       result += std::use_facet<std::ctype<wchar_t> >(loc).narrow(arg[i]); 
    665     } 
    666     return result; 
     709template <typename T> std::string to_string(const T& arg) { 
     710  try { 
     711    return boost::lexical_cast<std::string>(arg) ; 
     712  } 
     713  catch(boost::bad_lexical_cast& e) { 
     714    return ""; 
    667715  } 
    668716} 
    669  
     717template <typename T> std::wstring to_wstring(const T& arg) { 
     718  try { 
     719    return boost::lexical_cast<std::wstring>(arg) ; 
     720  } 
     721  catch(boost::bad_lexical_cast& e) { 
     722    return _T(""); 
     723  } 
     724} 
Note: See TracChangeset for help on using the changeset viewer.