boost/interprocess/detail/win32_api.hpp
////////////////////////////////////////////////////////////////////////////// // // (C) Copyright Ion Gaztanaga 2005-2015. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/interprocess for documentation. // ////////////////////////////////////////////////////////////////////////////// #ifndef BOOST_INTERPROCESS_WIN32_API_HPP #define BOOST_INTERPROCESS_WIN32_API_HPP #ifndef BOOST_CONFIG_HPP # include <boost/config.hpp> #endif # #if defined(BOOST_HAS_PRAGMA_ONCE) # pragma once #endif #include <boost/interprocess/detail/config_begin.hpp> #include <boost/interprocess/detail/workaround.hpp> #include <boost/date_time/filetime_functions.hpp> #include <cstddef> #include <cstring> #include <cstdlib> #include <cstdio> #include <boost/assert.hpp> #include <string> #include <vector> //#define BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME //#define BOOST_INTERPROCESS_BOOTSTAMP_IS_EVENTLOG_BASED //#define BOOST_INTERPROCESS_BOOTSTAMP_IS_SESSION_MANAGER_BASED #ifdef BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME # define BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME_VALUE 1 #else # define BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME_VALUE 0 #endif #ifdef BOOST_INTERPROCESS_BOOTSTAMP_IS_EVENTLOG_BASED # define BOOST_INTERPROCESS_BOOTSTAMP_IS_EVENTLOG_BASED_VALUE 1 #else # define BOOST_INTERPROCESS_BOOTSTAMP_IS_EVENTLOG_BASED_VALUE 0 #endif #ifdef BOOST_INTERPROCESS_BOOTSTAMP_IS_SESSION_MANAGER_BASED # define BOOST_INTERPROCESS_BOOTSTAMP_IS_SESSION_MANAGER_BASED_VALUE 1 #else # define BOOST_INTERPROCESS_BOOTSTAMP_IS_SESSION_MANAGER_BASED_VALUE 0 #endif #define BOOST_INTERPROCESS_BOOTSTAMP_VALUE_SUM \ (BOOST_INTERPROCESS_BOOTSTAMP_IS_EVENTLOG_BASED_VALUE + \ BOOST_INTERPROCESS_BOOTSTAMP_IS_SESSION_MANAGER_BASED_VALUE + \ BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME_VALUE) #if 1 < BOOST_INTERPROCESS_BOOTSTAMP_VALUE_SUM # error "Only one of BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME, \ BOOST_INTERPROCESS_BOOTSTAMP_IS_SESSION_MANAGER_BASED and \ BOOST_INTERPROCESS_BOOTSTAMP_IS_EVENTLOG_BASED can be defined" #endif #if 0 == BOOST_INTERPROCESS_BOOTSTAMP_VALUE_SUM # define BOOST_INTERPROCESS_BOOTSTAMP_IS_EVENTLOG_BASED #endif #ifdef BOOST_USE_WINDOWS_H #include <windows.h> # if defined(BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME) # include <wbemidl.h> # include <objbase.h> # endif #include <shlobj.h> #endif #if defined(_MSC_VER) # pragma once # pragma comment( lib, "Advapi32.lib" ) # pragma comment( lib, "oleaut32.lib" ) # pragma comment( lib, "Ole32.lib" ) # pragma comment( lib, "Shell32.lib" ) //SHGetFolderPath #endif #if defined (BOOST_INTERPROCESS_WINDOWS) # include <cstdarg> # include <boost/detail/interlocked.hpp> #else # error "This file can only be included in Windows OS" #endif ////////////////////////////////////////////////////////////////////////////// // // Declaration of Windows structures or typedefs if BOOST_USE_WINDOWS_H is used // ////////////////////////////////////////////////////////////////////////////// //Ignore -pedantic errors here (anonymous structs, etc.) #if defined(BOOST_GCC) # if (BOOST_GCC >= 40600) # pragma GCC diagnostic push # if (BOOST_GCC >= 60000) # pragma GCC diagnostic ignored "-Wpedantic" # else # pragma GCC diagnostic ignored "-pedantic" # endif # else # pragma GCC system_header # endif #endif namespace boost { namespace interprocess { namespace winapi { //Own defines static const unsigned long MaxPath = 260; #ifndef BOOST_USE_WINDOWS_H struct GUID_BIPC { unsigned long Data1; unsigned short Data2; unsigned short Data3; unsigned char Data4[8]; }; #if defined(_MSC_VER) #pragma warning (push) #pragma warning (disable : 4201) // nonstandard extension used #endif struct decimal { unsigned short wReserved; union { struct { unsigned char scale; unsigned char sign; }; unsigned short signscale; }; unsigned long Hi32; union { struct { unsigned long Lo32; unsigned long Mid32; }; ::boost::ulong_long_type Lo64; }; }; typedef unsigned short *bstr; struct wchar_variant { union { struct { unsigned short vt; unsigned short wReserved1; unsigned short wReserved2; unsigned short wReserved3; union { bstr bstrVal; struct { void* pvRecord; void* pRecInfo; }; }; }; decimal decVal; }; }; #if defined(_MSC_VER) #pragma warning (pop) #endif struct IUnknown_BIPC { public: virtual long __stdcall QueryInterface( const GUID_BIPC &riid, // [in] void **ppvObject) = 0; // [iid_is][out] virtual unsigned long __stdcall AddRef (void) = 0; virtual unsigned long __stdcall Release(void) = 0; }; struct IWbemClassObject_BIPC : public IUnknown_BIPC { public: virtual long __stdcall GetQualifierSet( /* [out] */ void **ppQualSet) = 0; virtual long __stdcall Get( /* [string][in] */ const bstr wszName, /* [in] */ long lFlags, /* [unique][in][out] */ wchar_variant *pVal, /* [unique][in][out] */ long *pType, /* [unique][in][out] */ long *plFlavor) = 0; virtual long __stdcall Put( /* [string][in] */ const bstr wszName, /* [in] */ long lFlags, /* [in] */ wchar_variant *pVal, /* [in] */ long Type) = 0; virtual long __stdcall Delete( /* [string][in] */ const bstr wszName) = 0; virtual long __stdcall GetNames( /* [string][in] */ const bstr wszQualifierName, /* [in] */ long lFlags, /* [in] */ wchar_variant *pQualifierVal, /* [out] */ void * *pNames) = 0; virtual long __stdcall BeginEnumeration( /* [in] */ long lEnumFlags) = 0; virtual long __stdcall Next( /* [in] */ long lFlags, /* [unique][in][out] */ bstr *strName, /* [unique][in][out] */ wchar_variant *pVal, /* [unique][in][out] */ long *pType, /* [unique][in][out] */ long *plFlavor) = 0; virtual long __stdcall EndEnumeration( void) = 0; virtual long __stdcall GetPropertyQualifierSet( /* [string][in] */ const bstr wszProperty, /* [out] */ void **ppQualSet) = 0; virtual long __stdcall Clone( /* [out] */ IWbemClassObject_BIPC **ppCopy) = 0; virtual long __stdcall GetObjectText( /* [in] */ long lFlags, /* [out] */ bstr *pstrObjectText) = 0; virtual long __stdcall SpawnDerivedClass( /* [in] */ long lFlags, /* [out] */ IWbemClassObject_BIPC **ppNewClass) = 0; virtual long __stdcall SpawnInstance( /* [in] */ long lFlags, /* [out] */ IWbemClassObject_BIPC **ppNewInstance) = 0; virtual long __stdcall CompareTo( /* [in] */ long lFlags, /* [in] */ IWbemClassObject_BIPC *pCompareTo) = 0; virtual long __stdcall GetPropertyOrigin( /* [string][in] */ const bstr wszName, /* [out] */ bstr *pstrClassName) = 0; virtual long __stdcall InheritsFrom( /* [in] */ const bstr strAncestor) = 0; virtual long __stdcall GetMethod( /* [string][in] */ const bstr wszName, /* [in] */ long lFlags, /* [out] */ IWbemClassObject_BIPC **ppInSignature, /* [out] */ IWbemClassObject_BIPC **ppOutSignature) = 0; virtual long __stdcall PutMethod( /* [string][in] */ const bstr wszName, /* [in] */ long lFlags, /* [in] */ IWbemClassObject_BIPC *pInSignature, /* [in] */ IWbemClassObject_BIPC *pOutSignature) = 0; virtual long __stdcall DeleteMethod( /* [string][in] */ const bstr wszName) = 0; virtual long __stdcall BeginMethodEnumeration( /* [in] */ long lEnumFlags) = 0; virtual long __stdcall NextMethod( /* [in] */ long lFlags, /* [unique][in][out] */ bstr *pstrName, /* [unique][in][out] */ IWbemClassObject_BIPC **ppInSignature, /* [unique][in][out] */ IWbemClassObject_BIPC **ppOutSignature) = 0; virtual long __stdcall EndMethodEnumeration( void) = 0; virtual long __stdcall GetMethodQualifierSet( /* [string][in] */ const bstr wszMethod, /* [out] */ void **ppQualSet) = 0; virtual long __stdcall GetMethodOrigin( /* [string][in] */ const bstr wszMethodName, /* [out] */ bstr *pstrClassName) = 0; }; struct IWbemContext_BIPC : public IUnknown_BIPC { public: virtual long __stdcall Clone( /* [out] */ IWbemContext_BIPC **ppNewCopy) = 0; virtual long __stdcall GetNames( /* [in] */ long lFlags, /* [out] */ void * *pNames) = 0; virtual long __stdcall BeginEnumeration( /* [in] */ long lFlags) = 0; virtual long __stdcall Next( /* [in] */ long lFlags, /* [out] */ bstr *pstrName, /* [out] */ wchar_variant *pValue) = 0; virtual long __stdcall EndEnumeration( void) = 0; virtual long __stdcall SetValue( /* [string][in] */ const bstr wszName, /* [in] */ long lFlags, /* [in] */ wchar_variant *pValue) = 0; virtual long __stdcall GetValue( /* [string][in] */ const bstr wszName, /* [in] */ long lFlags, /* [out] */ wchar_variant *pValue) = 0; virtual long __stdcall DeleteValue( /* [string][in] */ const bstr wszName, /* [in] */ long lFlags) = 0; virtual long __stdcall DeleteAll( void) = 0; }; struct IEnumWbemClassObject_BIPC : public IUnknown_BIPC { public: virtual long __stdcall Reset( void) = 0; virtual long __stdcall Next( /* [in] */ long lTimeout, /* [in] */ unsigned long uCount, /* [length_is][size_is][out] */ IWbemClassObject_BIPC **apObjects, /* [out] */ unsigned long *puReturned) = 0; virtual long __stdcall NextAsync( /* [in] */ unsigned long uCount, /* [in] */ void *pSink) = 0; virtual long __stdcall Clone( /* [out] */ void **ppEnum) = 0; virtual long __stdcall Skip( /* [in] */ long lTimeout, /* [in] */ unsigned long nCount) = 0; }; struct IWbemServices_BIPC : public IUnknown_BIPC { public: virtual long __stdcall OpenNamespace( /* [in] */ const bstr strNamespace, /* [in] */ long lFlags, /* [in] */ void *pCtx, /* [unique][in][out] */ void **ppWorkingNamespace, /* [unique][in][out] */ void **ppResult) = 0; virtual long __stdcall CancelAsyncCall( /* [in] */ void *pSink) = 0; virtual long __stdcall QueryObjectSink( /* [in] */ long lFlags, /* [out] */ void **ppResponseHandler) = 0; virtual long __stdcall GetObject( /* [in] */ const bstr strObjectPath, /* [in] */ long lFlags, /* [in] */ void *pCtx, /* [unique][in][out] */ void **ppObject, /* [unique][in][out] */ void **ppCallResult) = 0; virtual long __stdcall GetObjectAsync( /* [in] */ const bstr strObjectPath, /* [in] */ long lFlags, /* [in] */ void *pCtx, /* [in] */ void *pResponseHandler) = 0; virtual long __stdcall PutClass( /* [in] */ IWbemClassObject_BIPC *pObject, /* [in] */ long lFlags, /* [in] */ void *pCtx, /* [unique][in][out] */ void **ppCallResult) = 0; virtual long __stdcall PutClassAsync( /* [in] */ IWbemClassObject_BIPC *pObject, /* [in] */ long lFlags, /* [in] */ void *pCtx, /* [in] */ void *pResponseHandler) = 0; virtual long __stdcall DeleteClass( /* [in] */ const bstr strClass, /* [in] */ long lFlags, /* [in] */ void *pCtx, /* [unique][in][out] */ void **ppCallResult) = 0; virtual long __stdcall DeleteClassAsync( /* [in] */ const bstr strClass, /* [in] */ long lFlags, /* [in] */ void *pCtx, /* [in] */ void *pResponseHandler) = 0; virtual long __stdcall CreateClassEnum( /* [in] */ const bstr strSuperclass, /* [in] */ long lFlags, /* [in] */ void *pCtx, /* [out] */ void **ppEnum) = 0; virtual long __stdcall CreateClassEnumAsync( /* [in] */ const bstr strSuperclass, /* [in] */ long lFlags, /* [in] */ void *pCtx, /* [in] */ void *pResponseHandler) = 0; virtual long __stdcall PutInstance( /* [in] */ void *pInst, /* [in] */ long lFlags, /* [in] */ void *pCtx, /* [unique][in][out] */ void **ppCallResult) = 0; virtual long __stdcall PutInstanceAsync( /* [in] */ void *pInst, /* [in] */ long lFlags, /* [in] */ void *pCtx, /* [in] */ void *pResponseHandler) = 0; virtual long __stdcall DeleteInstance( /* [in] */ const bstr strObjectPath, /* [in] */ long lFlags, /* [in] */ void *pCtx, /* [unique][in][out] */ void **ppCallResult) = 0; virtual long __stdcall DeleteInstanceAsync( /* [in] */ const bstr strObjectPath, /* [in] */ long lFlags, /* [in] */ void *pCtx, /* [in] */ void *pResponseHandler) = 0; virtual long __stdcall CreateInstanceEnum( /* [in] */ const bstr strFilter, /* [in] */ long lFlags, /* [in] */ void *pCtx, /* [out] */ void **ppEnum) = 0; virtual long __stdcall CreateInstanceEnumAsync( /* [in] */ const bstr strFilter, /* [in] */ long lFlags, /* [in] */ void *pCtx, /* [in] */ void *pResponseHandler) = 0; virtual long __stdcall ExecQuery( /* [in] */ const bstr strQueryLanguage, /* [in] */ const bstr strQuery, /* [in] */ long lFlags, /* [in] */ IWbemContext_BIPC *pCtx, /* [out] */ IEnumWbemClassObject_BIPC **ppEnum) = 0; virtual long __stdcall ExecQueryAsync( /* [in] */ const bstr strQueryLanguage, /* [in] */ const bstr strQuery, /* [in] */ long lFlags, /* [in] */ IWbemContext_BIPC *pCtx, /* [in] */ void *pResponseHandler) = 0; virtual long __stdcall ExecNotificationQuery( /* [in] */ const bstr strQueryLanguage, /* [in] */ const bstr strQuery, /* [in] */ long lFlags, /* [in] */ IWbemContext_BIPC *pCtx, /* [out] */ void **ppEnum) = 0; virtual long __stdcall ExecNotificationQueryAsync( /* [in] */ const bstr strQueryLanguage, /* [in] */ const bstr strQuery, /* [in] */ long lFlags, /* [in] */ IWbemContext_BIPC *pCtx, /* [in] */ void *pResponseHandler) = 0; virtual long __stdcall ExecMethod( /* [in] */ const bstr strObjectPath, /* [in] */ const bstr strMethodName, /* [in] */ long lFlags, /* [in] */ IWbemContext_BIPC *pCtx, /* [in] */ IWbemClassObject_BIPC *pInParams, /* [unique][in][out] */ IWbemClassObject_BIPC **ppOutParams, /* [unique][in][out] */ void **ppCallResult) = 0; virtual long __stdcall ExecMethodAsync( /* [in] */ const bstr strObjectPath, /* [in] */ const bstr strMethodName, /* [in] */ long lFlags, /* [in] */ IWbemContext_BIPC *pCtx, /* [in] */ IWbemClassObject_BIPC *pInParams, /* [in] */ void *pResponseHandler) = 0; }; struct IWbemLocator_BIPC : public IUnknown_BIPC { public: virtual long __stdcall ConnectServer( /* [in] */ const bstr strNetworkResource, /* [in] */ const bstr strUser, /* [in] */ const bstr strPassword, /* [in] */ const bstr strLocale, /* [in] */ long lSecurityFlags, /* [in] */ const bstr strAuthority, /* [in] */ void *pCtx, /* [out] */ IWbemServices_BIPC **ppNamespace) = 0; }; struct interprocess_overlapped { unsigned long *internal; unsigned long *internal_high; union { struct { unsigned long offset; unsigned long offset_high; }dummy; void *pointer; }; void *h_event; }; struct interprocess_filetime { unsigned long dwLowDateTime; unsigned long dwHighDateTime; }; struct win32_find_data { unsigned long dwFileAttributes; interprocess_filetime ftCreationTime; interprocess_filetime ftLastAccessTime; interprocess_filetime ftLastWriteTime; unsigned long nFileSizeHigh; unsigned long nFileSizeLow; unsigned long dwReserved0; unsigned long dwReserved1; char cFileName[MaxPath]; char cAlternateFileName[14]; }; struct interprocess_security_attributes { unsigned long nLength; void *lpSecurityDescriptor; int bInheritHandle; }; struct system_info { union { unsigned long dwOemId; // Obsolete field...do not use struct { unsigned short wProcessorArchitecture; unsigned short wReserved; } dummy; }; unsigned long dwPageSize; void * lpMinimumApplicationAddress; void * lpMaximumApplicationAddress; unsigned long * dwActiveProcessorMask; unsigned long dwNumberOfProcessors; unsigned long dwProcessorType; unsigned long dwAllocationGranularity; unsigned short wProcessorLevel; unsigned short wProcessorRevision; }; struct interprocess_acl { unsigned char AclRevision; unsigned char Sbz1; unsigned short AclSize; unsigned short AceCount; unsigned short Sbz2; }; struct interprocess_security_descriptor { unsigned char Revision; unsigned char Sbz1; unsigned short Control; void *Owner; void *Group; interprocess_acl *Sacl; interprocess_acl *Dacl; }; struct interprocess_by_handle_file_information { unsigned long dwFileAttributes; interprocess_filetime ftCreationTime; interprocess_filetime ftLastAccessTime; interprocess_filetime ftLastWriteTime; unsigned long dwVolumeSerialNumber; unsigned long nFileSizeHigh; unsigned long nFileSizeLow; unsigned long nNumberOfLinks; unsigned long nFileIndexHigh; unsigned long nFileIndexLow; }; struct interprocess_eventlogrecord { unsigned long Length; // Length of full record unsigned long Reserved; // Used by the service unsigned long RecordNumber; // Absolute record number unsigned long TimeGenerated; // Seconds since 1-1-1970 unsigned long TimeWritten; // Seconds since 1-1-1970 unsigned long EventID; unsigned short EventType; unsigned short NumStrings; unsigned short EventCategory; unsigned short ReservedFlags; // For use with paired events (auditing) unsigned long ClosingRecordNumber; // For use with paired events (auditing) unsigned long StringOffset; // Offset from beginning of record unsigned long UserSidLength; unsigned long UserSidOffset; unsigned long DataLength; unsigned long DataOffset; // Offset from beginning of record // // Then follow: // // wchar_t SourceName[] // wchar_t Computername[] // SID UserSid // wchar_t Strings[] // BYTE Data[] // CHAR Pad[] // unsigned long Length; // }; union large_integer { __int64 QuadPart; }; struct hinstance_struct { int unused; }; typedef hinstance_struct *hmodule; struct hkey_struct; typedef hkey_struct *hkey; #ifdef _WIN64 typedef __int64 (__stdcall *farproc_t)(); #else typedef int (__stdcall *farproc_t)(); #endif // _WIN64 #else //#ifndef BOOST_USE_WINDOWS_H typedef GUID GUID_BIPC; typedef VARIANT wchar_variant; #if defined(BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME) typedef IUnknown IUnknown_BIPC; typedef IWbemClassObject IWbemClassObject_BIPC; typedef IWbemContext IWbemContext_BIPC; typedef IEnumWbemClassObject IEnumWbemClassObject_BIPC; typedef IWbemServices IWbemServices_BIPC; typedef IWbemLocator IWbemLocator_BIPC; #endif typedef OVERLAPPED interprocess_overlapped; typedef FILETIME interprocess_filetime; typedef WIN32_FIND_DATAA win32_find_data; typedef SECURITY_ATTRIBUTES interprocess_security_attributes; typedef SYSTEM_INFO system_info; typedef ACL interprocess_acl; typedef SECURITY_DESCRIPTOR interprocess_security_descriptor; typedef BY_HANDLE_FILE_INFORMATION interprocess_by_handle_file_information; typedef EVENTLOGRECORD interprocess_eventlogrecord; typedef LARGE_INTEGER large_integer; typedef HMODULE hmodule; typedef HKEY hkey; typedef BSTR bstr; typedef FARPROC farproc_t; #endif //#ifndef BOOST_USE_WINDOWS_H ////////////////////////////////////////////////////////////////////////////// // // Nt native structures // ////////////////////////////////////////////////////////////////////////////// struct interprocess_semaphore_basic_information { unsigned int count; // current semaphore count unsigned int limit; // max semaphore count }; struct interprocess_section_basic_information { void * base_address; unsigned long section_attributes; __int64 section_size; }; struct file_rename_information_t { int Replace; void *RootDir; unsigned long FileNameLength; wchar_t FileName[1]; }; struct unicode_string_t { unsigned short Length; unsigned short MaximumLength; wchar_t *Buffer; }; struct object_attributes_t { unsigned long Length; void * RootDirectory; unicode_string_t *ObjectName; unsigned long Attributes; void *SecurityDescriptor; void *SecurityQualityOfService; }; struct io_status_block_t { union { long Status; void *Pointer; }; unsigned long *Information; }; union system_timeofday_information { struct data_t { __int64 liKeBootTime; __int64 liKeSystemTime; __int64 liExpTimeZoneBias; unsigned long uCurrentTimeZoneId; unsigned long dwReserved; ::boost::ulong_long_type ullBootTimeBias; ::boost::ulong_long_type ullSleepTimeBias; } data; unsigned char Reserved1[sizeof(data_t)]; }; static const long BootstampLength = sizeof(__int64); static const long BootAndSystemstampLength = sizeof(__int64)*2; static const long SystemTimeOfDayInfoLength = sizeof(system_timeofday_information::data_t); struct object_name_information_t { unicode_string_t Name; wchar_t NameBuffer[1]; }; enum file_information_class_t { file_directory_information = 1, file_full_directory_information, file_both_directory_information, file_basic_information, file_standard_information, file_internal_information, file_ea_information, file_access_information, file_name_information, file_rename_information, file_link_information, file_names_information, file_disposition_information, file_position_information, file_full_ea_information, file_mode_information, file_alignment_information, file_all_information, file_allocation_information, file_end_of_file_information, file_alternate_name_information, file_stream_information, file_pipe_information, file_pipe_local_information, file_pipe_remote_information, file_mailslot_query_information, file_mailslot_set_information, file_compression_information, file_copy_on_write_information, file_completion_information, file_move_cluster_information, file_quota_information, file_reparse_point_information, file_network_open_information, file_object_id_information, file_tracking_information, file_ole_directory_information, file_content_index_information, file_inherit_content_index_information, file_ole_information, file_maximum_information }; enum semaphore_information_class { semaphore_basic_information = 0 }; enum system_information_class { system_basic_information = 0, system_performance_information = 2, system_time_of_day_information = 3, system_process_information = 5, system_processor_performance_information = 8, system_interrupt_information = 23, system_exception_information = 33, system_registry_quota_information = 37, system_lookaside_information = 45 }; enum object_information_class { object_basic_information, object_name_information, object_type_information, object_all_information, object_data_information }; enum section_information_class { section_basic_information, section_image_information }; ////////////////////////////////////////////////////////////////////////////// // // Forward declaration of winapi // ////////////////////////////////////////////////////////////////////////////// #ifndef BOOST_USE_WINDOWS_H //Kernel32.dll //Some windows API declarations extern "C" __declspec(dllimport) unsigned long __stdcall GetCurrentProcessId(); extern "C" __declspec(dllimport) unsigned long __stdcall GetCurrentThreadId(); extern "C" __declspec(dllimport) int __stdcall GetProcessTimes ( void *hProcess, interprocess_filetime* lpCreationTime , interprocess_filetime *lpExitTime,interprocess_filetime *lpKernelTime , interprocess_filetime *lpUserTime ); extern "C" __declspec(dllimport) void __stdcall Sleep(unsigned long); extern "C" __declspec(dllimport) unsigned long __stdcall GetTickCount(void); extern "C" __declspec(dllimport) int __stdcall SwitchToThread(); extern "C" __declspec(dllimport) unsigned long __stdcall GetLastError(); extern "C" __declspec(dllimport) void __stdcall SetLastError(unsigned long); extern "C" __declspec(dllimport) void * __stdcall GetCurrentProcess(); extern "C" __declspec(dllimport) int __stdcall CloseHandle(void*); extern "C" __declspec(dllimport) int __stdcall DuplicateHandle ( void *hSourceProcessHandle, void *hSourceHandle , void *hTargetProcessHandle, void **lpTargetHandle , unsigned long dwDesiredAccess, int bInheritHandle , unsigned long dwOptions); extern "C" __declspec(dllimport) long __stdcall GetFileType(void *hFile); extern "C" __declspec(dllimport) void *__stdcall FindFirstFileA(const char *lpFileName, win32_find_data *lpFindFileData); extern "C" __declspec(dllimport) int __stdcall FindNextFileA(void *hFindFile, win32_find_data *lpFindFileData); extern "C" __declspec(dllimport) int __stdcall FindClose(void *hFindFile); //extern "C" __declspec(dllimport) void __stdcall GetSystemTimeAsFileTime(interprocess_filetime*); //extern "C" __declspec(dllimport) int __stdcall FileTimeToLocalFileTime(const interprocess_filetime *in, const interprocess_filetime *out); extern "C" __declspec(dllimport) void * __stdcall CreateMutexA(interprocess_security_attributes*, int, const char *); extern "C" __declspec(dllimport) void * __stdcall OpenMutexA(unsigned long, int, const char *); extern "C" __declspec(dllimport) unsigned long __stdcall WaitForSingleObject(void *, unsigned long); extern "C" __declspec(dllimport) int __stdcall ReleaseMutex(void *); extern "C" __declspec(dllimport) int __stdcall UnmapViewOfFile(void *); extern "C" __declspec(dllimport) void * __stdcall CreateSemaphoreA(interprocess_security_attributes*, long, long, const char *); extern "C" __declspec(dllimport) int __stdcall ReleaseSemaphore(void *, long, long *); extern "C" __declspec(dllimport) void * __stdcall OpenSemaphoreA(unsigned long, int, const char *); extern "C" __declspec(dllimport) void * __stdcall CreateFileMappingA (void *, interprocess_security_attributes*, unsigned long, unsigned long, unsigned long, const char *); extern "C" __declspec(dllimport) void * __stdcall MapViewOfFileEx (void *, unsigned long, unsigned long, unsigned long, std::size_t, void*); extern "C" __declspec(dllimport) void * __stdcall OpenFileMappingA (unsigned long, int, const char *); extern "C" __declspec(dllimport) void * __stdcall CreateFileA (const char *, unsigned long, unsigned long, struct interprocess_security_attributes*, unsigned long, unsigned long, void *); extern "C" __declspec(dllimport) void __stdcall GetSystemInfo (struct system_info *); extern "C" __declspec(dllimport) int __stdcall FlushViewOfFile (void *, std::size_t); extern "C" __declspec(dllimport) int __stdcall VirtualUnlock (void *, std::size_t); extern "C" __declspec(dllimport) int __stdcall VirtualProtect (void *, std::size_t, unsigned long, unsigned long *); extern "C" __declspec(dllimport) int __stdcall FlushFileBuffers (void *); extern "C" __declspec(dllimport) int __stdcall GetFileSizeEx (void *, large_integer *size); extern "C" __declspec(dllimport) unsigned long __stdcall FormatMessageA (unsigned long dwFlags, const void *lpSource, unsigned long dwMessageId, unsigned long dwLanguageId, char *lpBuffer, unsigned long nSize, std::va_list *Arguments); extern "C" __declspec(dllimport) void *__stdcall LocalFree (void *); extern "C" __declspec(dllimport) unsigned long __stdcall GetFileAttributesA(const char *); extern "C" __declspec(dllimport) int __stdcall CreateDirectoryA(const char *, interprocess_security_attributes*); extern "C" __declspec(dllimport) int __stdcall RemoveDirectoryA(const char *lpPathName); extern "C" __declspec(dllimport) int __stdcall GetTempPathA(unsigned long length, char *buffer); extern "C" __declspec(dllimport) int __stdcall CreateDirectory(const char *, interprocess_security_attributes*); extern "C" __declspec(dllimport) int __stdcall SetFileValidData(void *, __int64 size); extern "C" __declspec(dllimport) int __stdcall SetEndOfFile(void *); extern "C" __declspec(dllimport) int __stdcall SetFilePointerEx(void *, large_integer distance, large_integer *new_file_pointer, unsigned long move_method); extern "C" __declspec(dllimport) int __stdcall LockFile (void *hnd, unsigned long offset_low, unsigned long offset_high, unsigned long size_low, unsigned long size_high); extern "C" __declspec(dllimport) int __stdcall UnlockFile(void *hnd, unsigned long offset_low, unsigned long offset_high, unsigned long size_low, unsigned long size_high); extern "C" __declspec(dllimport) int __stdcall LockFileEx(void *hnd, unsigned long flags, unsigned long reserved, unsigned long size_low, unsigned long size_high, interprocess_overlapped* overlapped); extern "C" __declspec(dllimport) int __stdcall UnlockFileEx(void *hnd, unsigned long reserved, unsigned long size_low, unsigned long size_high, interprocess_overlapped* overlapped); extern "C" __declspec(dllimport) int __stdcall WriteFile(void *hnd, const void *buffer, unsigned long bytes_to_write, unsigned long *bytes_written, interprocess_overlapped* overlapped); extern "C" __declspec(dllimport) int __stdcall ReadFile(void *hnd, void *buffer, unsigned long bytes_to_read, unsigned long *bytes_read, interprocess_overlapped* overlapped); extern "C" __declspec(dllimport) int __stdcall InitializeSecurityDescriptor(interprocess_security_descriptor *pSecurityDescriptor, unsigned long dwRevision); extern "C" __declspec(dllimport) int __stdcall SetSecurityDescriptorDacl(interprocess_security_descriptor *pSecurityDescriptor, int bDaclPresent, interprocess_acl *pDacl, int bDaclDefaulted); extern "C" __declspec(dllimport) hmodule __stdcall LoadLibraryA(const char *); extern "C" __declspec(dllimport) int __stdcall FreeLibrary(hmodule); extern "C" __declspec(dllimport) farproc_t __stdcall GetProcAddress(void *, const char*); extern "C" __declspec(dllimport) hmodule __stdcall GetModuleHandleA(const char*); extern "C" __declspec(dllimport) void *__stdcall GetFileInformationByHandle(void *, interprocess_by_handle_file_information*); //Advapi32.dll extern "C" __declspec(dllimport) long __stdcall RegOpenKeyExA(hkey, const char *, unsigned long, unsigned long, hkey*); extern "C" __declspec(dllimport) long __stdcall RegQueryValueExA(hkey, const char *, unsigned long*, unsigned long*, unsigned char *, unsigned long*); extern "C" __declspec(dllimport) long __stdcall RegCloseKey(hkey); //Ole32.dll extern "C" __declspec(dllimport) long __stdcall CoInitializeEx(void *pvReserved, unsigned long dwCoInit); extern "C" __declspec(dllimport) long __stdcall CoInitializeSecurity( void* pSecDesc, long cAuthSvc, void * asAuthSvc, void *pReserved1, unsigned long dwAuthnLevel, unsigned long dwImpLevel, void *pAuthList, unsigned long dwCapabilities, void *pReserved3 ); extern "C" __declspec(dllimport) long __stdcall CoSetProxyBlanket( IUnknown_BIPC *pProxy, unsigned long dwAuthnSvc, unsigned long dwAuthzSvc, wchar_t *pServerPrincName, unsigned long dwAuthnLevel, unsigned long dwImpLevel, void *pAuthInfo, unsigned long dwCapabilities); extern "C" __declspec(dllimport) long __stdcall CoCreateInstance(const GUID_BIPC & rclsid, IUnknown_BIPC *pUnkOuter, unsigned long dwClsContext, const GUID_BIPC & riid, void** ppv); extern "C" __declspec(dllimport) void __stdcall CoUninitialize(void); //OleAut32.dll extern "C" __declspec(dllimport) long __stdcall VariantClear(wchar_variant * pvarg); //Shell32.dll extern "C" __declspec(dllimport) int __stdcall SHGetSpecialFolderPathA (void* hwnd, const char *pszPath, int csidl, int fCreate); extern "C" __declspec(dllimport) int __stdcall SHGetFolderPathA(void *hwnd, int csidl, void *hToken, unsigned long dwFlags, const char *pszPath); //EventLog access functions extern "C" __declspec(dllimport) void* __stdcall OpenEventLogA (const char* lpUNCServerName, const char* lpSourceName); extern "C" __declspec(dllimport) int __stdcall CloseEventLog(void *hEventLog); extern "C" __declspec(dllimport) int __stdcall ReadEventLogA (void *hEventLog, unsigned long dwReadFlags, unsigned long dwRecordOffset, void *lpBuffer, unsigned long nNumberOfBytesToRead, unsigned long *pnBytesRead, unsigned long *pnMinNumberOfBytesNeeded ); #endif //#ifndef BOOST_USE_WINDOWS_H //kernel32.dll typedef int (__stdcall *QueryPerformanceCounter_t) (__int64 *lpPerformanceCount); typedef int (__stdcall *QueryPerformanceFrequency_t)(__int64 *lpFrequency); //ntdll.dll typedef long (__stdcall *NtDeleteFile_t)(object_attributes_t *ObjectAttributes); typedef long (__stdcall *NtSetInformationFile_t)(void *FileHandle, io_status_block_t *IoStatusBlock, void *FileInformation, unsigned long Length, int FileInformationClass ); typedef long (__stdcall *NtOpenFile)(void **FileHandle, unsigned long DesiredAccess, object_attributes_t *ObjectAttributes , io_status_block_t *IoStatusBlock, unsigned long ShareAccess, unsigned long Length, unsigned long OpenOptions); typedef long (__stdcall *NtQuerySystemInformation_t)(int, void*, unsigned long, unsigned long *); typedef long (__stdcall *NtQueryObject_t)(void*, object_information_class, void *, unsigned long, unsigned long *); typedef long (__stdcall *NtQuerySemaphore_t)(void*, unsigned int info_class, interprocess_semaphore_basic_information *pinfo, unsigned int info_size, unsigned int *ret_len); typedef long (__stdcall *NtQuerySection_t)(void*, section_information_class, interprocess_section_basic_information *pinfo, unsigned long info_size, unsigned long *ret_len); typedef long (__stdcall *NtQueryInformationFile_t)(void *,io_status_block_t *,void *, long, int); typedef long (__stdcall *NtOpenFile_t)(void*,unsigned long ,object_attributes_t*,io_status_block_t*,unsigned long,unsigned long); typedef long (__stdcall *NtClose_t) (void*); typedef long (__stdcall *NtQueryTimerResolution_t) (unsigned long* LowestResolution, unsigned long* HighestResolution, unsigned long* CurrentResolution); typedef long (__stdcall *NtSetTimerResolution_t) (unsigned long RequestedResolution, int Set, unsigned long* ActualResolution); } //namespace winapi { } //namespace interprocess { } //namespace boost { ////////////////////////////////////////////////////////////////////////////// // // Forward declaration of constants // ////////////////////////////////////////////////////////////////////////////// namespace boost { namespace interprocess { namespace winapi { //Some used constants static const unsigned long infinite_time = 0xFFFFFFFF; static const unsigned long error_already_exists = 183L; static const unsigned long error_invalid_handle = 6L; static const unsigned long error_sharing_violation = 32L; static const unsigned long error_file_not_found = 2u; static const unsigned long error_no_more_files = 18u; static const unsigned long error_not_locked = 158L; //Retries in CreateFile, see http://support.microsoft.com/kb/316609 static const unsigned long error_sharing_violation_tries = 3L; static const unsigned long error_sharing_violation_sleep_ms = 250L; static const unsigned long error_file_too_large = 223L; static const unsigned long error_insufficient_buffer = 122L; static const unsigned long error_handle_eof = 38L; static const unsigned long semaphore_all_access = (0x000F0000L)|(0x00100000L)|0x3; static const unsigned long mutex_all_access = (0x000F0000L)|(0x00100000L)|0x0001; static const unsigned long page_readonly = 0x02; static const unsigned long page_readwrite = 0x04; static const unsigned long page_writecopy = 0x08; static const unsigned long page_noaccess = 0x01; static const unsigned long standard_rights_required = 0x000F0000L; static const unsigned long section_query = 0x0001; static const unsigned long section_map_write = 0x0002; static const unsigned long section_map_read = 0x0004; static const unsigned long section_map_execute = 0x0008; static const unsigned long section_extend_size = 0x0010; static const unsigned long section_all_access = standard_rights_required | section_query | section_map_write | section_map_read | section_map_execute | section_extend_size; static const unsigned long file_map_copy = section_query; static const unsigned long file_map_write = section_map_write; static const unsigned long file_map_read = section_map_read; static const unsigned long file_map_all_access = section_all_access; static const unsigned long delete_access = 0x00010000L; static const unsigned long file_flag_backup_semantics = 0x02000000; static const long file_flag_delete_on_close = 0x04000000; //Native API constants static const unsigned long file_open_for_backup_intent = 0x00004000; static const int file_share_valid_flags = 0x00000007; static const long file_delete_on_close = 0x00001000L; static const long obj_case_insensitive = 0x00000040L; static const long delete_flag = 0x00010000L; static const unsigned long movefile_copy_allowed = 0x02; static const unsigned long movefile_delay_until_reboot = 0x04; static const unsigned long movefile_replace_existing = 0x01; static const unsigned long movefile_write_through = 0x08; static const unsigned long movefile_create_hardlink = 0x10; static const unsigned long movefile_fail_if_not_trackable = 0x20; static const unsigned long file_share_read = 0x00000001; static const unsigned long file_share_write = 0x00000002; static const unsigned long file_share_delete = 0x00000004; static const unsigned long file_attribute_readonly = 0x00000001; static const unsigned long file_attribute_hidden = 0x00000002; static const unsigned long file_attribute_system = 0x00000004; static const unsigned long file_attribute_directory = 0x00000010; static const unsigned long file_attribute_archive = 0x00000020; static const unsigned long file_attribute_device = 0x00000040; static const unsigned long file_attribute_normal = 0x00000080; static const unsigned long file_attribute_temporary = 0x00000100; static const unsigned long generic_read = 0x80000000L; static const unsigned long generic_write = 0x40000000L; static const unsigned long wait_object_0 = 0; static const unsigned long wait_abandoned = 0x00000080L; static const unsigned long wait_timeout = 258L; static const unsigned long wait_failed = (unsigned long)0xFFFFFFFF; static const unsigned long duplicate_close_source = (unsigned long)0x00000001; static const unsigned long duplicate_same_access = (unsigned long)0x00000002; static const unsigned long format_message_allocate_buffer = (unsigned long)0x00000100; static const unsigned long format_message_ignore_inserts = (unsigned long)0x00000200; static const unsigned long format_message_from_string = (unsigned long)0x00000400; static const unsigned long format_message_from_hmodule = (unsigned long)0x00000800; static const unsigned long format_message_from_system = (unsigned long)0x00001000; static const unsigned long format_message_argument_array = (unsigned long)0x00002000; static const unsigned long format_message_max_width_mask = (unsigned long)0x000000FF; static const unsigned long lang_neutral = (unsigned long)0x00; static const unsigned long sublang_default = (unsigned long)0x01; static const unsigned long invalid_file_size = (unsigned long)0xFFFFFFFF; static const unsigned long invalid_file_attributes = ((unsigned long)-1); static void * const invalid_handle_value = ((void*)(long)(-1)); static const unsigned long file_type_char = 0x0002L; static const unsigned long file_type_disk = 0x0001L; static const unsigned long file_type_pipe = 0x0003L; static const unsigned long file_type_remote = 0x8000L; static const unsigned long file_type_unknown = 0x0000L; static const unsigned long create_new = 1; static const unsigned long create_always = 2; static const unsigned long open_existing = 3; static const unsigned long open_always = 4; static const unsigned long truncate_existing = 5; static const unsigned long file_begin = 0; static const unsigned long file_current = 1; static const unsigned long file_end = 2; static const unsigned long lockfile_fail_immediately = 1; static const unsigned long lockfile_exclusive_lock = 2; static const unsigned long error_lock_violation = 33; static const unsigned long security_descriptor_revision = 1; const unsigned long max_record_buffer_size = 0x10000L; // 64K const unsigned long max_path = 260; //Keys static const hkey hkey_local_machine = (hkey)(unsigned long*)(long)(0x80000002); static unsigned long key_query_value = 0x0001; //COM API const unsigned long RPC_C_AUTHN_LEVEL_PKT_BIPC = 4; const unsigned long RPC_C_AUTHN_DEFAULT_BIPC = 0xffffffffL; const unsigned long RPC_C_AUTHZ_DEFAULT_BIPC = 0xffffffffL; const unsigned long RPC_C_IMP_LEVEL_IMPERSONATE_BIPC = 3; const signed long EOAC_NONE_BIPC = 0; const signed long CLSCTX_INPROC_SERVER_BIPC = 0x1; const signed long CLSCTX_LOCAL_SERVER_BIPC = 0x4; const signed long WBEM_FLAG_RETURN_IMMEDIATELY_BIPC = 0x10; const signed long WBEM_FLAG_RETURN_WHEN_COMPLETE_BIPC = 0x0; const signed long WBEM_FLAG_FORWARD_ONLY_BIPC = 0x20; const signed long WBEM_INFINITE_BIPC = 0xffffffffL; const signed long RPC_E_TOO_LATE_BIPC = 0x80010119L; const signed long S_OK_BIPC = 0L; const signed long S_FALSE_BIPC = 1; const signed long RPC_E_CHANGED_MODE_BIPC = 0x80010106L; const unsigned long COINIT_APARTMENTTHREADED_BIPC = 0x2; const unsigned long COINIT_MULTITHREADED_BIPC = 0x0; const unsigned long COINIT_DISABLE_OLE1DDE_BIPC = 0x4; const unsigned long COINIT_SPEED_OVER_MEMORY_BIPC = 0x4; // Registry types #define reg_none ( 0 ) // No value type #define reg_sz ( 1 ) // Unicode nul terminated string #define reg_expand_sz ( 2 ) // Unicode nul terminated string // (with environment variable references) #define reg_binary ( 3 ) // Free form binary #define reg_dword ( 4 ) // 32-bit number #define reg_dword_little_endian ( 4 ) // 32-bit number (same as REG_DWORD) #define reg_dword_big_endian ( 5 ) // 32-bit number #define reg_link ( 6 ) // Symbolic Link (unicode) #define reg_multi_sz ( 7 ) // Multiple Unicode strings #define reg_resource_list ( 8 ) // Resource list in the resource map #define reg_full_resource_descriptor ( 9 ) // Resource list in the hardware description #define reg_resource_requirements_list ( 10 ) #define reg_qword ( 11 ) // 64-bit number #define reg_qword_little_endian ( 11 ) // 64-bit number (same as reg_qword) //If the user needs to change default COM initialization model, //it can define BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL to one of these: // // COINIT_APARTMENTTHREADED_BIPC // COINIT_MULTITHREADED_BIPC // COINIT_DISABLE_OLE1DDE_BIPC // COINIT_SPEED_OVER_MEMORY_BIPC #if !defined(BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL) #define BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL COINIT_APARTMENTTHREADED_BIPC #elif (BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL != COINIT_APARTMENTTHREADED_BIPC) &&\ (BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL != COINIT_MULTITHREADED_BIPC) &&\ (BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL != COINIT_DISABLE_OLE1DDE_BIPC) &&\ (BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL != COINIT_SPEED_OVER_MEMORY_BIPC) #error "Wrong value for BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL macro" #endif const GUID_BIPC CLSID_WbemAdministrativeLocator = { 0xcb8555cc, 0x9128, 0x11d1, {0xad, 0x9b, 0x00, 0xc0, 0x4f, 0xd8, 0xfd, 0xff}}; const GUID_BIPC IID_IUnknown = { 0x00000000, 0x0000, 0x0000, {0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}; static const unsigned long eventlog_sequential_read = 0x0001; static const unsigned long eventlog_backwards_read = 0x0008; } //namespace winapi { } //namespace interprocess { } //namespace boost { namespace boost { namespace interprocess { namespace winapi { inline unsigned long get_last_error() { return GetLastError(); } inline void set_last_error(unsigned long err) { return SetLastError(err); } inline unsigned long format_message (unsigned long dwFlags, const void *lpSource, unsigned long dwMessageId, unsigned long dwLanguageId, char *lpBuffer, unsigned long nSize, std::va_list *Arguments) { return FormatMessageA (dwFlags, lpSource, dwMessageId, dwLanguageId, lpBuffer, nSize, Arguments); } //And now, wrapper functions inline void * local_free(void *hmem) { return LocalFree(hmem); } inline unsigned long make_lang_id(unsigned long p, unsigned long s) { return ((((unsigned short)(s)) << 10) | (unsigned short)(p)); } inline void sched_yield() { if(!SwitchToThread()){ Sleep(0); } } inline void sleep_tick() { Sleep(1); } inline void sleep(unsigned long ms) { Sleep(ms); } inline unsigned long get_current_thread_id() { return GetCurrentThreadId(); } inline bool get_process_times ( void *hProcess, interprocess_filetime* lpCreationTime , interprocess_filetime *lpExitTime, interprocess_filetime *lpKernelTime , interprocess_filetime *lpUserTime ) { return 0 != GetProcessTimes(hProcess, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime); } inline unsigned long get_current_process_id() { return GetCurrentProcessId(); } inline unsigned int close_handle(void* handle) { return CloseHandle(handle); } inline void * find_first_file(const char *lpFileName, win32_find_data *lpFindFileData) { return FindFirstFileA(lpFileName, lpFindFileData); } inline bool find_next_file(void *hFindFile, win32_find_data *lpFindFileData) { return FindNextFileA(hFindFile, lpFindFileData) != 0; } inline bool find_close(void *handle) { return FindClose(handle) != 0; } inline bool duplicate_current_process_handle (void *hSourceHandle, void **lpTargetHandle) { return 0 != DuplicateHandle ( GetCurrentProcess(), hSourceHandle, GetCurrentProcess() , lpTargetHandle, 0, 0 , duplicate_same_access); } inline unsigned long get_file_type(void *hFile) { return GetFileType(hFile); } /* inline void get_system_time_as_file_time(interprocess_filetime *filetime) { GetSystemTimeAsFileTime(filetime); } inline bool file_time_to_local_file_time (const interprocess_filetime *in, const interprocess_filetime *out) { return 0 != FileTimeToLocalFileTime(in, out); } */ inline void *open_or_create_mutex(const char *name, bool initial_owner, interprocess_security_attributes *attr) { return CreateMutexA(attr, (int)initial_owner, name); } inline unsigned long wait_for_single_object(void *handle, unsigned long time) { return WaitForSingleObject(handle, time); } inline int release_mutex(void *handle) { return ReleaseMutex(handle); } inline int unmap_view_of_file(void *address) { return UnmapViewOfFile(address); } inline void *open_or_create_semaphore(const char *name, long initial_count, long maximum_count, interprocess_security_attributes *attr) { return CreateSemaphoreA(attr, initial_count, maximum_count, name); } inline void *open_semaphore(const char *name) { return OpenSemaphoreA(semaphore_all_access, 0, name); } inline int release_semaphore(void *handle, long release_count, long *prev_count) { return ReleaseSemaphore(handle, release_count, prev_count); } class interprocess_all_access_security { interprocess_security_attributes sa; interprocess_security_descriptor sd; bool initialized; public: interprocess_all_access_security() : initialized(false) { if(!InitializeSecurityDescriptor(&sd, security_descriptor_revision)) return; if(!SetSecurityDescriptorDacl(&sd, true, 0, false)) return; sa.lpSecurityDescriptor = &sd; sa.nLength = sizeof(interprocess_security_attributes); sa.bInheritHandle = false; initialized = false; } interprocess_security_attributes *get_attributes() { return &sa; } }; inline void * create_file_mapping (void * handle, unsigned long access, ::boost::ulong_long_type file_offset, const char * name, interprocess_security_attributes *psec) { const unsigned long high_size(file_offset >> 32), low_size((boost::uint32_t)file_offset); return CreateFileMappingA (handle, psec, access, high_size, low_size, name); } inline void * open_file_mapping (unsigned long access, const char *name) { return OpenFileMappingA (access, 0, name); } inline void *map_view_of_file_ex(void *handle, unsigned long file_access, ::boost::ulong_long_type offset, std::size_t numbytes, void *base_addr) { const unsigned long offset_low = (unsigned long)(offset & ((::boost::ulong_long_type)0xFFFFFFFF)); const unsigned long offset_high = offset >> 32; return MapViewOfFileEx(handle, file_access, offset_high, offset_low, numbytes, base_addr); } inline void *create_file(const char *name, unsigned long access, unsigned long creation_flags, unsigned long attributes, interprocess_security_attributes *psec) { for (unsigned int attempt(0); attempt < error_sharing_violation_tries; ++attempt){ void * const handle = CreateFileA(name, access, file_share_read | file_share_write | file_share_delete, psec, creation_flags, attributes, 0); bool const invalid(invalid_handle_value == handle); if (!invalid){ return handle; } if (error_sharing_violation != get_last_error()){ return handle; } sleep(error_sharing_violation_sleep_ms); } return invalid_handle_value; } inline void get_system_info(system_info *info) { GetSystemInfo(info); } inline bool flush_view_of_file(void *base_addr, std::size_t numbytes) { return 0 != FlushViewOfFile(base_addr, numbytes); } inline bool virtual_unlock(void *base_addr, std::size_t numbytes) { return 0 != VirtualUnlock(base_addr, numbytes); } inline bool virtual_protect(void *base_addr, std::size_t numbytes, unsigned long flNewProtect, unsigned long &lpflOldProtect) { return 0 != VirtualProtect(base_addr, numbytes, flNewProtect, &lpflOldProtect); } inline bool flush_file_buffers(void *handle) { return 0 != FlushFileBuffers(handle); } inline bool get_file_size(void *handle, __int64 &size) { return 0 != GetFileSizeEx(handle, (large_integer*)&size); } inline bool create_directory(const char *name) { interprocess_all_access_security sec; return 0 != CreateDirectoryA(name, sec.get_attributes()); } inline bool remove_directory(const char *lpPathName) { return 0 != RemoveDirectoryA(lpPathName); } inline unsigned long get_temp_path(unsigned long length, char *buffer) { return GetTempPathA(length, buffer); } inline int set_end_of_file(void *handle) { return 0 != SetEndOfFile(handle); } inline bool set_file_pointer_ex(void *handle, __int64 distance, __int64 *new_file_pointer, unsigned long move_method) { large_integer d; d.QuadPart = distance; return 0 != SetFilePointerEx(handle, d, (large_integer*)new_file_pointer, move_method); } inline bool lock_file_ex(void *hnd, unsigned long flags, unsigned long reserved, unsigned long size_low, unsigned long size_high, interprocess_overlapped *overlapped) { return 0 != LockFileEx(hnd, flags, reserved, size_low, size_high, overlapped); } inline bool unlock_file_ex(void *hnd, unsigned long reserved, unsigned long size_low, unsigned long size_high, interprocess_overlapped *overlapped) { return 0 != UnlockFileEx(hnd, reserved, size_low, size_high, overlapped); } inline bool write_file(void *hnd, const void *buffer, unsigned long bytes_to_write, unsigned long *bytes_written, interprocess_overlapped* overlapped) { return 0 != WriteFile(hnd, buffer, bytes_to_write, bytes_written, overlapped); } inline bool read_file(void *hnd, void *buffer, unsigned long bytes_to_read, unsigned long *bytes_read, interprocess_overlapped* overlapped) { return 0 != ReadFile(hnd, buffer, bytes_to_read, bytes_read, overlapped); } inline bool get_file_information_by_handle(void *hnd, interprocess_by_handle_file_information *info) { return 0 != GetFileInformationByHandle(hnd, info); } inline long interlocked_increment(long volatile *addr) { return BOOST_INTERLOCKED_INCREMENT(const_cast<long*>(addr)); } inline long interlocked_decrement(long volatile *addr) { return BOOST_INTERLOCKED_DECREMENT(const_cast<long*>(addr)); } inline long interlocked_compare_exchange(long volatile *addr, long val1, long val2) { return BOOST_INTERLOCKED_COMPARE_EXCHANGE(const_cast<long*>(addr), val1, val2); } inline long interlocked_exchange_add(long volatile* addend, long value) { return BOOST_INTERLOCKED_EXCHANGE_ADD(const_cast<long*>(addend), value); } inline long interlocked_exchange(long volatile* addend, long value) { return BOOST_INTERLOCKED_EXCHANGE(const_cast<long*>(addend), value); } //Forward functions inline hmodule load_library(const char *name) { return LoadLibraryA(name); } inline bool free_library(hmodule module) { return 0 != FreeLibrary(module); } inline farproc_t get_proc_address(hmodule module, const char *name) { return GetProcAddress(module, name); } inline void *get_current_process() { return GetCurrentProcess(); } inline hmodule get_module_handle(const char *name) { return GetModuleHandleA(name); } inline long reg_open_key_ex(hkey hKey, const char *lpSubKey, unsigned long ulOptions, unsigned long samDesired, hkey *phkResult) { return RegOpenKeyExA(hKey, lpSubKey, ulOptions, samDesired, phkResult); } inline long reg_query_value_ex(hkey hKey, const char *lpValueName, unsigned long*lpReserved, unsigned long*lpType, unsigned char *lpData, unsigned long*lpcbData) { return RegQueryValueExA(hKey, lpValueName, lpReserved, lpType, lpData, lpcbData); } inline long reg_close_key(hkey hKey) { return RegCloseKey(hKey); } inline void initialize_object_attributes ( object_attributes_t *pobject_attr, unicode_string_t *name , unsigned long attr, void *rootdir, void *security_descr) { pobject_attr->Length = sizeof(object_attributes_t); pobject_attr->RootDirectory = rootdir; pobject_attr->Attributes = attr; pobject_attr->ObjectName = name; pobject_attr->SecurityDescriptor = security_descr; pobject_attr->SecurityQualityOfService = 0; } inline void rtl_init_empty_unicode_string(unicode_string_t *ucStr, wchar_t *buf, unsigned short bufSize) { ucStr->Buffer = buf; ucStr->Length = 0; ucStr->MaximumLength = bufSize; } //A class that locates and caches loaded DLL function addresses. template<int Dummy> struct function_address_holder { enum { NtSetInformationFile , NtQuerySystemInformation , NtQueryObject , NtQuerySemaphore , NtQuerySection , NtOpenFile , NtClose , NtQueryTimerResolution , NtSetTimerResolution , QueryPerformanceCounter , QueryPerformanceFrequency , NumFunction }; enum { NtDll_dll, Kernel32_dll, NumModule }; private: static const char *FunctionNames[NumFunction]; static const char *ModuleNames[NumModule]; static farproc_t FunctionAddresses[NumFunction]; static unsigned int FunctionModules[NumFunction]; static volatile long FunctionStates[NumFunction]; static hmodule ModuleAddresses[NumModule]; static volatile long ModuleStates[NumModule]; static hmodule get_module_from_id(unsigned int id) { BOOST_ASSERT(id < (unsigned int)NumModule); hmodule addr = get_module_handle(ModuleNames[id]); BOOST_ASSERT(addr); return addr; } static hmodule get_module(const unsigned int id) { BOOST_ASSERT(id < (unsigned int)NumModule); for(unsigned i = 0; ModuleStates[id] < 2; ++i){ if(interlocked_compare_exchange(&ModuleStates[id], 1, 0) == 0){ ModuleAddresses[id] = get_module_from_id(id); interlocked_increment(&ModuleStates[id]); break; } else if(i & 1){ sched_yield(); } else{ sleep_tick(); } } return ModuleAddresses[id]; } static farproc_t get_address_from_dll(const unsigned int id) { BOOST_ASSERT(id < (unsigned int)NumFunction); farproc_t addr = get_proc_address(get_module(FunctionModules[id]), FunctionNames[id]); BOOST_ASSERT(addr); return addr; } public: static farproc_t get(const unsigned int id) { BOOST_ASSERT(id < (unsigned int)NumFunction); for(unsigned i = 0; FunctionStates[id] < 2; ++i){ if(interlocked_compare_exchange(&FunctionStates[id], 1, 0) == 0){ FunctionAddresses[id] = get_address_from_dll(id); interlocked_increment(&FunctionStates[id]); break; } else if(i & 1){ sched_yield(); } else{ sleep_tick(); } } return FunctionAddresses[id]; } }; template<int Dummy> const char *function_address_holder<Dummy>::FunctionNames[function_address_holder<Dummy>::NumFunction] = { "NtSetInformationFile", "NtQuerySystemInformation", "NtQueryObject", "NtQuerySemaphore", "NtQuerySection", "NtOpenFile", "NtClose", "NtQueryTimerResolution", "NtSetTimerResolution", "QueryPerformanceCounter", "QueryPerformanceFrequency" }; template<int Dummy> unsigned int function_address_holder<Dummy>::FunctionModules[function_address_holder<Dummy>::NumFunction] = { NtDll_dll, NtDll_dll, NtDll_dll, NtDll_dll, NtDll_dll, NtDll_dll, NtDll_dll, NtDll_dll, NtDll_dll, Kernel32_dll, Kernel32_dll }; template<int Dummy> const char *function_address_holder<Dummy>::ModuleNames[function_address_holder<Dummy>::NumModule] = { "ntdll.dll", "kernel32.dll" }; template<int Dummy> farproc_t function_address_holder<Dummy>::FunctionAddresses[function_address_holder<Dummy>::NumFunction]; template<int Dummy> volatile long function_address_holder<Dummy>::FunctionStates[function_address_holder<Dummy>::NumFunction]; template<int Dummy> hmodule function_address_holder<Dummy>::ModuleAddresses[function_address_holder<Dummy>::NumModule]; template<int Dummy> volatile long function_address_holder<Dummy>::ModuleStates[function_address_holder<Dummy>::NumModule]; struct dll_func : public function_address_holder<0> {}; //Complex winapi based functions... struct library_unloader { hmodule lib_; library_unloader(hmodule module) : lib_(module){} ~library_unloader(){ free_library(lib_); } }; inline bool get_system_time_of_day_information(system_timeofday_information &info) { NtQuerySystemInformation_t pNtQuerySystemInformation = (NtQuerySystemInformation_t) dll_func::get(dll_func::NtQuerySystemInformation); unsigned long res; long status = pNtQuerySystemInformation(system_time_of_day_information, &info, sizeof(info), &res); if(status){ return false; } return true; } inline bool get_boot_time(unsigned char (&bootstamp) [BootstampLength]) { system_timeofday_information info; bool ret = get_system_time_of_day_information(info); if(!ret){ return false; } std::memcpy(&bootstamp[0], &info.Reserved1, sizeof(bootstamp)); return true; } inline bool get_boot_and_system_time(unsigned char (&bootsystemstamp) [BootAndSystemstampLength]) { system_timeofday_information info; bool ret = get_system_time_of_day_information(info); if(!ret){ return false; } std::memcpy(&bootsystemstamp[0], &info.Reserved1, sizeof(bootsystemstamp)); return true; } //Writes the hexadecimal value of the buffer, in the wide character string. //str must be twice length inline void buffer_to_wide_str(const void *buf, std::size_t length, wchar_t *str) { const wchar_t Characters [] = { L'0', L'1', L'2', L'3', L'4', L'5', L'6', L'7' , L'8', L'9', L'A', L'B', L'C', L'D', L'E', L'F' }; std::size_t char_counter = 0; const char *chbuf = static_cast<const char *>(buf); for(std::size_t i = 0; i != length; ++i){ str[char_counter++] = Characters[(chbuf[i]&0xF0)>>4]; str[char_counter++] = Characters[(chbuf[i]&0x0F)]; } } //Writes the hexadecimal value of the buffer, in the narrow character string. //str must be twice length inline void buffer_to_narrow_str(const void *buf, std::size_t length, char *str) { const char Characters [] = { '0', '1', '2', '3', '4', '5', '6', '7' , '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; std::size_t char_counter = 0; const char *chbuf = static_cast<const char *>(buf); for(std::size_t i = 0; i != length; ++i){ str[char_counter++] = Characters[(chbuf[i]&0xF0)>>4]; str[char_counter++] = Characters[(chbuf[i]&0x0F)]; } } inline bool get_boot_time_str(char *bootstamp_str, std::size_t &s) //will write BootstampLength chars { if(s < (BootstampLength*2)) return false; system_timeofday_information info; bool ret = get_system_time_of_day_information(info); if(!ret){ return false; } buffer_to_narrow_str(info.Reserved1, BootstampLength, bootstamp_str); s = BootstampLength*2; return true; } inline bool get_boot_and_system_time_wstr(wchar_t *bootsystemstamp, std::size_t &s) //will write BootAndSystemstampLength chars { if(s < (BootAndSystemstampLength*2)) return false; system_timeofday_information info; bool ret = get_system_time_of_day_information(info); if(!ret){ return false; } buffer_to_wide_str(&info.Reserved1[0], BootAndSystemstampLength, bootsystemstamp); s = BootAndSystemstampLength*2; return true; } class handle_closer { void *handle_; handle_closer(const handle_closer &); handle_closer& operator=(const handle_closer &); public: explicit handle_closer(void *handle) : handle_(handle){} ~handle_closer() { close_handle(handle_); } }; class eventlog_handle_closer { void *handle_; eventlog_handle_closer(const handle_closer &); eventlog_handle_closer& operator=(const eventlog_handle_closer &); public: explicit eventlog_handle_closer(void *handle) : handle_(handle){} ~eventlog_handle_closer() { CloseEventLog(handle_); } }; union ntquery_mem_t { object_name_information_t name; struct ren_t { file_rename_information_t info; wchar_t buf[1]; } ren; }; class nt_query_mem_deleter { static const std::size_t rename_offset = offsetof(ntquery_mem_t, ren.info.FileName) - offsetof(ntquery_mem_t, name.Name.Buffer); // Timestamp process id atomic count static const std::size_t rename_suffix = (SystemTimeOfDayInfoLength + sizeof(unsigned long) + sizeof(boost::uint32_t))*2; public: explicit nt_query_mem_deleter(std::size_t object_name_information_size) : m_size(object_name_information_size + rename_offset + rename_suffix) , m_buf(new char [m_size]) {} ~nt_query_mem_deleter() { delete[]m_buf; } void realloc_mem(std::size_t num_bytes) { num_bytes += rename_suffix + rename_offset; char *buf = m_buf; m_buf = new char[num_bytes]; delete[]buf; m_size = num_bytes; } ntquery_mem_t *query_mem() const { return static_cast<ntquery_mem_t *>(static_cast<void*>(m_buf)); } unsigned long object_name_information_size() const { return static_cast<unsigned long>(m_size - rename_offset - SystemTimeOfDayInfoLength*2); } std::size_t file_rename_information_size() const { return static_cast<unsigned long>(m_size); } private: std::size_t m_size; char *m_buf; }; class c_heap_deleter { public: explicit c_heap_deleter(std::size_t size) : m_buf(::malloc(size)) {} ~c_heap_deleter() { if(m_buf) ::free(m_buf); } void realloc_mem(std::size_t num_bytes) { void *buf = ::realloc(m_buf, num_bytes); if(!buf){ free(m_buf); m_buf = 0; } } void *get() const { return m_buf; } private: void *m_buf; }; inline bool unlink_file(const char *filename) { //Don't try to optimize doing a DeleteFile first //as there are interactions with permissions and //in-use files. // //if(!delete_file(filename)){ // (...) // //This functions tries to emulate UNIX unlink semantics in windows. // //- Open the file and mark the handle as delete-on-close //- Rename the file to an arbitrary name based on a random number //- Close the handle. If there are no file users, it will be deleted. // Otherwise it will be used by already connected handles but the // file name can't be used to open this file again try{ NtSetInformationFile_t pNtSetInformationFile = (NtSetInformationFile_t)dll_func::get(dll_func::NtSetInformationFile); NtQueryObject_t pNtQueryObject = (NtQueryObject_t)dll_func::get(dll_func::NtQueryObject); //First step: Obtain a handle to the file using Win32 rules. This resolves relative paths void *fh = create_file(filename, generic_read | delete_access, open_existing, 0, 0); if(fh == invalid_handle_value){ return false; } handle_closer h_closer(fh); { //Obtain name length unsigned long size; const std::size_t initial_string_mem = 512u; nt_query_mem_deleter nt_query_mem(sizeof(ntquery_mem_t)+initial_string_mem); //Obtain file name with guessed length if(pNtQueryObject(fh, object_name_information, nt_query_mem.query_mem(), nt_query_mem.object_name_information_size(), &size)){ //Obtain file name with exact length buffer nt_query_mem.realloc_mem(size); if(pNtQueryObject(fh, object_name_information, nt_query_mem.query_mem(), nt_query_mem.object_name_information_size(), &size)){ return false; } } ntquery_mem_t *pmem = nt_query_mem.query_mem(); file_rename_information_t *pfri = &pmem->ren.info; const std::size_t RenMaxNumChars = (((char*)(pmem) + nt_query_mem.file_rename_information_size()) - (char*)&pmem->ren.info.FileName[0])/sizeof(wchar_t); //Copy filename to the rename member std::memmove(pmem->ren.info.FileName, pmem->name.Name.Buffer, pmem->name.Name.Length); std::size_t filename_string_length = pmem->name.Name.Length/sizeof(wchar_t); //Search '\\' character to replace from it for(std::size_t i = filename_string_length; i != 0; --filename_string_length){ if(pmem->ren.info.FileName[--i] == L'\\') break; } //Add random number std::size_t s = RenMaxNumChars - filename_string_length; if(!get_boot_and_system_time_wstr(&pfri->FileName[filename_string_length], s)){ return false; } filename_string_length += s; //Sometimes the precission of the timestamp is not enough and we need to add another random number. //The process id (to exclude concurrent processes) and an atomic count (to exclude concurrent threads). //should be enough const unsigned long pid = get_current_process_id(); buffer_to_wide_str(&pid, sizeof(pid), &pfri->FileName[filename_string_length]); filename_string_length += sizeof(pid)*2; static volatile boost::uint32_t u32_count = 0; interlocked_decrement(reinterpret_cast<volatile long*>(&u32_count)); buffer_to_wide_str(const_cast<const boost::uint32_t *>(&u32_count), sizeof(boost::uint32_t), &pfri->FileName[filename_string_length]); filename_string_length += sizeof(boost::uint32_t)*2; //Fill rename information (FileNameLength is in bytes) pfri->FileNameLength = static_cast<unsigned long>(sizeof(wchar_t)*(filename_string_length)); pfri->Replace = 1; pfri->RootDir = 0; //Cange the name of the in-use file... io_status_block_t io; if(0 != pNtSetInformationFile(fh, &io, pfri, nt_query_mem.file_rename_information_size(), file_rename_information)){ return false; } } //...and mark it as delete-on-close { //Don't use pNtSetInformationFile with file_disposition_information as it can return STATUS_CANNOT_DELETE //if the file is still mapped. Reopen it with NtOpenFile and file_delete_on_close NtOpenFile_t pNtOpenFile = (NtOpenFile_t)dll_func::get(dll_func::NtOpenFile); NtClose_t pNtClose = (NtClose_t)dll_func::get(dll_func::NtClose); const wchar_t empty_str [] = L""; unicode_string_t ustring = { sizeof(empty_str) - sizeof (wchar_t) //length in bytes without null , sizeof(empty_str) //total size in bytes of memory allocated for Buffer. , const_cast<wchar_t*>(empty_str) }; object_attributes_t object_attr; initialize_object_attributes(&object_attr, &ustring, 0, fh, 0); void* fh2 = 0; io_status_block_t io; pNtOpenFile( &fh2, delete_flag, &object_attr, &io , file_share_read | file_share_write | file_share_delete, file_delete_on_close); pNtClose(fh2); //Even if NtOpenFile fails, the file was renamed and the original no longer exists, so return a success status return true; } } catch(...){ return false; } return true; } struct reg_closer { hkey key_; reg_closer(hkey key) : key_(key){} ~reg_closer(){ reg_close_key(key_); } }; inline bool get_registry_value_buffer(hkey key_type, const char *subkey_name, const char *value_name, void *buf, std::size_t &buflen) { bool bret = false; hkey key; if (reg_open_key_ex( key_type , subkey_name , 0 , key_query_value , &key) == 0){ reg_closer key_closer(key); //Obtain the value unsigned long size = buflen; unsigned long type; buflen = 0; bret = 0 == reg_query_value_ex( key, value_name, 0, &type, (unsigned char*)buf, &size); if(bret) buflen = (std::size_t)size; } return bret; } inline bool get_registry_value_string(hkey key_type, const char *subkey_name, const char *value_name, std::string &s) { bool bret = false; s.clear(); hkey key; if (reg_open_key_ex( key_type , subkey_name , 0 , key_query_value , &key) == 0){ reg_closer key_closer(key); //Obtain the value unsigned long size; unsigned long type; long err = reg_query_value_ex( key, value_name, 0, &type, 0, &size); if((reg_sz == type || reg_expand_sz == type) && !err){ //Size includes terminating NULL s.resize(size); err = reg_query_value_ex( key, value_name, 0, &type, (unsigned char*)(&s[0]), &size); if(!err){ s.erase(s.end()-1); bret = true; } (void)err; } } return bret; } inline void get_shared_documents_folder(std::string &s) { #if 1 //Original registry search code get_registry_value_string( hkey_local_machine , "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders" , "Common AppData" , s); #else //registry alternative: SHGetFolderPath const int BIPC_CSIDL_COMMON_APPDATA = 0x0023; // All Users\Application Data const int BIPC_CSIDL_FLAG_CREATE = 0x8000; // new for Win2K, or this in to force creation of folder const int BIPC_SHGFP_TYPE_CURRENT = 0; // current value for user, verify it exists s.clear(); char szPath[max_path]; if(0 == SHGetFolderPathA(0, BIPC_CSIDL_COMMON_APPDATA | BIPC_CSIDL_FLAG_CREATE, 0, BIPC_SHGFP_TYPE_CURRENT, szPath)){ s = szPath; } #endif } inline void get_registry_value(const char *folder, const char *value_key, std::vector<unsigned char> &s) { s.clear(); hkey key; if (reg_open_key_ex( hkey_local_machine , folder , 0 , key_query_value , &key) == 0){ reg_closer key_closer(key); //Obtain the value unsigned long size; unsigned long type; const char *const reg_value = value_key; //long err = (*pRegQueryValue)( key, reg_value, 0, &type, 0, &size); long err = reg_query_value_ex( key, reg_value, 0, &type, 0, &size); if(!err){ //Size includes terminating NULL s.resize(size); //err = (*pRegQueryValue)( key, reg_value, 0, &type, (unsigned char*)(&s[0]), &size); err = reg_query_value_ex( key, reg_value, 0, &type, (unsigned char*)(&s[0]), &size); if(!err) s.erase(s.end()-1); (void)err; } } } #if defined(BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME) struct co_uninitializer { co_uninitializer(bool b_uninitialize) : m_b_uninitialize(b_uninitialize) {} ~co_uninitializer() { if(m_b_uninitialize){ CoUninitialize(); } } private: const bool m_b_uninitialize; }; template<class Object> struct com_releaser { Object *&object_; com_releaser(Object *&object) : object_(object) {} ~com_releaser() { object_->Release(); object_ = 0; } }; inline bool get_wmi_class_attribute( std::wstring& strValue, const wchar_t *wmi_class, const wchar_t *wmi_class_var) { //See example http://msdn.microsoft.com/en-us/library/aa390423%28v=VS.85%29.aspx // //See BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL definition if you need to change the //default value of this macro in your application long co_init_ret = CoInitializeEx(0, BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL); if(co_init_ret != S_OK_BIPC && co_init_ret != S_FALSE_BIPC && co_init_ret != RPC_E_CHANGED_MODE_BIPC) return false; co_uninitializer co_initialize_end(co_init_ret != RPC_E_CHANGED_MODE_BIPC); (void)co_initialize_end; bool bRet = false; long sec_init_ret = CoInitializeSecurity ( 0 //pVoid ,-1 //cAuthSvc , 0 //asAuthSvc , 0 //pReserved1 , RPC_C_AUTHN_LEVEL_PKT_BIPC //dwAuthnLevel , RPC_C_IMP_LEVEL_IMPERSONATE_BIPC //dwImpLevel , 0 //pAuthList , EOAC_NONE_BIPC //dwCapabilities , 0 //pReserved3 ); if( 0 == sec_init_ret || RPC_E_TOO_LATE_BIPC == sec_init_ret) { IWbemLocator_BIPC * pIWbemLocator = 0; const wchar_t * bstrNamespace = L"root\\cimv2"; if( 0 != CoCreateInstance( CLSID_WbemAdministrativeLocator, 0, CLSCTX_INPROC_SERVER_BIPC | CLSCTX_LOCAL_SERVER_BIPC, IID_IUnknown, (void **)&pIWbemLocator)){ return false; } com_releaser<IWbemLocator_BIPC> IWbemLocator_releaser(pIWbemLocator); IWbemServices_BIPC *pWbemServices = 0; if( 0 != pIWbemLocator->ConnectServer( (bstr)bstrNamespace, // Namespace 0, // Userid 0, // PW 0, // Locale 0, // flags 0, // Authority 0, // Context &pWbemServices ) ){ return false; } if( S_OK_BIPC != CoSetProxyBlanket( pWbemServices, RPC_C_AUTHN_DEFAULT_BIPC, RPC_C_AUTHZ_DEFAULT_BIPC, 0, RPC_C_AUTHN_LEVEL_PKT_BIPC, RPC_C_IMP_LEVEL_IMPERSONATE_BIPC, 0, EOAC_NONE_BIPC ) ){ return false; } com_releaser<IWbemServices_BIPC> IWbemServices_releaser(pWbemServices); strValue.clear(); strValue += L"Select "; strValue += wmi_class_var; strValue += L" from "; strValue += wmi_class; IEnumWbemClassObject_BIPC * pEnumObject = 0; if ( 0 != pWbemServices->ExecQuery( (bstr)L"WQL", (bstr)strValue.c_str(), //WBEM_FLAG_RETURN_IMMEDIATELY_BIPC, WBEM_FLAG_RETURN_WHEN_COMPLETE_BIPC | WBEM_FLAG_FORWARD_ONLY_BIPC, 0, &pEnumObject ) ){ return false; } com_releaser<IEnumWbemClassObject_BIPC> IEnumWbemClassObject_releaser(pEnumObject); //WBEM_FLAG_FORWARD_ONLY_BIPC incompatible with Reset //if ( 0 != pEnumObject->Reset() ){ //return false; //} wchar_variant vwchar; unsigned long uCount = 1, uReturned; IWbemClassObject_BIPC * pClassObject = 0; while( 0 == pEnumObject->Next( WBEM_INFINITE_BIPC, uCount, &pClassObject, &uReturned ) ) { com_releaser<IWbemClassObject_BIPC> IWbemClassObject_releaser(pClassObject); if ( 0 == pClassObject->Get( (bstr)L"LastBootUpTime", 0, &vwchar, 0, 0 ) ){ bRet = true; strValue = (wchar_t*)vwchar.bstrVal; VariantClear(&vwchar ); break; } } } return bRet; } //Obtains the bootup time from WMI LastBootUpTime. //This time seems to change with hibernation and clock synchronization so avoid it. inline bool get_last_bootup_time( std::wstring& strValue ) { bool ret = get_wmi_class_attribute(strValue, L"Win32_OperatingSystem", L"LastBootUpTime"); std::size_t timezone = strValue.find(L'+'); if(timezone != std::wstring::npos){ strValue.erase(timezone); } timezone = strValue.find(L'-'); if(timezone != std::wstring::npos){ strValue.erase(timezone); } return ret; } inline bool get_last_bootup_time( std::string& str ) { std::wstring wstr; bool ret = get_last_bootup_time(wstr); str.resize(wstr.size()); for(std::size_t i = 0, max = str.size(); i != max; ++i){ str[i] = '0' + (wstr[i]-L'0'); } return ret; } #endif //BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME #if defined(BOOST_INTERPROCESS_BOOTSTAMP_IS_EVENTLOG_BASED) // Loop through the buffer and obtain the contents of the // requested record in the buffer. inline bool find_record_in_buffer( const void* pBuffer, unsigned long dwBytesRead, const char *provider_name , unsigned int id_to_find, interprocess_eventlogrecord *&pevent_log_record) { const unsigned char * pRecord = static_cast<const unsigned char*>(pBuffer); const unsigned char * pEndOfRecords = pRecord + dwBytesRead; while (pRecord < pEndOfRecords){ interprocess_eventlogrecord *pTypedRecord = (interprocess_eventlogrecord*)pRecord; // Check provider, written at the end of the fixed-part of the record if (0 == std::strcmp(provider_name, (char*)(pRecord + sizeof(interprocess_eventlogrecord)))) { // Check event id if(id_to_find == (pTypedRecord->EventID & 0xFFFF)){ pevent_log_record = pTypedRecord; return true; } } pRecord += pTypedRecord->Length; } pevent_log_record = 0; return false; } //Obtains the bootup time from the System Event Log, //event ID == 6005 (event log started). //Adapted from http://msdn.microsoft.com/en-us/library/windows/desktop/bb427356.aspx inline bool get_last_bootup_time(std::string &stamp) { const char *source_name = "System"; const char *provider_name = "EventLog"; const unsigned short event_id = 6005u; unsigned long status = 0; unsigned long dwBytesToRead = 0; unsigned long dwBytesRead = 0; unsigned long dwMinimumBytesToRead = 0; // The source name (provider) must exist as a subkey of Application. void *hEventLog = OpenEventLogA(0, source_name); if (hEventLog){ eventlog_handle_closer hnd_closer(hEventLog); (void)hnd_closer; // Allocate an initial block of memory used to read event records. The number // of records read into the buffer will vary depending on the size of each event. // The size of each event will vary based on the size of the user-defined // data included with each event, the number and length of insertion // strings, and other data appended to the end of the event record. dwBytesToRead = max_record_buffer_size; c_heap_deleter heap_deleter(dwBytesToRead); // Read blocks of records until you reach the end of the log or an // error occurs. The records are read from newest to oldest. If the buffer // is not big enough to hold a complete event record, reallocate the buffer. if (heap_deleter.get() != 0){ while (0 == status){ if (!ReadEventLogA(hEventLog, eventlog_sequential_read | eventlog_backwards_read, 0, heap_deleter.get(), dwBytesToRead, &dwBytesRead, &dwMinimumBytesToRead)) { status = get_last_error(); if (error_insufficient_buffer == status) { status = 0; dwBytesToRead = dwMinimumBytesToRead; heap_deleter.realloc_mem(dwMinimumBytesToRead); if (!heap_deleter.get()){ return false; } } else{ //Not found or EOF return false; } } else { interprocess_eventlogrecord *pTypedRecord; // Print the contents of each record in the buffer. if(find_record_in_buffer(heap_deleter.get(), dwBytesRead, provider_name, event_id, pTypedRecord)){ char stamp_str[sizeof(unsigned long)*3+1]; std::sprintf(&stamp_str[0], "%u", ((unsigned int)pTypedRecord->TimeGenerated)); stamp = stamp_str; break; } } } } } return true; } #endif //BOOST_INTERPROCESS_BOOTSTAMP_IS_EVENTLOG_BASED #if defined(BOOST_INTERPROCESS_BOOTSTAMP_IS_SESSION_MANAGER_BASED) inline bool get_last_bootup_time(std::string &stamp) { unsigned dword_val = 0; std::size_t dword_size = sizeof(dword_val); bool b_ret = get_registry_value_buffer( hkey_local_machine , "SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Memory Management\\PrefetchParameters" , "BootId", &dword_val, dword_size); if (b_ret) { char dword_str[sizeof(dword_val)*2u+1]; buffer_to_narrow_str(&dword_val, dword_size, dword_str); dword_str[sizeof(dword_val)*2] = '\0'; stamp = dword_str; b_ret = get_registry_value_buffer( hkey_local_machine , "SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Power" , "HybridBootAnimationTime", &dword_val, dword_size); //Old Windows versions have no HybridBootAnimationTime if(b_ret) { buffer_to_narrow_str(&dword_val, dword_size, dword_str); dword_str[sizeof(dword_val)*2] = '\0'; stamp += "_"; stamp += dword_str; } b_ret = true; } return b_ret; } #endif //BOOST_INTERPROCESS_BOOTSTAMP_IS_SESSION_MANAGER_BASED inline bool is_directory(const char *path) { unsigned long attrib = GetFileAttributesA(path); return (attrib != invalid_file_attributes && (attrib & file_attribute_directory)); } inline bool get_file_mapping_size(void *file_mapping_hnd, __int64 &size) { NtQuerySection_t pNtQuerySection = (NtQuerySection_t)dll_func::get(dll_func::NtQuerySection); //Obtain file name interprocess_section_basic_information info; unsigned long ntstatus = pNtQuerySection(file_mapping_hnd, section_basic_information, &info, sizeof(info), 0); size = info.section_size; return !ntstatus; } inline bool get_semaphore_info(void *handle, long &count, long &limit) { winapi::interprocess_semaphore_basic_information info; winapi::NtQuerySemaphore_t pNtQuerySemaphore = (winapi::NtQuerySemaphore_t)dll_func::get(winapi::dll_func::NtQuerySemaphore); unsigned int ret_len; long status = pNtQuerySemaphore(handle, winapi::semaphore_basic_information, &info, sizeof(info), &ret_len); count = info.count; limit = info.limit; return !status; } inline bool query_timer_resolution(unsigned long *lowres, unsigned long *highres, unsigned long *curres) { winapi::NtQueryTimerResolution_t pNtQueryTimerResolution = (winapi::NtQueryTimerResolution_t)dll_func::get(winapi::dll_func::NtQueryTimerResolution); return !pNtQueryTimerResolution(lowres, highres, curres); } inline bool set_timer_resolution(unsigned long RequestedResolution, int Set, unsigned long* ActualResolution) { winapi::NtSetTimerResolution_t pNtSetTimerResolution = (winapi::NtSetTimerResolution_t)dll_func::get(winapi::dll_func::NtSetTimerResolution); return !pNtSetTimerResolution(RequestedResolution, Set, ActualResolution); } inline bool query_performance_counter(__int64 *lpPerformanceCount) { QueryPerformanceCounter_t pQueryPerformanceCounter = (QueryPerformanceCounter_t) dll_func::get(dll_func::QueryPerformanceCounter); return 0 != pQueryPerformanceCounter(lpPerformanceCount); } inline bool query_performance_frequency(__int64 *lpFrequency) { QueryPerformanceCounter_t pQueryPerformanceFrequency = (QueryPerformanceFrequency_t) dll_func::get(dll_func::QueryPerformanceFrequency); return 0 != pQueryPerformanceFrequency(lpFrequency); } inline unsigned long get_tick_count() { return GetTickCount(); } } //namespace winapi } //namespace interprocess } //namespace boost #if defined(BOOST_GCC) && (BOOST_GCC >= 40600) # pragma GCC diagnostic pop #endif #include <boost/interprocess/detail/config_end.hpp> #endif //#ifdef BOOST_INTERPROCESS_WIN32_API_HPP