ceph/src/boost/libs/interprocess/include/boost/interprocess/detail/win32_api.hpp

   1 //////////////////////////////////////////////////////////////////////////////
   2 //
   3 // (C) Copyright Ion Gaztanaga 2005-2015. Distributed under the Boost
   4 // Software License, Version 1.0. (See accompanying file
   5 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6 //
   7 // See http://www.boost.org/libs/interprocess for documentation.
   8 //
   9 //////////////////////////////////////////////////////////////////////////////
  10
  11 #ifndef BOOST_INTERPROCESS_WIN32_API_HPP
  12 #define BOOST_INTERPROCESS_WIN32_API_HPP
  13
  14 #ifndef BOOST_CONFIG_HPP
  15 #  include <boost/config.hpp>
  16 #endif
  17 #
  18 #if defined(BOOST_HAS_PRAGMA_ONCE)
  19 #  pragma once
  20 #endif
  21
  22 #include <boost/interprocess/detail/config_begin.hpp>
  23 #include <boost/interprocess/detail/workaround.hpp>
  24 #include <boost/date_time/filetime_functions.hpp>
  25 #include <cstddef>
  26 #include <cstring>
  27 #include <cstdlib>
  28 #include <cstdio>
  29
  30 #include <boost/assert.hpp>
  31 #include <string>
  32 #include <vector>
  33
  34 #ifdef BOOST_USE_WINDOWS_H
  35 #include <windows.h>
  36
  37 #  if defined(BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME)
  38 #  include <wbemidl.h>
  39 #  include <objbase.h>
  40 #  endif
  41
  42 #include <shlobj.h>
  43 #endif
  44
  45 #if defined(_MSC_VER)
  46 #  pragma once
  47 #  pragma comment( lib, "Advapi32.lib" )
  48 #  pragma comment( lib, "oleaut32.lib" )
  49 #  pragma comment( lib, "Ole32.lib" )
  50 #  pragma comment( lib, "Shell32.lib" )   //SHGetFolderPath
  51 #endif
  52
  53 #if defined (BOOST_INTERPROCESS_WINDOWS)
  54 #  include <cstdarg>
  55 #  include <boost/detail/interlocked.hpp>
  56 #else
  57 # error "This file can only be included in Windows OS"
  58 #endif
  59
  60 //////////////////////////////////////////////////////////////////////////////
  61 //
  62 // Declaration of Windows structures or typedefs if BOOST_USE_WINDOWS_H is used
  63 //
  64 //////////////////////////////////////////////////////////////////////////////
  65
  66 //Ignore -pedantic errors here (anonymous structs, etc.)
  67 #if defined(BOOST_GCC)
  68 #  if (BOOST_GCC >= 40600)
  69 #     pragma GCC diagnostic push
  70 #     if (BOOST_GCC >= 60000)
  71 #        pragma GCC diagnostic ignored "-Wpedantic"
  72 #     else
  73 #        pragma GCC diagnostic ignored "-pedantic"
  74 #     endif
  75 #  else
  76 #     pragma GCC system_header
  77 #  endif
  78 #endif
  79
  80 namespace boost  {
  81 namespace interprocess  {
  82 namespace winapi {
  83
  84 //Own defines
  85 static const unsigned long MaxPath           = 260;
  86
  87 #ifndef BOOST_USE_WINDOWS_H
  88
  89 struct GUID_BIPC
  90 {
  91    unsigned long  Data1;
  92    unsigned short Data2;
  93    unsigned short Data3;
  94    unsigned char  Data4[8];
  95 };
  96
  97 #if defined(_MSC_VER)
  98 #pragma warning (push)
  99 #pragma warning (disable : 4201) // nonstandard extension used
 100 #endif
 101
 102 struct decimal
 103 {
 104     unsigned short wReserved;
 105     union {
 106         struct {
 107             unsigned char scale;
 108             unsigned char sign;
 109         };
 110         unsigned short signscale;
 111     };
 112     unsigned long Hi32;
 113     union {
 114         struct {
 115             unsigned long Lo32;
 116             unsigned long Mid32;
 117         };
 118         ::boost::ulong_long_type Lo64;
 119     };
 120 };
 121
 122 typedef unsigned short *bstr;
 123
 124
 125 struct wchar_variant
 126 {
 127    union
 128    {
 129       struct
 130       {
 131          unsigned short vt;
 132          unsigned short wReserved1;
 133          unsigned short wReserved2;
 134          unsigned short wReserved3;
 135          union
 136          {
 137             bstr bstrVal;
 138             struct
 139             {
 140                void* pvRecord;
 141                void* pRecInfo;
 142             };
 143          };
 144       };
 145       decimal decVal;
 146    };
 147 };
 148
 149 #if defined(_MSC_VER)
 150 #pragma warning (pop)
 151 #endif
 152
 153 struct IUnknown_BIPC
 154 {
 155    public:
 156    virtual long __stdcall QueryInterface(
 157       const GUID_BIPC &riid,  // [in]
 158       void **ppvObject) = 0;  // [iid_is][out]
 159
 160    virtual unsigned long __stdcall AddRef (void) = 0;
 161    virtual unsigned long __stdcall Release(void) = 0;
 162 };
 163
 164 struct IWbemClassObject_BIPC : public IUnknown_BIPC
 165 {
 166    public:
 167    virtual long __stdcall GetQualifierSet(
 168       /* [out] */ void **ppQualSet) = 0;
 169
 170    virtual long __stdcall Get(
 171       /* [string][in] */ const bstr wszName,
 172       /* [in] */ long lFlags,
 173       /* [unique][in][out] */ wchar_variant *pVal,
 174       /* [unique][in][out] */ long *pType,
 175       /* [unique][in][out] */ long *plFlavor) = 0;
 176
 177    virtual long __stdcall Put(
 178       /* [string][in] */ const bstr wszName,
 179       /* [in] */ long lFlags,
 180       /* [in] */ wchar_variant *pVal,
 181       /* [in] */ long Type) = 0;
 182
 183    virtual long __stdcall Delete(
 184       /* [string][in] */ const bstr wszName) = 0;
 185
 186    virtual long __stdcall GetNames(
 187       /* [string][in] */ const bstr wszQualifierName,
 188       /* [in] */ long lFlags,
 189       /* [in] */ wchar_variant *pQualifierVal,
 190       /* [out] */ void * *pNames) = 0;
 191
 192    virtual long __stdcall BeginEnumeration(
 193       /* [in] */ long lEnumFlags) = 0;
 194
 195    virtual long __stdcall Next(
 196       /* [in] */ long lFlags,
 197       /* [unique][in][out] */ bstr *strName,
 198       /* [unique][in][out] */ wchar_variant *pVal,
 199       /* [unique][in][out] */ long *pType,
 200       /* [unique][in][out] */ long *plFlavor) = 0;
 201
 202    virtual long __stdcall EndEnumeration( void) = 0;
 203
 204    virtual long __stdcall GetPropertyQualifierSet(
 205       /* [string][in] */ const bstr wszProperty,
 206       /* [out] */ void **ppQualSet) = 0;
 207
 208    virtual long __stdcall Clone(
 209       /* [out] */ IWbemClassObject_BIPC **ppCopy) = 0;
 210
 211    virtual long __stdcall GetObjectText(
 212       /* [in] */ long lFlags,
 213       /* [out] */ bstr *pstrObjectText) = 0;
 214
 215    virtual long __stdcall SpawnDerivedClass(
 216       /* [in] */ long lFlags,
 217       /* [out] */ IWbemClassObject_BIPC **ppNewClass) = 0;
 218
 219    virtual long __stdcall SpawnInstance(
 220       /* [in] */ long lFlags,
 221       /* [out] */ IWbemClassObject_BIPC **ppNewInstance) = 0;
 222
 223    virtual long __stdcall CompareTo(
 224       /* [in] */ long lFlags,
 225       /* [in] */ IWbemClassObject_BIPC *pCompareTo) = 0;
 226
 227    virtual long __stdcall GetPropertyOrigin(
 228       /* [string][in] */ const bstr wszName,
 229       /* [out] */ bstr *pstrClassName) = 0;
 230
 231    virtual long __stdcall InheritsFrom(
 232       /* [in] */ const bstr strAncestor) = 0;
 233
 234    virtual long __stdcall GetMethod(
 235       /* [string][in] */ const bstr wszName,
 236       /* [in] */ long lFlags,
 237       /* [out] */ IWbemClassObject_BIPC **ppInSignature,
 238       /* [out] */ IWbemClassObject_BIPC **ppOutSignature) = 0;
 239
 240    virtual long __stdcall PutMethod(
 241       /* [string][in] */ const bstr wszName,
 242       /* [in] */ long lFlags,
 243       /* [in] */ IWbemClassObject_BIPC *pInSignature,
 244       /* [in] */ IWbemClassObject_BIPC *pOutSignature) = 0;
 245
 246    virtual long __stdcall DeleteMethod(
 247       /* [string][in] */ const bstr wszName) = 0;
 248
 249    virtual long __stdcall BeginMethodEnumeration(
 250       /* [in] */ long lEnumFlags) = 0;
 251
 252    virtual long __stdcall NextMethod(
 253       /* [in] */ long lFlags,
 254       /* [unique][in][out] */ bstr *pstrName,
 255       /* [unique][in][out] */ IWbemClassObject_BIPC **ppInSignature,
 256       /* [unique][in][out] */ IWbemClassObject_BIPC **ppOutSignature) = 0;
 257
 258    virtual long __stdcall EndMethodEnumeration( void) = 0;
 259
 260    virtual long __stdcall GetMethodQualifierSet(
 261       /* [string][in] */ const bstr wszMethod,
 262       /* [out] */ void **ppQualSet) = 0;
 263
 264    virtual long __stdcall GetMethodOrigin(
 265       /* [string][in] */ const bstr wszMethodName,
 266       /* [out] */ bstr *pstrClassName) = 0;
 267
 268 };
 269
 270 struct IWbemContext_BIPC : public IUnknown_BIPC
 271 {
 272 public:
 273    virtual long __stdcall Clone(
 274       /* [out] */ IWbemContext_BIPC **ppNewCopy) = 0;
 275
 276    virtual long __stdcall GetNames(
 277       /* [in] */ long lFlags,
 278       /* [out] */ void * *pNames) = 0;
 279
 280    virtual long __stdcall BeginEnumeration(
 281       /* [in] */ long lFlags) = 0;
 282
 283    virtual long __stdcall Next(
 284       /* [in] */ long lFlags,
 285       /* [out] */ bstr *pstrName,
 286       /* [out] */ wchar_variant *pValue) = 0;
 287
 288    virtual long __stdcall EndEnumeration( void) = 0;
 289
 290    virtual long __stdcall SetValue(
 291       /* [string][in] */ const bstr wszName,
 292       /* [in] */ long lFlags,
 293       /* [in] */ wchar_variant *pValue) = 0;
 294
 295    virtual long __stdcall GetValue(
 296       /* [string][in] */ const bstr wszName,
 297       /* [in] */ long lFlags,
 298       /* [out] */ wchar_variant *pValue) = 0;
 299
 300    virtual long __stdcall DeleteValue(
 301       /* [string][in] */ const bstr wszName,
 302       /* [in] */ long lFlags) = 0;
 303
 304    virtual long __stdcall DeleteAll( void) = 0;
 305
 306 };
 307
 308
 309 struct IEnumWbemClassObject_BIPC : public IUnknown_BIPC
 310 {
 311 public:
 312    virtual long __stdcall Reset( void) = 0;
 313
 314    virtual long __stdcall Next(
 315       /* [in] */ long lTimeout,
 316       /* [in] */ unsigned long uCount,
 317       /* [length_is][size_is][out] */ IWbemClassObject_BIPC **apObjects,
 318       /* [out] */ unsigned long *puReturned) = 0;
 319
 320    virtual long __stdcall NextAsync(
 321       /* [in] */ unsigned long uCount,
 322       /* [in] */ void *pSink) = 0;
 323
 324    virtual long __stdcall Clone(
 325       /* [out] */ void **ppEnum) = 0;
 326
 327    virtual long __stdcall Skip(
 328       /* [in] */ long lTimeout,
 329       /* [in] */ unsigned long nCount) = 0;
 330
 331 };
 332
 333 struct IWbemServices_BIPC : public IUnknown_BIPC
 334 {
 335 public:
 336    virtual long __stdcall OpenNamespace(
 337       /* [in] */ const bstr strNamespace,
 338       /* [in] */ long lFlags,
 339       /* [in] */ void *pCtx,
 340       /* [unique][in][out] */ void **ppWorkingNamespace,
 341       /* [unique][in][out] */ void **ppResult) = 0;
 342
 343    virtual long __stdcall CancelAsyncCall(
 344       /* [in] */ void *pSink) = 0;
 345
 346    virtual long __stdcall QueryObjectSink(
 347       /* [in] */ long lFlags,
 348       /* [out] */ void **ppResponseHandler) = 0;
 349
 350    virtual long __stdcall GetObject(
 351       /* [in] */ const bstr strObjectPath,
 352       /* [in] */ long lFlags,
 353       /* [in] */ void *pCtx,
 354       /* [unique][in][out] */ void **ppObject,
 355       /* [unique][in][out] */ void **ppCallResult) = 0;
 356
 357    virtual long __stdcall GetObjectAsync(
 358       /* [in] */ const bstr strObjectPath,
 359       /* [in] */ long lFlags,
 360       /* [in] */ void *pCtx,
 361       /* [in] */ void *pResponseHandler) = 0;
 362
 363    virtual long __stdcall PutClass(
 364       /* [in] */ IWbemClassObject_BIPC *pObject,
 365       /* [in] */ long lFlags,
 366       /* [in] */ void *pCtx,
 367       /* [unique][in][out] */ void **ppCallResult) = 0;
 368
 369    virtual long __stdcall PutClassAsync(
 370       /* [in] */ IWbemClassObject_BIPC *pObject,
 371       /* [in] */ long lFlags,
 372       /* [in] */ void *pCtx,
 373       /* [in] */ void *pResponseHandler) = 0;
 374
 375    virtual long __stdcall DeleteClass(
 376       /* [in] */ const bstr strClass,
 377       /* [in] */ long lFlags,
 378       /* [in] */ void *pCtx,
 379       /* [unique][in][out] */ void **ppCallResult) = 0;
 380
 381    virtual long __stdcall DeleteClassAsync(
 382       /* [in] */ const bstr strClass,
 383       /* [in] */ long lFlags,
 384       /* [in] */ void *pCtx,
 385       /* [in] */ void *pResponseHandler) = 0;
 386
 387    virtual long __stdcall CreateClassEnum(
 388       /* [in] */ const bstr strSuperclass,
 389       /* [in] */ long lFlags,
 390       /* [in] */ void *pCtx,
 391       /* [out] */ void **ppEnum) = 0;
 392
 393    virtual long __stdcall CreateClassEnumAsync(
 394       /* [in] */ const bstr strSuperclass,
 395       /* [in] */ long lFlags,
 396       /* [in] */ void *pCtx,
 397       /* [in] */ void *pResponseHandler) = 0;
 398
 399    virtual long __stdcall PutInstance(
 400       /* [in] */ void *pInst,
 401       /* [in] */ long lFlags,
 402       /* [in] */ void *pCtx,
 403       /* [unique][in][out] */ void **ppCallResult) = 0;
 404
 405    virtual long __stdcall PutInstanceAsync(
 406       /* [in] */ void *pInst,
 407       /* [in] */ long lFlags,
 408       /* [in] */ void *pCtx,
 409       /* [in] */ void *pResponseHandler) = 0;
 410
 411    virtual long __stdcall DeleteInstance(
 412       /* [in] */ const bstr strObjectPath,
 413       /* [in] */ long lFlags,
 414       /* [in] */ void *pCtx,
 415       /* [unique][in][out] */ void **ppCallResult) = 0;
 416
 417    virtual long __stdcall DeleteInstanceAsync(
 418       /* [in] */ const bstr strObjectPath,
 419       /* [in] */ long lFlags,
 420       /* [in] */ void *pCtx,
 421       /* [in] */ void *pResponseHandler) = 0;
 422
 423    virtual long __stdcall CreateInstanceEnum(
 424       /* [in] */ const bstr strFilter,
 425       /* [in] */ long lFlags,
 426       /* [in] */ void *pCtx,
 427       /* [out] */ void **ppEnum) = 0;
 428
 429    virtual long __stdcall CreateInstanceEnumAsync(
 430       /* [in] */ const bstr strFilter,
 431       /* [in] */ long lFlags,
 432       /* [in] */ void *pCtx,
 433       /* [in] */ void *pResponseHandler) = 0;
 434
 435    virtual long __stdcall ExecQuery(
 436       /* [in] */ const bstr strQueryLanguage,
 437       /* [in] */ const bstr strQuery,
 438       /* [in] */ long lFlags,
 439       /* [in] */ IWbemContext_BIPC *pCtx,
 440       /* [out] */ IEnumWbemClassObject_BIPC **ppEnum) = 0;
 441
 442    virtual long __stdcall ExecQueryAsync(
 443       /* [in] */ const bstr strQueryLanguage,
 444       /* [in] */ const bstr strQuery,
 445       /* [in] */ long lFlags,
 446       /* [in] */ IWbemContext_BIPC *pCtx,
 447       /* [in] */ void *pResponseHandler) = 0;
 448
 449    virtual long __stdcall ExecNotificationQuery(
 450       /* [in] */ const bstr strQueryLanguage,
 451       /* [in] */ const bstr strQuery,
 452       /* [in] */ long lFlags,
 453       /* [in] */ IWbemContext_BIPC *pCtx,
 454       /* [out] */ void **ppEnum) = 0;
 455
 456    virtual long __stdcall ExecNotificationQueryAsync(
 457       /* [in] */ const bstr strQueryLanguage,
 458       /* [in] */ const bstr strQuery,
 459       /* [in] */ long lFlags,
 460       /* [in] */ IWbemContext_BIPC *pCtx,
 461       /* [in] */ void *pResponseHandler) = 0;
 462
 463    virtual long __stdcall ExecMethod(
 464       /* [in] */ const bstr strObjectPath,
 465       /* [in] */ const bstr strMethodName,
 466       /* [in] */ long lFlags,
 467       /* [in] */ IWbemContext_BIPC *pCtx,
 468       /* [in] */ IWbemClassObject_BIPC *pInParams,
 469       /* [unique][in][out] */ IWbemClassObject_BIPC **ppOutParams,
 470       /* [unique][in][out] */ void **ppCallResult) = 0;
 471
 472    virtual long __stdcall ExecMethodAsync(
 473       /* [in] */ const bstr strObjectPath,
 474       /* [in] */ const bstr strMethodName,
 475       /* [in] */ long lFlags,
 476       /* [in] */ IWbemContext_BIPC *pCtx,
 477       /* [in] */ IWbemClassObject_BIPC *pInParams,
 478       /* [in] */ void *pResponseHandler) = 0;
 479
 480 };
 481
 482 struct IWbemLocator_BIPC : public IUnknown_BIPC
 483 {
 484 public:
 485    virtual long __stdcall ConnectServer(
 486       /* [in] */ const bstr strNetworkResource,
 487       /* [in] */ const bstr strUser,
 488       /* [in] */ const bstr strPassword,
 489       /* [in] */ const bstr strLocale,
 490       /* [in] */ long lSecurityFlags,
 491       /* [in] */ const bstr strAuthority,
 492       /* [in] */ void *pCtx,
 493       /* [out] */ IWbemServices_BIPC **ppNamespace) = 0;
 494
 495 };
 496
 497 struct interprocess_overlapped
 498 {
 499    unsigned long *internal;
 500    unsigned long *internal_high;
 501    union {
 502       struct {
 503          unsigned long offset;
 504          unsigned long offset_high;
 505       }dummy;
 506       void *pointer;
 507    };
 508
 509    void *h_event;
 510 };
 511
 512
 513 struct interprocess_filetime
 514 {
 515    unsigned long  dwLowDateTime;
 516    unsigned long  dwHighDateTime;
 517 };
 518
 519 struct win32_find_data
 520 {
 521    unsigned long dwFileAttributes;
 522    interprocess_filetime ftCreationTime;
 523    interprocess_filetime ftLastAccessTime;
 524    interprocess_filetime ftLastWriteTime;
 525    unsigned long nFileSizeHigh;
 526    unsigned long nFileSizeLow;
 527    unsigned long dwReserved0;
 528    unsigned long dwReserved1;
 529    char cFileName[MaxPath];
 530    char cAlternateFileName[14];
 531 };
 532
 533 struct interprocess_security_attributes
 534 {
 535    unsigned long nLength;
 536    void *lpSecurityDescriptor;
 537    int bInheritHandle;
 538 };
 539
 540 struct system_info {
 541     union {
 542         unsigned long dwOemId;          // Obsolete field...do not use
 543         struct {
 544             unsigned short wProcessorArchitecture;
 545             unsigned short wReserved;
 546         } dummy;
 547     };
 548     unsigned long dwPageSize;
 549     void * lpMinimumApplicationAddress;
 550     void * lpMaximumApplicationAddress;
 551     unsigned long * dwActiveProcessorMask;
 552     unsigned long dwNumberOfProcessors;
 553     unsigned long dwProcessorType;
 554     unsigned long dwAllocationGranularity;
 555     unsigned short wProcessorLevel;
 556     unsigned short wProcessorRevision;
 557 };
 558
 559 struct interprocess_acl
 560 {
 561    unsigned char  AclRevision;
 562    unsigned char  Sbz1;
 563    unsigned short AclSize;
 564    unsigned short AceCount;
 565    unsigned short Sbz2;
 566 };
 567
 568 struct interprocess_security_descriptor
 569 {
 570    unsigned char Revision;
 571    unsigned char Sbz1;
 572    unsigned short Control;
 573    void *Owner;
 574    void *Group;
 575    interprocess_acl *Sacl;
 576    interprocess_acl *Dacl;
 577 };
 578
 579 struct interprocess_by_handle_file_information
 580 {
 581     unsigned long dwFileAttributes;
 582     interprocess_filetime ftCreationTime;
 583     interprocess_filetime ftLastAccessTime;
 584     interprocess_filetime ftLastWriteTime;
 585     unsigned long dwVolumeSerialNumber;
 586     unsigned long nFileSizeHigh;
 587     unsigned long nFileSizeLow;
 588     unsigned long nNumberOfLinks;
 589     unsigned long nFileIndexHigh;
 590     unsigned long nFileIndexLow;
 591 };
 592
 593 struct interprocess_eventlogrecord
 594 {
 595     unsigned long  Length;        // Length of full record
 596     unsigned long  Reserved;      // Used by the service
 597     unsigned long  RecordNumber;  // Absolute record number
 598     unsigned long  TimeGenerated; // Seconds since 1-1-1970
 599     unsigned long  TimeWritten;   // Seconds since 1-1-1970
 600     unsigned long  EventID;
 601     unsigned short EventType;
 602     unsigned short NumStrings;
 603     unsigned short EventCategory;
 604     unsigned short ReservedFlags; // For use with paired events (auditing)
 605     unsigned long  ClosingRecordNumber; // For use with paired events (auditing)
 606     unsigned long  StringOffset;  // Offset from beginning of record
 607     unsigned long  UserSidLength;
 608     unsigned long  UserSidOffset;
 609     unsigned long  DataLength;
 610     unsigned long  DataOffset;    // Offset from beginning of record
 611     //
 612     // Then follow:
 613     //
 614     // wchar_t SourceName[]
 615     // wchar_t Computername[]
 616     // SID   UserSid
 617     // wchar_t Strings[]
 618     // BYTE  Data[]
 619     // CHAR  Pad[]
 620     // unsigned long Length;
 621     //
 622 };
 623
 624 union large_integer
 625 {
 626     __int64 QuadPart;
 627 };
 628
 629 struct hinstance_struct { int unused; };
 630 typedef hinstance_struct *hmodule;
 631
 632 struct hkey_struct;
 633 typedef hkey_struct *hkey;
 634
 635 #ifdef _WIN64
 636 typedef __int64 (__stdcall *farproc_t)();
 637 #else
 638 typedef int     (__stdcall *farproc_t)();
 639 #endif  // _WIN64
 640
 641 #else    //#ifndef BOOST_USE_WINDOWS_H
 642
 643 typedef GUID GUID_BIPC;
 644 typedef VARIANT wchar_variant;
 645
 646 #if defined(BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME)
 647
 648 typedef IUnknown IUnknown_BIPC;
 649
 650 typedef IWbemClassObject IWbemClassObject_BIPC;
 651
 652 typedef IWbemContext IWbemContext_BIPC;
 653
 654 typedef IEnumWbemClassObject IEnumWbemClassObject_BIPC;
 655
 656 typedef IWbemServices IWbemServices_BIPC;
 657
 658 typedef IWbemLocator IWbemLocator_BIPC;
 659
 660 #endif
 661
 662 typedef OVERLAPPED interprocess_overlapped;
 663
 664 typedef FILETIME interprocess_filetime;
 665
 666 typedef WIN32_FIND_DATAA win32_find_data;
 667
 668 typedef SECURITY_ATTRIBUTES interprocess_security_attributes;
 669
 670 typedef SYSTEM_INFO system_info;
 671
 672 typedef ACL interprocess_acl;
 673
 674 typedef SECURITY_DESCRIPTOR interprocess_security_descriptor;
 675
 676 typedef BY_HANDLE_FILE_INFORMATION interprocess_by_handle_file_information;
 677
 678 typedef EVENTLOGRECORD interprocess_eventlogrecord;
 679
 680 typedef LARGE_INTEGER large_integer;
 681
 682 typedef HMODULE hmodule;
 683
 684 typedef HKEY hkey;
 685
 686 typedef BSTR bstr;
 687
 688 typedef FARPROC farproc_t;
 689
 690 #endif   //#ifndef BOOST_USE_WINDOWS_H
 691
 692 //////////////////////////////////////////////////////////////////////////////
 693 //
 694 // Nt native structures
 695 //
 696 //////////////////////////////////////////////////////////////////////////////
 697
 698 struct interprocess_semaphore_basic_information
 699 {
 700    unsigned int count;      // current semaphore count
 701    unsigned int limit;      // max semaphore count
 702 };
 703
 704 struct interprocess_section_basic_information
 705 {
 706   void *          base_address;
 707   unsigned long   section_attributes;
 708   __int64         section_size;
 709 };
 710
 711 struct file_rename_information_t {
 712    int Replace;
 713    void *RootDir;
 714    unsigned long FileNameLength;
 715    wchar_t FileName[1];
 716 };
 717
 718 struct unicode_string_t {
 719    unsigned short Length;
 720    unsigned short MaximumLength;
 721    wchar_t *Buffer;
 722 };
 723
 724 struct object_attributes_t {
 725    unsigned long Length;
 726    void * RootDirectory;
 727    unicode_string_t *ObjectName;
 728    unsigned long Attributes;
 729    void *SecurityDescriptor;
 730    void *SecurityQualityOfService;
 731 };
 732
 733 struct io_status_block_t {
 734    union {
 735       long Status;
 736       void *Pointer;
 737    };
 738
 739    unsigned long *Information;
 740 };
 741
 742 union system_timeofday_information
 743 {
 744    struct data_t
 745    {
 746       __int64 liKeBootTime;
 747       __int64 liKeSystemTime;
 748       __int64 liExpTimeZoneBias;
 749       unsigned long uCurrentTimeZoneId;
 750       unsigned long dwReserved;
 751       ::boost::ulong_long_type ullBootTimeBias;
 752       ::boost::ulong_long_type ullSleepTimeBias;
 753    } data;
 754    unsigned char Reserved1[sizeof(data_t)];
 755 };
 756
 757 static const long BootstampLength            = sizeof(__int64);
 758 static const long BootAndSystemstampLength   = sizeof(__int64)*2;
 759 static const long SystemTimeOfDayInfoLength  = sizeof(system_timeofday_information::data_t);
 760
 761 struct object_name_information_t
 762 {
 763    unicode_string_t Name;
 764    wchar_t NameBuffer[1];
 765 };
 766
 767 enum file_information_class_t {
 768    file_directory_information = 1,
 769    file_full_directory_information,
 770    file_both_directory_information,
 771    file_basic_information,
 772    file_standard_information,
 773    file_internal_information,
 774    file_ea_information,
 775    file_access_information,
 776    file_name_information,
 777    file_rename_information,
 778    file_link_information,
 779    file_names_information,
 780    file_disposition_information,
 781    file_position_information,
 782    file_full_ea_information,
 783    file_mode_information,
 784    file_alignment_information,
 785    file_all_information,
 786    file_allocation_information,
 787    file_end_of_file_information,
 788    file_alternate_name_information,
 789    file_stream_information,
 790    file_pipe_information,
 791    file_pipe_local_information,
 792    file_pipe_remote_information,
 793    file_mailslot_query_information,
 794    file_mailslot_set_information,
 795    file_compression_information,
 796    file_copy_on_write_information,
 797    file_completion_information,
 798    file_move_cluster_information,
 799    file_quota_information,
 800    file_reparse_point_information,
 801    file_network_open_information,
 802    file_object_id_information,
 803    file_tracking_information,
 804    file_ole_directory_information,
 805    file_content_index_information,
 806    file_inherit_content_index_information,
 807    file_ole_information,
 808    file_maximum_information
 809 };
 810
 811 enum semaphore_information_class {
 812    semaphore_basic_information = 0
 813 };
 814
 815
 816 enum system_information_class {
 817    system_basic_information = 0,
 818    system_performance_information = 2,
 819    system_time_of_day_information = 3,
 820    system_process_information = 5,
 821    system_processor_performance_information = 8,
 822    system_interrupt_information = 23,
 823    system_exception_information = 33,
 824    system_registry_quota_information = 37,
 825    system_lookaside_information = 45
 826 };
 827
 828 enum object_information_class
 829 {
 830    object_basic_information,
 831    object_name_information,
 832    object_type_information,
 833    object_all_information,
 834    object_data_information
 835 };
 836
 837 enum section_information_class
 838 {
 839    section_basic_information,
 840    section_image_information
 841 };
 842
 843 //////////////////////////////////////////////////////////////////////////////
 844 //
 845 // Forward declaration of winapi
 846 //
 847 //////////////////////////////////////////////////////////////////////////////
 848
 849 #ifndef BOOST_USE_WINDOWS_H
 850
 851 //Kernel32.dll
 852
 853 //Some windows API declarations
 854 extern "C" __declspec(dllimport) unsigned long __stdcall GetCurrentProcessId();
 855 extern "C" __declspec(dllimport) unsigned long __stdcall GetCurrentThreadId();
 856 extern "C" __declspec(dllimport) int __stdcall GetProcessTimes
 857    ( void *hProcess, interprocess_filetime* lpCreationTime
 858    , interprocess_filetime *lpExitTime,interprocess_filetime *lpKernelTime
 859    , interprocess_filetime *lpUserTime );
 860 extern "C" __declspec(dllimport) void __stdcall Sleep(unsigned long);
 861 extern "C" __declspec(dllimport) unsigned long __stdcall GetTickCount(void);
 862 extern "C" __declspec(dllimport) int __stdcall SwitchToThread();
 863 extern "C" __declspec(dllimport) unsigned long __stdcall GetLastError();
 864 extern "C" __declspec(dllimport) void __stdcall SetLastError(unsigned long);
 865 extern "C" __declspec(dllimport) void * __stdcall GetCurrentProcess();
 866 extern "C" __declspec(dllimport) int __stdcall CloseHandle(void*);
 867 extern "C" __declspec(dllimport) int __stdcall DuplicateHandle
 868    ( void *hSourceProcessHandle,    void *hSourceHandle
 869    , void *hTargetProcessHandle,    void **lpTargetHandle
 870    , unsigned long dwDesiredAccess, int bInheritHandle
 871    , unsigned long dwOptions);
 872 extern "C" __declspec(dllimport) long __stdcall GetFileType(void *hFile);
 873 extern "C" __declspec(dllimport) void *__stdcall FindFirstFileA(const char *lpFileName, win32_find_data *lpFindFileData);
 874 extern "C" __declspec(dllimport) int   __stdcall FindNextFileA(void *hFindFile, win32_find_data *lpFindFileData);
 875 extern "C" __declspec(dllimport) int   __stdcall FindClose(void *hFindFile);
 876 //extern "C" __declspec(dllimport) void __stdcall GetSystemTimeAsFileTime(interprocess_filetime*);
 877 //extern "C" __declspec(dllimport) int  __stdcall FileTimeToLocalFileTime(const interprocess_filetime *in, const interprocess_filetime *out);
 878 extern "C" __declspec(dllimport) void * __stdcall CreateMutexA(interprocess_security_attributes*, int, const char *);
 879 extern "C" __declspec(dllimport) void * __stdcall OpenMutexA(unsigned long, int, const char *);
 880 extern "C" __declspec(dllimport) unsigned long __stdcall WaitForSingleObject(void *, unsigned long);
 881 extern "C" __declspec(dllimport) int __stdcall ReleaseMutex(void *);
 882 extern "C" __declspec(dllimport) int __stdcall UnmapViewOfFile(void *);
 883 extern "C" __declspec(dllimport) void * __stdcall CreateSemaphoreA(interprocess_security_attributes*, long, long, const char *);
 884 extern "C" __declspec(dllimport) int __stdcall ReleaseSemaphore(void *, long, long *);
 885 extern "C" __declspec(dllimport) void * __stdcall OpenSemaphoreA(unsigned long, int, const char *);
 886 extern "C" __declspec(dllimport) void * __stdcall CreateFileMappingA (void *, interprocess_security_attributes*, unsigned long, unsigned long, unsigned long, const char *);
 887 extern "C" __declspec(dllimport) void * __stdcall MapViewOfFileEx (void *, unsigned long, unsigned long, unsigned long, std::size_t, void*);
 888 extern "C" __declspec(dllimport) void * __stdcall OpenFileMappingA (unsigned long, int, const char *);
 889 extern "C" __declspec(dllimport) void * __stdcall CreateFileA (const char *, unsigned long, unsigned long, struct interprocess_security_attributes*, unsigned long, unsigned long, void *);
 890 extern "C" __declspec(dllimport) void __stdcall GetSystemInfo (struct system_info *);
 891 extern "C" __declspec(dllimport) int __stdcall FlushViewOfFile (void *, std::size_t);
 892 extern "C" __declspec(dllimport) int __stdcall VirtualUnlock (void *, std::size_t);
 893 extern "C" __declspec(dllimport) int __stdcall VirtualProtect (void *, std::size_t, unsigned long, unsigned long *);
 894 extern "C" __declspec(dllimport) int __stdcall FlushFileBuffers (void *);
 895 extern "C" __declspec(dllimport) int __stdcall GetFileSizeEx (void *, large_integer *size);
 896 extern "C" __declspec(dllimport) unsigned long __stdcall FormatMessageA
 897    (unsigned long dwFlags,       const void *lpSource,   unsigned long dwMessageId,
 898    unsigned long dwLanguageId,   char *lpBuffer,         unsigned long nSize,
 899    std::va_list *Arguments);
 900 extern "C" __declspec(dllimport) void *__stdcall LocalFree (void *);
 901 extern "C" __declspec(dllimport) unsigned long __stdcall GetFileAttributesA(const char *);
 902 extern "C" __declspec(dllimport) int __stdcall CreateDirectoryA(const char *, interprocess_security_attributes*);
 903 extern "C" __declspec(dllimport) int __stdcall RemoveDirectoryA(const char *lpPathName);
 904 extern "C" __declspec(dllimport) int __stdcall GetTempPathA(unsigned long length, char *buffer);
 905 extern "C" __declspec(dllimport) int __stdcall CreateDirectory(const char *, interprocess_security_attributes*);
 906 extern "C" __declspec(dllimport) int __stdcall SetFileValidData(void *, __int64 size);
 907 extern "C" __declspec(dllimport) int __stdcall SetEndOfFile(void *);
 908 extern "C" __declspec(dllimport) int __stdcall SetFilePointerEx(void *, large_integer distance, large_integer *new_file_pointer, unsigned long move_method);
 909 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);
 910 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);
 911 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);
 912 extern "C" __declspec(dllimport) int __stdcall UnlockFileEx(void *hnd, unsigned long reserved, unsigned long size_low, unsigned long size_high, interprocess_overlapped* overlapped);
 913 extern "C" __declspec(dllimport) int __stdcall WriteFile(void *hnd, const void *buffer, unsigned long bytes_to_write, unsigned long *bytes_written, interprocess_overlapped* overlapped);
 914 extern "C" __declspec(dllimport) int __stdcall ReadFile(void *hnd, void *buffer, unsigned long bytes_to_read, unsigned long *bytes_read, interprocess_overlapped* overlapped);
 915 extern "C" __declspec(dllimport) int __stdcall InitializeSecurityDescriptor(interprocess_security_descriptor *pSecurityDescriptor, unsigned long dwRevision);
 916 extern "C" __declspec(dllimport) int __stdcall SetSecurityDescriptorDacl(interprocess_security_descriptor *pSecurityDescriptor, int bDaclPresent, interprocess_acl *pDacl, int bDaclDefaulted);
 917 extern "C" __declspec(dllimport) hmodule __stdcall LoadLibraryA(const char *);
 918 extern "C" __declspec(dllimport) int   __stdcall FreeLibrary(hmodule);
 919 extern "C" __declspec(dllimport) farproc_t __stdcall GetProcAddress(void *, const char*);
 920 extern "C" __declspec(dllimport) hmodule __stdcall GetModuleHandleA(const char*);
 921 extern "C" __declspec(dllimport) void *__stdcall GetFileInformationByHandle(void *, interprocess_by_handle_file_information*);
 922
 923 //Advapi32.dll
 924 extern "C" __declspec(dllimport) long __stdcall RegOpenKeyExA(hkey, const char *, unsigned long, unsigned long, hkey*);
 925 extern "C" __declspec(dllimport) long __stdcall RegQueryValueExA(hkey, const char *, unsigned long*, unsigned long*, unsigned char *, unsigned long*);
 926 extern "C" __declspec(dllimport) long __stdcall RegCloseKey(hkey);
 927
 928 //Ole32.dll
 929 extern "C" __declspec(dllimport) long __stdcall CoInitializeEx(void *pvReserved, unsigned long dwCoInit);
 930 extern "C" __declspec(dllimport) long __stdcall CoInitializeSecurity(
 931                     void*          pSecDesc,
 932                     long           cAuthSvc,
 933                     void *         asAuthSvc,
 934                     void          *pReserved1,
 935                     unsigned long  dwAuthnLevel,
 936                     unsigned long  dwImpLevel,
 937                     void          *pAuthList,
 938                     unsigned long  dwCapabilities,
 939                     void          *pReserved3 );
 940
 941  extern "C" __declspec(dllimport) long __stdcall CoSetProxyBlanket(
 942                      IUnknown_BIPC *pProxy,
 943                      unsigned long dwAuthnSvc,
 944                      unsigned long dwAuthzSvc,
 945                      wchar_t *pServerPrincName,
 946                      unsigned long dwAuthnLevel,
 947                      unsigned long dwImpLevel,
 948                      void *pAuthInfo,
 949                      unsigned long dwCapabilities);
 950 extern "C" __declspec(dllimport) long __stdcall CoCreateInstance(const GUID_BIPC & rclsid, IUnknown_BIPC *pUnkOuter,
 951                     unsigned long dwClsContext, const GUID_BIPC & riid, void** ppv);
 952 extern "C" __declspec(dllimport) void __stdcall CoUninitialize(void);
 953
 954 //OleAut32.dll
 955 extern "C" __declspec(dllimport) long __stdcall VariantClear(wchar_variant * pvarg);
 956
 957 //Shell32.dll
 958 extern "C" __declspec(dllimport) int __stdcall SHGetSpecialFolderPathA
 959    (void* hwnd, const char *pszPath, int csidl, int fCreate);
 960
 961 extern "C" __declspec(dllimport) int __stdcall SHGetFolderPathA(void *hwnd, int csidl, void *hToken, unsigned long dwFlags, const char *pszPath);
 962
 963 //EventLog access functions
 964
 965 extern "C" __declspec(dllimport) void* __stdcall OpenEventLogA
 966    (const char* lpUNCServerName, const char* lpSourceName);
 967
 968 extern "C" __declspec(dllimport) int __stdcall CloseEventLog(void *hEventLog);
 969
 970 extern "C" __declspec(dllimport) int __stdcall ReadEventLogA
 971    (void *hEventLog,
 972     unsigned long dwReadFlags,
 973     unsigned long dwRecordOffset,
 974     void *lpBuffer,
 975     unsigned long nNumberOfBytesToRead,
 976     unsigned long *pnBytesRead,
 977     unsigned long *pnMinNumberOfBytesNeeded
 978    );
 979
 980 #endif   //#ifndef BOOST_USE_WINDOWS_H
 981
 982 //kernel32.dll
 983 typedef int (__stdcall *QueryPerformanceCounter_t)  (__int64 *lpPerformanceCount);
 984 typedef int (__stdcall *QueryPerformanceFrequency_t)(__int64 *lpFrequency);
 985
 986 //ntdll.dll
 987 typedef long (__stdcall *NtDeleteFile_t)(object_attributes_t *ObjectAttributes);
 988 typedef long (__stdcall *NtSetInformationFile_t)(void *FileHandle, io_status_block_t *IoStatusBlock, void *FileInformation, unsigned long Length, int FileInformationClass );
 989 typedef long (__stdcall *NtOpenFile)(void **FileHandle, unsigned long DesiredAccess, object_attributes_t *ObjectAttributes
 990                                     , io_status_block_t *IoStatusBlock, unsigned long ShareAccess, unsigned long Length, unsigned long OpenOptions);
 991 typedef long (__stdcall *NtQuerySystemInformation_t)(int, void*, unsigned long, unsigned long *);
 992 typedef long (__stdcall *NtQueryObject_t)(void*, object_information_class, void *, unsigned long, unsigned long *);
 993 typedef long (__stdcall *NtQuerySemaphore_t)(void*, unsigned int info_class, interprocess_semaphore_basic_information *pinfo, unsigned int info_size, unsigned int *ret_len);
 994 typedef long (__stdcall *NtQuerySection_t)(void*, section_information_class, interprocess_section_basic_information *pinfo, unsigned long info_size, unsigned long *ret_len);
 995 typedef long (__stdcall *NtQueryInformationFile_t)(void *,io_status_block_t *,void *, long, int);
 996 typedef long (__stdcall *NtOpenFile_t)(void*,unsigned long ,object_attributes_t*,io_status_block_t*,unsigned long,unsigned long);
 997 typedef long (__stdcall *NtClose_t) (void*);
 998 typedef long (__stdcall *NtQueryTimerResolution_t) (unsigned long* LowestResolution, unsigned long* HighestResolution, unsigned long* CurrentResolution);
 999 typedef long (__stdcall *NtSetTimerResolution_t) (unsigned long RequestedResolution, int Set, unsigned long* ActualResolution);
