Changeset 216

Timestamp:

11/15/09 17:20:03 (2 years ago)

Author:

mickem

Message:

Next major "milestone" we now have one working plugin (CheckHelpers) which loads and works both on Linux and Windows.
This is (as always) a broken build which many many features disabled and non functional...

Location:

trunk

Files:

• CMakeLists.txt (added)
• include/NSCHelper.cpp (modified) (1 diff)
• include/NSCHelper.h (modified) (1 diff)
• include/arrayBuffer.cpp (modified) (1 diff)
• include/charEx.h (modified) (1 diff)
• include/com_helpers.hpp (modified) (1 diff)
• include/dll/impl_unix.hpp (modified) (1 diff)
• include/dll/impl_w32.hpp (modified) (2 diffs)
• include/error_impl_unix.hpp (modified) (2 diffs)
• include/nsc_module_wrapper.hpp (modified) (1 diff)
• include/settings/Settings.h (modified) (6 diffs)
• include/settings/settings_ini.hpp (modified) (5 diffs)
• include/settings/settings_old.hpp (modified) (2 diffs)
• include/strEx.h (modified) (5 diffs)
• include/types.hpp (modified) (2 diffs)
• modules/CheckHelpers/CMakeLists.txt (added)
• modules/CheckHelpers/CheckHelpers.cpp (modified) (2 diffs)
• modules/CheckHelpers/stdafx.h (modified) (2 diffs)
• service/CMakeLists.txt (modified) (2 diffs)
• service/NSCPlugin.cpp (modified) (4 diffs)
• service/NSCPlugin.h (modified) (1 diff)
• service/NSClient++.cpp (modified) (14 diffs)
• service/NSClient++.h (modified) (4 diffs)
• service/StdAfx.h (modified) (3 diffs)
• service/core_api.cpp (modified) (1 diff)
• service/settings_manager_impl.cpp (modified) (1 diff)
• service/settings_manager_impl.h (modified) (6 diffs)

trunk/include/NSCHelper.cpp

@@ -730 +730 @@
   NSCModuleHelper::fNSAPIMessage = (NSCModuleHelper::lpNSAPIMessage)f(_T("NSAPIMessage"));
   NSCModuleHelper::fNSAPIStopServer = (NSCModuleHelper::lpNSAPIStopServer)f(_T("NSAPIStopServer"));
-  NSCModuleHelper::fNSAPIExit = (NSCModuleHelper::lpNSAPIExit)f(_T("NSAPIExit"));
+  //NSCModuleHelper::fNSAPIExit = (NSCModuleHelper::lpNSAPIExit)f(_T("NSAPIExit"));
   NSCModuleHelper::fNSAPIInject = (NSCModuleHelper::lpNSAPIInject)f(_T("NSAPIInject"));
   NSCModuleHelper::fNSAPIGetBasePath = (NSCModuleHelper::lpNSAPIGetBasePath)f(_T("NSAPIGetBasePath"));

trunk/include/NSCHelper.h

@@ -23 +23 @@
 #include <string>
 #include <list>
+#include <iostream>
+
 #include <NSCAPI.h>
-#include <iostream>
 #include <charEx.h>
 #include <arrayBuffer.h>

trunk/include/arrayBuffer.cpp

@@ -19 +19 @@
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
+#include <types.hpp>
 #include <arrayBuffer.h>
 #include <msvc_wrappers.h>

trunk/include/charEx.h

@@ -105 +105 @@
     return token(std::wstring(buffer, p-buffer-1), p);
   }
-#ifdef _DEBUG
-  inline void test_getToken(wchar_t* in1, wchar_t in2, std::wstring out1, wchar_t * out2) {
-    token t = getToken(in1, in2);
-    std::wcout << _T("charEx::test_getToken(") << in1 << _T(", ") << in2 << _T(") : ");
-    if (t.first == out1)  {
-      if ((t.second == NULL) && (out2 == NULL))
-        std::wcout << _T("Succeeded") << std::endl;
-      else if (t.second == NULL)
-        std::wcout << _T("Failed [NULL=") << out2 << _T("]") << std::endl;
-      else if (out2 == NULL)
-        std::wcout << _T("Failed [") << t.second << _T("=NULL]") << std::endl;
-      else if (wcscmp(t.second, out2) == 0)
-        std::wcout << _T("Succeeded") << std::endl;
-      else
-        std::wcout << _T("Failed") << std::endl;
-    } else
-      std::wcout << _T("Failed [") << out1 << _T("=") << t.first << _T("]") << std::endl;
-  }
-  inline void run_test_getToken() {
-    test_getToken(_T(""), '&', _T(""), NULL);
-    test_getToken(_T("&"), '&', _T(""), NULL);
-    test_getToken(_T("&&"), '&', _T(""), _T("&"));
-    test_getToken(_T("foo"), '&', _T("foo"), NULL);
-    test_getToken(_T("foo&"), '&', _T("foo"), NULL);
-    test_getToken(_T("foo&bar"), '&', _T("foo"), _T("bar"));
-    test_getToken(_T("foo&bar&test"), '&', _T("foo"), _T("bar&test"));
-  }
-#endif
-
 };

trunk/include/com_helpers.hpp

@@ -1 +1 @@
 #pragma once
 
+#define _WIN32_DCOM
+#define _WIN32_WINNT 0x0400
+
 #include <error.hpp>
