Returned code

src/contrib/epee/include/misc_os_dependent.h

@@ -0,0 +1,108 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+#ifdef WIN32
+  #ifndef WIN32_LEAN_AND_MEAN 
+  #define WIN32_LEAN_AND_MEAN
+  #endif
+
+  //#ifdef _WIN32_WINNT 
+  //  #undef _WIN32_WINNT
+  //  #define _WIN32_WINNT 0x0600
+  //#endif
+
+  
+#include <windows.h>
+#endif
+
+#ifdef __MACH__
+#include <mach/clock.h>
+#include <mach/mach.h>
+#endif
+
+#pragma once 
+namespace epee
+{
+namespace misc_utils
+{
+
+        inline uint64_t get_tick_count()
+        {
+#if defined(_MSC_VER)
+                return ::GetTickCount64();
+#elif defined(__MACH__)
+                clock_serv_t cclock;
+                mach_timespec_t mts;
+
+                host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock);
+                clock_get_time(cclock, &mts);
+                mach_port_deallocate(mach_task_self(), cclock);
+
+                return (mts.tv_sec * 1000) + (mts.tv_nsec/1000000);
+#else
+                struct timespec ts;
+                if(clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
+                        return 0;
+                }
+                return (ts.tv_sec * 1000) + (ts.tv_nsec/1000000);
+#endif
+        }
+
+
+        inline int call_sys_cmd(const std::string& cmd)
+	{      
+                std::cout << "# " << cmd << std::endl;
+
+		FILE * fp ;
+		//char tstCommand[] ="ls *";
+		char path[1000] = {0};
+#if !defined(__GNUC__) 
+		fp = _popen(cmd.c_str(), "r");
+#else
+		fp = popen(cmd.c_str(), "r");
+#endif
+		while ( fgets( path, 1000, fp ) != NULL )
+			std::cout << path;
+
+#if !defined(__GNUC__) 
+		_pclose(fp);
+#else
+		pclose(fp);
+#endif
+		return 0;
+
+	}
+
+
+	inline std::string get_thread_string_id()
+	{
+#if defined(_MSC_VER)
+		return boost::lexical_cast<std::string>(GetCurrentThreadId());
+#elif defined(__GNUC__)  
+		return boost::lexical_cast<std::string>(pthread_self());
+#endif
+	}
+}
+}

src/contrib/epee/include/pragma_comp_defs.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#if defined(__GNUC__)
+  #define PRAGMA_WARNING_PUSH _Pragma("GCC diagnostic push")
+  #define PRAGMA_WARNING_POP _Pragma("GCC diagnostic pop")
+  #define PRAGMA_WARNING_DISABLE_VS(w)
+  #define PRAGMA_GCC(w) _Pragma(w)
+#elif defined(_MSC_VER)
+  #define PRAGMA_WARNING_PUSH __pragma(warning( push ))
+  #define PRAGMA_WARNING_POP __pragma(warning( pop ))
+  #define PRAGMA_WARNING_DISABLE_VS(w) __pragma( warning ( disable: w ))
+  //#define PRAGMA_WARNING_DISABLE_GCC(w)
+  #define PRAGMA_GCC(w)
+#endif

src/contrib/epee/include/static_initializer.h

@@ -0,0 +1,82 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+
+
+#ifndef _STATIC_INITIALIZER_H_
+#define _STATIC_INITIALIZER_H_
+
+
+namespace epee
+{
+/***********************************************************************
+class initializer - useful to initialize some static classes 
+                       which have init() and un_init() static members
+************************************************************************/
+
+template<class to_initialize>
+class initializer
+{
+public:
+	initializer()
+	{
+		to_initialize::init();
+		//get_set_is_initialized(true, true);
+	}
+	~initializer()
+	{
+		to_initialize::un_init();
+		//get_set_is_uninitialized(true, true);
+	}
+
+	/*static inline bool is_initialized()
+	{
+		return get_set_is_initialized();
+	}
+	static inline bool is_uninitialized()
+	{
+		return get_set_is_uninitialized();
+	}
+
+private: 
+	static inline bool get_set_is_initialized(bool need_to_set = false, bool val_to_set= false)
+	{
+		static bool val_is_initialized = false;
+		if(need_to_set)
+			val_is_initialized = val_to_set;
+		return val_is_initialized;
+	}
+	static inline bool get_set_is_uninitialized(bool need_to_set = false, bool val_to_set = false)
+	{
+		static bool val_is_uninitialized = false;
+		if(need_to_set)
+			val_is_uninitialized = val_to_set;
+		return val_is_uninitialized;
+	}*/
+};
+
+}
+#endif //_STATIC_INITIALIZER_H_