1000
1001 }  //namespace winapi {
1002 }  //namespace interprocess  {
1003 }  //namespace boost  {
1004
1005 //////////////////////////////////////////////////////////////////////////////
1006 //
1007 // Forward declaration of constants
1008 //
1009 //////////////////////////////////////////////////////////////////////////////
1010
1011 namespace boost {
1012 namespace interprocess {
1013 namespace winapi {
1014
1015 //Some used constants
1016 static const unsigned long infinite_time        = 0xFFFFFFFF;
1017 static const unsigned long error_already_exists = 183L;
1018 static const unsigned long error_invalid_handle = 6L;
1019 static const unsigned long error_sharing_violation = 32L;
1020 static const unsigned long error_file_not_found = 2u;
1021 static const unsigned long error_no_more_files  = 18u;
1022 static const unsigned long error_not_locked     = 158L;
1023 //Retries in CreateFile, see http://support.microsoft.com/kb/316609
1024 static const unsigned long error_sharing_violation_tries = 3L;
1025 static const unsigned long error_sharing_violation_sleep_ms = 250L;
1026 static const unsigned long error_file_too_large = 223L;
1027 static const unsigned long error_insufficient_buffer = 122L;
1028 static const unsigned long error_handle_eof = 38L;
1029 static const unsigned long semaphore_all_access = (0x000F0000L)|(0x00100000L)|0x3;
1030 static const unsigned long mutex_all_access     = (0x000F0000L)|(0x00100000L)|0x0001;
1031
1032 static const unsigned long page_readonly        = 0x02;
1033 static const unsigned long page_readwrite       = 0x04;
1034 static const unsigned long page_writecopy       = 0x08;
1035 static const unsigned long page_noaccess        = 0x01;
1036
1037 static const unsigned long standard_rights_required   = 0x000F0000L;
1038 static const unsigned long section_query              = 0x0001;
1039 static const unsigned long section_map_write          = 0x0002;
1040 static const unsigned long section_map_read           = 0x0004;
1041 static const unsigned long section_map_execute        = 0x0008;
1042 static const unsigned long section_extend_size        = 0x0010;
1043 static const unsigned long section_all_access         = standard_rights_required |
1044                                                         section_query            |
1045                                                         section_map_write        |
1046                                                         section_map_read         |
1047                                                         section_map_execute      |
1048                                                         section_extend_size;
1049
1050 static const unsigned long file_map_copy        = section_query;
1051 static const unsigned long file_map_write       = section_map_write;
1052 static const unsigned long file_map_read        = section_map_read;
1053 static const unsigned long file_map_all_access  = section_all_access;
1054 static const unsigned long delete_access = 0x00010000L;
1055 static const unsigned long file_flag_backup_semantics = 0x02000000;
1056 static const long file_flag_delete_on_close = 0x04000000;
1057
1058 //Native API constants
1059 static const unsigned long file_open_for_backup_intent = 0x00004000;
1060 static const int file_share_valid_flags = 0x00000007;
1061 static const long file_delete_on_close = 0x00001000L;
1062 static const long obj_case_insensitive = 0x00000040L;
1063 static const long delete_flag = 0x00010000L;
1064
1065 static const unsigned long movefile_copy_allowed            = 0x02;
1066 static const unsigned long movefile_delay_until_reboot      = 0x04;
1067 static const unsigned long movefile_replace_existing        = 0x01;
1068 static const unsigned long movefile_write_through           = 0x08;
1069 static const unsigned long movefile_create_hardlink         = 0x10;
1070 static const unsigned long movefile_fail_if_not_trackable   = 0x20;
1071
1072 static const unsigned long file_share_read      = 0x00000001;
1073 static const unsigned long file_share_write     = 0x00000002;
1074 static const unsigned long file_share_delete    = 0x00000004;
1075
1076 static const unsigned long file_attribute_readonly    = 0x00000001;
1077 static const unsigned long file_attribute_hidden      = 0x00000002;
1078 static const unsigned long file_attribute_system      = 0x00000004;
1079 static const unsigned long file_attribute_directory   = 0x00000010;
1080 static const unsigned long file_attribute_archive     = 0x00000020;
1081 static const unsigned long file_attribute_device      = 0x00000040;
1082 static const unsigned long file_attribute_normal      = 0x00000080;
1083 static const unsigned long file_attribute_temporary   = 0x00000100;
1084
1085 static const unsigned long generic_read         = 0x80000000L;
1086 static const unsigned long generic_write        = 0x40000000L;
1087
1088 static const unsigned long wait_object_0        = 0;
1089 static const unsigned long wait_abandoned       = 0x00000080L;
1090 static const unsigned long wait_timeout         = 258L;
1091 static const unsigned long wait_failed          = (unsigned long)0xFFFFFFFF;
1092
1093 static const unsigned long duplicate_close_source  = (unsigned long)0x00000001;
1094 static const unsigned long duplicate_same_access   = (unsigned long)0x00000002;
1095
1096 static const unsigned long format_message_allocate_buffer
1097    = (unsigned long)0x00000100;
1098 static const unsigned long format_message_ignore_inserts
1099    = (unsigned long)0x00000200;
1100 static const unsigned long format_message_from_string
1101    = (unsigned long)0x00000400;
1102 static const unsigned long format_message_from_hmodule
1103    = (unsigned long)0x00000800;
1104 static const unsigned long format_message_from_system
1105    = (unsigned long)0x00001000;
1106 static const unsigned long format_message_argument_array
1107    = (unsigned long)0x00002000;
1108 static const unsigned long format_message_max_width_mask
1109    = (unsigned long)0x000000FF;
1110 static const unsigned long lang_neutral         = (unsigned long)0x00;
1111 static const unsigned long sublang_default      = (unsigned long)0x01;
1112 static const unsigned long invalid_file_size    = (unsigned long)0xFFFFFFFF;
1113 static const unsigned long invalid_file_attributes =  ((unsigned long)-1);
1114 static       void * const  invalid_handle_value = ((void*)(long)(-1));
1115
1116 static const unsigned long file_type_char    =  0x0002L;
1117 static const unsigned long file_type_disk    =  0x0001L;
1118 static const unsigned long file_type_pipe    =  0x0003L;
1119 static const unsigned long file_type_remote  =  0x8000L;
1120 static const unsigned long file_type_unknown =  0x0000L;
1121
1122 static const unsigned long create_new        = 1;
1123 static const unsigned long create_always     = 2;
1124 static const unsigned long open_existing     = 3;
1125 static const unsigned long open_always       = 4;
1126 static const unsigned long truncate_existing = 5;
1127
1128 static const unsigned long file_begin     = 0;
1129 static const unsigned long file_current   = 1;
1130 static const unsigned long file_end       = 2;
1131
1132 static const unsigned long lockfile_fail_immediately  = 1;
1133 static const unsigned long lockfile_exclusive_lock    = 2;
1134 static const unsigned long error_lock_violation       = 33;
1135 static const unsigned long security_descriptor_revision = 1;
1136
1137 const unsigned long max_record_buffer_size = 0x10000L;   // 64K
1138 const unsigned long max_path = 260;
1139
1140 //Keys
1141 static const  hkey hkey_local_machine = (hkey)(unsigned long*)(long)(0x80000002);
1142 static unsigned long key_query_value    = 0x0001;
1143
1144 //COM API
1145 const unsigned long RPC_C_AUTHN_LEVEL_PKT_BIPC = 4;
1146 const unsigned long RPC_C_AUTHN_DEFAULT_BIPC = 0xffffffffL;
1147 const unsigned long RPC_C_AUTHZ_DEFAULT_BIPC = 0xffffffffL;
1148 const unsigned long RPC_C_IMP_LEVEL_IMPERSONATE_BIPC = 3;
1149 const   signed long EOAC_NONE_BIPC = 0;
1150 const   signed long CLSCTX_INPROC_SERVER_BIPC   = 0x1;
1151 const   signed long CLSCTX_LOCAL_SERVER_BIPC   = 0x4;
1152 const   signed long WBEM_FLAG_RETURN_IMMEDIATELY_BIPC = 0x10;
1153 const   signed long WBEM_FLAG_RETURN_WHEN_COMPLETE_BIPC = 0x0;
1154 const   signed long WBEM_FLAG_FORWARD_ONLY_BIPC = 0x20;
1155 const   signed long WBEM_INFINITE_BIPC = 0xffffffffL;
1156 const   signed long RPC_E_TOO_LATE_BIPC = 0x80010119L;
1157 const   signed long S_OK_BIPC = 0L;
1158 const   signed long S_FALSE_BIPC = 1;
1159 const   signed long RPC_E_CHANGED_MODE_BIPC = 0x80010106L;
1160 const unsigned long COINIT_APARTMENTTHREADED_BIPC   = 0x2;
1161 const unsigned long COINIT_MULTITHREADED_BIPC       = 0x0;
1162 const unsigned long COINIT_DISABLE_OLE1DDE_BIPC     = 0x4;
1163 const unsigned long COINIT_SPEED_OVER_MEMORY_BIPC   = 0x4;
1164
1165
1166 //If the user needs to change default COM initialization model,
1167 //it can define BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL to one of these:
1168 //
1169 // COINIT_APARTMENTTHREADED_BIPC
1170 // COINIT_MULTITHREADED_BIPC
1171 // COINIT_DISABLE_OLE1DDE_BIPC
1172 // COINIT_SPEED_OVER_MEMORY_BIPC
1173 #if !defined(BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL)
1174    #define BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL COINIT_APARTMENTTHREADED_BIPC
1175 #elif (BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL != COINIT_APARTMENTTHREADED_BIPC) &&\
1176       (BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL != COINIT_MULTITHREADED_BIPC)     &&\
1177       (BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL != COINIT_DISABLE_OLE1DDE_BIPC)   &&\
1178       (BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL != COINIT_SPEED_OVER_MEMORY_BIPC)
1179    #error "Wrong value for BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL macro"
1180 #endif
1181
1182 const GUID_BIPC CLSID_WbemAdministrativeLocator =
1183    { 0xcb8555cc, 0x9128, 0x11d1, {0xad, 0x9b, 0x00, 0xc0, 0x4f, 0xd8, 0xfd, 0xff}};
1184
1185 const GUID_BIPC IID_IUnknown = { 0x00000000, 0x0000, 0x0000, {0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}};
1186
1187 static const unsigned long eventlog_sequential_read = 0x0001;
1188 static const unsigned long eventlog_backwards_read  = 0x0008;
1189
1190 }  //namespace winapi {
1191 }  //namespace interprocess  {
1192 }  //namespace boost  {
1193
1194
1195 namespace boost {
1196 namespace interprocess {
1197 namespace winapi {
1198
1199 inline unsigned long get_last_error()
1200 {  return GetLastError();  }
1201
1202 inline void set_last_error(unsigned long err)
1203 {  return SetLastError(err);  }
1204
1205 inline unsigned long format_message
1206    (unsigned long dwFlags, const void *lpSource,
1207     unsigned long dwMessageId, unsigned long dwLanguageId,
1208     char *lpBuffer, unsigned long nSize, std::va_list *Arguments)
1209 {
1210    return FormatMessageA
1211       (dwFlags, lpSource, dwMessageId, dwLanguageId, lpBuffer, nSize, Arguments);
1212 }
1213
1214 //And now, wrapper functions
1215 inline void * local_free(void *hmem)
1216 {  return LocalFree(hmem); }
1217
1218 inline unsigned long make_lang_id(unsigned long p, unsigned long s)
1219 {  return ((((unsigned short)(s)) << 10) | (unsigned short)(p));   }
1220
1221 inline void sched_yield()
1222 {
1223    if(!SwitchToThread()){
1224       Sleep(0);
1225    }
1226 }
1227
1228 inline void sleep_tick()
1229 {  Sleep(1);   }
1230
1231 inline void sleep(unsigned long ms)
1232 {  Sleep(ms);  }
1233
1234 inline unsigned long get_current_thread_id()
1235 {  return GetCurrentThreadId();  }
1236
1237 inline bool get_process_times
1238    ( void *hProcess, interprocess_filetime* lpCreationTime
1239    , interprocess_filetime *lpExitTime, interprocess_filetime *lpKernelTime
1240    , interprocess_filetime *lpUserTime )
1241 {  return 0 != GetProcessTimes(hProcess, lpCreationTime, lpExitTime, lpKernelTime, lpUserTime); }
1242
1243 inline unsigned long get_current_process_id()
1244 {  return GetCurrentProcessId();  }
1245
1246 inline unsigned int close_handle(void* handle)
1247 {  return CloseHandle(handle);   }
1248
1249 inline void * find_first_file(const char *lpFileName, win32_find_data *lpFindFileData)
1250 {  return FindFirstFileA(lpFileName, lpFindFileData);   }
1251
1252 inline bool find_next_file(void *hFindFile, win32_find_data *lpFindFileData)
1253 {  return FindNextFileA(hFindFile, lpFindFileData) != 0;   }
1254
1255 inline bool find_close(void *handle)
1256 {  return FindClose(handle) != 0;   }
1257
1258 inline bool duplicate_current_process_handle
1259    (void *hSourceHandle, void **lpTargetHandle)
1260 {
1261    return 0 != DuplicateHandle
1262       ( GetCurrentProcess(),  hSourceHandle,    GetCurrentProcess()
1263       , lpTargetHandle,       0,                0
1264       , duplicate_same_access);
1265 }
1266
1267 inline unsigned long get_file_type(void *hFile)
1268 {
1269    return GetFileType(hFile);
1270 }
1271
1272 /*
1273 inline void get_system_time_as_file_time(interprocess_filetime *filetime)
1274 {  GetSystemTimeAsFileTime(filetime);  }
1275
1276 inline bool file_time_to_local_file_time
1277    (const interprocess_filetime *in, const interprocess_filetime *out)
1278 {  return 0 != FileTimeToLocalFileTime(in, out);  }
1279 */
1280 inline void *open_or_create_mutex(const char *name, bool initial_owner, interprocess_security_attributes *attr)
1281 {  return CreateMutexA(attr, (int)initial_owner, name);  }
1282
1283 inline unsigned long wait_for_single_object(void *handle, unsigned long time)
1284 {  return WaitForSingleObject(handle, time); }
1285
1286 inline int release_mutex(void *handle)
1287 {  return ReleaseMutex(handle);  }
1288
1289 inline int unmap_view_of_file(void *address)
1290 {  return UnmapViewOfFile(address); }
1291
1292 inline void *open_or_create_semaphore(const char *name, long initial_count, long maximum_count, interprocess_security_attributes *attr)
1293 {  return CreateSemaphoreA(attr, initial_count, maximum_count, name);  }
1294
1295 inline void *open_semaphore(const char *name)
1296 {  return OpenSemaphoreA(semaphore_all_access, 0, name);  }
1297
1298 inline int release_semaphore(void *handle, long release_count, long *prev_count)
1299 {  return ReleaseSemaphore(handle, release_count, prev_count); }
1300
1301 class interprocess_all_access_security
1302 {
1303    interprocess_security_attributes sa;
1304    interprocess_security_descriptor sd;
1305    bool initialized;
1306
1307    public:
1308    interprocess_all_access_security()
1309       : initialized(false)
1310    {
1311       if(!InitializeSecurityDescriptor(&sd, security_descriptor_revision))
1312          return;
1313       if(!SetSecurityDescriptorDacl(&sd, true, 0, false))
1314          return;
1315       sa.lpSecurityDescriptor = &sd;
1316       sa.nLength = sizeof(interprocess_security_attributes);
1317       sa.bInheritHandle = false;
1318       initialized = false;
1319    }
1320
1321    interprocess_security_attributes *get_attributes()
1322    {  return &sa; }
1323 };
1324
1325 inline void * create_file_mapping (void * handle, unsigned long access, ::boost::ulong_long_type file_offset, const char * name, interprocess_security_attributes *psec)
1326 {
1327    const unsigned long high_size(file_offset >> 32), low_size((boost::uint32_t)file_offset);
1328    return CreateFileMappingA (handle, psec, access, high_size, low_size, name);
1329 }
1330
1331 inline void * open_file_mapping (unsigned long access, const char *name)
1332 {  return OpenFileMappingA (access, 0, name);   }
1333
1334 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)
1335 {
1336    const unsigned long offset_low  = (unsigned long)(offset & ((::boost::ulong_long_type)0xFFFFFFFF));
1337    const unsigned long offset_high = offset >> 32;
1338    return MapViewOfFileEx(handle, file_access, offset_high, offset_low, numbytes, base_addr);
1339 }
1340
1341 inline void *create_file(const char *name, unsigned long access, unsigned long creation_flags, unsigned long attributes, interprocess_security_attributes *psec)
1342 {
1343    for (unsigned int attempt(0); attempt < error_sharing_violation_tries; ++attempt){
1344       void * const handle = CreateFileA(name, access,
1345                                         file_share_read | file_share_write | file_share_delete,
1346                                         psec, creation_flags, attributes, 0);
1347       bool const invalid(invalid_handle_value == handle);
1348       if (!invalid){
1349          return handle;
1350       }
1351       if (error_sharing_violation != get_last_error()){
1352          return handle;
1353       }
1354       sleep(error_sharing_violation_sleep_ms);
1355    }
1356    return invalid_handle_value;
1357 }
1358
1359 inline void get_system_info(system_info *info)
1360 {  GetSystemInfo(info); }
1361
1362 inline bool flush_view_of_file(void *base_addr, std::size_t numbytes)
1363 {  return 0 != FlushViewOfFile(base_addr, numbytes); }
1364
1365 inline bool virtual_unlock(void *base_addr, std::size_t numbytes)
1366 {  return 0 != VirtualUnlock(base_addr, numbytes); }
1367
1368 inline bool virtual_protect(void *base_addr, std::size_t numbytes, unsigned long flNewProtect, unsigned long &lpflOldProtect)
1369 {  return 0 != VirtualProtect(base_addr, numbytes, flNewProtect, &lpflOldProtect); }
1370
1371 inline bool flush_file_buffers(void *handle)
1372 {  return 0 != FlushFileBuffers(handle); }
1373
1374 inline bool get_file_size(void *handle, __int64 &size)
1375 {  return 0 != GetFileSizeEx(handle, (large_integer*)&size);  }
1376
1377 inline bool create_directory(const char *name)
1378 {
1379    interprocess_all_access_security sec;
1380    return 0 != CreateDirectoryA(name, sec.get_attributes());
1381 }
1382
1383 inline bool remove_directory(const char *lpPathName)
1384 {  return 0 != RemoveDirectoryA(lpPathName);   }
1385
1386 inline unsigned long get_temp_path(unsigned long length, char *buffer)
1387 {  return GetTempPathA(length, buffer);   }
1388
1389 inline int set_end_of_file(void *handle)
1390 {  return 0 != SetEndOfFile(handle);   }
1391
1392 inline bool set_file_pointer_ex(void *handle, __int64 distance, __int64 *new_file_pointer, unsigned long move_method)
1393 {
1394    large_integer d; d.QuadPart = distance;
1395    return 0 != SetFilePointerEx(handle, d, (large_integer*)new_file_pointer, move_method);
1396 }
1397
1398 inline bool lock_file_ex(void *hnd, unsigned long flags, unsigned long reserved, unsigned long size_low, unsigned long size_high, interprocess_overlapped *overlapped)
1399 {  return 0 != LockFileEx(hnd, flags, reserved, size_low, size_high, overlapped); }
1400
1401 inline bool unlock_file_ex(void *hnd, unsigned long reserved, unsigned long size_low, unsigned long size_high, interprocess_overlapped *overlapped)
1402 {  return 0 != UnlockFileEx(hnd, reserved, size_low, size_high, overlapped);  }
1403
1404 inline bool write_file(void *hnd, const void *buffer, unsigned long bytes_to_write, unsigned long *bytes_written, interprocess_overlapped* overlapped)
1405 {  return 0 != WriteFile(hnd, buffer, bytes_to_write, bytes_written, overlapped);  }
1406
1407 inline bool read_file(void *hnd, void *buffer, unsigned long bytes_to_read, unsigned long *bytes_read, interprocess_overlapped* overlapped)
1408 {  return 0 != ReadFile(hnd, buffer, bytes_to_read, bytes_read, overlapped);  }
1409
1410 inline bool get_file_information_by_handle(void *hnd, interprocess_by_handle_file_information *info)
1411 {  return 0 != GetFileInformationByHandle(hnd, info);  }
1412
1413 inline long interlocked_increment(long volatile *addr)
1414 {  return BOOST_INTERLOCKED_INCREMENT(const_cast<long*>(addr));  }
1415
1416 inline long interlocked_decrement(long volatile *addr)
1417 {  return BOOST_INTERLOCKED_DECREMENT(const_cast<long*>(addr));  }
1418
1419 inline long interlocked_compare_exchange(long volatile *addr, long val1, long val2)
1420 {  return BOOST_INTERLOCKED_COMPARE_EXCHANGE(const_cast<long*>(addr), val1, val2);  }
1421
1422 inline long interlocked_exchange_add(long volatile* addend, long value)
1423 {  return BOOST_INTERLOCKED_EXCHANGE_ADD(const_cast<long*>(addend), value);  }
1424
1425 inline long interlocked_exchange(long volatile* addend, long value)
1426 {  return BOOST_INTERLOCKED_EXCHANGE(const_cast<long*>(addend), value);  }
1427
1428 //Forward functions
1429 inline hmodule load_library(const char *name)
1430 {  return LoadLibraryA(name); }
1431
1432 inline bool free_library(hmodule module)
1433 {  return 0 != FreeLibrary(module); }
1434
1435 inline farproc_t get_proc_address(hmodule module, const char *name)
1436 {  return GetProcAddress(module, name); }
1437
1438 inline void *get_current_process()
1439 {  return GetCurrentProcess();  }
1440
1441 inline hmodule get_module_handle(const char *name)
1442 {  return GetModuleHandleA(name); }
1443
1444 inline long reg_open_key_ex(hkey hKey, const char *lpSubKey, unsigned long ulOptions, unsigned long samDesired, hkey *phkResult)
1445 {  return RegOpenKeyExA(hKey, lpSubKey, ulOptions, samDesired, phkResult); }
1446
1447 inline long reg_query_value_ex(hkey hKey, const char *lpValueName, unsigned long*lpReserved, unsigned long*lpType, unsigned char *lpData, unsigned long*lpcbData)
1448 {  return RegQueryValueExA(hKey, lpValueName, lpReserved, lpType, lpData, lpcbData); }
1449
1450 inline long reg_close_key(hkey hKey)
1451 {  return RegCloseKey(hKey); }
1452
1453 inline void initialize_object_attributes
1454 ( object_attributes_t *pobject_attr, unicode_string_t *name
1455  , unsigned long attr, void *rootdir, void *security_descr)
1456
1457 {
1458    pobject_attr->Length = sizeof(object_attributes_t);
1459    pobject_attr->RootDirectory = rootdir;
1460    pobject_attr->Attributes = attr;
1461    pobject_attr->ObjectName = name;
1462    pobject_attr->SecurityDescriptor = security_descr;
1463    pobject_attr->SecurityQualityOfService = 0;
1464 }
1465
1466 inline void rtl_init_empty_unicode_string(unicode_string_t *ucStr, wchar_t *buf, unsigned short bufSize)
1467 {
1468    ucStr->Buffer = buf;
1469    ucStr->Length = 0;
1470    ucStr->MaximumLength = bufSize;
1471 }
1472
1473 //A class that locates and caches loaded DLL function addresses.
1474 template<int Dummy>
1475 struct function_address_holder
1476 {
1477    enum  { NtSetInformationFile
1478          , NtQuerySystemInformation
1479          , NtQueryObject
1480          , NtQuerySemaphore
1481          , NtQuerySection
1482          , NtOpenFile
1483          , NtClose
1484          , NtQueryTimerResolution
1485          , NtSetTimerResolution
1486          , QueryPerformanceCounter
1487          , QueryPerformanceFrequency
1488          , NumFunction
1489          };
1490    enum { NtDll_dll, Kernel32_dll, NumModule };
1491
1492    private:
1493    static const char *FunctionNames[NumFunction];
1494    static const char *ModuleNames[NumModule];
1495    static farproc_t FunctionAddresses[NumFunction];
1496    static unsigned int FunctionModules[NumFunction];
1497    static volatile long FunctionStates[NumFunction];
1498    static hmodule ModuleAddresses[NumModule];
1499    static volatile long ModuleStates[NumModule];
1500
1501    static hmodule get_module_from_id(unsigned int id)
1502    {
1503       BOOST_ASSERT(id < (unsigned int)NumModule);
1504       hmodule addr = get_module_handle(ModuleNames[id]);
1505       BOOST_ASSERT(addr);
1506       return addr;
1507    }
1508
1509    static hmodule get_module(const unsigned int id)
1510    {
1511       BOOST_ASSERT(id < (unsigned int)NumModule);
1512       for(unsigned i = 0; ModuleStates[id] < 2; ++i){
1513          if(interlocked_compare_exchange(&ModuleStates[id], 1, 0) == 0){
1514             ModuleAddresses[id] = get_module_from_id(id);
1515             interlocked_increment(&ModuleStates[id]);
1516             break;
1517          }
1518          else if(i & 1){
1519             sched_yield();
1520          }
1521          else{
1522             sleep_tick();
1523          }
1524       }
1525       return ModuleAddresses[id];
1526    }
1527
1528    static farproc_t get_address_from_dll(const unsigned int id)
1529    {
1530       BOOST_ASSERT(id < (unsigned int)NumFunction);
1531       farproc_t addr = get_proc_address(get_module(FunctionModules[id]), FunctionNames[id]);
1532       BOOST_ASSERT(addr);
1533       return addr;
1534    }
1535
1536    public:
1537    static farproc_t get(const unsigned int id)
1538    {
1539       BOOST_ASSERT(id < (unsigned int)NumFunction);
1540       for(unsigned i = 0; FunctionStates[id] < 2; ++i){
1541          if(interlocked_compare_exchange(&FunctionStates[id], 1, 0) == 0){
1542             FunctionAddresses[id] = get_address_from_dll(id);
1543             interlocked_increment(&FunctionStates[id]);
1544             break;
1545          }
1546          else if(i & 1){
1547             sched_yield();
1548          }
1549          else{
1550             sleep_tick();
1551          }
1552       }
1553       return FunctionAddresses[id];
1554    }
1555 };
1556
1557 template<int Dummy>
1558 const char *function_address_holder<Dummy>::FunctionNames[function_address_holder<Dummy>::NumFunction] =
1559 {
1560    "NtSetInformationFile",
1561    "NtQuerySystemInformation",
1562    "NtQueryObject",
1563    "NtQuerySemaphore",
1564    "NtQuerySection",
1565    "NtOpenFile",
1566    "NtClose",
1567    "NtQueryTimerResolution",
1568    "NtSetTimerResolution",
1569    "QueryPerformanceCounter",
1570    "QueryPerformanceFrequency"
1571 };
1572
1573 template<int Dummy>
1574 unsigned int function_address_holder<Dummy>::FunctionModules[function_address_holder<Dummy>::NumFunction] =
1575 {
1576    NtDll_dll,
1577    NtDll_dll,
1578    NtDll_dll,
1579    NtDll_dll,
1580    NtDll_dll,
1581    NtDll_dll,
1582    NtDll_dll,
1583    NtDll_dll,
1584    NtDll_dll,
1585    Kernel32_dll,
1586    Kernel32_dll
1587 };
1588
1589 template<int Dummy>
1590 const char *function_address_holder<Dummy>::ModuleNames[function_address_holder<Dummy>::NumModule] =
1591 {
1592    "ntdll.dll",
1593    "kernel32.dll"
1594 };
1595
1596
1597 template<int Dummy>
1598 farproc_t function_address_holder<Dummy>::FunctionAddresses[function_address_holder<Dummy>::NumFunction];
1599
1600 template<int Dummy>
1601 volatile long function_address_holder<Dummy>::FunctionStates[function_address_holder<Dummy>::NumFunction];
1602
1603 template<int Dummy>
1604 hmodule function_address_holder<Dummy>::ModuleAddresses[function_address_holder<Dummy>::NumModule];
1605
1606 template<int Dummy>
1607 volatile long function_address_holder<Dummy>::ModuleStates[function_address_holder<Dummy>::NumModule];
1608
1609
1610 struct dll_func
1611    : public function_address_holder<0>
1612 {};
1613
1614 //Complex winapi based functions...
1615 struct library_unloader
1616 {
1617    hmodule lib_;
1618    library_unloader(hmodule module) : lib_(module){}
1619    ~library_unloader(){ free_library(lib_);  }
1620 };
1621
1622
1623 inline bool get_system_time_of_day_information(system_timeofday_information &info)
1624 {
1625    NtQuerySystemInformation_t pNtQuerySystemInformation = (NtQuerySystemInformation_t)
1626          dll_func::get(dll_func::NtQuerySystemInformation);
1627    unsigned long res;
1628    long status = pNtQuerySystemInformation(system_time_of_day_information, &info, sizeof(info), &res);
1629    if(status){
1630       return false;
1631    }
1632    return true;
1633 }
1634
1635 inline bool get_boot_time(unsigned char (&bootstamp) [BootstampLength])
1636 {
1637    system_timeofday_information info;
1638    bool ret = get_system_time_of_day_information(info);
1639    if(!ret){
1640       return false;
1641    }
1642    std::memcpy(&bootstamp[0], &info.Reserved1, sizeof(bootstamp));
1643    return true;
1644 }
1645
1646 inline bool get_boot_and_system_time(unsigned char (&bootsystemstamp) [BootAndSystemstampLength])
1647 {
1648    system_timeofday_information info;
1649    bool ret = get_system_time_of_day_information(info);
1650    if(!ret){
1651       return false;
1652    }
1653    std::memcpy(&bootsystemstamp[0], &info.Reserved1, sizeof(bootsystemstamp));
1654    return true;
1655 }
1656
1657 inline bool get_boot_time_str(char *bootstamp_str, std::size_t &s)
1658    //will write BootstampLength chars
1659 {
1660    if(s < (BootstampLength*2))
1661       return false;
1662    system_timeofday_information info;
1663    bool ret = get_system_time_of_day_information(info);
1664    if(!ret){
1665       return false;
1666    }
1667    const char Characters [] =
1668       { '0', '1', '2', '3', '4', '5', '6', '7'
1669       , '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
1670    std::size_t char_counter = 0;
1671    for(std::size_t i = 0; i != static_cast<std::size_t>(BootstampLength); ++i){
1672       bootstamp_str[char_counter++] = Characters[(info.Reserved1[i]&0xF0)>>4];
1673       bootstamp_str[char_counter++] = Characters[(info.Reserved1[i]&0x0F)];
1674    }
1675    s = BootstampLength*2;
1676    return true;
1677 }
1678
1679 //Writes the hexadecimal value of the buffer, in the wide character string.
1680 //str must be twice length
1681 inline void buffer_to_wide_str(const void *buf, std::size_t length, wchar_t *str)
1682 {
1683    const wchar_t Characters [] =
1684       { L'0', L'1', L'2', L'3', L'4', L'5', L'6', L'7'
1685       , L'8', L'9', L'A', L'B', L'C', L'D', L'E', L'F' };
1686    std::size_t char_counter = 0;
1687    const char *chbuf = static_cast<const char *>(buf);
1688    for(std::size_t i = 0; i != length; ++i){
1689       str[char_counter++] = Characters[(chbuf[i]&0xF0)>>4];
1690       str[char_counter++] = Characters[(chbuf[i]&0x0F)];
1691    }
1692 }
1693
1694 inline bool get_boot_and_system_time_wstr(wchar_t *bootsystemstamp, std::size_t &s)
1695    //will write BootAndSystemstampLength chars
1696 {
1697    if(s < (BootAndSystemstampLength*2))
1698       return false;
1699    system_timeofday_information info;
1700    bool ret = get_system_time_of_day_information(info);
1701    if(!ret){
1702       return false;
1703    }
1704
1705    buffer_to_wide_str(&info.Reserved1[0], BootAndSystemstampLength, bootsystemstamp);
1706    s = BootAndSystemstampLength*2;
1707    return true;
1708 }
1709
1710 class handle_closer
1711 {
1712    void *handle_;
1713    handle_closer(const handle_closer &);
1714    handle_closer& operator=(const handle_closer &);
1715    public:
1716    explicit handle_closer(void *handle) : handle_(handle){}
1717    ~handle_closer()
1718    {  close_handle(handle_);  }
1719 };
1720
1721 class eventlog_handle_closer
1722 {
1723    void *handle_;
1724    eventlog_handle_closer(const handle_closer &);
1725    eventlog_handle_closer& operator=(const eventlog_handle_closer &);
1726    public:
1727    explicit eventlog_handle_closer(void *handle) : handle_(handle){}
1728    ~eventlog_handle_closer()
1729    {  CloseEventLog(handle_);  }
1730 };
1731
1732 union ntquery_mem_t
1733 {
1734    object_name_information_t name;
1735    struct ren_t
1736    {
1737       file_rename_information_t info;
1738       wchar_t buf[1];
1739    } ren;
1740 };
1741
1742 class nt_query_mem_deleter
1743 {
1744    static const std::size_t rename_offset = offsetof(ntquery_mem_t, ren.info.FileName) -
1745       offsetof(ntquery_mem_t, name.Name.Buffer);
1746    //                                           Timestamp                      process id              atomic count
1747    static const std::size_t rename_suffix =
1748       (SystemTimeOfDayInfoLength + sizeof(unsigned long) + sizeof(boost::uint32_t))*2;
1749
1750    public:
1751    nt_query_mem_deleter(std::size_t object_name_information_size)
1752       : m_size(object_name_information_size + rename_offset + rename_suffix)
1753       , m_buf(new char [m_size])
1754    {}
1755
1756    ~nt_query_mem_deleter()
1757    {
1758       delete[]m_buf;
1759    }
1760
1761    void realloc_mem(std::size_t num_bytes)
1762    {
1763       num_bytes += rename_suffix + rename_offset;
1764       char *buf = m_buf;
1765       m_buf = new char[num_bytes];
1766       delete[]buf;
1767       m_size = num_bytes;
1768    }
1769
1770    ntquery_mem_t *query_mem() const
1771    {  return static_cast<ntquery_mem_t *>(static_cast<void*>(m_buf));  }
1772
1773    unsigned long object_name_information_size() const
1774    {
1775       return static_cast<unsigned long>(m_size - rename_offset - SystemTimeOfDayInfoLength*2);
1776    }
1777
1778    std::size_t file_rename_information_size() const
1779    {  return static_cast<unsigned long>(m_size);  }
1780
1781    private:
1782    std::size_t m_size;
1783    char *m_buf;
1784 };
1785
1786 class c_heap_deleter
1787 {
1788    public:
1789    c_heap_deleter(std::size_t size)
1790       : m_buf(::malloc(size))
1791    {}
1792
1793    ~c_heap_deleter()
1794    {
1795       if(m_buf) ::free(m_buf);
1796    }
1797
1798    void realloc_mem(std::size_t num_bytes)
1799    {
1800       void *buf = ::realloc(m_buf, num_bytes);
1801       if(!buf){
1802          free(m_buf);
1803          m_buf = 0;
1804       }
1805    }
1806
1807    void *get() const
1808    {  return m_buf;  }
1809
1810    private:
1811    void *m_buf;
1812 };
1813
1814 inline bool unlink_file(const char *filename)
1815 {
1816    //Don't try to optimize doing a DeleteFile first
1817    //as there are interactions with permissions and
1818    //in-use files.
1819    //
1820    //if(!delete_file(filename)){
1821    //   (...)
1822    //
1823
1824    //This functions tries to emulate UNIX unlink semantics in windows.
1825    //
1826    //- Open the file and mark the handle as delete-on-close
1827    //- Rename the file to an arbitrary name based on a random number
1828    //- Close the handle. If there are no file users, it will be deleted.
1829    //  Otherwise it will be used by already connected handles but the
1830    //  file name can't be used to open this file again
1831    try{
1832       NtSetInformationFile_t pNtSetInformationFile =
1833          (NtSetInformationFile_t)dll_func::get(dll_func::NtSetInformationFile);
1834
1835       NtQueryObject_t pNtQueryObject = (NtQueryObject_t)dll_func::get(dll_func::NtQueryObject);
1836
1837       //First step: Obtain a handle to the file using Win32 rules. This resolves relative paths
1838       void *fh = create_file(filename, generic_read | delete_access, open_existing, 0, 0);
1839       if(fh == invalid_handle_value){
1840          return false;
1841       }
1842
1843       handle_closer h_closer(fh);
1844       {
1845          //Obtain name length
1846          unsigned long size;
1847          const std::size_t initial_string_mem = 512u;
1848
1849          nt_query_mem_deleter nt_query_mem(sizeof(ntquery_mem_t)+initial_string_mem);
1850          //Obtain file name with guessed length
1851          if(pNtQueryObject(fh, object_name_information, nt_query_mem.query_mem(), nt_query_mem.object_name_information_size(), &size)){
1852             //Obtain file name with exact length buffer
1853             nt_query_mem.realloc_mem(size);
1854             if(pNtQueryObject(fh, object_name_information, nt_query_mem.query_mem(), nt_query_mem.object_name_information_size(), &size)){
1855                return false;
1856             }
1857          }
1858          ntquery_mem_t *pmem = nt_query_mem.query_mem();
1859          file_rename_information_t *pfri = &pmem->ren.info;
1860          const std::size_t RenMaxNumChars =
1861             (((char*)(pmem) + nt_query_mem.file_rename_information_size()) - (char*)&pmem->ren.info.FileName[0])/sizeof(wchar_t);
1862
1863          //Copy filename to the rename member
1864          std::memmove(pmem->ren.info.FileName, pmem->name.Name.Buffer, pmem->name.Name.Length);
1865          std::size_t filename_string_length = pmem->name.Name.Length/sizeof(wchar_t);
1866
1867          //Search '\\' character to replace from it
1868          for(std::size_t i = filename_string_length; i != 0; --filename_string_length){
1869             if(pmem->ren.info.FileName[--i] == L'\\')
1870                break;
1871          }
1872
1873          //Add random number
1874          std::size_t s = RenMaxNumChars - filename_string_length;
1875          if(!get_boot_and_system_time_wstr(&pfri->FileName[filename_string_length], s)){
1876             return false;
1877          }
1878          filename_string_length += s;
1879
1880          //Sometimes the precission of the timestamp is not enough and we need to add another random number.
1881          //The process id (to exclude concurrent processes) and an atomic count (to exclude concurrent threads).
1882          //should be enough
1883          const unsigned long pid = get_current_process_id();
1884          buffer_to_wide_str(&pid, sizeof(pid), &pfri->FileName[filename_string_length]);
1885          filename_string_length += sizeof(pid)*2;
1886
1887          static volatile boost::uint32_t u32_count = 0;
1888          interlocked_decrement(reinterpret_cast<volatile long*>(&u32_count));
1889          buffer_to_wide_str(const_cast<const boost::uint32_t *>(&u32_count), sizeof(boost::uint32_t), &pfri->FileName[filename_string_length]);
1890          filename_string_length += sizeof(boost::uint32_t)*2;
1891
1892          //Fill rename information (FileNameLength is in bytes)
1893          pfri->FileNameLength = static_cast<unsigned long>(sizeof(wchar_t)*(filename_string_length));
1894          pfri->Replace = 1;
1895          pfri->RootDir = 0;
1896
1897          //Cange the name of the in-use file...
1898          io_status_block_t io;
1899          if(0 != pNtSetInformationFile(fh, &io, pfri, nt_query_mem.file_rename_information_size(), file_rename_information)){
1900             return false;
1901          }
1902       }
1903       //...and mark it as delete-on-close
1904       {
1905          //Don't use pNtSetInformationFile with file_disposition_information as it can return STATUS_CANNOT_DELETE
1906          //if the file is still mapped. Reopen it with NtOpenFile and file_delete_on_close
1907          NtOpenFile_t pNtOpenFile = (NtOpenFile_t)dll_func::get(dll_func::NtOpenFile);
1908          NtClose_t pNtClose = (NtClose_t)dll_func::get(dll_func::NtClose);
1909          const wchar_t empty_str [] = L"";
1910          unicode_string_t ustring = { sizeof(empty_str) - sizeof (wchar_t)   //length in bytes without null
1911                                     , sizeof(empty_str)   //total size in bytes of memory allocated for Buffer.
1912                                     , const_cast<wchar_t*>(empty_str)
1913                                     };
1914          object_attributes_t object_attr;
1915          initialize_object_attributes(&object_attr, &ustring, 0, fh, 0);
1916          void* fh2 = 0;
1917          io_status_block_t io;
1918          pNtOpenFile( &fh2, delete_flag, &object_attr, &io
1919                     , file_share_read | file_share_write | file_share_delete, file_delete_on_close);
1920          pNtClose(fh2);
1921          //Even if NtOpenFile fails, the file was renamed and the original no longer exists, so return a success status
1922          return true;
1923       }
1924    }
1925    catch(...){
1926       return false;
1927    }
1928    return true;
1929 }
1930
1931 struct reg_closer
1932 {
1933    hkey key_;
1934    reg_closer(hkey key) : key_(key){}
1935    ~reg_closer(){ reg_close_key(key_);  }
1936 };
1937
1938 inline void get_shared_documents_folder(std::string &s)
1939 {
1940    #if 1 //Original registry search code
1941    s.clear();
1942    hkey key;
1943    if (reg_open_key_ex( hkey_local_machine
1944                      , "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders"
1945                      , 0
1946                      , key_query_value
1947                      , &key) == 0){
1948       reg_closer key_closer(key);
1949
1950       //Obtain the value
1951       unsigned long size;
1952       unsigned long type;
1953       const char *const reg_value = "Common AppData";
1954       //long err = (*pRegQueryValue)( key, reg_value, 0, &type, 0, &size);
1955       long err = reg_query_value_ex( key, reg_value, 0, &type, 0, &size);
1956       if(!err){
1957          //Size includes terminating NULL
1958          s.resize(size);
1959          //err = (*pRegQueryValue)( key, reg_value, 0, &type, (unsigned char*)(&s[0]), &size);
1960          err = reg_query_value_ex( key, reg_value, 0, &type, (unsigned char*)(&s[0]), &size);
1961          if(!err)
1962             s.erase(s.end()-1);
1963          (void)err;
1964       }
1965    }
1966    #else //registry alternative: SHGetFolderPath
1967    const int BIPC_CSIDL_COMMON_APPDATA = 0x0023;  // All Users\Application Data
1968    const int BIPC_CSIDL_FLAG_CREATE = 0x8000;     // new for Win2K, or this in to force creation of folder
1969    const int BIPC_SHGFP_TYPE_CURRENT  = 0;        // current value for user, verify it exists
1970
1971    s.clear();
1972    char szPath[max_path];
1973    if(0 == SHGetFolderPathA(0, BIPC_CSIDL_COMMON_APPDATA | BIPC_CSIDL_FLAG_CREATE, 0, BIPC_SHGFP_TYPE_CURRENT, szPath)){
1974       s = szPath;
1975    }
1976
1977    #endif
1978 }
1979
1980 inline void get_registry_value(const char *folder, const char *value_key, std::vector<unsigned char> &s)
1981 {
1982    s.clear();
1983    hkey key;
1984    if (reg_open_key_ex( hkey_local_machine
1985                      , folder
1986                      , 0
1987                      , key_query_value
1988                      , &key) == 0){
1989       reg_closer key_closer(key);
1990
1991       //Obtain the value
1992       unsigned long size;
1993       unsigned long type;
1994       const char *const reg_value = value_key;
1995       //long err = (*pRegQueryValue)( key, reg_value, 0, &type, 0, &size);
1996       long err = reg_query_value_ex( key, reg_value, 0, &type, 0, &size);
1997       if(!err){
1998          //Size includes terminating NULL
1999          s.resize(size);
2000          //err = (*pRegQueryValue)( key, reg_value, 0, &type, (unsigned char*)(&s[0]), &size);
2001          err = reg_query_value_ex( key, reg_value, 0, &type, (unsigned char*)(&s[0]), &size);
2002          if(!err)
2003             s.erase(s.end()-1);
2004          (void)err;
2005       }
2006    }
2007 }
2008
2009 #if defined(BOOST_INTERPROCESS_BOOTSTAMP_IS_LASTBOOTUPTIME)
2010
2011 struct co_uninitializer
2012 {
2013    co_uninitializer(bool b_uninitialize)
2014       : m_b_uninitialize(b_uninitialize)
2015    {}
2016
2017    ~co_uninitializer()
2018    {
2019       if(m_b_uninitialize){
2020          CoUninitialize();
2021       }
2022    }
2023
2024    private:
2025    const bool m_b_uninitialize;
2026 };
2027
2028 template<class Object>
2029 struct com_releaser
2030 {
2031    Object *&object_;
2032    com_releaser(Object *&object) : object_(object) {}
2033    ~com_releaser()  {  object_->Release();    object_ = 0;  }
2034 };
2035
2036 inline bool get_wmi_class_attribute( std::wstring& strValue, const wchar_t *wmi_class, const wchar_t *wmi_class_var)
2037 {
2038    //See example http://msdn.microsoft.com/en-us/library/aa390423%28v=VS.85%29.aspx
2039    //
2040    //See BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL definition if you need to change the
2041    //default value of this macro in your application
2042    long co_init_ret = CoInitializeEx(0, BOOST_INTERPROCESS_WINDOWS_COINIT_MODEL);
2043    if(co_init_ret != S_OK_BIPC && co_init_ret != S_FALSE_BIPC && co_init_ret != RPC_E_CHANGED_MODE_BIPC)
2044       return false;
2045    co_uninitializer co_initialize_end(co_init_ret != RPC_E_CHANGED_MODE_BIPC);
2046    (void)co_initialize_end;
2047
2048    bool bRet = false;
2049    long sec_init_ret = CoInitializeSecurity
2050       ( 0   //pVoid
2051       ,-1   //cAuthSvc
2052       , 0   //asAuthSvc
2053       , 0   //pReserved1
2054       , RPC_C_AUTHN_LEVEL_PKT_BIPC //dwAuthnLevel
2055       , RPC_C_IMP_LEVEL_IMPERSONATE_BIPC //dwImpLevel
2056       , 0   //pAuthList
2057       , EOAC_NONE_BIPC //dwCapabilities
2058       , 0   //pReserved3
2059       );
2060    if( 0 == sec_init_ret || RPC_E_TOO_LATE_BIPC == sec_init_ret)
2061    {
2062       IWbemLocator_BIPC * pIWbemLocator = 0;
2063       const wchar_t * bstrNamespace = L"root\\cimv2";
2064
2065       if( 0 != CoCreateInstance(
2066             CLSID_WbemAdministrativeLocator,
2067             0,
2068             CLSCTX_INPROC_SERVER_BIPC | CLSCTX_LOCAL_SERVER_BIPC,
2069             IID_IUnknown, (void **)&pIWbemLocator)){
2070          return false;
2071       }
2072
2073       com_releaser<IWbemLocator_BIPC> IWbemLocator_releaser(pIWbemLocator);
2074
2075       IWbemServices_BIPC *pWbemServices = 0;
2076
2077       if( 0 != pIWbemLocator->ConnectServer(
2078             (bstr)bstrNamespace,  // Namespace
2079             0,          // Userid
2080             0,           // PW
2081             0,           // Locale
2082             0,              // flags
2083             0,           // Authority
2084             0,           // Context
2085             &pWbemServices
2086             )
2087          ){
2088          return false;
2089       }
2090
2091       if( S_OK_BIPC != CoSetProxyBlanket(
2092             pWbemServices,
2093             RPC_C_AUTHN_DEFAULT_BIPC,
2094             RPC_C_AUTHZ_DEFAULT_BIPC,
2095             0,
2096             RPC_C_AUTHN_LEVEL_PKT_BIPC,
2097             RPC_C_IMP_LEVEL_IMPERSONATE_BIPC,
2098             0,
2099             EOAC_NONE_BIPC
2100             )
2101          ){
2102          return false;
2103       }
2104
2105       com_releaser<IWbemServices_BIPC> IWbemServices_releaser(pWbemServices);
2106
2107       strValue.clear();
2108       strValue += L"Select ";
2109       strValue += wmi_class_var;
2110       strValue += L" from ";
2111       strValue += wmi_class;
2112
2113       IEnumWbemClassObject_BIPC * pEnumObject  = 0;
2114
2115       if ( 0 != pWbemServices->ExecQuery(
2116             (bstr)L"WQL",
2117             (bstr)strValue.c_str(),
2118             //WBEM_FLAG_RETURN_IMMEDIATELY_BIPC,
2119             WBEM_FLAG_RETURN_WHEN_COMPLETE_BIPC | WBEM_FLAG_FORWARD_ONLY_BIPC,
2120             0,
2121             &pEnumObject
2122             )
2123          ){
2124          return false;
2125       }
2126
2127       com_releaser<IEnumWbemClassObject_BIPC> IEnumWbemClassObject_releaser(pEnumObject);
2128
2129       //WBEM_FLAG_FORWARD_ONLY_BIPC incompatible with Reset
2130       //if ( 0 != pEnumObject->Reset() ){
2131          //return false;
2132       //}
2133
2134       wchar_variant vwchar;
2135       unsigned long uCount = 1, uReturned;
2136       IWbemClassObject_BIPC * pClassObject = 0;
2137       while( 0 == pEnumObject->Next( WBEM_INFINITE_BIPC, uCount, &pClassObject, &uReturned ) )
2138       {
2139          com_releaser<IWbemClassObject_BIPC> IWbemClassObject_releaser(pClassObject);
2140          if ( 0 == pClassObject->Get( (bstr)L"LastBootUpTime", 0, &vwchar, 0, 0 ) ){
2141             bRet = true;
2142             strValue = (wchar_t*)vwchar.bstrVal;
2143             VariantClear(&vwchar );
2144             break;
2145          }
2146       }
2147    }
2148    return bRet;
2149 }
2150
2151 //Obtains the bootup time from WMI LastBootUpTime.
2152 //This time seems to change with hibernation and clock synchronization so avoid it.
2153 inline bool get_last_bootup_time( std::wstring& strValue )
2154 {
2155    bool ret = get_wmi_class_attribute(strValue, L"Win32_OperatingSystem", L"LastBootUpTime");
2156    std::size_t timezone = strValue.find(L'+');
2157    if(timezone != std::wstring::npos){
2158       strValue.erase(timezone);
2159    }
2160    timezone = strValue.find(L'-');
2161    if(timezone != std::wstring::npos){
2162       strValue.erase(timezone);
2163    }
2164    return ret;
2165 }
2166
2167 inline bool get_last_bootup_time( std::string& str )
2168 {
2169    std::wstring wstr;
2170    bool ret = get_last_bootup_time(wstr);
2171    str.resize(wstr.size());
2172    for(std::size_t i = 0, max = str.size(); i != max; ++i){
2173       str[i] = '0' + (wstr[i]-L'0');
2174    }
2175    return ret;
2176 }
2177
2178 #else
2179
2180 // Loop through the buffer and obtain the contents of the
2181 // requested record in the buffer.
2182 inline bool find_record_in_buffer( const void* pBuffer, unsigned long dwBytesRead, const char *provider_name
2183                                  , unsigned int id_to_find, interprocess_eventlogrecord *&pevent_log_record)
2184 {
2185    const unsigned char * pRecord = static_cast<const unsigned char*>(pBuffer);
2186    const unsigned char * pEndOfRecords = pRecord + dwBytesRead;
2187
2188    while (pRecord < pEndOfRecords){
2189       interprocess_eventlogrecord *pTypedRecord = (interprocess_eventlogrecord*)pRecord;
2190       // Check provider, written at the end of the fixed-part of the record
2191       if (0 == std::strcmp(provider_name, (char*)(pRecord + sizeof(interprocess_eventlogrecord))))
2192       {
2193          // Check event id
2194          if(id_to_find == (pTypedRecord->EventID & 0xFFFF)){
2195             pevent_log_record = pTypedRecord;
2196             return true;
2197          }
2198       }
2199
2200       pRecord += pTypedRecord->Length;
2201    }
2202    pevent_log_record = 0;
2203    return false;
2204 }
2205
2206 //Obtains the bootup time from the System Event Log,
2207 //event ID == 6005 (event log started).
2208 //Adapted from http://msdn.microsoft.com/en-us/library/windows/desktop/bb427356.aspx
2209 inline bool get_last_bootup_time(std::string &stamp)
2210 {
2211    const char *source_name = "System";
2212    const char *provider_name = "EventLog";
2213    const unsigned short event_id = 6005u;
2214
2215    unsigned long status = 0;
2216    unsigned long dwBytesToRead = 0;
2217    unsigned long dwBytesRead = 0;
2218    unsigned long dwMinimumBytesToRead = 0;
2219
2220    // The source name (provider) must exist as a subkey of Application.
2221    void *hEventLog = OpenEventLogA(0, source_name);
2222    if (hEventLog){
2223       eventlog_handle_closer hnd_closer(hEventLog); (void)hnd_closer;
2224       // Allocate an initial block of memory used to read event records. The number
2225       // of records read into the buffer will vary depending on the size of each event.
2226       // The size of each event will vary based on the size of the user-defined
2227       // data included with each event, the number and length of insertion
2228       // strings, and other data appended to the end of the event record.
2229       dwBytesToRead = max_record_buffer_size;
2230       c_heap_deleter heap_deleter(dwBytesToRead);
2231
2232       // Read blocks of records until you reach the end of the log or an
2233       // error occurs. The records are read from newest to oldest. If the buffer
2234       // is not big enough to hold a complete event record, reallocate the buffer.
2235       if (heap_deleter.get() != 0){
2236          while (0 == status){
2237             if (!ReadEventLogA(hEventLog,
2238                   eventlog_sequential_read | eventlog_backwards_read,
2239                   0,
2240                   heap_deleter.get(),
2241                   dwBytesToRead,
2242                   &dwBytesRead,
2243                   &dwMinimumBytesToRead)) {
2244                status = get_last_error();
2245                if (error_insufficient_buffer == status) {
2246                   status = 0;
2247                   dwBytesToRead = dwMinimumBytesToRead;
2248                   heap_deleter.realloc_mem(dwMinimumBytesToRead);
2249                   if (!heap_deleter.get()){
2250                      return false;
2251                   }
2252                }
2253                else{  //Not found or EOF
2254                   return false;
2255                }
2256             }
2257             else
2258             {
2259                interprocess_eventlogrecord *pTypedRecord;
2260                // Print the contents of each record in the buffer.
2261                if(find_record_in_buffer(heap_deleter.get(), dwBytesRead, provider_name, event_id, pTypedRecord)){
2262                   char stamp_str[sizeof(unsigned long)*3+1];
2263                   std::sprintf(&stamp_str[0], "%u", ((unsigned int)pTypedRecord->TimeGenerated));
2264                   stamp = stamp_str;
2265                   break;
2266                }
2267             }
2268          }
2269       }
2270    }
2271    return true;
2272 }
2273
2274 #endif
2275
2276 inline bool is_directory(const char *path)
2277 {
2278    unsigned long attrib = GetFileAttributesA(path);
2279
2280    return (attrib != invalid_file_attributes &&
2281            (attrib & file_attribute_directory));
2282 }
2283
2284 inline bool get_file_mapping_size(void *file_mapping_hnd, __int64 &size)
2285 {
2286    NtQuerySection_t pNtQuerySection =
2287       (NtQuerySection_t)dll_func::get(dll_func::NtQuerySection);
2288    //Obtain file name
2289    interprocess_section_basic_information info;
2290    unsigned long ntstatus =
2291       pNtQuerySection(file_mapping_hnd, section_basic_information, &info, sizeof(info), 0);
2292    size = info.section_size;
2293    return !ntstatus;
2294 }
2295
2296 inline bool get_semaphore_info(void *handle, long &count, long &limit)
2297 {
2298    winapi::interprocess_semaphore_basic_information info;
2299    winapi::NtQuerySemaphore_t pNtQuerySemaphore =
2300          (winapi::NtQuerySemaphore_t)dll_func::get(winapi::dll_func::NtQuerySemaphore);
2301    unsigned int ret_len;
2302    long status = pNtQuerySemaphore(handle, winapi::semaphore_basic_information, &info, sizeof(info), &ret_len);
2303    count = info.count;
2304    limit = info.limit;
2305    return !status;
2306 }
2307
2308 inline bool query_timer_resolution(unsigned long *lowres, unsigned long *highres, unsigned long *curres)
2309 {
2310    winapi::NtQueryTimerResolution_t pNtQueryTimerResolution =
2311          (winapi::NtQueryTimerResolution_t)dll_func::get(winapi::dll_func::NtQueryTimerResolution);
2312    return !pNtQueryTimerResolution(lowres, highres, curres);
2313 }
2314
2315 inline bool set_timer_resolution(unsigned long RequestedResolution, int Set, unsigned long* ActualResolution)
2316 {
2317    winapi::NtSetTimerResolution_t pNtSetTimerResolution =
2318          (winapi::NtSetTimerResolution_t)dll_func::get(winapi::dll_func::NtSetTimerResolution);
2319    return !pNtSetTimerResolution(RequestedResolution, Set, ActualResolution);
2320 }
2321
2322 inline bool query_performance_counter(__int64 *lpPerformanceCount)
2323 {
2324    QueryPerformanceCounter_t pQueryPerformanceCounter = (QueryPerformanceCounter_t)
2325          dll_func::get(dll_func::QueryPerformanceCounter);
2326    return 0 != pQueryPerformanceCounter(lpPerformanceCount);
2327 }
2328
2329 inline bool query_performance_frequency(__int64 *lpFrequency)
2330 {
2331    QueryPerformanceCounter_t pQueryPerformanceFrequency = (QueryPerformanceFrequency_t)
2332          dll_func::get(dll_func::QueryPerformanceFrequency);
2333    return 0 != pQueryPerformanceFrequency(lpFrequency);
2334 }
2335
2336 inline unsigned long get_tick_count()
2337 {  return GetTickCount();  }
2338
2339 }  //namespace winapi
2340 }  //namespace interprocess
2341 }  //namespace boost
2342
2343 #if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
2344 #  pragma GCC diagnostic pop
2345 #endif
2346
2347 #include <boost/interprocess/detail/config_end.hpp>
2348
2349 #endif //#ifdef BOOST_INTERPROCESS_WIN32_API_HPP