Changeset d5356c1 in nscp for service/NSClient++.cpp


Ignore:
Timestamp:
11/04/09 06:52:49 (4 years ago)
Author:
Michael Medin <michael@…>
Branches:
master, 0.4.0, 0.4.1, 0.4.2
Children:
3b4097d
Parents:
2305b35
Message:

tried boost::asio in the NRPECLient and split settings to a new file (reduces build time)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • service/NSClient++.cpp

    rf0eb62d rd5356c1  
    1919#include <charEx.h> 
    2020#include <Socket.h> 
    21 #include <b64/b64.h> 
    2221#include <config.h> 
    2322#include <msvc_wrappers.h> 
    … …  
    2827#include <crtdbg.h> 
    2928//#endif 
    30 #include <settings/settings_ini.hpp> 
    31 #include <settings/settings_registry.hpp> 
    32 #include <settings/settings_old.hpp> 
    3329#include <Userenv.h> 
    3430#include <remote_processes.hpp> 
    3531#include <Lmcons.h> 
     32#include "core_api.h" 
     33#include "settings_manager_impl.h" 
     34#include <settings/macros.h> 
    3635 
    3736NSClient mainClient(SZSERVICENAME); // Global core instance. 
    3837bool g_bConsoleLog = false; 
    3938 
     39#define SETTINGS_GET_BOOL_CORE(key) \ 
     40  settings_manager::get_settings()->get_bool(setting_keys::key ## _PATH, setting_keys::key, setting_keys::key ## _DEFAULT) 
     41 
     42#define SETTINGS_GET_STRING_CORE(key) \ 
     43  settings_manager::get_settings()->get_string(setting_keys::key ## _PATH, setting_keys::key, setting_keys::key ## _DEFAULT) 
     44/* 
     45#define SETTINGS_SET_STRING_CORE(key, value) \ 
     46  Settings::get_settings()->set_string(setting_keys::key ## _PATH, setting_keys::key, value); 
     47*/ 
    4048/** 
    4149 * START OF Tray starter MERGE HELPER 
    … …  
    7179 
    7280  static bool start(DWORD dwSessionId) { 
    73     std::wstring program = mainClient.getBasePath() +  _T("\\") + SETTINGS_GET_STRING(nsclient::SYSTRAY_EXE); 
     81    std::wstring program = mainClient.getBasePath() +  _T("\\") +  
     82      SETTINGS_GET_STRING_CORE(settings_def::SYSTRAY_EXE); 
    7483    std::wstring cmdln = _T("\"") + program + _T("\" -channel __") + strEx::itos(dwSessionId) + _T("__"); 
    7584    return tray_starter::startTrayHelper(dwSessionId, program, cmdln); 
    … …  
    186195} 
    187196 
    188 class NSC_logger : public Settings::LoggerInterface { 
    189 public: 
    190   ////////////////////////////////////////////////////////////////////////// 
    191   /// Log an ERROR message. 
    192   /// 
    193   /// @param file the file where the event happened 
    194   /// @param line the line where the event happened 
    195   /// @param message the message to log 
    196   /// 
    197   /// @author mickem 
    198   void err(std::wstring file, int line, std::wstring message) { 
    199     NSAPIMessage(NSCAPI::error, file.c_str(), line, message.c_str()); 
    200   } 
    201   ////////////////////////////////////////////////////////////////////////// 
    202   /// Log an WARNING message. 
    203   /// 
    204   /// @param file the file where the event happened 
    205   /// @param line the line where the event happened 
    206   /// @param message the message to log 
    207   /// 
    208   /// @author mickem 
    209   void warn(std::wstring file, int line, std::wstring message) { 
    210     NSAPIMessage(NSCAPI::warning, file.c_str(), line, message.c_str()); 
    211   } 
    212   ////////////////////////////////////////////////////////////////////////// 
    213   /// Log an INFO message. 
    214   /// 
    215   /// @param file the file where the event happened 
    216   /// @param line the line where the event happened 
    217   /// @param message the message to log 
    218   /// 
    219   /// @author mickem 
    220   void info(std::wstring file, int line, std::wstring message) { 
    221     NSAPIMessage(NSCAPI::log, file.c_str(), line, message.c_str()); 
    222   } 
    223   ////////////////////////////////////////////////////////////////////////// 
    224   /// Log an DEBUG message. 
    225   /// 
    226   /// @param file the file where the event happened 
    227   /// @param line the line where the event happened 
    228   /// @param message the message to log 
    229   /// 
    230   /// @author mickem 
    231   void debug(std::wstring file, int line, std::wstring message) { 
    232     NSAPIMessage(NSCAPI::debug, file.c_str(), line, message.c_str()); 
    233   } 
    234 }; 
    235  
    236 #define SETTINGS_GET_BOOL(key) \ 
    237   settings_manager::get_settings()->get_bool(settings::key ## _PATH, settings::key, settings::key ## _DEFAULT) 
    238  
    239 namespace settings_manager { 
    240   class NSCSettingsImpl : public Settings::SettingsHandlerImpl { 
    241   private: 
    242     std::wstring boot_; 
    243     bool old_; 
    244   public: 
    245     NSCSettingsImpl() : old_(false) {} 
    246     ////////////////////////////////////////////////////////////////////////// 
    247     /// Get a string form the boot file. 
    248     /// 
    249     /// @param section section to read a value from. 
    250     /// @param key the key to read. 
    251     /// @param def a default value. 
    252     /// @return the value of the key or the default value. 
    253     /// 
    254     /// @author mickem 
    255     std::wstring get_boot_string(std::wstring section, std::wstring key, std::wstring def) { 
    256       TCHAR* buffer = new TCHAR[1024]; 
    257       GetPrivateProfileString(section.c_str(), key.c_str(), def.c_str(), buffer, 1023, boot_.c_str()); 
    258       std::wstring ret = buffer; 
    259       delete [] buffer; 
    260       return ret; 
    261     } 
    262     ////////////////////////////////////////////////////////////////////////// 
    263     /// Boot the settings subsystem from the given file (boot.ini). 
    264     /// 
    265     /// @param file the file to use when booting. 
    266     /// 
    267     /// @author mickem 
    268     void boot(std::wstring file = _T("boot.ini")) { 
    269       boot_ = get_base() + _T("\\") + file; 
    270       std::wstring subsystem = get_boot_string(_T("settings"), _T("type"), _T("old")); 
    271       get_logger()->debug(__FILEW__, __LINE__, _T("Trying to boot: ") + subsystem); 
    272       settings_type type = string_to_type(subsystem); 
    273       std::wstring context = get_boot_string(_T("settings"), _T("context"), subsystem); 
    274       Settings::SettingsInterface *impl = create_instance(type, context); 
    275       if (impl == NULL) 
    276         throw Settings::SettingsException(_T("Could not create settings instance: ") + subsystem); 
    277       add_type_impl(type, create_instance(type, context)); 
    278       set_type(type); 
    279       if (old_) 
    280         get()->set_bool(settings::settings_def::COMPATIBLITY_PATH, settings::settings_def::COMPATIBLITY, true); 
    281     } 
    282     ////////////////////////////////////////////////////////////////////////// 
    283     /// Create an instance of a given type. 
    284     /// Used internally to create instances of various settings types. 
    285     /// 
    286     /// @param type the type to create 
    287     /// @param context the context to use 
    288     /// @return a new instance of given type. 
    289     /// 
    290     /// @author mickem 
    291     Settings::SettingsInterface* create_instance(settings_type type, std::wstring context) { 
    292       get_logger()->debug(__FILEW__, __LINE__, _T("Trying to create: ") + SettingsCore::type_to_string(type) + _T(": ") + context); 
    293       if (type == SettingsCore::old_ini_file) { 
    294         old_ = true; 
    295         return new Settings::OLDSettings(this, context); 
    296       }  
    297       if (type == SettingsCore::ini_file) 
    298         return new Settings::INISettings(this, context); 
    299       if (type == SettingsCore::registry) 
    300         return new Settings::REGSettings(this, context); 
    301       throw SettingsException(_T("Undefined settings type: ") + SettingsCore::type_to_string(type)); 
    302     } 
    303  
    304   }; 
    305  
    306   typedef Singleton<NSCSettingsImpl> SettingsHandler; 
    307  
    308   // Alias to make handling "compatible" with old syntax 
    309   Settings::SettingsInterface* get_settings() { 
    310     return SettingsHandler::getInstance()->get(); 
    311   } 
    312   Settings::SettingsCore* get_core() { 
    313     return SettingsHandler::getInstance(); 
    314   } 
    315   void destroy_settings() { 
    316     SettingsHandler::destroyInstance(); 
    317   } 
    318  
    319  
    320   bool init_settings() { 
    321     try { 
    322       get_core()->set_logger(new NSC_logger()); 
    323       get_core()->set_base(mainClient.getBasePath()); 
    324       get_core()->boot(_T("boot.ini")); 
    325       get_core()->register_key(SETTINGS_REG_KEY_I_GEN(settings_def::PAYLOAD_LEN, Settings::SettingsCore::key_integer)); 
    326       get_core()->register_key(SETTINGS_REG_KEY_S_GEN(protocol_def::ALLOWED_HOSTS, Settings::SettingsCore::key_string)); 
    327       get_core()->register_key(SETTINGS_REG_KEY_B_GEN(protocol_def::CACHE_ALLOWED, Settings::SettingsCore::key_bool)); 
    328       get_core()->register_key(SETTINGS_REG_KEY_S_GEN(protocol_def::MASTER_KEY, Settings::SettingsCore::key_string)); 
    329       get_core()->register_key(SETTINGS_REG_KEY_S_GEN(protocol_def::PWD, Settings::SettingsCore::key_string)); 
    330       get_core()->register_key(SETTINGS_REG_KEY_S_GEN(protocol_def::OBFUSCATED_PWD, Settings::SettingsCore::key_string)); 
    331  
    332     } catch (SettingsException e) { 
    333       LOG_CRITICAL_STD(_T("Failed to initialize settings: ") + e.getError()); 
    334       return false; 
    335     } catch (...) { 
    336       LOG_CRITICAL(_T("FATAL ERROR IN SETTINGS SUBSYTEM")); 
    337       return false; 
    338     } 
    339     return true; 
    340   } 
    341  
    342 } 
    343  
    344 #define SETTINGS_GET_STRING(key) \ 
    345   Settings::get_settings()->get_string(key ## _PATH, key, key ## _DEFAULT) 
    346 #define SETTINGS_SET_STRING(key, value) \ 
    347   Settings::get_settings()->set_string(key ## _PATH, key, value); 
    348197 
    349198/** 
    … …  
    442291      g_bConsoleLog = true; 
    443292      std::wstring password; 
    444       if (!settings_manager::init_settings()) { 
     293      if (!settings_manager::init_settings(mainClient.getBasePath())) { 
    445294        std::wcout << _T("Could not find settings") << std::endl;; 
    446295        return 1; 
    … …  
    888737bool NSClientT::initCore(bool boot) { 
    889738  LOG_MESSAGE(_T("Attempting to start NSCLient++ - " SZVERSION)); 
    890   if (!settings_manager::init_settings()) { 
     739  if (!settings_manager::init_settings(getBasePath())) { 
    891740    return false; 
    892741  } 
    … …  
    895744      settings_manager::get_settings()->set_int(_T("log"), _T("debug"), 1); 
    896745      settings_manager::get_settings()->set_int(_T("Settings"), _T("shared_Session"), 1); 
    897     enable_shared_session_ = SETTINGS_GET_BOOL(settings_def::SHARED_SESSION); 
     746    enable_shared_session_ = SETTINGS_GET_BOOL_CORE(settings_def::SHARED_SESSION); 
    898747  } catch (SettingsException e) { 
    899748    LOG_ERROR_STD(_T("Could not find settings: ") + e.getMessage()); 
    … …  
    963812      Settings::string_list list = settings_manager::get_settings()->get_keys(MAIN_MODULES_SECTION); 
    964813      for (Settings::string_list::const_iterator cit = list.begin(); cit != list.end(); ++cit) { 
     814        LOG_DEBUG_STD(_T("Processing plugin: " + *cit)); 
    965815        try { 
    966816          if (settings_manager::get_settings()->get_string(MAIN_MODULES_SECTION, *cit) == _T("disabled")) { 
    … …  
    13951245    } catch (SettingsException &e) { 
    13961246      LOG_DEBUG_STD(_T("Failed to get length: ") + e.getMessage()); 
    1397       return settings::settings_def::PAYLOAD_LEN_DEFAULT; 
     1247      return setting_keys::settings_def::PAYLOAD_LEN_DEFAULT; 
    13981248    } catch (...) { 
    13991249      LOG_ERROR(_T("Failed to get length: :(")); 
    1400       return settings::settings_def::PAYLOAD_LEN_DEFAULT; 
     1250      return setting_keys::settings_def::PAYLOAD_LEN_DEFAULT; 
    14011251    } 
    14021252  } 
    … …  
    15281378bool NSClientT::logDebug() { 
    15291379  if (debug_ == log_unknown) { 
     1380    debug_ = log_looking; 
    15301381    try { 
    15311382      if (settings_manager::get_settings()->get_int(_T("log"), _T("debug"), 0) == 1) 
    … …  
    15361387      return true; 
    15371388    } 
    1538   } 
     1389  } else if (debug_ == log_looking)  
     1390    return true; 
    15391391  return (debug_ == log_debug); 
    15401392} 
    … …  
    15531405 */ 
    15541406void NSClientT::reportMessage(int msgType, const TCHAR* file, const int line, std::wstring message) { 
     1407  strEx::replace(message, _T("\n"), _T(" ")); 
     1408  strEx::replace(message, _T("\r"), _T(" ")); 
    15551409  if ((msgType == NSCAPI::debug)&&(!logDebug())) { 
    15561410    return; 
    … …  
    16591513 
    16601514 
    1661 NSCAPI::errorReturn NSAPIGetSettingsString(const TCHAR* section, const TCHAR* key, const TCHAR* defaultValue, TCHAR* buffer, unsigned int bufLen) { 
    1662   try { 
    1663     return NSCHelper::wrapReturnString(buffer, bufLen, settings_manager::get_settings()->get_string(section, key, defaultValue), NSCAPI::isSuccess); 
    1664   } catch (...) { 
    1665     LOG_ERROR_STD(_T("Failed to getString: ") + key); 
    1666     return NSCAPI::hasFailed; 
    1667   } 
    1668 } 
    1669 int NSAPIGetSettingsInt(const TCHAR* section, const TCHAR* key, int defaultValue) { 
    1670   try { 
    1671     return settings_manager::get_settings()->get_int(section, key, defaultValue); 
    1672   } catch (SettingsException e) { 
    1673     LOG_ERROR_STD(_T("Failed to set settings file") + e.getMessage()); 
    1674     return defaultValue; 
    1675   } 
    1676 } 
    1677 NSCAPI::errorReturn NSAPIGetBasePath(TCHAR*buffer, unsigned int bufLen) { 
    1678   return NSCHelper::wrapReturnString(buffer, bufLen, mainClient.getBasePath(), NSCAPI::isSuccess); 
    1679 } 
    1680 NSCAPI::errorReturn NSAPIGetApplicationName(TCHAR*buffer, unsigned int bufLen) { 
    1681   return NSCHelper::wrapReturnString(buffer, bufLen, SZAPPNAME, NSCAPI::isSuccess); 
    1682 } 
    1683 NSCAPI::errorReturn NSAPIGetApplicationVersionStr(TCHAR*buffer, unsigned int bufLen) { 
    1684   return NSCHelper::wrapReturnString(buffer, bufLen, SZVERSION, NSCAPI::isSuccess); 
    1685 } 
    1686 void NSAPIMessage(int msgType, const TCHAR* file, const int line, const TCHAR* message) { 
    1687   mainClient.reportMessage(msgType, file, line, message); 
    1688 } 
    1689 void NSAPIStopServer(void) { 
    1690   serviceControll::StopNoWait(SZSERVICENAME); 
    1691 } 
    1692 NSCAPI::nagiosReturn NSAPIInject(const TCHAR* command, const unsigned int argLen, TCHAR **argument, TCHAR *returnMessageBuffer, unsigned int returnMessageBufferLen, TCHAR *returnPerfBuffer, unsigned int returnPerfBufferLen) { 
    1693   return mainClient.injectRAW(command, argLen, argument, returnMessageBuffer, returnMessageBufferLen, returnPerfBuffer, returnPerfBufferLen); 
    1694 } 
    1695 NSCAPI::errorReturn NSAPIGetSettingsSection(const TCHAR* section, TCHAR*** aBuffer, unsigned int * bufLen) { 
    1696   try { 
    1697     unsigned int len = 0; 
    1698     *aBuffer = arrayBuffer::list2arrayBuffer(settings_manager::get_settings()->get_keys(section), len); 
    1699     *bufLen = len; 
    1700     return NSCAPI::isSuccess; 
    1701   } catch (SettingsException e) { 
    1702     LOG_ERROR_STD(_T("Failed to get section: ") + e.getMessage()); 
    1703   } catch (...) { 
    1704     LOG_ERROR_STD(_T("Failed to getSection: ") + section); 
    1705   } 
    1706   return NSCAPI::hasFailed; 
    1707 } 
    1708 NSCAPI::errorReturn NSAPIReleaseSettingsSectionBuffer(TCHAR*** aBuffer, unsigned int * bufLen) { 
    1709   arrayBuffer::destroyArrayBuffer(*aBuffer, *bufLen); 
    1710   *bufLen = 0; 
    1711   *aBuffer = NULL; 
    1712   return NSCAPI::isSuccess; 
    1713 } 
    1714  
    1715 NSCAPI::boolReturn NSAPICheckLogMessages(int messageType) { 
    1716   if (mainClient.logDebug()) 
    1717     return NSCAPI::istrue; 
    1718   return NSCAPI::isfalse; 
    1719 } 
    1720  
    17211515std::wstring Encrypt(std::wstring str, unsigned int algorithm) { 
    17221516  unsigned int len = 0; 
    … …  
    17461540} 
    17471541 
    1748 NSCAPI::errorReturn NSAPIEncrypt(unsigned int algorithm, const TCHAR* inBuffer, unsigned int inBufLen, TCHAR* outBuf, unsigned int *outBufLen) { 
    1749   if (algorithm != NSCAPI::xor) { 
    1750     LOG_ERROR(_T("Unknown algortihm requested.")); 
    1751     return NSCAPI::hasFailed; 
    1752   } 
    1753   std::wstring key = settings_manager::get_settings()->get_string(SETTINGS_KEY(protocol_def::MASTER_KEY)); 
    1754   int tcharInBufLen = 0; 
    1755   char *c = charEx::tchar_to_char(inBuffer, inBufLen, tcharInBufLen); 
    1756   std::wstring::size_type j=0; 
    1757   for (int i=0;i<tcharInBufLen;i++,j++) { 
    1758     if (j > key.size()) 
    1759       j = 0; 
    1760     c[i] ^= key[j]; 
    1761   } 
    1762   size_t cOutBufLen = b64::b64_encode(reinterpret_cast<void*>(c), tcharInBufLen, NULL, NULL); 
    1763   if (!outBuf) { 
    1764     *outBufLen = static_cast<unsigned int>(cOutBufLen*2); // TODO: Guessing wildly here but no proper way to tell without a lot of extra work 
    1765     return NSCAPI::isSuccess; 
    1766   } 
    1767   char *cOutBuf = new char[cOutBufLen+1]; 
    1768   size_t len = b64::b64_encode(reinterpret_cast<void*>(c), tcharInBufLen, cOutBuf, cOutBufLen); 
    1769   delete [] c; 
    1770   if (len == 0) { 
    1771     LOG_ERROR(_T("Invalid out buffer length.")); 
    1772     return NSCAPI::isInvalidBufferLen; 
    1773   } 
    1774   int realOutLen; 
    1775   TCHAR *realOut = charEx::char_to_tchar(cOutBuf, cOutBufLen, realOutLen); 
    1776   if (static_cast<unsigned int>(realOutLen) >= *outBufLen) { 
    1777     LOG_ERROR_STD(_T("Invalid out buffer length: ") + strEx::itos(realOutLen) + _T(" was needed but only ") + strEx::itos(*outBufLen) + _T(" was allocated.")); 
    1778     return NSCAPI::isInvalidBufferLen; 
    1779   } 
    1780   wcsncpy_s(outBuf, *outBufLen, realOut, realOutLen); 
    1781   delete [] realOut; 
    1782   outBuf[realOutLen] = 0; 
    1783   *outBufLen = static_cast<unsigned int>(realOutLen); 
    1784   return NSCAPI::isSuccess; 
    1785 } 
    1786  
    1787 NSCAPI::errorReturn NSAPIDecrypt(unsigned int algorithm, const TCHAR* inBuffer, unsigned int inBufLen, TCHAR* outBuf, unsigned int *outBufLen) { 
    1788   if (algorithm != NSCAPI::xor) { 
    1789     LOG_ERROR(_T("Unknown algortihm requested.")); 
    1790     return NSCAPI::hasFailed; 
    1791   } 
    1792   int inBufLenC = 0; 
    1793   char *inBufferC = charEx::tchar_to_char(inBuffer, inBufLen, inBufLenC); 
    1794   size_t cOutLen =  b64::b64_decode(inBufferC, inBufLenC, NULL, NULL); 
    1795   if (!outBuf) { 
    1796     *outBufLen = static_cast<unsigned int>(cOutLen*2); // TODO: Guessing wildly here but no proper way to tell without a lot of extra work 
    1797     return NSCAPI::isSuccess; 
    1798   } 
    1799   char *cOutBuf = new char[cOutLen+1]; 
    1800   size_t len = b64::b64_decode(inBufferC, inBufLenC, reinterpret_cast<void*>(cOutBuf), cOutLen); 
    1801   delete [] inBufferC; 
    1802   if (len == 0) { 
    1803     LOG_ERROR(_T("Invalid out buffer length.")); 
    1804     return NSCAPI::isInvalidBufferLen; 
    1805   } 
    1806   int realOutLen; 
    1807  
    1808   std::wstring key = settings_manager::get_settings()->get_string(SETTINGS_KEY(protocol_def::MASTER_KEY)); 
    1809   std::wstring::size_type j=0; 
    1810   for (int i=0;i<cOutLen;i++,j++) { 
    1811     if (j > key.size()) 
    1812       j = 0; 
    1813     cOutBuf[i] ^= key[j]; 
    1814   } 
    1815  
    1816   TCHAR *realOut = charEx::char_to_tchar(cOutBuf, cOutLen, realOutLen); 
    1817   if (static_cast<unsigned int>(realOutLen) >= *outBufLen) { 
    1818     LOG_ERROR_STD(_T("Invalid out buffer length: ") + strEx::itos(realOutLen) + _T(" was needed but only ") + strEx::itos(*outBufLen) + _T(" was allocated.")); 
    1819     return NSCAPI::isInvalidBufferLen; 
    1820   } 
    1821   wcsncpy_s(outBuf, *outBufLen, realOut, realOutLen); 
    1822   delete [] realOut; 
    1823   outBuf[realOutLen] = 0; 
    1824   *outBufLen = static_cast<unsigned int>(realOutLen); 
    1825   return NSCAPI::isSuccess; 
    1826 } 
    1827  
    1828 NSCAPI::errorReturn NSAPISetSettingsString(const TCHAR* section, const TCHAR* key, const TCHAR* value) { 
    1829   try { 
    1830     settings_manager::get_settings()->set_string(section, key, value); 
    1831   } catch (...) { 
    1832     LOG_ERROR_STD(_T("Failed to setString: ") + key); 
    1833     return NSCAPI::hasFailed; 
    1834   } 
    1835   return NSCAPI::isSuccess; 
    1836 } 
    1837 NSCAPI::errorReturn NSAPISetSettingsInt(const TCHAR* section, const TCHAR* key, int value) { 
    1838   try { 
    1839     settings_manager::get_settings()->set_int(section, key, value); 
    1840   } catch (...) { 
    1841     LOG_ERROR_STD(_T("Failed to setInt: ") + key); 
    1842     return NSCAPI::hasFailed; 
    1843   } 
    1844   return NSCAPI::isSuccess; 
    1845 } 
    1846 NSCAPI::errorReturn NSAPIWriteSettings(int type) { 
    1847   try { 
    1848     if (type == NSCAPI::settings_registry) 
    1849       settings_manager::get_core()->migrate_to(Settings::SettingsCore::registry); 
    1850     else if (type == NSCAPI::settings_inifile) 
    1851       settings_manager::get_core()->migrate_to(Settings::SettingsCore::ini_file); 
    1852     else 
    1853       settings_manager::get_settings()->save(); 
    1854   } catch (SettingsException e) { 
    1855     LOG_ERROR_STD(_T("Failed to write settings: ") + e.getMessage()); 
    1856     return NSCAPI::hasFailed; 
    1857   } catch (...) { 
    1858     LOG_ERROR_STD(_T("Failed to write settings")); 
    1859     return NSCAPI::hasFailed; 
    1860   } 
    1861   return NSCAPI::isSuccess; 
    1862 } 
    1863 NSCAPI::errorReturn NSAPIReadSettings(int type) { 
    1864   try { 
    1865     if (type == NSCAPI::settings_registry) 
    1866       settings_manager::get_core()->migrate_from(Settings::SettingsCore::registry); 
    1867     else if (type == NSCAPI::settings_inifile) 
    1868       settings_manager::get_core()->migrate_from(Settings::SettingsCore::ini_file); 
    1869     else 
    1870       settings_manager::get_settings()->reload(); 
    1871   } catch (SettingsException e) { 
    1872     LOG_ERROR_STD(_T("Failed to read settings: ") + e.getMessage()); 
    1873     return NSCAPI::hasFailed; 
    1874   } catch (...) { 
    1875     LOG_ERROR_STD(_T("Failed to read settings")); 
    1876     return NSCAPI::hasFailed; 
    1877   } 
    1878   return NSCAPI::isSuccess; 
    1879 } 
    1880 NSCAPI::errorReturn NSAPIRehash(int flag) { 
    1881   return NSCAPI::hasFailed; 
    1882 } 
    1883 NSCAPI::errorReturn NSAPIDescribeCommand(const TCHAR* command, TCHAR* buffer, unsigned int bufLen) { 
    1884   return NSCHelper::wrapReturnString(buffer, bufLen, mainClient.describeCommand(command), NSCAPI::isSuccess); 
    1885 } 
    1886 NSCAPI::errorReturn NSAPIGetAllCommandNames(arrayBuffer::arrayBuffer* aBuffer, unsigned int *bufLen) { 
    1887   unsigned int len = 0; 
    1888   *aBuffer = arrayBuffer::list2arrayBuffer(mainClient.getAllCommandNames(), len); 
    1889   *bufLen = len; 
    1890   return NSCAPI::isSuccess; 
    1891 } 
    1892 NSCAPI::errorReturn NSAPIReleaseAllCommandNamessBuffer(TCHAR*** aBuffer, unsigned int * bufLen) { 
    1893   arrayBuffer::destroyArrayBuffer(*aBuffer, *bufLen); 
    1894   *bufLen = 0; 
    1895   *aBuffer = NULL; 
    1896   return NSCAPI::isSuccess; 
    1897 } 
    1898 NSCAPI::errorReturn NSAPIRegisterCommand(const TCHAR* cmd,const TCHAR* desc) { 
    1899   mainClient.registerCommand(cmd, desc); 
    1900   return NSCAPI::isSuccess; 
    1901 } 
    1902 NSCAPI::errorReturn NSAPISettingsRegKey(const TCHAR* path, const TCHAR* key, int type, const TCHAR* title, const TCHAR* description, const TCHAR* defVal, int advanced) { 
    1903   try { 
    1904     if (type == NSCAPI::key_string) 
    1905       settings_manager::get_core()->register_key(path, key, Settings::SettingsCore::key_string, title, description, defVal, advanced); 
    1906     if (type == NSCAPI::key_bool) 
    1907       settings_manager::get_core()->register_key(path, key, Settings::SettingsCore::key_bool, title, description, defVal, advanced); 
    1908     if (type == NSCAPI::key_integer) 
    1909       settings_manager::get_core()->register_key(path, key, Settings::SettingsCore::key_integer, title, description, defVal, advanced); 
    1910     return NSCAPI::hasFailed; 
    1911   } catch (SettingsException e) { 
    1912     LOG_ERROR_STD(_T("Failed register key: ") + e.getMessage()); 
    1913     return NSCAPI::hasFailed; 
    1914   } catch (...) { 
    1915     LOG_ERROR_STD(_T("Failed register key")); 
    1916     return NSCAPI::hasFailed; 
    1917   } 
    1918   return NSCAPI::isSuccess; 
    1919 } 
    1920  
    1921  
    1922 NSCAPI::errorReturn NSAPISettingsRegPath(const TCHAR* path, const TCHAR* title, const TCHAR* description, int advanced) { 
    1923   try { 
    1924     settings_manager::get_core()->register_path(path, title, description, advanced); 
    1925   } catch (SettingsException e) { 
    1926     LOG_ERROR_STD(_T("Failed register path: ") + e.getMessage()); 
    1927     return NSCAPI::hasFailed; 
    1928   } catch (...) { 
    1929     LOG_ERROR_STD(_T("Failed register path")); 
    1930     return NSCAPI::hasFailed; 
    1931   } 
    1932   return NSCAPI::isSuccess; 
    1933 } 
    1934  
    1935 //int wmain(int argc, TCHAR* argv[], TCHAR* envp[]) 
    1936 TCHAR* copyString(const std::wstring &str) { 
    1937   int sz = str.size(); 
    1938   TCHAR *tc = new TCHAR[sz+2]; 
    1939   wcsncpy_s(tc, sz+1, str.c_str(), sz); 
    1940   return tc; 
    1941 } 
    1942 NSCAPI::errorReturn NSAPIGetPluginList(int *len, NSCAPI::plugin_info *list[]) { 
    1943   NSClientT::plugin_info_list plugList= mainClient.get_all_plugins(); 
    1944   *len = plugList.size(); 
    1945  
    1946   *list = new NSCAPI::plugin_info[*len+1]; 
    1947   int i=0; 
    1948   for(NSClientT::plugin_info_list::const_iterator cit = plugList.begin(); cit != plugList.end(); ++cit,i++) { 
    1949     (*list)[i].dll = copyString((*cit).dll); 
    1950     (*list)[i].name = copyString((*cit).name); 
    1951     (*list)[i].version = copyString((*cit).version); 
    1952     (*list)[i].description = copyString((*cit).description); 
    1953   } 
    1954   return NSCAPI::isSuccess; 
    1955 } 
    1956 NSCAPI::errorReturn NSAPIReleasePluginList(int len, NSCAPI::plugin_info *list[]) { 
    1957   for (int i=0;i<len;i++) { 
    1958     delete [] (*list)[i].dll; 
    1959     delete [] (*list)[i].name; 
    1960     delete [] (*list)[i].version; 
    1961     delete [] (*list)[i].description; 
    1962   } 
    1963   delete [] *list; 
    1964   return NSCAPI::isSuccess; 
    1965 } 
    1966  
    1967  
    1968 NSCAPI::errorReturn NSAPISettingsSave(void) { 
    1969   try { 
    1970     settings_manager::get_settings()->save(); 
    1971   } catch (SettingsException e) { 
    1972     LOG_ERROR_STD(_T("Failed to save: ") + e.getMessage()); 
    1973     return NSCAPI::hasFailed; 
    1974   } catch (...) { 
    1975     LOG_ERROR_STD(_T("Failed to save")); 
    1976     return NSCAPI::hasFailed; 
    1977   } 
    1978   return NSCAPI::isSuccess; 
    1979 } 
    1980  
    1981  
    1982  
    1983 LPVOID NSAPILoader(TCHAR*buffer) { 
    1984   if (_wcsicmp(buffer, _T("NSAPIGetApplicationName")) == 0) 
    1985     return &NSAPIGetApplicationName; 
    1986   if (_wcsicmp(buffer, _T("NSAPIGetApplicationVersionStr")) == 0) 
    1987     return &NSAPIGetApplicationVersionStr; 
    1988   if (_wcsicmp(buffer, _T("NSAPIGetSettingsString")) == 0) 
    1989     return &NSAPIGetSettingsString; 
    1990   if (_wcsicmp(buffer, _T("NSAPIGetSettingsSection")) == 0) 
    1991     return &NSAPIGetSettingsSection; 
    1992   if (_wcsicmp(buffer, _T("NSAPIReleaseSettingsSectionBuffer")) == 0) 
    1993     return &NSAPIReleaseSettingsSectionBuffer; 
    1994   if (_wcsicmp(buffer, _T("NSAPIGetSettingsInt")) == 0) 
    1995     return &NSAPIGetSettingsInt; 
    1996   if (_wcsicmp(buffer, _T("NSAPIMessage")) == 0) 
    1997     return &NSAPIMessage; 
    1998   if (_wcsicmp(buffer, _T("NSAPIStopServer")) == 0) 
    1999     return &NSAPIStopServer; 
    2000   if (_wcsicmp(buffer, _T("NSAPIInject")) == 0) 
    2001     return &NSAPIInject; 
    2002   if (_wcsicmp(buffer, _T("NSAPIGetBasePath")) == 0) 
    2003     return &NSAPIGetBasePath; 
    2004   if (_wcsicmp(buffer, _T("NSAPICheckLogMessages")) == 0) 
    2005     return &NSAPICheckLogMessages; 
    2006   if (_wcsicmp(buffer, _T("NSAPIEncrypt")) == 0) 
    2007     return &NSAPIEncrypt; 
    2008   if (_wcsicmp(buffer, _T("NSAPIDecrypt")) == 0) 
    2009     return &NSAPIDecrypt; 
    2010   if (_wcsicmp(buffer, _T("NSAPISetSettingsString")) == 0) 
    2011     return &NSAPISetSettingsString; 
    2012   if (_wcsicmp(buffer, _T("NSAPISetSettingsInt")) == 0) 
    2013     return &NSAPISetSettingsInt; 
    2014   if (_wcsicmp(buffer, _T("NSAPIWriteSettings")) == 0) 
    2015     return &NSAPIWriteSettings; 
    2016   if (_wcsicmp(buffer, _T("NSAPIReadSettings")) == 0) 
    2017     return &NSAPIReadSettings; 
    2018   if (_wcsicmp(buffer, _T("NSAPIRehash")) == 0) 
    2019     return &NSAPIRehash; 
    2020   if (_wcsicmp(buffer, _T("NSAPIDescribeCommand")) == 0) 
    2021     return &NSAPIDescribeCommand; 
    2022   if (_wcsicmp(buffer, _T("NSAPIGetAllCommandNames")) == 0) 
    2023     return &NSAPIGetAllCommandNames; 
    2024   if (_wcsicmp(buffer, _T("NSAPIReleaseAllCommandNamessBuffer")) == 0) 
    2025     return &NSAPIReleaseAllCommandNamessBuffer; 
    2026   if (_wcsicmp(buffer, _T("NSAPIRegisterCommand")) == 0) 
    2027     return &NSAPIRegisterCommand; 
    2028   if (_wcsicmp(buffer, _T("NSAPISettingsRegKey")) == 0) 
    2029     return &NSAPISettingsRegKey; 
    2030   if (_wcsicmp(buffer, _T("NSAPISettingsRegPath")) == 0) 
    2031     return &NSAPISettingsRegPath; 
    2032   if (_wcsicmp(buffer, _T("NSAPIGetPluginList")) == 0) 
    2033     return &NSAPIGetPluginList; 
    2034   if (_wcsicmp(buffer, _T("NSAPIReleasePluginList")) == 0) 
    2035     return &NSAPIReleasePluginList; 
    2036   if (_wcsicmp(buffer, _T("NSAPISettingsSave")) == 0) 
    2037     return &NSAPISettingsSave; 
    2038  
    2039   LOG_ERROR_STD(_T("Function not found: ") + buffer); 
    2040   return NULL; 
    2041 } 
    2042  
    2043  
     1542 
Note: See TracChangeset for help on using the changeset viewer.