src/contrib/epee/include/string_tools.h

@@ -0,0 +1,744 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+
+
+#ifndef _STRING_TOOLS_H_
+#define _STRING_TOOLS_H_
+
+//#include <objbase.h>
+#include <locale>
+#include <cstdlib>
+//#include <strsafe.h>
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/asio.hpp>
+#include <boost/algorithm/string/compare.hpp>
+#include <boost/algorithm/string.hpp>
+#include "warnings.h"
+
+
+#ifndef OUT
+	#define OUT
+#endif
+
+#ifdef WINDOWS_PLATFORM
+#pragma comment (lib, "Rpcrt4.lib")
+#endif
+
+namespace epee
+{
+namespace string_tools
+{
+	inline std::wstring get_str_from_guid(const boost::uuids::uuid& rid)
+	{
+		return boost::lexical_cast<std::wstring>(rid);
+	}
+	//----------------------------------------------------------------------------
+	inline std::string get_str_from_guid_a(const boost::uuids::uuid& rid)
+	{
+		return boost::lexical_cast<std::string>(rid);
+	}
+	//----------------------------------------------------------------------------
+	inline bool get_guid_from_string( boost::uuids::uuid& inetifer, std::wstring str_id)
+	{
+		if(str_id.size() < 36)
+			return false;
+
+		if('{' == *str_id.begin())
+			str_id.erase(0, 1);
+
+		if('}' == *(--str_id.end()))
+			str_id.erase(--str_id.end());
+
+		try
+		{
+			inetifer = boost::lexical_cast<boost::uuids::uuid>(str_id);
+			return true;
+		}
+		catch(...)
+		{
+			return false;
+		}
+	}
+	//----------------------------------------------------------------------------
+	inline bool get_guid_from_string(OUT boost::uuids::uuid& inetifer, const std::string& str_id)
+	{
+		std::string local_str_id = str_id;
+		if(local_str_id.size() < 36)
+			return false;
+
+		if('{' == *local_str_id.begin())
+			local_str_id.erase(0, 1);
+
+		if('}' == *(--local_str_id.end()))
+			local_str_id.erase(--local_str_id.end());
+
+		try
+		{
+			inetifer = boost::lexical_cast<boost::uuids::uuid>(local_str_id);
+			return true;
+		}
+		catch(...)
+		{
+			return false;
+		}
+	}
+	//----------------------------------------------------------------------------
+  template<class CharT>
+  std::basic_string<CharT> buff_to_hex(const std::basic_string<CharT>& s)
+  {
+    using namespace std;
+    basic_stringstream<CharT> hexStream;
+    hexStream << hex << noshowbase << setw(2);
+
+    for(typename std::basic_string<CharT>::const_iterator it = s.begin(); it != s.end(); it++)
+    {
+      hexStream << "0x"<< static_cast<unsigned int>(static_cast<unsigned char>(*it)) << " ";
+    }
+    return hexStream.str();
+  }
+  //----------------------------------------------------------------------------
+  template<class CharT>
+  std::basic_string<CharT> buff_to_hex_nodelimer(const std::basic_string<CharT>& s)
+  {
+    using namespace std;
+    basic_stringstream<CharT> hexStream;
+    hexStream << hex << noshowbase;
+
+    for(typename std::basic_string<CharT>::const_iterator it = s.begin(); it != s.end(); it++)
+    {
+      hexStream << setw(2) << setfill('0') << static_cast<unsigned int>(static_cast<unsigned char>(*it));
+    }
+    return hexStream.str();
+  }
+  //----------------------------------------------------------------------------
+  template<class CharT>
+  bool parse_hexstr_to_binbuff(const std::basic_string<CharT>& s, std::basic_string<CharT>& res)
+  {
+    res.clear();
+    try
+    {
+      long v = 0;
+      for(size_t i = 0; i < (s.size() + 1) / 2; i++)
+      {
+        CharT byte_str[3];
+        size_t copied = s.copy(byte_str, 2, 2 * i);
+        byte_str[copied] = CharT(0);
+        CharT* endptr;
+        v = strtoul(byte_str, &endptr, 16);
+        if (v < 0 || 0xFF < v || endptr != byte_str + copied)
+        {
+          return false;
+        }
+        res.push_back(static_cast<unsigned char>(v));
+      }
+
+      return true;
+    }catch(...)
+    {
+      return false;
+    }
+  }
+  //----------------------------------------------------------------------------
+  template<class t_pod_type>
+  bool parse_tpod_from_hex_string(const std::string& str_hash, t_pod_type& t_pod)
+  {
+    std::string buf;
+    bool res = epee::string_tools::parse_hexstr_to_binbuff(str_hash, buf);
+    if (!res || buf.size() != sizeof(t_pod_type))
+    {
+      return false;
+    }
+    else
+    {
+      buf.copy(reinterpret_cast<char *>(&t_pod), sizeof(t_pod_type));
+      return true;
+    }
+  }
+  //----------------------------------------------------------------------------
+PUSH_WARNINGS
+DISABLE_GCC_WARNING(maybe-uninitialized)
+  template<class XType>
+  inline bool get_xtype_from_string(OUT XType& val, const std::string& str_id)
+  {
+    if (std::is_integral<XType>::value && !std::numeric_limits<XType>::is_signed && !std::is_same<XType, bool>::value)
+    {
+      for (char c : str_id)
+      {
+        if (!std::isdigit(c))
+          return false;
+      }
+    }
+
+    try
+    {
+      val = boost::lexical_cast<XType>(str_id);
+      return true;
+    }
+    catch(std::exception& /*e*/)
+    {
+      //const char* pmsg = e.what();
+      return false;
+    }
+    catch(...)
+    {
+      return false;
+    }
+
+    return true;
+  }
+POP_WARNINGS
+	//---------------------------------------------------
+	template<typename int_t>
+	bool get_xnum_from_hex_string(const std::string str, int_t& res )
+	{
+		try
+		{
+			std::stringstream ss;
+			ss << std::hex << str;
+			ss >> res;
+			return true;	
+		}
+		catch(...)
+		{
+			return false;
+		}
+	}
+	//----------------------------------------------------------------------------
+	template<class XType>
+	inline bool xtype_to_string(const  XType& val, std::string& str)
+	{
+		try
+		{
+			str = boost::lexical_cast<std::string>(val);
+		}
+		catch(...)
+		{
+			return false;
+		}
+
+		return true;
+	}
+    
+	typedef std::map<std::string, std::string> command_line_params_a;
+	typedef std::map<std::wstring, std::wstring> command_line_params_w;
+
+	template<class t_string>
+	bool parse_commandline(std::map<t_string, t_string>& res, int argc, char** argv)
+	{
+    t_string key;
+    for(int i = 1; i < argc; i++)
+    {
+      if(!argv[i])
+        break;
+      t_string s = argv[i];
+      std::string::size_type p = s.find('=');
+      if(std::string::npos == p)
+      {
+        res[s] = "";
+      }else
+      {
+        std::string ss;
+        t_string nm = s.substr(0, p);
+        t_string vl = s.substr(p+1, s.size());
+        res[nm] = vl;
+      }
+    }
+    return true;
+	}
+
+/*  template<typename t_type>
+  bool get_xparam_from_command_line(const std::map<std::string, std::string>& res, const std::basic_string<typename t_string::value_type> & key, t_type& val)
+  {
+
+  }
+  */
+
+	template<class t_string, typename t_type>
+	bool get_xparam_from_command_line(const std::map<t_string, t_string>& res, const t_string & key, t_type& val)
+	{
+		typename std::map<t_string, t_string>::const_iterator it = res.find(key);
+		if(it == res.end())
+			return false;
+
+		if(it->second.size())
+		{
+			return get_xtype_from_string(val, it->second);
+		}
+
+		return true;
+	}
+
+    template<class t_string, typename t_type>
+    t_type get_xparam_from_command_line(const std::map<t_string, t_string>& res, const t_string & key, const t_type& default_value)
+    {
+        typename std::map<t_string, t_string>::const_iterator it = res.find(key);
+        if(it == res.end())
+            return default_value;
+
+        if(it->second.size())
+        {
+            t_type s;
+            get_xtype_from_string(s, it->second);
+            return s;
+        }
+
+        return default_value;
+    }
+
+  template<class t_string>
+  bool have_in_command_line(const std::map<t_string, t_string>& res, const std::basic_string<typename t_string::value_type>& key)
+  {
+    typename std::map<t_string, t_string>::const_iterator it = res.find(key);
+    if(it == res.end())
+      return false;
+
+    return true;
+  }
+
+	//----------------------------------------------------------------------------
+//#ifdef _WINSOCK2API_
+	inline std::string get_ip_string_from_int32(uint32_t ip)
+	{
+		in_addr adr;
+		adr.s_addr = ip;
+		const char* pbuf = inet_ntoa(adr);
+		if(pbuf)
+			return pbuf;
+		else
+			return "[failed]";
+	}
+	//----------------------------------------------------------------------------
+	inline bool get_ip_int32_from_string(uint32_t& ip, const std::string& ip_str)
+	{
+		ip = inet_addr(ip_str.c_str());
+		if(INADDR_NONE == ip)
+			return false;
+
+		return true;
+	}
+  //----------------------------------------------------------------------------
+  inline bool parse_peer_from_string(uint32_t& ip, uint32_t& port, const std::string& addres)
+  {
+    //parse ip and address
+    std::string::size_type p = addres.find(':');
+    if(p == std::string::npos)
+    {
+      return false;
+    }
+    std::string ip_str = addres.substr(0, p);
+    std::string port_str = addres.substr(p+1, addres.size());
+
+    if(!get_ip_int32_from_string(ip, ip_str))
+    {
+      return false;
+    }
+
+    if(!get_xtype_from_string(port, port_str))
+    {
+      return false;
+    }
+    return true;
+  }
+
+//#endif
+	//----------------------------------------------------------------------------
+  template<typename t>
+	inline std::string get_t_as_hex_nwidth(const t& v, std::streamsize w = 8)
+  {
+    std::stringstream ss;
+    ss << std::setfill ('0') << std::setw (w) << std::hex << std::noshowbase;
+    ss << v;
+    return ss.str();
+  }
+
+	inline std::string num_to_string_fast(int64_t val)
+	{
+		/*
+		char  buff[30] = {0};
+		i64toa_s(val, buff, sizeof(buff)-1, 10);
+		return buff;*/
+		return boost::lexical_cast<std::string>(val);
+	}
+	//----------------------------------------------------------------------------
+	inline bool string_to_num_fast(const std::string& buff, int64_t& val)
+	{
+		//return get_xtype_from_string(val, buff);
+#if (defined _MSC_VER)
+    val = _atoi64(buff.c_str());
+#else
+    val = atoll(buff.c_str());
+#endif
+		/*
+		 * val = atoi64(buff.c_str());
+     */
+		if(buff != "0" && val == 0)
+			return false;
+		return true;
+	}
+	//----------------------------------------------------------------------------
+	inline bool string_to_num_fast(const std::string& buff, int& val)
+	{
+		val = atoi(buff.c_str());
+		if(buff != "0" && val == 0)
+			return false;
+
+		return true;
+	}
+	//----------------------------------------------------------------------------
+#ifdef WINDOWS_PLATFORM
+	inline std::string system_time_to_string(const SYSTEMTIME& st)
+	{
+	
+		/*
+		TIME_ZONE_INFORMATION tzi;
+		GetTimeZoneInformation(&tzi);
+		SystemTimeToTzSpecificLocalTime(&tzi, &stUTC, &stLocal);
+		*/
+
+		char szTime[25], szDate[25];
+		::GetTimeFormatA(
+			LOCALE_USER_DEFAULT,    // locale
+			TIME_FORCE24HOURFORMAT, // options
+			&st,					// time
+			NULL,                   // time format string
+			szTime,                 // formatted string buffer
+			25                      // size of string buffer
+			);
+
+		::GetDateFormatA(
+			LOCALE_USER_DEFAULT,    // locale
+			NULL,                   // options
+			&st,					// date
+			NULL,                   // date format
+			szDate,                 // formatted string buffer
+			25                      // size of buffer
+			);
+		szTime[24] = szDate[24] = 0; //be happy :)
+		
+		std::string res = szDate;
+		(res += " " )+= szTime;
+		return res; 
+
+	}
+#endif
+	//----------------------------------------------------------------------------
+	
+	inline bool compare_no_case(const std::string& str1, const std::string& str2)
+	{
+		
+		return !boost::iequals(str1, str2);
+	}
+	//----------------------------------------------------------------------------
+	inline bool compare_no_case(const std::wstring& str1, const std::wstring& str2)
+	{
+		return !boost::iequals(str1, str2);
+	}
+	//----------------------------------------------------------------------------
+	inline bool is_match_prefix(const std::wstring& str1, const std::wstring& prefix)
+	{	
+		if(prefix.size()>str1.size())
+			return false;
+
+		if(!compare_no_case(str1.substr(0, prefix.size()), prefix))
+			return true;
+		else
+			return false;
+	}
+	//----------------------------------------------------------------------------
+	inline bool is_match_prefix(const std::string& str1, const std::string& prefix)
+	{	
+		if(prefix.size()>str1.size())
+			return false;
+
+		if(!compare_no_case(str1.substr(0, prefix.size()), prefix))
+			return true;
+		else
+			return false;
+	}
+	//----------------------------------------------------------------------------
+	inline std::string& get_current_module_name()
+	{
+		static std::string module_name;
+		return module_name;
+	}
+	//----------------------------------------------------------------------------
+	inline std::string& get_current_module_folder()
+	{	
+		static std::string module_folder;
+		return module_folder;
+	}
+  //----------------------------------------------------------------------------
+#ifdef _WIN32
+  inline std::string get_current_module_path()
+  {
+    char pname [5000] = {0};
+    GetModuleFileNameA( NULL, pname, sizeof(pname));
+    pname[sizeof(pname)-1] = 0; //be happy ;)
+    return pname;
+  }
+#endif
+	//----------------------------------------------------------------------------
+	inline bool set_module_name_and_folder(const std::string& path_to_process_)
+	{
+    std::string path_to_process = path_to_process_;
+#ifdef _WIN32
+    path_to_process = get_current_module_path();
+#endif 
+		std::string::size_type a = path_to_process.rfind( '\\' );
+		if(a == std::string::npos )
+		{
+			a = path_to_process.rfind( '/' );
+		}
+		if ( a != std::string::npos )
+		{	
+			get_current_module_name() = path_to_process.substr(a+1, path_to_process.size());
+			get_current_module_folder() = path_to_process.substr(0, a);
+			return true;
+		}else
+			return false;
+
+	}
+
+	//----------------------------------------------------------------------------
+	inline bool trim_left(std::string& str)
+	{
+		for(std::string::iterator it = str.begin(); it!= str.end() && isspace(static_cast<unsigned char>(*it));)
+			str.erase(str.begin());
+			
+		return true;
+	}
+	//----------------------------------------------------------------------------
+	inline bool trim_right(std::string& str)
+	{
+
+		for(std::string::reverse_iterator it = str.rbegin(); it!= str.rend() && isspace(static_cast<unsigned char>(*it));)
+			str.erase( --((it++).base()));
+
+		return true;
+	}
+	//----------------------------------------------------------------------------
+	inline std::string& trim(std::string& str)
+	{
+
+		trim_left(str);
+		trim_right(str);
+		return str;
+	}
+  //----------------------------------------------------------------------------
+  inline std::string trim(const std::string& str_)
+  {
+    std::string str = str_;
+    trim_left(str);
+    trim_right(str);
+    return str;
+  }
+  //----------------------------------------------------------------------------
+  template<class t_pod_type>
+  std::string pod_to_hex(const t_pod_type& s)
+  {
+    std::string buff;
+    buff.assign(reinterpret_cast<const char*>(&s), sizeof(s));
+    return buff_to_hex_nodelimer(buff);
+  }
+  //----------------------------------------------------------------------------
+  template<class t_pod_type>
+  bool hex_to_pod(const std::string& hex_str, t_pod_type& s)
+  {
+    std::string hex_str_tr = trim(hex_str);
+    if(sizeof(s)*2 != hex_str.size())
+      return false;
+    std::string bin_buff;
+    if(!parse_hexstr_to_binbuff(hex_str_tr, bin_buff))
+      return false;
+    if(bin_buff.size()!=sizeof(s))
+      return false;
+
+    s = *(t_pod_type*)bin_buff.data();
+    return true;
+  }
+  //----------------------------------------------------------------------------
+	inline std::string get_extension(const std::string& str)
+	{
+		std::string res;
+		std::string::size_type pos = str.rfind('.');
+		if(std::string::npos == pos)
+			return res;
+		
+		res = str.substr(pos+1, str.size()-pos);
+		return res;
+	}
+	//----------------------------------------------------------------------------
+	inline std::string get_filename_from_path(const std::string& str)
+	{
+		std::string res;
+		std::string::size_type pos = str.rfind('\\');
+		if(std::string::npos == pos)
+			return str;
+
+		res = str.substr(pos+1, str.size()-pos);
+		return res;
+	}
+	//----------------------------------------------------------------------------
+
+
+
+	inline std::string cut_off_extension(const std::string& str)
+	{
+		std::string res;
+		std::string::size_type pos = str.rfind('.');
+		if(std::string::npos == pos)
+			return str;
+
+		res = str.substr(0, pos);
+		return res;
+	}
+
+	//----------------------------------------------------------------------------
+#ifdef _WININET_
+	inline std::string get_string_from_systemtime(const SYSTEMTIME& sys_time)
+	{
+		std::string result_string;
+
+		char buff[100] = {0};
+		BOOL res = ::InternetTimeFromSystemTimeA(&sys_time, INTERNET_RFC1123_FORMAT, buff, 99);
+		if(!res)
+		{
+			LOG_ERROR("Failed to load SytemTime to string");
+		}
+
+		result_string = buff;
+		return result_string;
+
+	}
+	//-------------------------------------------------------------------------------------
+	inline SYSTEMTIME get_systemtime_from_string(const std::string& buff)
+	{
+		SYSTEMTIME result_time = {0};
+
+		BOOL res = ::InternetTimeToSystemTimeA(buff.c_str(), &result_time, NULL);
+		if(!res)
+		{
+			LOG_ERROR("Failed to load SytemTime from string " << buff << "interval set to 15 minutes");
+		}
+
+		return result_time;
+	}
+#endif
+
+#ifdef WINDOWS_PLATFORM
+	static const DWORD INFO_BUFFER_SIZE = 10000;
+
+	static const wchar_t* get_pc_name()
+	{
+		static wchar_t	info[INFO_BUFFER_SIZE];
+		static DWORD	bufCharCount = INFO_BUFFER_SIZE;
+		static bool		init = false;
+
+		if (!init) {
+			if (!GetComputerNameW( info, &bufCharCount ))
+				info[0] = 0;
+			else
+				init = true;
+		}
+
+		return info;
+	}
+
+	static const wchar_t* get_user_name()
+	{
+		static wchar_t	info[INFO_BUFFER_SIZE];
+		static DWORD	bufCharCount = INFO_BUFFER_SIZE;
+		static bool		init = false;
+
+		if (!init) {
+			if (!GetUserNameW( info, &bufCharCount ))
+				info[0] = 0;
+			else
+				init = true;
+		}
+
+		return info;
+	}
+#endif
+
+#ifdef _LM_
+	static const wchar_t* get_domain_name()
+	{
+		static wchar_t	info[INFO_BUFFER_SIZE];
+		static DWORD	bufCharCount = 0;
+		static bool		init = false;
+
+		if (!init) {
+			LPWSTR domain( NULL );
+			NETSETUP_JOIN_STATUS status;
+			info[0] = 0;
+
+			if (NET_API_STATUS result = NetGetJoinInformation( NULL, &domain, &status )) 
+			{
+				LOG_ERROR("get_domain_name error: " << log_space::get_win32_err_descr(result));
+			} else
+			{
+				StringCchCopyW( info, sizeof(info)/sizeof( info[0] ), domain );
+				NetApiBufferFree((void*)domain);
+				init = true;
+			}
+		}
+
+		return info;
+	}
+#endif
+#ifdef WINDOWS_PLATFORM
+	inline
+	std::string load_resource_string_a(int id, const char* pmodule_name = NULL)
+	{
+		//slow realization 
+		HMODULE h = ::GetModuleHandleA( pmodule_name );
+		
+		char buff[2000] = {0};
+		
+		::LoadStringA( h, id, buff, sizeof(buff));
+		buff[sizeof(buff)-1] = 0; //be happy :)
+		return buff;
+	}
+	inline
+	std::wstring load_resource_string_w(int id, const char* pmodule_name = NULL)
+	{
+		//slow realization 
+		HMODULE h = ::GetModuleHandleA( pmodule_name );
+		
+		wchar_t buff[2000] = {0};
+		
+		::LoadStringW( h, id, buff, sizeof(buff) / sizeof( buff[0] ) );
+		buff[(sizeof(buff)/sizeof(buff[0]))-1] = 0; //be happy :)
+		return buff;	
+	}
+#endif
+}
+}
+#endif //_STRING_TOOLS_H_

