890 lines
34 KiB
C++
890 lines
34 KiB
C++
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// (C) Copyright Ion Gaztanaga 2005-2008. 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_SYNC_PRIMITIVES_HPP
|
|
#define BOOST_INTERPROCESS_WIN32_SYNC_PRIMITIVES_HPP
|
|
|
|
#include <boost/interprocess/detail/config_begin.hpp>
|
|
#include <boost/interprocess/detail/workaround.hpp>
|
|
#include <cstddef>
|
|
#include <cstring>
|
|
#include <memory>
|
|
|
|
#if (defined _MSC_VER) && (_MSC_VER >= 1200)
|
|
# pragma once
|
|
# pragma comment( lib, "advapi32.lib" )
|
|
#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
|
|
|
|
//The structures used in Interprocess with the
|
|
//same binary interface as windows ones
|
|
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_file_not_found = 2u;
|
|
static const unsigned long error_no_more_files = 18u;
|
|
|
|
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 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 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 void * const invalid_handle_value = (void*)(long)(-1);
|
|
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;
|
|
|
|
//Own defines
|
|
static const long SystemTimeOfDayInfoLength = 48;
|
|
static const long BootAndSystemstampLength = 16;
|
|
static const long BootstampLength = 8;
|
|
static const unsigned long MaxPath = 260;
|
|
|
|
|
|
} //namespace winapi {
|
|
} //namespace interprocess {
|
|
} //namespace boost {
|
|
|
|
#if !defined( BOOST_USE_WINDOWS_H )
|
|
|
|
namespace boost {
|
|
namespace interprocess {
|
|
namespace winapi {
|
|
|
|
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_t
|
|
{
|
|
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_memory_basic_information
|
|
{
|
|
void * BaseAddress;
|
|
void * AllocationBase;
|
|
unsigned long AllocationProtect;
|
|
unsigned long RegionSize;
|
|
unsigned long State;
|
|
unsigned long Protect;
|
|
unsigned long Type;
|
|
};
|
|
|
|
typedef struct _interprocess_acl
|
|
{
|
|
unsigned char AclRevision;
|
|
unsigned char Sbz1;
|
|
unsigned short AclSize;
|
|
unsigned short AceCount;
|
|
unsigned short Sbz2;
|
|
} interprocess_acl;
|
|
|
|
typedef struct _interprocess_security_descriptor
|
|
{
|
|
unsigned char Revision;
|
|
unsigned char Sbz1;
|
|
unsigned short Control;
|
|
void *Owner;
|
|
void *Group;
|
|
interprocess_acl *Sacl;
|
|
interprocess_acl *Dacl;
|
|
} interprocess_security_descriptor;
|
|
|
|
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
|
|
};
|
|
|
|
struct file_name_information_t {
|
|
unsigned long FileNameLength;
|
|
wchar_t FileName[1];
|
|
};
|
|
|
|
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;
|
|
} data;
|
|
unsigned char Reserved1[SystemTimeOfDayInfoLength];
|
|
};
|
|
|
|
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
|
|
};
|
|
|
|
struct object_name_information_t
|
|
{
|
|
unicode_string_t Name;
|
|
wchar_t NameBuffer[1];
|
|
};
|
|
|
|
//Some windows API declarations
|
|
extern "C" __declspec(dllimport) unsigned long __stdcall GetCurrentProcessId();
|
|
extern "C" __declspec(dllimport) unsigned long __stdcall GetCurrentThreadId();
|
|
extern "C" __declspec(dllimport) void __stdcall Sleep(unsigned long);
|
|
extern "C" __declspec(dllimport) unsigned long __stdcall GetLastError();
|
|
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) void *__stdcall FindFirstFileA(const char *lpFileName, win32_find_data_t *lpFindFileData);
|
|
extern "C" __declspec(dllimport) int __stdcall FindNextFileA(void *hFindFile, win32_find_data_t *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) int __stdcall DeleteFileA (const char *);
|
|
extern "C" __declspec(dllimport) int __stdcall MoveFileExA (const char *, const char *, unsigned long);
|
|
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 GetFileSizeEx (void *, __int64 *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) 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 *, __int64 distance, __int64 *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 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) void *__stdcall LoadLibraryA(const char *);
|
|
extern "C" __declspec(dllimport) int __stdcall FreeLibrary(void *);
|
|
extern "C" __declspec(dllimport) void *__stdcall GetProcAddress(void *, const char*);
|
|
extern "C" __declspec(dllimport) void *__stdcall GetModuleHandleA(const char*);
|
|
|
|
//API function typedefs
|
|
//Pointer to functions
|
|
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 *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 *RtlCreateUnicodeStringFromAsciiz_t)(unicode_string_t *, const char *);
|
|
typedef void (__stdcall *RtlFreeUnicodeString_t)(unicode_string_t *);
|
|
typedef void (__stdcall *RtlInitUnicodeString_t)( unicode_string_t *, const wchar_t * );
|
|
typedef long (__stdcall *RtlAppendUnicodeToString_t)(unicode_string_t *Destination, const wchar_t *Source);
|
|
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 unsigned long (__stdcall * GetMappedFileName_t)(void *, void *, wchar_t *, unsigned long);
|
|
|
|
} //namespace winapi {
|
|
} //namespace interprocess {
|
|
} //namespace boost {
|
|
|
|
#else
|
|
# include <windows.h>
|
|
#endif //#if !defined( BOOST_USE_WINDOWS_H )
|
|
|
|
namespace boost {
|
|
namespace interprocess {
|
|
namespace winapi {
|
|
|
|
static 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
|
|
static inline void * local_free(void *hmem)
|
|
{ return LocalFree(hmem); }
|
|
|
|
static inline unsigned long make_lang_id(unsigned long p, unsigned long s)
|
|
{ return ((((unsigned short)(s)) << 10) | (unsigned short)(p)); }
|
|
|
|
static inline void sched_yield()
|
|
{ Sleep(1); }
|
|
|
|
static inline unsigned long get_current_thread_id()
|
|
{ return GetCurrentThreadId(); }
|
|
|
|
static inline unsigned long get_current_process_id()
|
|
{ return GetCurrentProcessId(); }
|
|
|
|
static inline unsigned int close_handle(void* handle)
|
|
{ return CloseHandle(handle); }
|
|
|
|
static inline void * find_first_file(const char *lpFileName, win32_find_data_t *lpFindFileData)
|
|
{ return FindFirstFileA(lpFileName, lpFindFileData); }
|
|
|
|
static inline bool find_next_file(void *hFindFile, win32_find_data_t *lpFindFileData)
|
|
{ return FindNextFileA(hFindFile, lpFindFileData) != 0; }
|
|
|
|
static inline bool find_close(void *handle)
|
|
{ return FindClose(handle) != 0; }
|
|
|
|
static inline bool duplicate_current_process_handle
|
|
(void *hSourceHandle, void **lpTargetHandle)
|
|
{
|
|
return 0 != DuplicateHandle
|
|
( GetCurrentProcess(), hSourceHandle, GetCurrentProcess()
|
|
, lpTargetHandle, 0, 0
|
|
, duplicate_same_access);
|
|
}
|
|
|
|
static inline unsigned long get_last_error()
|
|
{ return GetLastError(); }
|
|
|
|
static inline void get_system_time_as_file_time(interprocess_filetime *filetime)
|
|
{ GetSystemTimeAsFileTime(filetime); }
|
|
|
|
static inline bool file_time_to_local_file_time
|
|
(const interprocess_filetime *in, const interprocess_filetime *out)
|
|
{ return 0 != FileTimeToLocalFileTime(in, out); }
|
|
|
|
static inline void *create_mutex(const char *name)
|
|
{ return CreateMutexA(0, 0, name); }
|
|
|
|
static inline void *open_mutex(const char *name)
|
|
{ return OpenMutexA(mutex_all_access, 0, name); }
|
|
|
|
static inline unsigned long wait_for_single_object(void *handle, unsigned long time)
|
|
{ return WaitForSingleObject(handle, time); }
|
|
|
|
static inline int release_mutex(void *handle)
|
|
{ return ReleaseMutex(handle); }
|
|
|
|
static inline int unmap_view_of_file(void *address)
|
|
{ return UnmapViewOfFile(address); }
|
|
|
|
static inline void *create_semaphore(long initialCount, const char *name)
|
|
{ return CreateSemaphoreA(0, initialCount, (long)(((unsigned long)(-1))>>1), name); }
|
|
|
|
static inline int release_semaphore(void *handle, long release_count, long *prev_count)
|
|
{ return ReleaseSemaphore(handle, release_count, prev_count); }
|
|
|
|
static inline void *open_semaphore(const char *name)
|
|
{ return OpenSemaphoreA(semaphore_all_access, 1, name); }
|
|
|
|
static inline void * create_file_mapping (void * handle, unsigned long access, unsigned long high_size, unsigned long low_size, const char * name)
|
|
{
|
|
interprocess_security_attributes sa;
|
|
interprocess_security_descriptor sd;
|
|
|
|
if(!InitializeSecurityDescriptor(&sd, security_descriptor_revision))
|
|
return 0;
|
|
if(!SetSecurityDescriptorDacl(&sd, true, 0, false))
|
|
return 0;
|
|
sa.lpSecurityDescriptor = &sd;
|
|
sa.nLength = sizeof(interprocess_security_attributes);
|
|
sa.bInheritHandle = false;
|
|
return CreateFileMappingA (handle, &sa, access, high_size, low_size, name);
|
|
//return CreateFileMappingA (handle, 0, access, high_size, low_size, name);
|
|
}
|
|
|
|
static inline void * open_file_mapping (unsigned long access, const char *name)
|
|
{ return OpenFileMappingA (access, 0, name); }
|
|
|
|
static inline void *map_view_of_file_ex(void *handle, unsigned long file_access, unsigned long highoffset, unsigned long lowoffset, std::size_t numbytes, void *base_addr)
|
|
{ return MapViewOfFileEx(handle, file_access, highoffset, lowoffset, numbytes, base_addr); }
|
|
|
|
static inline void *create_file(const char *name, unsigned long access, unsigned long creation_flags, unsigned long attributes = 0)
|
|
{ return CreateFileA(name, access, file_share_read | file_share_write | file_share_delete, 0, creation_flags, attributes, 0); }
|
|
|
|
static inline bool delete_file(const char *name)
|
|
{ return 0 != DeleteFileA(name); }
|
|
|
|
static inline bool move_file_ex(const char *source_filename, const char *destination_filename, unsigned long flags)
|
|
{ return 0 != MoveFileExA(source_filename, destination_filename, flags); }
|
|
|
|
static inline void get_system_info(system_info *info)
|
|
{ GetSystemInfo(info); }
|
|
|
|
static inline int flush_view_of_file(void *base_addr, std::size_t numbytes)
|
|
{ return FlushViewOfFile(base_addr, numbytes); }
|
|
|
|
static inline bool get_file_size(void *handle, __int64 &size)
|
|
{ return 0 != GetFileSizeEx(handle, &size); }
|
|
|
|
static inline bool create_directory(const char *name, interprocess_security_attributes* security)
|
|
{ return 0 != CreateDirectoryA(name, security); }
|
|
|
|
static inline bool remove_directory(const char *lpPathName)
|
|
{ return 0 != RemoveDirectoryA(lpPathName); }
|
|
|
|
static inline unsigned long get_temp_path(unsigned long length, char *buffer)
|
|
{ return GetTempPathA(length, buffer); }
|
|
|
|
static inline int set_end_of_file(void *handle)
|
|
{ return 0 != SetEndOfFile(handle); }
|
|
|
|
static inline bool set_file_pointer_ex(void *handle, __int64 distance, __int64 *new_file_pointer, unsigned long move_method)
|
|
{ return 0 != SetFilePointerEx(handle, distance, new_file_pointer, move_method); }
|
|
|
|
static 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); }
|
|
|
|
static 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); }
|
|
|
|
static 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); }
|
|
|
|
static inline long interlocked_increment(long volatile *addr)
|
|
{ return BOOST_INTERLOCKED_INCREMENT(addr); }
|
|
|
|
static inline long interlocked_decrement(long volatile *addr)
|
|
{ return BOOST_INTERLOCKED_DECREMENT(addr); }
|
|
|
|
static inline long interlocked_compare_exchange(long volatile *addr, long val1, long val2)
|
|
{ return BOOST_INTERLOCKED_COMPARE_EXCHANGE(addr, val1, val2); }
|
|
|
|
static inline long interlocked_exchange_add(long volatile* addend, long value)
|
|
{ return BOOST_INTERLOCKED_EXCHANGE_ADD(const_cast<long*>(addend), value); }
|
|
|
|
static inline long interlocked_exchange(long volatile* addend, long value)
|
|
{ return BOOST_INTERLOCKED_EXCHANGE(const_cast<long*>(addend), value); }
|
|
|
|
//Forward functions
|
|
static inline void *load_library(const char *name)
|
|
{ return LoadLibraryA(name); }
|
|
|
|
static inline bool free_library(void *module)
|
|
{ return 0 != FreeLibrary(module); }
|
|
|
|
static inline void *get_proc_address(void *module, const char *name)
|
|
{ return GetProcAddress(module, name); }
|
|
|
|
static inline void *get_current_process()
|
|
{ return GetCurrentProcess(); }
|
|
|
|
static inline void *get_module_handle(const char *name)
|
|
{ return GetModuleHandleA(name); }
|
|
|
|
static 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;
|
|
}
|
|
|
|
static 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;
|
|
}
|
|
|
|
//Complex winapi based functions...
|
|
|
|
//pszFilename must have room for at least MaxPath+1 characters
|
|
static inline bool get_file_name_from_handle_function
|
|
(void * hFile, wchar_t *pszFilename, std::size_t length, std::size_t &out_length)
|
|
{
|
|
if(length <= MaxPath){
|
|
return false;
|
|
}
|
|
|
|
void *hiPSAPI = load_library("PSAPI.DLL");
|
|
if (0 == hiPSAPI)
|
|
return 0;
|
|
|
|
class library_unloader
|
|
{
|
|
void *lib_;
|
|
|
|
public:
|
|
library_unloader(void *module) : lib_(module){}
|
|
~library_unloader(){ free_library(lib_); }
|
|
} unloader(hiPSAPI);
|
|
|
|
// Pointer to function getMappedFileName() in PSAPI.DLL
|
|
GetMappedFileName_t pfGMFN =
|
|
(GetMappedFileName_t)get_proc_address(hiPSAPI, "GetMappedFileNameW");
|
|
if (! pfGMFN){
|
|
return 0; // Failed: unexpected error
|
|
}
|
|
|
|
bool bSuccess = false;
|
|
|
|
// Create a file mapping object.
|
|
void * hFileMap = create_file_mapping(hFile, page_readonly, 0, 1, 0);
|
|
if(hFileMap)
|
|
{
|
|
// Create a file mapping to get the file name.
|
|
void* pMem = map_view_of_file_ex(hFileMap, file_map_read, 0, 0, 1, 0);
|
|
|
|
if (pMem){
|
|
out_length = pfGMFN(get_current_process(), pMem, pszFilename, MaxPath);
|
|
if(out_length){
|
|
bSuccess = true;
|
|
}
|
|
unmap_view_of_file(pMem);
|
|
}
|
|
close_handle(hFileMap);
|
|
}
|
|
|
|
return(bSuccess);
|
|
}
|
|
|
|
static inline bool get_system_time_of_day_information(system_timeofday_information &info)
|
|
{
|
|
NtQuerySystemInformation_t pNtQuerySystemInformation = (NtQuerySystemInformation_t)
|
|
get_proc_address(get_module_handle("ntdll.dll"), "NtQuerySystemInformation");
|
|
unsigned long res;
|
|
long status = pNtQuerySystemInformation(system_time_of_day_information, &info, sizeof(info), &res);
|
|
if(status){
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static 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;
|
|
}
|
|
|
|
static 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;
|
|
}
|
|
|
|
static 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;
|
|
}
|
|
|
|
static 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;
|
|
}
|
|
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;
|
|
for(std::size_t i = 0; i != static_cast<std::size_t>(BootAndSystemstampLength); ++i){
|
|
bootsystemstamp[char_counter++] = Characters[(info.Reserved1[i]&0xF0)>>4];
|
|
bootsystemstamp[char_counter++] = Characters[(info.Reserved1[i]&0x0F)];
|
|
}
|
|
s = BootAndSystemstampLength*2;
|
|
return true;
|
|
}
|
|
|
|
static inline bool unlink_file(const char *filename)
|
|
{
|
|
try{
|
|
NtSetInformationFile_t pNtSetInformationFile =
|
|
(NtSetInformationFile_t)get_proc_address(get_module_handle("ntdll.dll"), "NtSetInformationFile");
|
|
if(!pNtSetInformationFile){
|
|
return false;
|
|
}
|
|
|
|
NtQueryObject_t pNtQueryObject =
|
|
(NtQueryObject_t)get_proc_address(get_module_handle("ntdll.dll"), "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,
|
|
file_flag_backup_semantics | file_flag_delete_on_close);
|
|
if(fh == invalid_handle_value){
|
|
return false;
|
|
}
|
|
|
|
class handle_closer
|
|
{
|
|
void *handle_;
|
|
public:
|
|
handle_closer(void *handle) : handle_(handle){}
|
|
~handle_closer(){ close_handle(handle_); }
|
|
} handle_closer(fh);
|
|
|
|
const std::size_t CharArraySize = 32767; //Max name length
|
|
|
|
union mem_t
|
|
{
|
|
object_name_information_t name;
|
|
struct ren_t
|
|
{
|
|
file_rename_information_t info;
|
|
wchar_t buf[CharArraySize];
|
|
} ren;
|
|
};
|
|
|
|
class auto_ptr
|
|
{
|
|
public:
|
|
explicit auto_ptr(mem_t *ptr) : ptr_(ptr){}
|
|
~auto_ptr(){ delete ptr_; }
|
|
mem_t *get() const{ return (ptr_); }
|
|
mem_t *operator->() const{ return this->get(); }
|
|
private:
|
|
mem_t *ptr_;
|
|
} pmem(new mem_t);
|
|
|
|
file_rename_information_t *pfri = (file_rename_information_t*)&pmem->ren.info;
|
|
const std::size_t RenMaxNumChars =
|
|
((char*)pmem.get() - (char*)&pmem->ren.info.FileName[0])/sizeof(wchar_t);
|
|
|
|
//Obtain file name
|
|
unsigned long size;
|
|
if(pNtQueryObject(fh, object_name_information, pmem.get(), sizeof(mem_t), &size)){
|
|
return false;
|
|
}
|
|
|
|
//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);
|
|
|
|
//Second step: obtain the complete native-nt filename
|
|
//if(!get_file_name_from_handle_function(fh, pfri->FileName, RenMaxNumChars, filename_string_length)){
|
|
//return 0;
|
|
//}
|
|
|
|
//Add trailing mark
|
|
if((RenMaxNumChars-filename_string_length) < (SystemTimeOfDayInfoLength*2)){
|
|
return false;
|
|
}
|
|
|
|
//Search '\\' character to replace 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;
|
|
|
|
//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;
|
|
|
|
//Final step: change the name of the in-use file:
|
|
io_status_block_t io;
|
|
if(0 != pNtSetInformationFile(fh, &io, pfri, sizeof(mem_t::ren_t), file_rename_information)){
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
catch(...){
|
|
return false;
|
|
}
|
|
}
|
|
|
|
} //namespace winapi
|
|
} //namespace interprocess
|
|
} //namespace boost
|
|
|
|
#include <boost/interprocess/detail/config_end.hpp>
|
|
|
|
#endif //#ifdef BOOST_INTERPROCESS_WIN32_SYNC_PRIMITIVES_HPP
|