-/*
+#include <windows.h>
+#include <objbase.h>
 #include <atlbase.h>
 #include <atlsafe.h>
-#include <windows.h>
-*/
+
 namespace com_helper {
 

trunk/include/dll/impl_unix.hpp

@@ -4 +4 @@
 #include <boost/noncopyable.hpp>
 #include <error.hpp>
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#if defined(AIX)
+#include <dlfcn.h>
+#elif defined(LINUX) || defined(SUN) || defined(CYGWIN)
+#include <dlfcn.h>
+#elif defined(HP)
+#include <dl.h>
+#endif
+
 namespace dll {
   namespace iunix {
-
     class impl : public boost::noncopyable {
     private:
-      std::wstring module_;
+      boost::filesystem::wpath module_;
+      void* handle_;
+
     public:
-      impl(std::wstring module) : module_(module) {}
+      impl(boost::filesystem::wpath module) : module_(module), handle_(NULL) {
+        if (!boost::filesystem::is_regular(module)) {
+          module_ = fix_module_name(module_);
+        }
+      }
+      boost::filesystem::wpath fix_module_name( boost::filesystem::wpath module_ ) {
+        boost::filesystem::wpath mod = module_ / get_extension();
+        if (boost::filesystem::is_regular(mod))
+          return mod;
+        return module_;
+      }
+      static std::wstring get_extension() {
+#if defined(CYGWIN)
+        return _T(".so");
+#elif defined(HP)
+        return _T(".so");
+#else
+        return _T(".so");
+#endif
+      }
+
+      static bool is_module(std::wstring file) {
+        return boost::ends_with(file, get_extension());
+      }
 
       void load_library() {
-        throw dll_exception(_T("Could not load library: ") + module_);
+        std::string dllname = to_string(module_.string());
+#if defined(LINUX) || defined(SUN) || defined(AIX) || defined(CYGWIN)
+        handle_ = dlopen(dllname.c_str(), RTLD_NOW);
+        if (handle_ == NULL)
+          throw dll_exception(_T("Could not load library: ") + to_wstring(dlerror()) + _T(": ") + module_.string());
+#elif defined(HP)
+        handle_ = shl_load(dllname.c_str(), BIND_DEFERRED|DYNAMIC_PATH, 0L);
+        if (handle_ == NULL)
+          throw dll_exception(_T("Could not load library: ") + error::lookup::last_error() + _T(": ") + module_.string());
+#else
+        /* This type of UNIX has no DLL support yet */
+        throw dll_exception(_T("Unsupported Unix flavour (please report this): ") + module_.string());
+#endif
       }
       void* load_proc(std::string name) {
-        throw dll_exception(_T("Failed to load process from module: ") + module_);
+        if (handle_ == NULL)
+          throw dll_exception(_T("Failed to load process from module: ") + module_.string());
+        void *ep = NULL;
+#if defined(LINUX) || defined(SUN) || defined(AIX) || defined(CYGWIN)
+        ep = (void*) dlsym(handle_, name.c_str());
+        if (ep == NULL)
+          throw dll_exception(_T("Failed to load process from module: ") + module_.string() + _T(" because: ") + to_wstring(dlerror()));
+#elif defined(HP)
+        int rcode = shl_findsym((shl_t)&handle_, name.c_str(), TYPE_PROCEDURE, &ep);
+        if (rcode == -1)
+          return NULL;
+          //throw dll_exception(_T("Failed to load process from module: ") + module_.string());
+        return ep;
+#else
+        /* This type of UNIX has no DLL support yet */
+        throw dll_exception(_T("Unsupported Unix flavour (please report this): ") + module_.string());
+#endif
       }
 
       void unload_library() {
+#if defined(LINUX) || defined(SUN) || defined(AIX) || defined(CYGWIN)
+        dlclose(handle_);
+#elif defined(HP)
+        shl_unload(handle_);
+#else
+        /* This type of UNIX has no DLL support yet */
+        throw dll_exception(_T("Unsupported Unix flavour (please report this): ") + module_.string());
+#endif
+
       }
 
-      bool is_loaded() const { return false; }
-      std::wstring get_file() const { return module_; }
+      bool is_loaded() const { return handle_!=NULL; }
+      std::wstring get_file() const { return module_.string(); }
     };
   }

trunk/include/dll/impl_w32.hpp

@@ -9 +9 @@
     private:
       HMODULE handle_;
-      std::wstring module_;
+      boost::filesystem::wpath module_;
     public:
-      impl(std::wstring module) : module_(module), handle_(NULL) {}
+      impl(boost::filesystem::wpath module) : module_(module), handle_(NULL) {
+        if (!boost::filesystem::is_regular(module_)) {
+          module_ = fix_module_name(module_);
+        }
+      }
+      boost::filesystem::wpath fix_module_name( boost::filesystem::wpath module_ ) {
+        boost::filesystem::wpath mod = module_ / std::wstring(_T(".dll"));
+        if (boost::filesystem::is_regular(mod))
+          return mod;
+        std::wstring tmp = module_.file_string() + _T(".dll");
+        mod = tmp;
+        if (boost::filesystem::is_regular(mod))
+          return mod;
+        return module_;
+      }
+
+      static bool is_module(std::wstring file) {
+        return boost::ends_with(file, _T(".dll"));
+      }
 
       void load_library() {
         if (handle_ != NULL)
           unload_library();
-        handle_ = LoadLibrary(module_.c_str());
+        handle_ = LoadLibrary(module_.file_string().c_str());
         if (handle_ == NULL)
-          throw dll_exception(_T("Could not load library: ") + error::lookup::last_error() + _T(": ") + module_);
+          throw dll_exception(_T("Could not load library: ") + error::lookup::last_error() + _T(": ") + module_.file_string());
       }
       LPVOID load_proc(std::string name) {
         if (handle_ == NULL)
-          throw dll_exception(_T("Failed to load process from module: ") + module_);
-        return GetProcAddress(handle_, name.c_str());
+          throw dll_exception(_T("Failed to load process since module is not loaded: ") + module_.file_string());
+        LPVOID ep = GetProcAddress(handle_, name.c_str());
+        return ep;
       }
 
@@ -32 +51 @@
         handle_ = NULL;
       }
-
       bool is_loaded() const { return handle_ != NULL; }
-      std::wstring get_file() const { return module_; }
+      std::wstring get_file() const { return module_.file_string(); }
     };
   }

trunk/include/error_impl_unix.hpp