src/contrib/epee/include/syncobj.h

@@ -0,0 +1,243 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+
+
+
+#ifndef __WINH_OBJ_H__
+#define __WINH_OBJ_H__
+
+#include <condition_variable>
+#include <mutex>
+#include <boost/thread/locks.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/recursive_mutex.hpp>
+
+namespace epee
+{
+
+  struct simple_event
+  {
+    simple_event() : m_rised(false)
+    {
+    }
+
+    void raise()
+    {
+      std::unique_lock<std::mutex> lock(m_mx);
+      m_rised = true;
+      m_cond_var.notify_one();
+    }
+
+    void wait()
+    {
+      std::unique_lock<std::mutex> lock(m_mx);
+      while (!m_rised) 
+        m_cond_var.wait(lock);
+      m_rised = false;
+    }
+
+  private:
+    std::mutex m_mx;
+    std::condition_variable m_cond_var;
+    bool m_rised;
+  };
+
+  class critical_region;
+
+  class critical_section
+  {
+    boost::recursive_mutex m_section;
+
+  public:
+    //to make copy fake!
+    critical_section(const critical_section& section)
+    {
+    }
+
+    critical_section()
+    {
+    }
+
+    ~critical_section()
+    {
+    }
+
+    void lock()
+    {
+      m_section.lock();
+      //EnterCriticalSection( &m_section );
+    }
+
+    void unlock()
+    {
+      m_section.unlock();
+    }
+
+    bool tryLock()
+    {
+      return m_section.try_lock();
+    }
+
+    // to make copy fake
+    critical_section& operator=(const critical_section& section)
+    {
+      return *this;
+    }
+  };
+
+
+  template<class t_lock>
+  class critical_region_t
+  {
+    t_lock&	m_locker;
+    bool m_unlocked;
+
+    critical_region_t(const critical_region_t&) {}
+
+  public:
+    critical_region_t(t_lock& cs): m_locker(cs), m_unlocked(false)
+    {
+      m_locker.lock();
+    }
+
+    ~critical_region_t()
+    {
+      unlock();
+    }
+
+    void unlock()
+    {
+      if (!m_unlocked)
+      {
+        m_locker.unlock();
+        m_unlocked = true;
+      }
+    }
+  };
+
+
+#if defined(WINDWOS_PLATFORM)
+  class shared_critical_section
+  {
+  public: 
+    shared_critical_section()
+    {
+      ::InitializeSRWLock(&m_srw_lock);
+    }
+    ~shared_critical_section()
+    {}
+
+    bool lock_shared()
+    {
+      AcquireSRWLockShared(&m_srw_lock);
+      return true;
+    }
+    bool unlock_shared()
+    {
+      ReleaseSRWLockShared(&m_srw_lock);
+      return true;
+    }
+    bool lock_exclusive()
+    {
+      ::AcquireSRWLockExclusive(&m_srw_lock);
+      return true;
+    }
+    bool unlock_exclusive()
+    {
+      ::ReleaseSRWLockExclusive(&m_srw_lock);
+      return true;
+    }
+  private:
+    SRWLOCK m_srw_lock;
+  };
+
+
+  class shared_guard
+  {
+  public:
+    shared_guard(shared_critical_section& ref_sec):m_ref_sec(ref_sec)
+    {
+      m_ref_sec.lock_shared();
+    }
+
+    ~shared_guard()
+    {
+      m_ref_sec.unlock_shared();
+    }
+
+  private:
+    shared_critical_section& m_ref_sec;
+  };
+
+
+  class exclusive_guard
+  {
+  public:
+    exclusive_guard(shared_critical_section& ref_sec):m_ref_sec(ref_sec)
+    {
+      m_ref_sec.lock_exclusive();
+    }
+
+    ~exclusive_guard()
+    {
+      m_ref_sec.unlock_exclusive();
+    }
+
+  private:
+    shared_critical_section& m_ref_sec;
+  };
+#endif
+
+#define  SHARED_CRITICAL_REGION_BEGIN(x) { shared_guard   critical_region_var(x)
+#define  EXCLUSIVE_CRITICAL_REGION_BEGIN(x) { exclusive_guard   critical_region_var(x)
+
+#define  CRITICAL_REGION_LOCAL(x) epee::critical_region_t<decltype(x)>   critical_region_var(x)
+#define  CRITICAL_REGION_BEGIN(x) { epee::critical_region_t<decltype(x)>   critical_region_var(x)
+#define  CRITICAL_REGION_LOCAL1(x) epee::critical_region_t<decltype(x)>   critical_region_var1(x)
+#define  CRITICAL_REGION_BEGIN1(x) { epee::critical_region_t<decltype(x)>   critical_region_var1(x)
+
+#define  CRITICAL_REGION_END() }
+
+
+#if defined(WINDWOS_PLATFORM)
+  inline const char* get_wait_for_result_as_text(DWORD res)
+  {
+    switch(res)
+    {
+    case WAIT_ABANDONED:  return "WAIT_ABANDONED";
+    case WAIT_TIMEOUT:    return "WAIT_TIMEOUT";
+    case WAIT_OBJECT_0:   return "WAIT_OBJECT_0";
+    case WAIT_OBJECT_0+1: return "WAIT_OBJECT_1";
+    case WAIT_OBJECT_0+2: return "WAIT_OBJECT_2";
+    default:              return "UNKNOWN CODE";
+    }
+  }
+#endif
+
+}
+
+#endif

