| ////////////////////////////////////////////////////////////////////////////// |
| // |
| // (C) Copyright Ion Gaztanaga 2005-2012. 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> |
| |
| #ifdef BOOST_USE_WINDOWS_H |
| #include <windows.h> |
| #include <Wbemidl.h> |
| #include <Objbase.h> |
| #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, "Psapi.lib" ) |
| # pragma comment( lib, "Shell32.lib" ) //SHGetSpecialFolderPathA |
| #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) && (BOOST_GCC >= 40600) |
| # pragma GCC diagnostic push |
| # pragma GCC diagnostic ignored "-pedantic" |
| #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; |
| |
| typedef IUnknown IUnknown_BIPC; |
| |
| typedef IWbemClassObject IWbemClassObject_BIPC; |
| |
| typedef IWbemContext IWbemContext_BIPC; |
| |
| typedef IEnumWbemClassObject IEnumWbemClassObject_BIPC; |
| |
| typedef IWbemServices IWbemServices_BIPC; |
| |
| typedef IWbemLocator IWbemLocator_BIPC; |
| |
| 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; |
| |
| |
| //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(addr); } |
| |
| inline long interlocked_decrement(long volatile *addr) |
| { return BOOST_INTERLOCKED_DECREMENT(addr); } |
| |
| inline long interlocked_compare_exchange(long volatile *addr, long val1, long val2) |
| { return BOOST_INTERLOCKED_COMPARE_EXCHANGE(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; |
| } |
| |
| 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; |
| } |
| 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; |
| for(std::size_t i = 0; i != static_cast<std::size_t>(BootstampLength); ++i){ |
| bootstamp_str[char_counter++] = Characters[(info.Reserved1[i]&0xF0)>>4]; |
| bootstamp_str[char_counter++] = Characters[(info.Reserved1[i]&0x0F)]; |
| } |
| s = BootstampLength*2; |
| 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)]; |
| } |
| } |
| |
| 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: |
| 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: |
| 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 void get_shared_documents_folder(std::string &s) |
| { |
| #if 1 //Original registry search code |
| s.clear(); |
| hkey key; |
| if (reg_open_key_ex( hkey_local_machine |
| , "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders" |
| , 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 = "Common AppData"; |
| //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; |
| } |
| } |
| #else //registry alternative: SHGetSpecialFolderPathA |
| 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; |
| } |
| } |
| } |
| |
| 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; |
| } |
| |
| #ifdef BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME |
| |
| //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; |
| } |
| |
| #else |
| |
| // 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 |
| |
| 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 |