@@ -6 +6 @@
   class format {
   public:
-    static std::wstring from_system(unsigned long dwError) {
-      return _T("ERROR TODO");
+    static std::wstring from_system(int dwError) {
+      char buf [1024];
+      return to_wstring(::strerror_r(dwError, buf, sizeof (buf)));
     }
     static std::wstring from_module(std::wstring module, unsigned long dwError) {
@@ -41 +42 @@
   class lookup {
   public:
-    static std::wstring last_error(unsigned long dwLastError = -1) {
-      return _T("ERROR TODO");
+    static std::wstring last_error(int dwLastError = -1) {
+      return ::error::format::from_system(dwLastError);
     }
-    static std::string last_error_ansi(unsigned long dwLastError = -1) {
-      return "ERROR TODO";
+    static std::string last_error_ansi(int dwLastError = -1) {
+      return to_string(::error::format::from_system(dwLastError));
     }
   };

trunk/include/nsc_module_wrapper.hpp

@@ -31 +31 @@
 #define NSC_WRAPPERS_MAIN() \
   extern "C" int NSModuleHelperInit(NSCModuleHelper::lpNSAPILoader f); \
-  extern int NSLoadModule(int mode); \
-  extern int NSGetModuleName(wchar_t* buf, int buflen); \
-  extern int NSGetModuleDescription(wchar_t* buf, int buflen); \
-  extern int NSGetModuleVersion(int *major, int *minor, int *revision); \
-  extern NSCAPI::boolReturn NSHasCommandHandler(); \
-  extern NSCAPI::boolReturn NSHasMessageHandler(); \
-  extern void NSHandleMessage(int msgType, wchar_t* file, int line, wchar_t* message); \
-  extern NSCAPI::nagiosReturn NSHandleCommand(const wchar_t* IN_cmd, const unsigned int IN_argsLen, wchar_t **IN_args, \
+  extern "C" int NSLoadModule(int mode); \
+  extern "C" int NSGetModuleName(wchar_t* buf, int buflen); \
+  extern "C" int NSGetModuleDescription(wchar_t* buf, int buflen); \
+  extern "C" int NSGetModuleVersion(int *major, int *minor, int *revision); \
+  extern "C" NSCAPI::boolReturn NSHasCommandHandler(); \
+  extern "C" NSCAPI::boolReturn NSHasMessageHandler(); \
+  extern "C" void NSHandleMessage(int msgType, wchar_t* file, int line, wchar_t* message); \
+  extern "C" NSCAPI::nagiosReturn NSHandleCommand(const wchar_t* IN_cmd, const unsigned int IN_argsLen, wchar_t **IN_args, \
     wchar_t *OUT_retBufMessage, unsigned int IN_retBufMessageLen, wchar_t *OUT_retBufPerf, unsigned int IN_retBufPerfLen); \
-  extern int NSUnloadModule(); \
-  extern int NSGetConfigurationMeta(int IN_retBufLen, wchar_t *OUT_retBuf)
+  extern "C" int NSUnloadModule(); \
+  extern "C" int NSGetConfigurationMeta(int IN_retBufLen, wchar_t *OUT_retBuf)
 
 #define NSC_WRAPPERS_CLI() \
-  extern int NSCommandLineExec(const wchar_t*,const unsigned int,wchar_t**)
+  extern "C" int NSCommandLineExec(const wchar_t*,const unsigned int,wchar_t**)
 
 #ifdef DEBUG

trunk/include/settings/Settings.h

@@ -27 +27 @@
 #include <boost/thread/thread.hpp>
 #include <boost/thread/locks.hpp>
+#include <boost/filesystem/path.hpp>
 #include <strEx.h>
 #define BUFF_LEN 4096
@@ -369 +370 @@
     ///
     /// @author mickem
-    virtual void set_base(std::wstring path) = 0;
+    virtual void set_base(boost::filesystem::wpath path) = 0;
 
     //////////////////////////////////////////////////////////////////////////
@@ -378 +379 @@
     ///
     /// @author mickem
-    virtual std::wstring get_base() = 0;
+    virtual boost::filesystem::wpath get_base() = 0;
 
     //////////////////////////////////////////////////////////////////////////
@@ -654 +655 @@
     //path_map path_mappings_;
     //path_map reversed_path_mappings_;
-    std::wstring base_path_;
+    boost::filesystem::wpath base_path_;
     LoggerInterface *logger_;
     typedef std::map<std::wstring,path_description> reg_paths_type;
@@ -676 +677 @@
     ///
     /// @author mickem
-    void set_base(std::wstring path) {
+    void set_base(boost::filesystem::wpath path) {
       base_path_ = path;
     }
@@ -711 +712 @@
     ///
     /// @author mickem
-    std::wstring get_base() {
+    boost::filesystem::wpath get_base() {
       return base_path_;
     }

trunk/include/settings/settings_ini.hpp

@@ -3 +3 @@
 #include <string>
 #include <map>
+
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
+
 #include <settings/Settings.h>
-
 #include <simpleini/simpleini.h>
 #include <error.hpp>
@@ -11 +14 @@
   class INISettings : public Settings::SettingsInterfaceImpl {
   private:
-    std::wstring filename_;
+    boost::filesystem::wpath filename_;
     bool is_loaded_;
     CSimpleIni ini;
@@ -184 +187 @@
     virtual void save() {
       SettingsInterfaceImpl::save();
-      SI_Error rc = ini.SaveFile(get_file_name().c_str());
+      SI_Error rc = ini.SaveFile(get_file_name().string().c_str());
       if (rc < 0)
         throw_SI_error(rc, _T("Failed to save file"));
@@ -199 +202 @@
         return;
       }
-      SI_Error rc = ini.LoadFile(get_file_name().c_str());
+      SI_Error rc = ini.LoadFile(get_file_name().string().c_str());
       if (rc < 0)
         throw_SI_error(rc, _T("Failed to load file"));
@@ -214 +217 @@
       throw SettingsException(msg + _T(": ") + get_context() + _T(" - ") + error_str);
     }
-    std::wstring get_file_name() {
+    boost::filesystem::wpath get_file_name() {
       if (filename_.empty()) {
-        filename_ = get_core()->get_base() + _T("\\") + get_core()->get_boot_string(get_context(), _T("file"), _T("nsclient.ini"));
-        get_core()->get_logger()->debug(__FILEW__, __LINE__, _T("Reading INI settings from: ") + filename_);
+        filename_ = get_core()->get_base() / boost::filesystem::wpath(get_core()->get_boot_string(get_context(), _T("file"), _T("nsclient.ini")));
+        get_core()->get_logger()->debug(__FILEW__, __LINE__, _T("Reading INI settings from: ") + filename_.string());
       }
       return filename_;
     }
     bool file_exists() {
-      std::wstring filename = get_file_name();
-      FILE * fp = NULL;
-      bool found = false;
-#if __STDC_WANT_SECURE_LIB__
-      if (_wfopen_s(&fp, filename.c_str(), L"rb") != 0)
-        return false;
-#elif WIN32
-      fp = _wfopen(filename.c_str(), L"rb");
-#else
-      fp = fopen(to_string(filename).c_str(), "rb");
-#endif
-      if (!fp)
-        return false;
-      fclose(fp);
-      return true;
+      return boost::filesystem::is_regular(get_file_name());
     }
   };

trunk/include/settings/settings_old.hpp

@@ -447 +447 @@
     inline std::wstring get_file_name() {
       if (filename_.empty()) {
-        filename_ = get_core()->get_base() + _T("\\") + get_core()->get_boot_string(get_context(), _T("file"), _T("nsc.ini"));
+        filename_ = (get_core()->get_base() / get_core()->get_boot_string(get_context(), _T("file"), _T("nsc.ini"))).string();
         get_core()->get_logger()->debug(__FILEW__, __LINE__, _T("Reading old settings from: ") + filename_);
       }
@@ -453 +453 @@
     }
     bool file_exists() {
-      std::wstring filename = get_file_name();
-      FILE * fp = NULL;
-      bool found = false;
-#if __STDC_WANT_SECURE_LIB__
-      if (_wfopen_s(&fp, filename.c_str(), L"rb") != 0)
-        return false;
-#else
-      fp = _wfopen(filename.c_str(), L"rb");
-#endif
-      if (!fp)
-        return false;
-      fclose(fp);
-      return true;
+      return boost::filesystem::is_regular_file(get_file_name());
     }
   };

trunk/include/strEx.h

@@ -35 +35 @@
 #include <boost/date_time.hpp>
 #include <boost/lexical_cast.hpp>
+#include <boost/algorithm/string.hpp>
 //#include <boost/date_time/local_time/local_date_time.hpp>
 //#include <boost/date_time/gregorian/conversion.hpp>
@@ -582 +583 @@
   struct blind_traits : public std::char_traits<_E>
   {
+    
     static bool eq(const _E& x, const _E& y) {
-      return tolower( x ) == tolower( y ); 
+      return boost::algorithm::iequals(x,y);
     }
     static bool lt(const _E& x, const _E& y) {
-      return tolower( x ) < tolower( y ); 
-    }
-
+      return ilexicographical_compare(x, y);
+    }
+/*
     static int compare(const _E *x, const _E *y, size_t n) { 
+      return ilexicographical_compare(x, y);
       return _wcsnicmp( x, y, n );
     }
 
     //  There's no memichr(), so we roll our own.  It ain't rocket science.
-    static const _E * /*__cdecl*/ find(const _E *buf, size_t len, const _E& ch) {
+    static const _E * / *__cdecl* / find(const _E *buf, size_t len, const _E& ch) {
       //  Jerry says that x86s have special mojo for memchr(), so the 
       //  memchr() calls end up being reasonably efficient in practice.
@@ -613 +616 @@
       return std::char_traits<_E>::eq_int_type( tolower( ch1 ), tolower( ch2 ) ); 
     }
+    */
   };
 
@@ -618 +622 @@
   //typedef std::basic_string<char, blind_traits<char>, std::allocator<char> >  blindstr;
   typedef std::basic_string<wchar_t, blind_traits<wchar_t>, std::allocator<wchar_t> >  blindstr;
-
+/*
   class StrICmp
   {
@@ -665 +669 @@
     }
   };
+  */
 
 #ifdef _DEBUG

trunk/include/types.hpp

@@ -1 +1 @@
 #pragma once
+
+typedef wchar_t TCHAR;
 
 
@@ -5 +7 @@
 typedef unsigned long DWORD;
 typedef void* LPVOID;
+typedef int BOOL;
 #endif
 
 
 #ifdef WIN32
+#include <windows.h>
 #define wcscasecmp _wcsicmp
 #endif

trunk/modules/CheckHelpers/CheckHelpers.cpp

@@ -26 +26 @@
 
 CheckHelpers gCheckHelpers;
-
+#ifdef WIN32
 BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
 {
@@ -32 +32 @@
   return TRUE;
 }
+#endif
 
 CheckHelpers::CheckHelpers() {

trunk/modules/CheckHelpers/stdafx.h

@@ -21 +21 @@
 #pragma once
 
-#define WIN32_LEAN_AND_MEAN   // Exclude rarely-used stuff from Windows headers
-// Windows Header Files:
-#include <windows.h>
+#include <types.hpp>
+#include <unicode_char.hpp>
 
 #include <string>
@@ -32 +31 @@
 #include <NSCHelper.h>
 
-#ifdef MEMCHECK
-#include <vld.h>
-#endif

trunk/service/CMakeLists.txt

@@ -1 +1 @@
 cmake_minimum_required(VERSION 2.6)
-  
-PROJECT(NSCP)
-#SET(CMAKE_MODULE_PATH ${NSCP_SOURCE_DIR})
 
-SET(VERSION_SERIES 0)
-SET(VERSION_MAJOR 4)
-SET(VERSION_MINOR 0)
-
-IF(NOT SHARED_LIBS)
-  IF(WIN32)
-    OPTION(SHARED_LIBS "Compile shared libraries" OFF)
-  ELSE(WIN32)
-    OPTION(SHARED_LIBS "Compile shared libraries" ON)
-  ENDIF(WIN32)
-ENDIF(NOT SHARED_LIBS)
-
-IF(NOT SHARED_LIBS)
-  SET(NSCP_STATIC true)
-ENDIF(NOT SHARED_LIBS)
-
-IF(NOT MULTI_THREADED)
-  OPTION(MULTI_THREADED "Build multi-threaded httpd deamon (if possible)" ON)
-ENDIF(NOT MULTI_THREADED)
-
-SET(BUILD_SHARED_LIBS ${SHARED_LIBS})
-
-SET(NSCP_LOCAL_INCLUDE_PATH "${PROJECT_BINARY_DIR}/../include" CACHE PATH "directory containing NSCP specific includes")
-
-
-set(Boost_USE_STATIC_LIBS   ON)
-set(Boost_USE_MULTITHREADED ON)
-
-
-IF(WIN32)
-  #SET(USERLIB_ROOT "c:/libraries" CACHE PATH "directory containing the dependency libraries")
-  SET(LIB_INSTALL_DIR "lib" CACHE STRING "Default path for libraries within ${CMAKE_INSTALL_PREFIX}")
-  SET(RUNDIR "c:/nscp" CACHE PATH "Not really used in WIN32")
-  #SET(CONFIGURATION c:/witty/wt_config.xml CACHE PATH "Path for the wt configuration file")
-  #SET(DEPLOYROOT c:/nscp/ CACHE PATH "Path to deploy examples into")
-  #SET(BOOST_DIR ${USERLIB_ROOT} CACHE PATH "Use boost in directory")
-  SET(BOOST_LIBRARYDIR c:/src/lib/x86 CACHE PATH "")
-  SET(BOOST_INCLUDEDIR c:/src/include/boost-1_39 CACHE PATH "")
-  
-  SET(BOOST_LIB_PREFIX lib CACHE STRING "Look for Boost libraries prefixed with this")
-  SET(BOOST_LIB_SUFFIX vc80-mt CACHE STRING "Look for Boost libraries ending with this")
-
-  #SET(BOOST_VERSION "1_34_1" CACHE STRING "Use boost version in BOOST_DIR")
-  #OPTION(BOOST_DYNAMIC "Link to boost DLLs (OFF means static link)" OFF)
-
-ELSE(WIN32)
-
-  SET(USERLIB_ROOT /usr CACHE PATH "Other installation prefix for dependent libraries")
-  SET(LIB_INSTALL_DIR "lib" CACHE STRING "Default path for libraries within ${CMAKE_INSTALL_PREFIX}")
-  SET(RUNDIR "/usr/wt/run" CACHE PATH "Default path for wt session management (only used by FCGI connector; not relative to CMAKE_INSTALL_PREFIX)")
-  SET(CONFIGURATION /etc/nscp/boot.ini CACHE PATH "Path to the boot configuration file")
-  SET(MAIN_CONFIGURATION /etc/nscp/nscp.xml CACHE PATH "Path for the client configurtion file")
-  SET(DEPLOYROOT /usr/bin CACHE PATH "Path to deploy examples into)")
-  SET(BOOST_DIR /usr CACHE PATH "Boost installation path prefix")
-  SET(BOOST_COMPILER gcc CACHE STRING "Boost libraries compiler signature")
-  SET(BOOST_VERSION "1_34_1" CACHE STRING "Boost libraries version signature")
-ENDIF(WIN32)
-
-#SET(CMAKE_MODULE_PATH "../cmake/")
-FIND_PACKAGE(Boost COMPONENTS system filesystem thread REQUIRED)
-
-#INCLUDE(../cmake/WtFindBoost.txt)
-#INCLUDE(../cmake/WtFindAsio.txt)
-INCLUDE(../cmake/WtFindSsl.txt)
-#INCLUDE(../cmake/FindICU.cmake)
-
-#IF(NOT WIN32)
-# FIND_PACKAGE(ICU REQUIRED)
-# IF(NOT ICU_FOUND)
-#   MESSAGE(FATAL_ERROR "ICU package not found..")
-# ELSE(NOT ICU_FOUND)
-#   ADD_DEFINITIONS( -DSI_CONVERT_ICU )
-# ENDIF(NOT ICU_FOUND)
-#ENDIF(NOT WIN32)
-
-IF(NOT WIN32)
-  FIND_PACKAGE(Threads REQUIRED)
-  IF (NOT CMAKE_USE_PTHREADS_INIT)
-    message(FATAL_ERROR "Could not find POSIX threads")
-  ELSE (NOT CMAKE_USE_PTHREADS_INIT)
-    #add_definitions(-D_REENTRANT)
-  ENDIF (NOT CMAKE_USE_PTHREADS_INIT)
-  FIND_PACKAGE(Threads REQUIRED)
-ENDIF(NOT WIN32)
-
-
-
-# Boost is used nearly everywhere, so we can put these here
+PROJECT(service)
 INCLUDE_DIRECTORIES(${BOOST_INCLUDE_DIRS})
 LINK_DIRECTORIES(${BOOST_LIB_DIRS})
-IF(WIN32)
-  IF(BOOST_DYNAMIC)
-    ADD_DEFINITIONS(-DBOOST_ALL_DYN_LINK)
-  ENDIF(BOOST_DYNAMIC)
-  set (EXTRA_LIBS ${EXTRA_LIBS} Userenv ole32)
-ENDIF(WIN32)
+#INCLUDE_DIRECTORIES(${NSCP_INCLUDE_PATH})
 
-IF(NOT CMAKE_BUILD_TYPE)
-  SET(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING
-      "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel."
-      FORCE)
-ENDIF(NOT CMAKE_BUILD_TYPE)
+ADD_DEFINITIONS(${NSCP_GLOBAL_DEFINES})
 
-# Compile time constants & make sure our build finds it
-CONFIGURE_FILE(
-  config.h.in
-  xconfig.h
-)
-INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})
-INCLUDE_DIRECTORIES(${NSCP_LOCAL_INCLUDE_PATH})
-INSTALL_FILES(/include FILES ${WCONFIG_H_PATH})
-
-add_definitions(-DUNICODE -D_UNICODE)
-
-include_directories("${PROJECT_BINARY_DIR}")
-
-
-add_executable (NSCP 
+SET(service_SRCS
   NSClient++.cpp
   NSCPlugin.cpp
   core_api.cpp
   settings_manager_impl.cpp
-  ../include/NSCHelper.cpp
-  ../include/arrayBuffer.cpp
-  ../include/simpleini/ConvertUTF.c
-# ../include/ServiceCmd.cpp
-  ../include/b64/b64.c
+  ${NSCP_INCLUDE_PATH}/NSCHelper.cpp
+  ${NSCP_INCLUDE_PATH}/arrayBuffer.cpp
+  ${NSCP_INCLUDE_PATH}/simpleini/ConvertUTF.c
+  ${NSCP_INCLUDE_PATH}/b64/b64.c
 )
 
-target_link_libraries(NSCP 
+IF(WIN32)
+  SET(service_SRCS ${service_SRCS}
+    ${NSCP_INCLUDE_PATH}/ServiceCmd.cpp
+  )
+  SET(service_SRCS ${service_SRCS}
+    ${NSCP_INCLUDE_PATH}/settings/Settings.h
+    ${NSCP_INCLUDE_PATH}/charEx.h
+    ${NSCP_INCLUDE_PATH}/config.h
+    ${NSCP_INCLUDE_PATH}/msvc_wrappers.h
+    ${NSCP_INCLUDE_PATH}/settings/macros.h
+    ${NSCP_INCLUDE_PATH}/settings/settings_ini.hpp
+    ${NSCP_INCLUDE_PATH}/settings/settings_old.hpp
+    ${NSCP_INCLUDE_PATH}/settings/settings_registry.hpp
+    ${NSCP_INCLUDE_PATH}/settings/Settings.h
+    ${NSCP_INCLUDE_PATH}/NSCHelper.h
+    ${NSCP_INCLUDE_PATH}/com_helpers.hpp
+    ${NSCP_INCLUDE_PATH}/dll/dll.hpp
+    ${NSCP_INCLUDE_PATH}/dll/impl_unix.hpp
+    ${NSCP_INCLUDE_PATH}/dll/impl_w32.hpp
+    core_api.h
+    settings_manager_impl.h
+  )
+  ADD_DEFINITIONS(-D_WIN32_DCOM)
+
+ENDIF(WIN32)
+
+add_executable (nsclient++ ${service_SRCS})
+
+target_link_libraries(nsclient++ 
   ${Boost_FILESYSTEM_LIBRARY}
   ${Boost_LIBRARIES}
@@ -140 +54 @@
 )
 
-
-
-
 INSTALL(FILES ${PROJECT_SOURCE_DIR}/cmake/FindWt.cmake DESTINATION
     ${CMAKE_INSTALL_PREFIX}/${WT_CMAKE_FINDER_INSTALL_DIR} )

trunk/service/NSCPlugin.cpp

@@ -20 +20 @@
 ***************************************************************************/
 #include "StdAfx.h"
-#include "NSClient++.h"
-#include <error.hpp>
+#include "NSCPlugin.h"
 #include "core_api.h"
 /**
@@ -30 +29 @@
  * @param file The file (DLL) to load as a NSC plug in.
  */
-NSCPlugin::NSCPlugin(const std::wstring file)
-  : module_(file)
+NSCPlugin::NSCPlugin(const boost::filesystem::wpath file)
+  : module_(file.string())
   ,fLoadModule(NULL)
   ,fGetName(NULL)
@@ -48 +47 @@
   ,broken_(false)
 {
+
 }
 /*
@@ -305 +305 @@
 void NSCPlugin::loadRemoteProcs_(void) {
 
-  fLoadModule = (lpLoadModule)module_.load_proc("NSLoadModule");
-  if (!fLoadModule)
-    throw NSPluginException(module_, _T("Could not load NSLoadModule"));
-
-  fModuleHelperInit = (lpModuleHelperInit)module_.load_proc("NSModuleHelperInit");
-  if (!fModuleHelperInit)
-    throw NSPluginException(module_, _T("Could not load NSModuleHelperInit"));
-
-  try {
-    fModuleHelperInit(NSAPILoader);
-  } catch (...) {
-    throw NSPluginException(module_, _T("Unhandled exception in getDescription."));
-  }
-  
-  fGetName = (lpGetName)module_.load_proc("NSGetModuleName");
-  if (!fGetName)
-    throw NSPluginException(module_, _T("Could not load NSGetModuleName"));
-
-  fGetVersion = (lpGetVersion)module_.load_proc("NSGetModuleVersion");
-  if (!fGetVersion)
-    throw NSPluginException(module_, _T("Could not load NSGetModuleVersion"));
-
-  fGetDescription = (lpGetDescription)module_.load_proc("NSGetModuleDescription");
-  if (!fGetDescription)
-    throw NSPluginException(module_, _T("Could not load NSGetModuleDescription"));
-
-  fHasCommandHandler = (lpHasCommandHandler)module_.load_proc("NSHasCommandHandler");
-  if (!fHasCommandHandler)
-    throw NSPluginException(module_, _T("Could not load NSHasCommandHandler"));
-
-  fHasMessageHandler = (lpHasMessageHandler)module_.load_proc("NSHasMessageHandler");
-  if (!fHasMessageHandler)
-    throw NSPluginException(module_, _T("Could not load NSHasMessageHandler"));
-
-  fHandleCommand = (lpHandleCommand)module_.load_proc("NSHandleCommand");
-  if (!fHandleCommand)
-    throw NSPluginException(module_, _T("Could not load NSHandleCommand"));
-
-  fHandleMessage = (lpHandleMessage)module_.load_proc("NSHandleMessage");
-  if (!fHandleMessage)
-    throw NSPluginException(module_, _T("Could not load NSHandleMessage"));
-
-  fUnLoadModule = (lpUnLoadModule)module_.load_proc("NSUnloadModule");
-  if (!fUnLoadModule)
-    throw NSPluginException(module_, _T("Could not load NSUnloadModule"));
-
-  fGetConfigurationMeta = (lpGetConfigurationMeta)module_.load_proc("NSGetConfigurationMeta");
-  fCommandLineExec = (lpCommandLineExec)module_.load_proc("NSCommandLineExec");
-
-  fShowTray = (lpShowTray)module_.load_proc("ShowIcon");
-  fHideTray = (lpHideTray)module_.load_proc("HideIcon");
+  try {
+    fLoadModule = (lpLoadModule)module_.load_proc("NSLoadModule");
+    if (!fLoadModule)
+      throw NSPluginException(module_, _T("Could not load NSLoadModule"));
+
+    fModuleHelperInit = (lpModuleHelperInit)module_.load_proc("NSModuleHelperInit");
+    if (!fModuleHelperInit)
+      throw NSPluginException(module_, _T("Could not load NSModuleHelperInit"));
+
+    try {
+      fModuleHelperInit(NSAPILoader);
+    } catch (...) {
+      throw NSPluginException(module_, _T("Unhandled exception in getDescription."));
+    }
+
+    fGetName = (lpGetName)module_.load_proc("NSGetModuleName");
+    if (!fGetName)
+      throw NSPluginException(module_, _T("Could not load NSGetModuleName"));
+
+    fGetVersion = (lpGetVersion)module_.load_proc("NSGetModuleVersion");
+    if (!fGetVersion)
+      throw NSPluginException(module_, _T("Could not load NSGetModuleVersion"));
+
+    fGetDescription = (lpGetDescription)module_.load_proc("NSGetModuleDescription");
+    if (!fGetDescription)
+      throw NSPluginException(module_, _T("Could not load NSGetModuleDescription"));
+
+    fHasCommandHandler = (lpHasCommandHandler)module_.load_proc("NSHasCommandHandler");
+    if (!fHasCommandHandler)
+      throw NSPluginException(module_, _T("Could not load NSHasCommandHandler"));
+
+    fHasMessageHandler = (lpHasMessageHandler)module_.load_proc("NSHasMessageHandler");
+    if (!fHasMessageHandler)
+      throw NSPluginException(module_, _T("Could not load NSHasMessageHandler"));
+
+    fHandleCommand = (lpHandleCommand)module_.load_proc("NSHandleCommand");
+    if (!fHandleCommand)
+      throw NSPluginException(module_, _T("Could not load NSHandleCommand"));
+
+    fHandleMessage = (lpHandleMessage)module_.load_proc("NSHandleMessage");
+    if (!fHandleMessage)
+      throw NSPluginException(module_, _T("Could not load NSHandleMessage"));
+
+    fUnLoadModule = (lpUnLoadModule)module_.load_proc("NSUnloadModule");
+    if (!fUnLoadModule)
+      throw NSPluginException(module_, _T("Could not load NSUnloadModule"));
+
+    fGetConfigurationMeta = (lpGetConfigurationMeta)module_.load_proc("NSGetConfigurationMeta");
+    fCommandLineExec = (lpCommandLineExec)module_.load_proc("NSCommandLineExec");
+
+    fShowTray = (lpShowTray)module_.load_proc("ShowIcon");
+    fHideTray = (lpHideTray)module_.load_proc("HideIcon");
+  } catch (dll::dll_exception &e) {
+    throw NSPluginException(module_, _T("Unhandled exception when loading proces: ") + e.what());
+  }
 
 }

trunk/service/NSCPlugin.h

@@ -141 +141 @@
 
 public:
-  NSCPlugin(const std::wstring file);
+  NSCPlugin(const boost::filesystem::wpath file);
   NSCPlugin(NSCPlugin &other);
   virtual ~NSCPlugin(void);

trunk/service/NSClient++.cpp

@@ -84 +84 @@
 
   static bool start(unsigned long  dwSessionId) {
-    std::wstring program = mainClient.getBasePath() +  _T("\\") + 
-      SETTINGS_GET_STRING_CORE(settings_def::SYSTRAY_EXE);
-    std::wstring cmdln = _T("\"") + program + _T("\" -channel __") + strEx::itos(dwSessionId) + _T("__");
-    return tray_starter::startTrayHelper(dwSessionId, program, cmdln);
+    boost::filesystem::wpath program = mainClient.getBasePath() / SETTINGS_GET_STRING_CORE(settings_def::SYSTRAY_EXE);
+    std::wstring cmdln = _T("\"") + program.string() + _T("\" -channel __") + strEx::itos(dwSessionId) + _T("__");
+    return tray_starter::startTrayHelper(dwSessionId, program.string(), cmdln);
   }
 
@@ -205 +204 @@
 
 
-bool is_module( std::wstring file ) 
+bool is_module(boost::filesystem::wpath file ) 
 {
-  return boost::ends_with(file, _T(".dll"));
+  return boost::ends_with(file.string(), _T(".dll")) || boost::ends_with(file.string(), _T(".so"));
 }
 /**
@@ -390 +389 @@
       return 0;
     } else if ( wcscasecmp( _T("about"), argv[1]+1 ) == 0 ) {
-      g_bConsoleLog = true;
-      LOG_MESSAGE(SZAPPNAME _T(" (C) Michael Medin - michael<at>medin<dot>name"));
-      LOG_MESSAGE(_T("Version: ") SZVERSION);
-      LOG_MESSAGE(_T("Architecture: ") SZARCH);
-
-      std::wstring pluginPath = mainClient.getBasePath() + _T("modules\\");
-      LOG_MESSAGE_STD(_T("Looking at plugins in: ") + pluginPath);
-
-      boost::filesystem::wdirectory_iterator end_itr; // default construction yields past-the-end
-      for ( boost::filesystem::wdirectory_iterator itr( pluginPath ); itr != end_itr; ++itr ) {
-        if ( !is_directory(itr->status()) ) {
-          std::wstring file= itr->leaf();
-          if (is_module(pluginPath + _T("\\") + file)) {
-            NSCPlugin *plugin = new NSCPlugin(pluginPath + _T("\\") + file);
-            std::wstring name = _T("<unknown>");
-            std::wstring description = _T("<unknown>");
-            try {
-              plugin->load_dll();
-              name = plugin->getName();
-              description = plugin->getDescription();
-            } catch(const NSPluginException& e) {
-              LOG_ERROR_STD(_T("Exception raised: ") + e.error_ + _T(" in module: ") + e.file_);
-            } catch (std::exception e) {
-              LOG_ERROR_STD(_T("exception loading plugin: ") + strEx::string_to_wstring(e.what()));
-            } catch (...) {
-              LOG_ERROR_STD(_T("Unknown exception loading plugin"));
-            }
-            LOG_MESSAGE_STD(_T("* ") + name + _T(" (") + file + _T(")"));
-            std::list<std::wstring> list = strEx::splitEx(description, _T("\n"));
-            for (std::list<std::wstring>::const_iterator cit = list.begin(); cit != list.end(); ++cit) {
-              LOG_MESSAGE_STD(_T("    ") + *cit);
+      try {
+        g_bConsoleLog = true;
+        LOG_MESSAGE(SZAPPNAME _T(" (C) Michael Medin - michael<at>medin<dot>name"));
+        LOG_MESSAGE(_T("Version: ") SZVERSION);
+        LOG_MESSAGE(_T("Architecture: ") SZARCH);
+
+        boost::filesystem::wpath pluginPath = (boost::filesystem::wpath)mainClient.getBasePath() / _T("modules");
+        LOG_MESSAGE_STD(_T("Looking at plugins in: ") + pluginPath.string());
+
+        boost::filesystem::wdirectory_iterator end_itr; // default construction yields past-the-end
+        for ( boost::filesystem::wdirectory_iterator itr( pluginPath ); itr != end_itr; ++itr ) {
+          if ( !is_directory(itr->status()) ) {
+            std::wstring file= itr->leaf();
+            LOG_MESSAGE_STD(_T("Found: ") + file);
+            if (is_module(pluginPath / file)) {
+              NSCPlugin *plugin = new NSCPlugin(pluginPath / file);
+              std::wstring name = _T("<unknown>");
+              std::wstring description = _T("<unknown>");
+              try {
+                plugin->load_dll();
+                name = plugin->getName();
+                description = plugin->getDescription();
+              } catch(const NSPluginException& e) {
+                LOG_ERROR_STD(_T("Exception raised: ") + e.error_ + _T(" in module: ") + e.file_);
+              } catch (std::exception e) {
+                LOG_ERROR_STD(_T("exception loading plugin: ") + strEx::string_to_wstring(e.what()));
+              } catch (...) {
+                LOG_ERROR_STD(_T("Unknown exception loading plugin"));
+              }
+              LOG_MESSAGE_STD(_T("* ") + name + _T(" (") + file + _T(")"));
+              std::list<std::wstring> list = strEx::splitEx(description, _T("\n"));
+              for (std::list<std::wstring>::const_iterator cit = list.begin(); cit != list.end(); ++cit) {
+                LOG_MESSAGE_STD(_T("    ") + *cit);
+              }
             }
           }
         }
+        LOG_MESSAGE_STD(_T("Done listing plugins from: ") + pluginPath.string());
+        return true;
+      } catch (std::exception &e) {
+        LOG_ERROR_STD(_T("Exception: ") + to_wstring(e.what()));
+      } catch (...) {
+        LOG_ERROR_STD(_T("Unknown Exception: "));
       }
       return false;
@@ -568 +576 @@
 NSClientT::plugin_info_list NSClientT::get_all_plugins() {
   plugin_info_list ret;
-  std::wstring pluginPath = getBasePath() + _T("modules\\");
+  boost::filesystem::wpath pluginPath = getBasePath() / boost::filesystem::wpath(_T("modules"));
   boost::filesystem::wdirectory_iterator end_itr; // default construction yields past-the-end
   for ( boost::filesystem::wdirectory_iterator itr( pluginPath ); itr != end_itr; ++itr ) {
     if ( !is_directory(itr->status()) ) {
-      std::wstring file= itr->leaf();
-      if (is_module(pluginPath + _T("\\") + file)) {
+      boost::filesystem::wpath file= itr->leaf();
+      if (is_module(pluginPath  / file)) {
         plugin_info_type info;
         info.dll = itr->leaf();
         try {
-          LOG_DEBUG_STD(_T("Attempting to fake load: ") + file);
-          NSCPlugin plugin(pluginPath + _T("\\") + file);
+          LOG_DEBUG_STD(_T("Attempting to fake load: ") + file.string());
+          NSCPlugin plugin(pluginPath / file);
           plugin.load_dll();
           plugin.load_plugin(NSCAPI::dontStart);
@@ -587 +595 @@
           LOG_CRITICAL_STD(_T("Error loading: ") + e.file_ + _T(" root cause: ") + e.error_);
         } catch (...) {
-          LOG_CRITICAL_STD(_T("Unknown Error loading: ") + file);
+          LOG_CRITICAL_STD(_T("Unknown Error loading: ") + file.string());
         }
         ret.push_back(info);
@@ -598 +606 @@
 
 void NSClientT::load_all_plugins(int mode) {
-  std::wstring modPath = getBasePath() + _T("modules\\");
+  boost::filesystem::wpath modPath = getBasePath() / boost::filesystem::wpath(_T("modules"));
 
   boost::filesystem::wdirectory_iterator end_itr; // default construction yields past-the-end
   for ( boost::filesystem::wdirectory_iterator itr( modPath ); itr != end_itr; ++itr ) {
     if ( !is_directory(itr->status()) ) {
-      std::wstring file= itr->leaf();
-      if (is_module(modPath + _T("\\") + file)) {
-        if (settings_manager::get_settings()->has_key(MAIN_MODULES_SECTION, file)) {
-          if (settings_manager::get_settings()->get_string(MAIN_MODULES_SECTION, file) == _T("disabled")) {
+      boost::filesystem::wpath file= itr->leaf();
+      if (is_module(modPath / file)) {
+        if (settings_manager::get_settings()->has_key(MAIN_MODULES_SECTION, file.string())) {
+          if (settings_manager::get_settings()->get_string(MAIN_MODULES_SECTION, file.string()) == _T("disabled")) {
             try {
-              LOG_DEBUG_STD(_T("Attempting to fake load: ") + file);
-              NSCPlugin plugin(modPath + file);
+              LOG_DEBUG_STD(_T("Attempting to fake load: ") + file.string());
+              NSCPlugin plugin(modPath / file);
               plugin.load_dll();
               plugin.load_plugin(mode);
@@ -616 +624 @@
               LOG_CRITICAL_STD(_T("Error loading: ") + e.file_ + _T(" root cause: ") + e.error_);
             } catch (...) {
-              LOG_CRITICAL_STD(_T("Unknown Error loading: ") + file);
+              LOG_CRITICAL_STD(_T("Unknown Error loading: ") + file.string());
             }
           }
@@ -622 +630 @@
           std::wstring desc;
           try {
-            NSCPlugin plugin(modPath + file);
+            NSCPlugin plugin(modPath / file);
             plugin.load_dll();
             plugin.load_plugin(mode);
@@ -633 +641 @@
           } catch (...) {
             desc += _T("unknown module");
-            LOG_CRITICAL_STD(_T("Unknown Error loading: ") + file);
+            LOG_CRITICAL_STD(_T("Unknown Error loading: ") + file.string());
           }
-          settings_manager::get_core()->register_key(MAIN_MODULES_SECTION, file, Settings::SettingsCore::key_string, desc, desc, _T("disabled"), false);
+          settings_manager::get_core()->register_key(MAIN_MODULES_SECTION, file.string(), Settings::SettingsCore::key_string, desc, desc, _T("disabled"), false);
         }
       }
@@ -846 +854 @@
         }
         try {
-          loadPlugin(getBasePath() + _T("modules\\") + (*cit));
+          loadPlugin(getBasePath() / boost::filesystem::wpath(_T("modules")) / boost::filesystem::wpath(*cit));
         } catch(const NSPluginException& e) {
-          LOG_ERROR_STD(_T("Exception raised: ") + e.error_ + _T(" in module: ") + e.file_);
+          LOG_ERROR_STD(_T("Exception raised: '") + e.error_ + _T("' in module: ") + e.file_);
           //return false;
         } catch (std::exception e) {
@@ -1068 +1076 @@
   }
   try {
-    plugin_type plugin = loadPlugin(getBasePath() + _T("modules\\") + module);
-    LOG_DEBUG_STD(_T("Loading plugin: ") + plugin->getName() + _T("..."));
-    plugin->load_plugin(NSCAPI::dontStart);
-    return plugin->commandLineExec(command, argLen, args);
-  } catch (NSPluginException e) {
-    LOG_MESSAGE_STD(_T("Module (") + e.file_ + _T(") was not found: ") + e.error_);
-  }
-  try {
-    plugin_type plugin = loadPlugin(getBasePath() + _T("modules\\") + module + _T(".dll"));
+    plugin_type plugin = loadPlugin(getBasePath() / boost::filesystem::wpath(_T("modules")) / boost::filesystem::wpath(module));
     LOG_DEBUG_STD(_T("Loading plugin: ") + plugin->getName() + _T("..."));
     plugin->load_plugin(NSCAPI::dontStart);
@@ -1208 +1208 @@
  * @param file The DLL file
  */
-NSClientT::plugin_type NSClientT::loadPlugin(const std::wstring file) {
+NSClientT::plugin_type NSClientT::loadPlugin(const boost::filesystem::wpath file) {
   return addPlugin(new NSCPlugin(file));
 }
@@ -1522 +1522 @@
   }
 }
-std::wstring NSClientT::getBasePath(void) {
+boost::filesystem::wpath NSClientT::getBasePath(void) {
   boost::unique_lock<boost::timed_mutex> lock(internalVariables, boost::get_system_time() + boost::posix_time::seconds(5));
   if (!lock.owns_lock()) {
@@ -1538 +1538 @@
   basePath = path.substr(0, pos) + _T("\\");
   delete [] buffer;
+#else 
+  basePath = to_wstring(boost::filesystem::initial_path().string());
 #endif
   try {

trunk/service/NSClient++.h

@@ -20 +20 @@
 ***************************************************************************/
 #pragma once
+#ifdef WIN32
+#include <com_helpers.hpp>
+#endif
+
 #include <types.hpp>
 #include <config.h>
 #include <service/system_service.hpp>
 #include "NSCPlugin.h"
-//#include <Mutex.h>
-#include <NSCAPI.h>
-//#include <MutexRW.h>
-#include <map>
-#ifdef WIN32
-#include <com_helpers.hpp>
-#endif
 //#include <nsclient_session.hpp>
-#include <boost/thread/thread.hpp>
-#include <boost/thread/locks.hpp>
-#include <boost/thread/shared_mutex.hpp>
 
 /**
@@ -101 +95 @@
   pluginList commandHandlers_;
   pluginList messageHandlers_;
-  std::wstring basePath;
+  boost::filesystem::wpath  basePath;
   boost::timed_mutex internalVariables;
   boost::timed_mutex messageMutex;
@@ -145 +139 @@
 
   // Member functions
-  std::wstring getBasePath(void);
+  boost::filesystem::wpath  getBasePath(void);
   NSCAPI::nagiosReturn injectRAW(const wchar_t* command, const unsigned int argLen, wchar_t **argument, wchar_t *returnMessageBuffer, unsigned int returnMessageBufferLen, wchar_t *returnPerfBuffer, unsigned int returnPerfBufferLen);
   NSCAPI::nagiosReturn inject(std::wstring command, std::wstring arguments, wchar_t splitter, bool escape, std::wstring &msg, std::wstring & perf);
@@ -154 +148 @@
 
   void addPlugins(const std::list<std::wstring> plugins);
-  plugin_type loadPlugin(const std::wstring plugin);
+  plugin_type loadPlugin(const boost::filesystem::wpath plugin);
   void loadPlugins(NSCAPI::moduleLoadMode mode);
   void unloadPlugins(bool unloadLoggers);

trunk/service/StdAfx.h

@@ -21 +21 @@
 #pragma once
 #include <types.hpp>
-
+/*
 #ifdef WIN32
 #define _WINSOCKAPI_
-//#include <WinSock2.h>
 #include <tchar.h>
-
-#define _WIN32_DCOM
-#include <objbase.h>
-
 #define VC_EXTRALEAN    // Exclude rarely-used stuff from Windows headers
 #include <windows.h>
@@ -37 +32 @@
 #define WANT_GETLONGPATHNAME_WRAPPER
 //#include <NewAPIs.h>
-
+*/
 #include <iostream>
 #include <string>
@@ -43 +38 @@
 #include <sstream>
 #include <vector>
+#include <memory>
+#include <map>
 
 #include "config.h"
 #include <Singleton.h>
 #include <charEx.h>
-#include <memory>
+#include <error.hpp>
+#include <NSCAPI.h>
 
+#include <boost/thread/thread.hpp>
+#include <boost/thread/locks.hpp>
+#include <boost/thread/shared_mutex.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/filesystem.hpp>
-
-#ifdef MEMCHECK
-#include <vld.h>
-#endif

trunk/service/core_api.cpp

@@ -49 +49 @@
 }
 NSCAPI::errorReturn NSAPIGetBasePath(wchar_t*buffer, unsigned int bufLen) {
-  return NSCHelper::wrapReturnString(buffer, bufLen, mainClient.getBasePath(), NSCAPI::isSuccess);
+  return NSCHelper::wrapReturnString(buffer, bufLen, mainClient.getBasePath().string(), NSCAPI::isSuccess);
 }
 NSCAPI::errorReturn NSAPIGetApplicationName(wchar_t*buffer, unsigned int bufLen) {

trunk/service/settings_manager_impl.cpp

@@ -18 +18 @@
     SettingsHandler::destroyInstance();
   }
-  bool init_settings(std::wstring path) {
+  bool init_settings(boost::filesystem::wpath path) {
     try {
       get_core()->set_logger(new settings_logger());

trunk/service/settings_manager_impl.h

@@ -3 +3 @@
 #include "settings_logger_impl.hpp"
 #include <settings/Settings.h>
+#include <settings/settings_ini.hpp>
 #ifdef WIN32
-#include <settings/settings_ini.hpp>
 #include <settings/settings_old.hpp>
 #include <settings/settings_registry.hpp>
@@ -12 +12 @@
   class NSCSettingsImpl : public Settings::SettingsHandlerImpl {
   private:
-    std::wstring boot_;
+    boost::filesystem::wpath boot_;
     bool old_;
   public:
@@ -28 +28 @@
 #ifdef WIN32
       wchar_t* buffer = new wchar_t[1024];
-      GetPrivateProfileString(section.c_str(), key.c_str(), def.c_str(), buffer, 1023, boot_.c_str());
+      GetPrivateProfileString(section.c_str(), key.c_str(), def.c_str(), buffer, 1023, boot_.string().c_str());
       std::wstring ret = buffer;
       delete [] buffer;
       return ret;
 #else
-      return _T("ini");
+      return def;
 #endif
     }
@@ -43 +43 @@
     /// @author mickem
     void boot(std::wstring file = _T("boot.ini")) {
-      boot_ = get_base() + _T("\\") + file;
+      boot_ = get_base() / file;
+#ifdef WIN32
       std::wstring subsystem = get_boot_string(_T("settings"), _T("type"), _T("old"));
-      get_logger()->debug(__FILEW__, __LINE__, _T("Trying to boot: ") + subsystem + _T(" from base: ") + boot_);
+#else
+      std::wstring subsystem = get_boot_string(_T("settings"), _T("type"), _T("ini"));
+#endif
+      get_logger()->debug(__FILEW__, __LINE__, _T("Trying to boot: ") + subsystem + _T(" from base: ") + boot_.string());
       settings_type type = string_to_type(subsystem);
       std::wstring context = get_boot_string(_T("settings"), _T("context"), subsystem);
@@ -72 +76 @@
       if (type == SettingsCore::registry)
         return new Settings::REGSettings(this, context);
+#endif
       if (type == SettingsCore::ini_file)
         return new Settings::INISettings(this, context);
-#endif
       throw SettingsException(_T("Undefined settings type: ") + SettingsCore::type_to_string(type));
     }
@@ -86 +90 @@
   Settings::SettingsCore* get_core();
   void destroy_settings();
-  bool init_settings(std::wstring path);
+  bool init_settings(boost::filesystem::wpath path);
 }