src/contrib/epee/include/time_helper.h

@@ -0,0 +1,159 @@
+// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of the Andrey N. Sabelnikov nor the
+// names of its contributors may be used to endorse or promote products
+// derived from this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER  BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+// 
+
+
+
+#pragma once
+
+//#include <atltime.h>
+//#include <sqlext.h>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/date_time/local_time/local_time.hpp>
+#include "pragma_comp_defs.h"
+
+namespace epee
+{
+namespace misc_utils
+{
+
+#ifdef __ATLTIME_H__
+
+	inline
+	bool get_time_t_from_ole_date(DATE src, time_t& res)
+	{
+		SYSTEMTIME st = {0};
+		if(TRUE != ::VariantTimeToSystemTime(src, &st))
+			return false;
+		ATL::CTime ss(st);
+		res = ss.GetTime();
+		return true;
+	}
+#endif
+	inline 
+	std::string get_time_str(const time_t& time_)
+	{
+
+
+		char tmpbuf[200] = {0};
+		tm* pt = NULL;
+PRAGMA_WARNING_PUSH
+PRAGMA_WARNING_DISABLE_VS(4996)
+		pt = localtime(&time_);
+PRAGMA_WARNING_POP
+
+		if(pt)
+			strftime( tmpbuf, 199, "%d.%m.%Y %H:%M:%S", pt );
+		else
+		{
+			std::stringstream strs;
+			strs << "[wrong_time: " << std::hex << time_ << "]";
+			return strs.str();
+		}
+		return tmpbuf;
+	}
+
+	inline 
+		std::string get_time_str_v2(const time_t& time_)
+	{
+
+		char tmpbuf[200] = {0};
+		tm* pt = NULL;
+PRAGMA_WARNING_PUSH
+PRAGMA_WARNING_DISABLE_VS(4996)
+		pt = localtime(&time_);
+PRAGMA_WARNING_POP
+
+		if(pt)
+			strftime( tmpbuf, 199, "%Y_%m_%d %H_%M_%S", pt );
+		else
+		{
+			std::stringstream strs;
+			strs << "[wrong_time: " << std::hex << time_ << "]";
+			return strs.str();
+		}
+		return tmpbuf;
+	}
+
+  inline 
+    std::string get_time_str_v3(const boost::posix_time::ptime& time_)
+  {
+    return boost::posix_time::to_simple_string(time_);
+  }
+
+  
+
+	inline std::string get_internet_time_str(const time_t& time_)
+	{
+		char tmpbuf[200] = {0};
+		tm* pt = NULL;
+PRAGMA_WARNING_PUSH
+PRAGMA_WARNING_DISABLE_VS(4996)
+		pt = gmtime(&time_);
+PRAGMA_WARNING_POP
+		strftime( tmpbuf, 199, "%a, %d %b %Y %H:%M:%S GMT", pt );
+		return tmpbuf;
+	}
+
+	inline std::string get_time_interval_string(const time_t& time_)
+	{
+		std::string res;
+		time_t tail = time_;
+PRAGMA_WARNING_PUSH
+PRAGMA_WARNING_DISABLE_VS(4244)
+		int days = tail/(60*60*24);
+		tail = tail%(60*60*24);
+		int hours = tail/(60*60);
+		tail = tail%(60*60);
+		int minutes = tail/(60);
+		tail = tail%(60);
+		int seconds = tail;
+PRAGMA_WARNING_POP
+		res = std::string() + "d" + boost::lexical_cast<std::string>(days) + ".h" + boost::lexical_cast<std::string>(hours) + ".m" + boost::lexical_cast<std::string>(minutes) + ".s" + boost::lexical_cast<std::string>(seconds);
+		return res;
+	}
+
+#ifdef __SQLEXT
+	inline
+	bool odbc_time_to_oledb_taime(const SQL_TIMESTAMP_STRUCT& odbc_timestamp, DATE& oledb_date)
+	{
+		
+		SYSTEMTIME st = {0};
+		st.wYear = odbc_timestamp.year;
+		st.wDay = odbc_timestamp.day;
+		st.wHour = odbc_timestamp.hour ;
+		st.wMilliseconds = (WORD)odbc_timestamp.fraction ;
+		st.wMinute = odbc_timestamp.minute ;
+		st.wMonth = odbc_timestamp.month ;
+		st.wSecond = odbc_timestamp.second ;
+
+		if(TRUE != ::SystemTimeToVariantTime(&st, &oledb_date))
+			return false;
+		return true;
+	}
+
+#endif
+}
+}