JclWin32.pas | searchcode

/components/jcl/source/windows/JclWin32.pas

https://github.com/padcom/delcos
Pascal | 1185 lines | 419 code | 118 blank | 648 comment | 0 complexity | 9fe2437c46373efb01a9b22fbbdb329d MD5 | raw file

{**************************************************************************************************}

{  WARNING:  JEDI preprocessor generated unit.  Do not edit.                                       }

{**************************************************************************************************}



{**************************************************************************************************}

{                                                                                                  }

{ Project JEDI Code Library (JCL)                                                                  }

{                                                                                                  }

{ The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License"); }

{ you may not use this file except in compliance with the License. You may obtain a copy of the    }

{ License at http://www.mozilla.org/MPL/                                                           }

{                                                                                                  }

{ Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF   }

{ ANY KIND, either express or implied. See the License for the specific language governing rights  }

{ and limitations under the License.                                                               }

{                                                                                                  }

{ Portions of this code are translated from DelayImp.h.                                            }

{ The Initial Developer of DelayImp.h is Inprise Corporation. Portions created by Inprise          }

{ Corporation are Copyright (C) 1999, 2000 by Inprise Corporation. All Rights Reserved.            }

{                                                                                                  }

{ The Original Code is JclWin32.pas.                                                               }

{                                                                                                  }

{ The Initial Developer of the Original Code is Marcel van Brakel. Portions created by Marcel van  }

{ Brakel are Copyright (C) Marcel van Brakel. All Rights Reserved.                                 }

{                                                                                                  }

{ Contributors:                                                                                    }

{   Marcel van Brakel                                                                              }

{   Peter Friese                                                                                   }

{   Andreas Hausladen (ahuser)                                                                     }

{   Flier Lu (flier)                                                                               }

{   Robert Marquardt (marquardt)                                                                   }

{   Robert Rossmair (rrossmair)                                                                    }

{   Olivier Sannier (obones)                                                                       }

{   Matthias Thoma (mthoma)                                                                        }

{   Petr Vones (pvones)                                                                            }

{   Florent Ouchet (outchy)                                                                        }

{                                                                                                  }

{**************************************************************************************************}

{                                                                                                  }

{ This unit defines various Win32 API declarations which are either missing or incorrect in one or }

{ more of the supported Delphi versions. This unit is not intended for regular code, only API      }

{ declarations.                                                                                    }

{                                                                                                  }

{**************************************************************************************************}

{                                                                                                  }

{ Last modified: $Date:: 2010-08-02 21:27:59 +0200 (lun., 02 août 2010)                         $ }

{ Revision:      $Rev:: 3276                                                                     $ }

{ Author:        $Author:: outchy                                                                $ }

{                                                                                                  }

{**************************************************************************************************}



unit JclWin32;



{$I jcl.inc}



{$MINENUMSIZE 4}

{$ALIGN ON}

{$WARNINGS OFF}



interface



uses

  {$IFDEF UNITVERSIONING}

  JclUnitVersioning,

  {$ENDIF UNITVERSIONING}

  Windows, SysUtils,

  {$IFNDEF FPC}

  AccCtrl,

  ActiveX,

  {$ENDIF ~FPC}

  JclBase;



{$HPPEMIT '#include <WinDef.h>'}

{$HPPEMIT '#include <WinNT.h>'}

{$HPPEMIT '#include <WinBase.h>'}

{$HPPEMIT '#include <BaseTsd.h>'}

{$HPPEMIT '#include <ImageHlp.h>'}

{$HPPEMIT '#include <lm.h>'}

{$HPPEMIT '#include <Nb30.h>'}

{$HPPEMIT '#include <RasDlg.h>'}

{$HPPEMIT '#include <Reason.h>'}

{$HPPEMIT '#include <ShlWApi.h>'}

{$HPPEMIT '#include <WinError.h>'}

{$HPPEMIT '#include <WinIoCtl.h>'}

{$HPPEMIT '#include <WinUser.h>'}

//{$HPPEMIT '#include <Powrprof.h>'}

{$HPPEMIT '#include <delayimp.h>'}

{$HPPEMIT '#include <propidl.h>'}

{$HPPEMIT '#include <msidefs.h>'}

{$HPPEMIT '#include <shlguid.h>'}

{$IFNDEF COMPILER14_UP}

{$HPPEMIT '#include <imgguids.h>'}

{$ENDIF ~COMPILER14_UP}

{$HPPEMIT '#include <objbase.h>'}

{$HPPEMIT '#include <ntsecapi.h>'}

{$HPPEMIT ''}



// EJclWin32Error

type

  EJclWin32Error = class(EJclError)

  private

    FLastError: DWORD;

    FLastErrorMsg: string;

  public

    constructor Create(const Msg: string);

    constructor CreateFmt(const Msg: string; const Args: array of const);

    constructor CreateRes(Ident: Integer); overload;

    constructor CreateRes(ResStringRec: PResStringRec); overload;

    property LastError: DWORD read FLastError;

    property LastErrorMsg: string read FLastErrorMsg;

  end;



{$IFNDEF FPC}



//

// Unsigned Basics

//



type

  USHORT = Word;

  {$EXTERNALSYM USHORT}



{$ENDIF ~FPC}

//==================================================================================================

// presumable from any older WinNT.h or from WinIfs.h

//==================================================================================================



//--------------------------------------------------------------------------------------------------

// NTFS Reparse Points

//--------------------------------------------------------------------------------------------------



// The reparse structure is used by layered drivers to store data in a

// reparse point. The constraints on reparse tags are defined below.

// This version of the reparse data buffer is only for Microsoft tags.



(*$HPPEMIT 'typedef struct _REPARSE_DATA_BUFFER {'*)

(*$HPPEMIT ''*)

(*$HPPEMIT '    DWORD   ReparseTag;'*)

(*$HPPEMIT '    WORD    ReparseDataLength;'*)

(*$HPPEMIT '    WORD    Reserved;'*)

(*$HPPEMIT ''*)

(*$HPPEMIT '    union {'*)

(*$HPPEMIT ''*)

(*$HPPEMIT '        struct {'*)

(*$HPPEMIT '            WORD    SubstituteNameOffset;'*)

(*$HPPEMIT '            WORD    SubstituteNameLength;'*)

(*$HPPEMIT '            WORD    PrintNameOffset;'*)

(*$HPPEMIT '            WORD    PrintNameLength;'*)

(*$HPPEMIT '            WCHAR   PathBuffer[1];'*)

(*$HPPEMIT '        } SymbolicLinkReparseBuffer;'*)

(*$HPPEMIT ''*)

(*$HPPEMIT '        struct {'*)

(*$HPPEMIT '            WORD    SubstituteNameOffset;'*)

(*$HPPEMIT '            WORD    SubstituteNameLength;'*)

(*$HPPEMIT '            WORD    PrintNameOffset;'*)

(*$HPPEMIT '            WORD    PrintNameLength;'*)

(*$HPPEMIT '            WCHAR   PathBuffer[1];'*)

(*$HPPEMIT '        } MountPointReparseBuffer;'*)

(*$HPPEMIT ''*)

(*$HPPEMIT '        struct {'*)

(*$HPPEMIT '            UCHAR   DataBuffer[1];'*)

(*$HPPEMIT '        } GenericReparseBuffer;'*)

(*$HPPEMIT '    };'*)

(*$HPPEMIT ''*)

(*$HPPEMIT '} REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;'*)

(*$HPPEMIT ''*)

(*$HPPEMIT '#ifndef REPARSE_DATA_BUFFER_HEADER_SIZE'*)

(*$HPPEMIT '#define REPARSE_DATA_BUFFER_HEADER_SIZE   8'*)

(*$HPPEMIT '#endif'*)

(*$HPPEMIT ''*)

(*$HPPEMIT 'typedef struct _REPARSE_POINT_INFORMATION {'*)

(*$HPPEMIT '        WORD    ReparseDataLength;'*)

(*$HPPEMIT '        WORD    UnparsedNameLength;'*)

(*$HPPEMIT '} REPARSE_POINT_INFORMATION, *PREPARSE_POINT_INFORMATION;'*)

(*$HPPEMIT ''*)

(*$HPPEMIT '#ifndef IO_REPARSE_TAG_VALID_VALUES'*)

(*$HPPEMIT '#define IO_REPARSE_TAG_VALID_VALUES 0x0E000FFFF'*)

(*$HPPEMIT '#endif'*)

(*$HPPEMIT ''*)



type

  {$EXTERNALSYM _REPARSE_DATA_BUFFER}

  _REPARSE_DATA_BUFFER = record

    ReparseTag: DWORD;

    ReparseDataLength: Word;

    Reserved: Word;

    case Integer of

      0: ( // SymbolicLinkReparseBuffer and MountPointReparseBuffer

        SubstituteNameOffset: Word;

        SubstituteNameLength: Word;

        PrintNameOffset: Word;

        PrintNameLength: Word;

        PathBuffer: array [0..0] of WCHAR);

      1: ( // GenericReparseBuffer

        DataBuffer: array [0..0] of Byte);

  end;

  {$EXTERNALSYM REPARSE_DATA_BUFFER}

  REPARSE_DATA_BUFFER = _REPARSE_DATA_BUFFER;

  {$EXTERNALSYM PREPARSE_DATA_BUFFER}

  PREPARSE_DATA_BUFFER = ^_REPARSE_DATA_BUFFER;

  TReparseDataBuffer = _REPARSE_DATA_BUFFER;

  PReparseDataBuffer = PREPARSE_DATA_BUFFER;



const

  {$EXTERNALSYM REPARSE_DATA_BUFFER_HEADER_SIZE}

  REPARSE_DATA_BUFFER_HEADER_SIZE = 8;



type

  {$EXTERNALSYM _REPARSE_POINT_INFORMATION}

  _REPARSE_POINT_INFORMATION = record

    ReparseDataLength: Word;

    UnparsedNameLength: Word;

  end;

  {$EXTERNALSYM REPARSE_POINT_INFORMATION}

  REPARSE_POINT_INFORMATION = _REPARSE_POINT_INFORMATION;

  {$EXTERNALSYM PREPARSE_POINT_INFORMATION}

  PREPARSE_POINT_INFORMATION = ^_REPARSE_POINT_INFORMATION;

  TReparsePointInformation = _REPARSE_POINT_INFORMATION;

  PReparsePointInformation = PREPARSE_POINT_INFORMATION;



const

  {$EXTERNALSYM IO_REPARSE_TAG_VALID_VALUES}

  IO_REPARSE_TAG_VALID_VALUES = DWORD($E000FFFF);



//==================================================================================================



// from JwaWinNT.pas (few declarations from JwaWinType)



const

  MAXLONGLONG = $7fffffffffffffff;

  {$EXTERNALSYM MAXLONGLONG}



{$IFNDEF FPC}

type

  ULONGLONG = Int64;

  {$EXTERNALSYM ULONGLONG}

  PLONGLONG = ^LONGLONG;

  {$EXTERNALSYM PLONGLONG}

  PULONGLONG = ^ULONGLONG;

  {$EXTERNALSYM PULONGLONG}

{$ENDIF ~FPC}



const

  ANYSIZE_ARRAY = 1;

  {$EXTERNALSYM ANYSIZE_ARRAY}



  MAX_NATURAL_ALIGNMENT = SizeOf(ULONG);

  {$EXTERNALSYM MAX_NATURAL_ALIGNMENT}



// line 72



const

  VER_SERVER_NT                      = DWORD($80000000);

  {$EXTERNALSYM VER_SERVER_NT}

  VER_WORKSTATION_NT                 = $40000000;

  {$EXTERNALSYM VER_WORKSTATION_NT}

  VER_SUITE_SMALLBUSINESS            = $00000001;

  {$EXTERNALSYM VER_SUITE_SMALLBUSINESS}

  VER_SUITE_ENTERPRISE               = $00000002;

  {$EXTERNALSYM VER_SUITE_ENTERPRISE}

  VER_SUITE_BACKOFFICE               = $00000004;

  {$EXTERNALSYM VER_SUITE_BACKOFFICE}

  VER_SUITE_COMMUNICATIONS           = $00000008;

  {$EXTERNALSYM VER_SUITE_COMMUNICATIONS}

  VER_SUITE_TERMINAL                 = $00000010;

  {$EXTERNALSYM VER_SUITE_TERMINAL}

  VER_SUITE_SMALLBUSINESS_RESTRICTED = $00000020;

  {$EXTERNALSYM VER_SUITE_SMALLBUSINESS_RESTRICTED}

  VER_SUITE_EMBEDDEDNT               = $00000040;

  {$EXTERNALSYM VER_SUITE_EMBEDDEDNT}

  VER_SUITE_DATACENTER               = $00000080;

  {$EXTERNALSYM VER_SUITE_DATACENTER}

  VER_SUITE_SINGLEUSERTS             = $00000100;

  {$EXTERNALSYM VER_SUITE_SINGLEUSERTS}

  VER_SUITE_PERSONAL                 = $00000200;

  {$EXTERNALSYM VER_SUITE_PERSONAL}

  VER_SUITE_BLADE                    = $00000400;

  {$EXTERNALSYM VER_SUITE_BLADE}

  VER_SUITE_EMBEDDED_RESTRICTED      = $00000800;

  {$EXTERNALSYM VER_SUITE_EMBEDDED_RESTRICTED}

  VER_SUITE_SECURITY_APPLIANCE       = $00001000;

  {$EXTERNALSYM VER_SUITE_SECURITY_APPLIANCE}

  VER_SUITE_STORAGE_SERVER           = $00002000;

  {$EXTERNALSYM VER_SUITE_STORAGE_SERVER}

  VER_SUITE_COMPUTE_SERVER           = $00004000;

  {$EXTERNALSYM VER_SUITE_COMPUTE_SERVER}



// line 515



//

//  A language ID is a 16 bit value which is the combination of a

//  primary language ID and a secondary language ID.  The bits are

//  allocated as follows:

//

//       +-----------------------+-------------------------+

//       |     Sublanguage ID    |   Primary Language ID   |

//       +-----------------------+-------------------------+

//        15                   10 9                       0   bit

//

//

//  Language ID creation/extraction macros:

//

//    MAKELANGID    - construct language id from a primary language id and

//                    a sublanguage id.

//    PRIMARYLANGID - extract primary language id from a language id.

//    SUBLANGID     - extract sublanguage id from a language id.

//



function MAKELANGID(PrimaryLang, SubLang: USHORT): WORD;

{$EXTERNALSYM MAKELANGID}

function PRIMARYLANGID(LangId: WORD): WORD;

{$EXTERNALSYM PRIMARYLANGID}

function SUBLANGID(LangId: WORD): WORD;

{$EXTERNALSYM SUBLANGID}



//

//  A locale ID is a 32 bit value which is the combination of a

//  language ID, a sort ID, and a reserved area.  The bits are

//  allocated as follows:

//

//       +-------------+---------+-------------------------+

//       |   Reserved  | Sort ID |      Language ID        |

//       +-------------+---------+-------------------------+

//        31         20 19     16 15                      0   bit

//

//

//  Locale ID creation/extraction macros:

//

//    MAKELCID            - construct the locale id from a language id and a sort id.

//    MAKESORTLCID        - construct the locale id from a language id, sort id, and sort version.

//    LANGIDFROMLCID      - extract the language id from a locale id.

//    SORTIDFROMLCID      - extract the sort id from a locale id.

//    SORTVERSIONFROMLCID - extract the sort version from a locale id.

//



const

  NLS_VALID_LOCALE_MASK = $000fffff;

  {$EXTERNALSYM NLS_VALID_LOCALE_MASK}



function MAKELCID(LangId, SortId: WORD): DWORD;

{$EXTERNALSYM MAKELCID}

function MAKESORTLCID(LangId, SortId, SortVersion: WORD): DWORD;

{$EXTERNALSYM MAKESORTLCID}

function LANGIDFROMLCID(LocaleId: LCID): WORD;

{$EXTERNALSYM LANGIDFROMLCID}

function SORTIDFROMLCID(LocaleId: LCID): WORD;

{$EXTERNALSYM SORTIDFROMLCID}

function SORTVERSIONFROMLCID(LocaleId: LCID): WORD;

{$EXTERNALSYM SORTVERSIONFROMLCID}



// line 1154



////////////////////////////////////////////////////////////////////////

//                                                                    //

//              Security Id     (SID)                                 //

//                                                                    //

////////////////////////////////////////////////////////////////////////

//

//

// Pictorially the structure of an SID is as follows:

//

//         1   1   1   1   1   1

//         5   4   3   2   1   0   9   8   7   6   5   4   3   2   1   0

//      +---------------------------------------------------------------+

//      |      SubAuthorityCount        |Reserved1 (SBZ)|   Revision    |

//      +---------------------------------------------------------------+

//      |                   IdentifierAuthority[0]                      |

//      +---------------------------------------------------------------+

//      |                   IdentifierAuthority[1]                      |

//      +---------------------------------------------------------------+

//      |                   IdentifierAuthority[2]                      |

//      +---------------------------------------------------------------+

//      |                                                               |

//      +- -  -  -  -  -  -  -  SubAuthority[]  -  -  -  -  -  -  -  - -+

//      |                                                               |

//      +---------------------------------------------------------------+

//

//



{$IFNDEF FPC}

type

  _SID_IDENTIFIER_AUTHORITY = record

    Value: array [0..5] of Byte;

  end;

  {$EXTERNALSYM _SID_IDENTIFIER_AUTHORITY}

  SID_IDENTIFIER_AUTHORITY = _SID_IDENTIFIER_AUTHORITY;

  {$EXTERNALSYM SID_IDENTIFIER_AUTHORITY}

  PSID_IDENTIFIER_AUTHORITY = ^_SID_IDENTIFIER_AUTHORITY;

  {$EXTERNALSYM PSID_IDENTIFIER_AUTHORITY}



  // PSid = ^SID;

  _SID = record

    Revision: Byte;

    SubAuthorityCount: Byte;

    IdentifierAuthority: SID_IDENTIFIER_AUTHORITY;

    SubAuthority: array [0..ANYSIZE_ARRAY - 1] of DWORD;

  end;

  {$EXTERNALSYM _SID}

  SID = _SID;

  {$EXTERNALSYM SID}

  PPSID = ^PSID;

  {$NODEFINE PPSID}

  TSid = SID;

{$ENDIF ~FPC}



const

  SID_REVISION                    = (1); // Current revision level

  {$EXTERNALSYM SID_REVISION}

  SID_MAX_SUB_AUTHORITIES         = (15);

  {$EXTERNALSYM SID_MAX_SUB_AUTHORITIES}

  SID_RECOMMENDED_SUB_AUTHORITIES = (1); // Will change to around 6 in a future release.

  {$EXTERNALSYM SID_RECOMMENDED_SUB_AUTHORITIES}



  SECURITY_MAX_SID_SIZE = SizeOf(SID) - SizeOf(DWORD) + (SID_MAX_SUB_AUTHORITIES * SizeOf(DWORD));

  {$EXTERNALSYM SECURITY_MAX_SID_SIZE}



{$IFNDEF FPC}

  SidTypeUser           = 1;

  {$EXTERNALSYM SidTypeUser}

  SidTypeGroup          = 2;

  {$EXTERNALSYM SidTypeGroup}

  SidTypeDomain         = 3;

  {$EXTERNALSYM SidTypeDomain}

  SidTypeAlias          = 4;

  {$EXTERNALSYM SidTypeAlias}

  SidTypeWellKnownGroup = 5;

  {$EXTERNALSYM SidTypeWellKnownGroup}

  SidTypeDeletedAccount = 6;

  {$EXTERNALSYM SidTypeDeletedAccount}

  SidTypeInvalid        = 7;

  {$EXTERNALSYM SidTypeInvalid}

  SidTypeUnknown        = 8;

  {$EXTERNALSYM SidTypeUnknown}

  SidTypeComputer       = 9;

  {$EXTERNALSYM SidTypeComputer}



type

  _SID_NAME_USE = DWORD;

  {$EXTERNALSYM _SID_NAME_USE}

//  SID_NAME_USE = _SID_NAME_USE;

//  {$EXTERNALSYM SID_NAME_USE}

  PSID_NAME_USE = ^SID_NAME_USE;

  {$EXTERNALSYM PSID_NAME_USE}

  TSidNameUse = SID_NAME_USE;

  PSidNameUSe = PSID_NAME_USE;



  PSID_AND_ATTRIBUTES = ^SID_AND_ATTRIBUTES;

  {$EXTERNALSYM PSID_AND_ATTRIBUTES}

  _SID_AND_ATTRIBUTES = record

    Sid: PSID;

    Attributes: DWORD;

  end;

  {$EXTERNALSYM _SID_AND_ATTRIBUTES}

  SID_AND_ATTRIBUTES = _SID_AND_ATTRIBUTES;

  {$EXTERNALSYM SID_AND_ATTRIBUTES}

  TSidAndAttributes = SID_AND_ATTRIBUTES;

  PSidAndAttributes = PSID_AND_ATTRIBUTES;



  SID_AND_ATTRIBUTES_ARRAY = array [0..ANYSIZE_ARRAY - 1] of SID_AND_ATTRIBUTES;

  {$EXTERNALSYM SID_AND_ATTRIBUTES_ARRAY}

  PSID_AND_ATTRIBUTES_ARRAY = ^SID_AND_ATTRIBUTES_ARRAY;

  {$EXTERNALSYM PSID_AND_ATTRIBUTES_ARRAY}

  PSidAndAttributesArray = ^TSidAndAttributesArray;

  TSidAndAttributesArray = SID_AND_ATTRIBUTES_ARRAY;

{$ENDIF ~FPC}



/////////////////////////////////////////////////////////////////////////////

//                                                                         //

// Universal well-known SIDs                                               //

//                                                                         //

//     Null SID                     S-1-0-0                                //

//     World                        S-1-1-0                                //

//     Local                        S-1-2-0                                //

//     Creator Owner ID             S-1-3-0                                //

//     Creator Group ID             S-1-3-1                                //

//     Creator Owner Server ID      S-1-3-2                                //

//     Creator Group Server ID      S-1-3-3                                //

//                                                                         //

//     (Non-unique IDs)             S-1-4                                  //

//                                                                         //

/////////////////////////////////////////////////////////////////////////////



const

  SECURITY_NULL_SID_AUTHORITY: TSidIdentifierAuthority = (Value: (0, 0, 0, 0, 0, 0));

  {$EXTERNALSYM SECURITY_NULL_SID_AUTHORITY}

  SECURITY_WORLD_SID_AUTHORITY: TSidIdentifierAuthority = (Value: (0, 0, 0, 0, 0, 1));

  {$EXTERNALSYM SECURITY_WORLD_SID_AUTHORITY}

  SECURITY_LOCAL_SID_AUTHORITY: TSidIdentifierAuthority = (Value: (0, 0, 0, 0, 0, 2));

  {$EXTERNALSYM SECURITY_LOCAL_SID_AUTHORITY}

  SECURITY_CREATOR_SID_AUTHORITY: TSidIdentifierAuthority = (Value: (0, 0, 0, 0, 0, 3));

  {$EXTERNALSYM SECURITY_CREATOR_SID_AUTHORITY}

  SECURITY_NON_UNIQUE_AUTHORITY: TSidIdentifierAuthority = (Value: (0, 0, 0, 0, 0, 4));

  {$EXTERNALSYM SECURITY_NON_UNIQUE_AUTHORITY}

  SECURITY_RESOURCE_MANAGER_AUTHORITY: TSidIdentifierAuthority = (Value: (0, 0, 0, 0, 0, 9));

  {$EXTERNALSYM SECURITY_RESOURCE_MANAGER_AUTHORITY}



  SECURITY_NULL_RID                 = ($00000000);

  {$EXTERNALSYM SECURITY_NULL_RID}

  SECURITY_WORLD_RID                = ($00000000);

  {$EXTERNALSYM SECURITY_WORLD_RID}

  SECURITY_LOCAL_RID                = ($00000000);

  {$EXTERNALSYM SECURITY_LOCAL_RID}



  SECURITY_CREATOR_OWNER_RID        = ($00000000);

  {$EXTERNALSYM SECURITY_CREATOR_OWNER_RID}

  SECURITY_CREATOR_GROUP_RID        = ($00000001);

  {$EXTERNALSYM SECURITY_CREATOR_GROUP_RID}



  SECURITY_CREATOR_OWNER_SERVER_RID = ($00000002);

  {$EXTERNALSYM SECURITY_CREATOR_OWNER_SERVER_RID}

  SECURITY_CREATOR_GROUP_SERVER_RID = ($00000003);

  {$EXTERNALSYM SECURITY_CREATOR_GROUP_SERVER_RID}



/////////////////////////////////////////////////////////////////////////////

//                                                                         //

// NT well-known SIDs                                                        //

//                                                                           //

//     NT Authority            S-1-5                                         //

//     Dialup                  S-1-5-1                                       //

//                                                                           //

//     Network                 S-1-5-2                                       //

//     Batch                   S-1-5-3                                       //

//     Interactive             S-1-5-4                                       //

//     (Logon IDs)             S-1-5-5-X-Y                                   //

//     Service                 S-1-5-6                                       //

//     AnonymousLogon          S-1-5-7       (aka null logon session)        //

//     Proxy                   S-1-5-8                                       //

//     Enterprise DC (EDC)     S-1-5-9       (aka domain controller account) //

//     Self                    S-1-5-10      (self RID)                      //

//     Authenticated User      S-1-5-11      (Authenticated user somewhere)  //

//     Restricted Code         S-1-5-12      (Running restricted code)       //

//     Terminal Server         S-1-5-13      (Running on Terminal Server)    //

//     Remote Logon            S-1-5-14      (Remote Interactive Logon)      //

//     This Organization       S-1-5-15                                      //

//                                                                           //

//     Local System            S-1-5-18                                      //

//     Local Service           S-1-5-19                                      //

//     Network Service         S-1-5-20                                      //

//                                                                           //

//     (NT non-unique IDs)     S-1-5-0x15-... (NT Domain Sids)               //

//                                                                           //

//     (Built-in domain)       S-1-5-0x20                                    //

//                                                                           //

//     (Security Package IDs)  S-1-5-0x40                                    //

//     NTLM Authentication     S-1-5-0x40-10                                 //

//     SChannel Authentication S-1-5-0x40-14                                 //

//     Digest Authentication   S-1-5-0x40-21                                 //

//                                                                           //

//     Other Organization      S-1-5-1000    (>=1000 can not be filtered)    //

//                                                                           //

//                                                                           //

// NOTE: the relative identifier values (RIDs) determine which security      //

//       boundaries the SID is allowed to cross.  Before adding new RIDs,    //

//       a determination needs to be made regarding which range they should  //

//       be added to in order to ensure proper "SID filtering"               //

//                                                                         //

/////////////////////////////////////////////////////////////////////////////



const

  SECURITY_NT_AUTHORITY: TSidIdentifierAuthority = (Value: (0, 0, 0, 0, 0, 5));

  {$EXTERNALSYM SECURITY_NT_AUTHORITY}



  SECURITY_DIALUP_RID                 = ($00000001);

  {$EXTERNALSYM SECURITY_DIALUP_RID}

  SECURITY_NETWORK_RID                = ($00000002);

  {$EXTERNALSYM SECURITY_NETWORK_RID}

  SECURITY_BATCH_RID                  = ($00000003);

  {$EXTERNALSYM SECURITY_BATCH_RID}

  SECURITY_INTERACTIVE_RID            = ($00000004);

  {$EXTERNALSYM SECURITY_INTERACTIVE_RID}

  SECURITY_LOGON_IDS_RID              = ($00000005);

  {$EXTERNALSYM SECURITY_LOGON_IDS_RID}

  SECURITY_LOGON_IDS_RID_COUNT        = (3);

  {$EXTERNALSYM SECURITY_LOGON_IDS_RID_COUNT}

  SECURITY_SERVICE_RID                = ($00000006);

  {$EXTERNALSYM SECURITY_SERVICE_RID}

  SECURITY_ANONYMOUS_LOGON_RID        = ($00000007);

  {$EXTERNALSYM SECURITY_ANONYMOUS_LOGON_RID}

  SECURITY_PROXY_RID                  = ($00000008);

  {$EXTERNALSYM SECURITY_PROXY_RID}

  SECURITY_ENTERPRISE_CONTROLLERS_RID = ($00000009);

  {$EXTERNALSYM SECURITY_ENTERPRISE_CONTROLLERS_RID}

  SECURITY_SERVER_LOGON_RID           = SECURITY_ENTERPRISE_CONTROLLERS_RID;

  {$EXTERNALSYM SECURITY_SERVER_LOGON_RID}

  SECURITY_PRINCIPAL_SELF_RID         = ($0000000A);

  {$EXTERNALSYM SECURITY_PRINCIPAL_SELF_RID}

  SECURITY_AUTHENTICATED_USER_RID     = ($0000000B);

  {$EXTERNALSYM SECURITY_AUTHENTICATED_USER_RID}

  SECURITY_RESTRICTED_CODE_RID        = ($0000000C);

  {$EXTERNALSYM SECURITY_RESTRICTED_CODE_RID}

  SECURITY_TERMINAL_SERVER_RID        = ($0000000D);

  {$EXTERNALSYM SECURITY_TERMINAL_SERVER_RID}

  SECURITY_REMOTE_LOGON_RID           = ($0000000E);

  {$EXTERNALSYM SECURITY_REMOTE_LOGON_RID}

  SECURITY_THIS_ORGANIZATION_RID      = ($0000000F);

  {$EXTERNALSYM SECURITY_THIS_ORGANIZATION_RID}



  SECURITY_LOCAL_SYSTEM_RID    = ($00000012);

  {$EXTERNALSYM SECURITY_LOCAL_SYSTEM_RID}

  SECURITY_LOCAL_SERVICE_RID   = ($00000013);

  {$EXTERNALSYM SECURITY_LOCAL_SERVICE_RID}

  SECURITY_NETWORK_SERVICE_RID = ($00000014);

  {$EXTERNALSYM SECURITY_NETWORK_SERVICE_RID}



  SECURITY_NT_NON_UNIQUE       = ($00000015);

  {$EXTERNALSYM SECURITY_NT_NON_UNIQUE}

  SECURITY_NT_NON_UNIQUE_SUB_AUTH_COUNT = (3);

  {$EXTERNALSYM SECURITY_NT_NON_UNIQUE_SUB_AUTH_COUNT}



  SECURITY_BUILTIN_DOMAIN_RID  = ($00000020);

  {$EXTERNALSYM SECURITY_BUILTIN_DOMAIN_RID}



  SECURITY_PACKAGE_BASE_RID       = ($00000040);

  {$EXTERNALSYM SECURITY_PACKAGE_BASE_RID}

  SECURITY_PACKAGE_RID_COUNT      = (2);

  {$EXTERNALSYM SECURITY_PACKAGE_RID_COUNT}

  SECURITY_PACKAGE_NTLM_RID       = ($0000000A);

  {$EXTERNALSYM SECURITY_PACKAGE_NTLM_RID}

  SECURITY_PACKAGE_SCHANNEL_RID   = ($0000000E);

  {$EXTERNALSYM SECURITY_PACKAGE_SCHANNEL_RID}

  SECURITY_PACKAGE_DIGEST_RID     = ($00000015);

  {$EXTERNALSYM SECURITY_PACKAGE_DIGEST_RID}



  SECURITY_MAX_ALWAYS_FILTERED    = ($000003E7);

  {$EXTERNALSYM SECURITY_MAX_ALWAYS_FILTERED}

  SECURITY_MIN_NEVER_FILTERED     = ($000003E8);

  {$EXTERNALSYM SECURITY_MIN_NEVER_FILTERED}



  SECURITY_OTHER_ORGANIZATION_RID = ($000003E8);

  {$EXTERNALSYM SECURITY_OTHER_ORGANIZATION_RID}



/////////////////////////////////////////////////////////////////////////////

//                                                                         //

// well-known domain relative sub-authority values (RIDs)...               //

//                                                                         //

/////////////////////////////////////////////////////////////////////////////



// Well-known users ...



  FOREST_USER_RID_MAX    = ($000001F3);

  {$EXTERNALSYM FOREST_USER_RID_MAX}



  DOMAIN_USER_RID_ADMIN  = ($000001F4);

  {$EXTERNALSYM DOMAIN_USER_RID_ADMIN}

  DOMAIN_USER_RID_GUEST  = ($000001F5);

  {$EXTERNALSYM DOMAIN_USER_RID_GUEST}

  DOMAIN_USER_RID_KRBTGT = ($000001F6);

  {$EXTERNALSYM DOMAIN_USER_RID_KRBTGT}



  DOMAIN_USER_RID_MAX    = ($000003E7);

  {$EXTERNALSYM DOMAIN_USER_RID_MAX}



// well-known groups ...



  DOMAIN_GROUP_RID_ADMINS            = ($00000200);

  {$EXTERNALSYM DOMAIN_GROUP_RID_ADMINS}

  DOMAIN_GROUP_RID_USERS             = ($00000201);

  {$EXTERNALSYM DOMAIN_GROUP_RID_USERS}

  DOMAIN_GROUP_RID_GUESTS            = ($00000202);

  {$EXTERNALSYM DOMAIN_GROUP_RID_GUESTS}

  DOMAIN_GROUP_RID_COMPUTERS         = ($00000203);

  {$EXTERNALSYM DOMAIN_GROUP_RID_COMPUTERS}

  DOMAIN_GROUP_RID_CONTROLLERS       = ($00000204);

  {$EXTERNALSYM DOMAIN_GROUP_RID_CONTROLLERS}

  DOMAIN_GROUP_RID_CERT_ADMINS       = ($00000205);

  {$EXTERNALSYM DOMAIN_GROUP_RID_CERT_ADMINS}

  DOMAIN_GROUP_RID_SCHEMA_ADMINS     = ($00000206);

  {$EXTERNALSYM DOMAIN_GROUP_RID_SCHEMA_ADMINS}

  DOMAIN_GROUP_RID_ENTERPRISE_ADMINS = ($00000207);

  {$EXTERNALSYM DOMAIN_GROUP_RID_ENTERPRISE_ADMINS}

  DOMAIN_GROUP_RID_POLICY_ADMINS     = ($00000208);

  {$EXTERNALSYM DOMAIN_GROUP_RID_POLICY_ADMINS}



// well-known aliases ...



  DOMAIN_ALIAS_RID_ADMINS           = ($00000220);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_ADMINS}

  DOMAIN_ALIAS_RID_USERS            = ($00000221);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_USERS}

  DOMAIN_ALIAS_RID_GUESTS           = ($00000222);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_GUESTS}

  DOMAIN_ALIAS_RID_POWER_USERS      = ($00000223);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_POWER_USERS}



  DOMAIN_ALIAS_RID_ACCOUNT_OPS      = ($00000224);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_ACCOUNT_OPS}

  DOMAIN_ALIAS_RID_SYSTEM_OPS       = ($00000225);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_SYSTEM_OPS}

  DOMAIN_ALIAS_RID_PRINT_OPS        = ($00000226);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_PRINT_OPS}

  DOMAIN_ALIAS_RID_BACKUP_OPS       = ($00000227);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_BACKUP_OPS}



  DOMAIN_ALIAS_RID_REPLICATOR       = ($00000228);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_REPLICATOR}

  DOMAIN_ALIAS_RID_RAS_SERVERS      = ($00000229);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_RAS_SERVERS}

  DOMAIN_ALIAS_RID_PREW2KCOMPACCESS = ($0000022A);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_PREW2KCOMPACCESS}

  DOMAIN_ALIAS_RID_REMOTE_DESKTOP_USERS = ($0000022B);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_REMOTE_DESKTOP_USERS}

  DOMAIN_ALIAS_RID_NETWORK_CONFIGURATION_OPS = ($0000022C);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_NETWORK_CONFIGURATION_OPS}

  DOMAIN_ALIAS_RID_INCOMING_FOREST_TRUST_BUILDERS = ($0000022D);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_INCOMING_FOREST_TRUST_BUILDERS}



  DOMAIN_ALIAS_RID_MONITORING_USERS      = ($0000022E);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_MONITORING_USERS}

  DOMAIN_ALIAS_RID_LOGGING_USERS         = ($0000022F);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_LOGGING_USERS}

  DOMAIN_ALIAS_RID_AUTHORIZATIONACCESS   = ($00000230);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_AUTHORIZATIONACCESS}

  DOMAIN_ALIAS_RID_TS_LICENSE_SERVERS    = ($00000231);

  {$EXTERNALSYM DOMAIN_ALIAS_RID_TS_LICENSE_SERVERS}



// line 2495



////////////////////////////////////////////////////////////////////////

//                                                                    //

//               NT Defined Privileges                                //

//                                                                    //

////////////////////////////////////////////////////////////////////////



const

  SE_CREATE_TOKEN_NAME        = 'SeCreateTokenPrivilege';

  {$EXTERNALSYM SE_CREATE_TOKEN_NAME}

  SE_ASSIGNPRIMARYTOKEN_NAME  = 'SeAssignPrimaryTokenPrivilege';

  {$EXTERNALSYM SE_ASSIGNPRIMARYTOKEN_NAME}

  SE_LOCK_MEMORY_NAME         = 'SeLockMemoryPrivilege';

  {$EXTERNALSYM SE_LOCK_MEMORY_NAME}

  SE_INCREASE_QUOTA_NAME      = 'SeIncreaseQuotaPrivilege';

  {$EXTERNALSYM SE_INCREASE_QUOTA_NAME}

  SE_UNSOLICITED_INPUT_NAME   = 'SeUnsolicitedInputPrivilege';

  {$EXTERNALSYM SE_UNSOLICITED_INPUT_NAME}

  SE_MACHINE_ACCOUNT_NAME     = 'SeMachineAccountPrivilege';

  {$EXTERNALSYM SE_MACHINE_ACCOUNT_NAME}

  SE_TCB_NAME                 = 'SeTcbPrivilege';

  {$EXTERNALSYM SE_TCB_NAME}

  SE_SECURITY_NAME            = 'SeSecurityPrivilege';

  {$EXTERNALSYM SE_SECURITY_NAME}

  SE_TAKE_OWNERSHIP_NAME      = 'SeTakeOwnershipPrivilege';

  {$EXTERNALSYM SE_TAKE_OWNERSHIP_NAME}

  SE_LOAD_DRIVER_NAME         = 'SeLoadDriverPrivilege';

  {$EXTERNALSYM SE_LOAD_DRIVER_NAME}

  SE_SYSTEM_PROFILE_NAME      = 'SeSystemProfilePrivilege';

  {$EXTERNALSYM SE_SYSTEM_PROFILE_NAME}

  SE_SYSTEMTIME_NAME          = 'SeSystemtimePrivilege';

  {$EXTERNALSYM SE_SYSTEMTIME_NAME}

  SE_PROF_SINGLE_PROCESS_NAME = 'SeProfileSingleProcessPrivilege';

  {$EXTERNALSYM SE_PROF_SINGLE_PROCESS_NAME}

  SE_INC_BASE_PRIORITY_NAME   = 'SeIncreaseBasePriorityPrivilege';

  {$EXTERNALSYM SE_INC_BASE_PRIORITY_NAME}

  SE_CREATE_PAGEFILE_NAME     = 'SeCreatePagefilePrivilege';

  {$EXTERNALSYM SE_CREATE_PAGEFILE_NAME}

  SE_CREATE_PERMANENT_NAME    = 'SeCreatePermanentPrivilege';

  {$EXTERNALSYM SE_CREATE_PERMANENT_NAME}

  SE_BACKUP_NAME              = 'SeBackupPrivilege';

  {$EXTERNALSYM SE_BACKUP_NAME}

  SE_RESTORE_NAME             = 'SeRestorePrivilege';

  {$EXTERNALSYM SE_RESTORE_NAME}

  SE_SHUTDOWN_NAME            = 'SeShutdownPrivilege';

  {$EXTERNALSYM SE_SHUTDOWN_NAME}

  SE_DEBUG_NAME               = 'SeDebugPrivilege';

  {$EXTERNALSYM SE_DEBUG_NAME}

  SE_AUDIT_NAME               = 'SeAuditPrivilege';

  {$EXTERNALSYM SE_AUDIT_NAME}

  SE_SYSTEM_ENVIRONMENT_NAME  = 'SeSystemEnvironmentPrivilege';

  {$EXTERNALSYM SE_SYSTEM_ENVIRONMENT_NAME}

  SE_CHANGE_NOTIFY_NAME       = 'SeChangeNotifyPrivilege';

  {$EXTERNALSYM SE_CHANGE_NOTIFY_NAME}

  SE_REMOTE_SHUTDOWN_NAME     = 'SeRemoteShutdownPrivilege';

  {$EXTERNALSYM SE_REMOTE_SHUTDOWN_NAME}

  SE_UNDOCK_NAME              = 'SeUndockPrivilege';

  {$EXTERNALSYM SE_UNDOCK_NAME}

  SE_SYNC_AGENT_NAME          = 'SeSyncAgentPrivilege';

  {$EXTERNALSYM SE_SYNC_AGENT_NAME}

  SE_ENABLE_DELEGATION_NAME   = 'SeEnableDelegationPrivilege';

  {$EXTERNALSYM SE_ENABLE_DELEGATION_NAME}

  SE_MANAGE_VOLUME_NAME       = 'SeManageVolumePrivilege';

  {$EXTERNALSYM SE_MANAGE_VOLUME_NAME}

  SE_IMPERSONATE_NAME         = 'SeImpersonatePrivilege';

  {$EXTERNALSYM SE_IMPERSONATE_NAME}

  SE_CREATE_GLOBAL_NAME       = 'SeCreateGlobalPrivilege';

  {$EXTERNALSYM SE_CREATE_GLOBAL_NAME}



//

// Thread Information Block (TIB)

//



type

  NT_TIB32 = packed record

    ExceptionList: DWORD;

    StackBase: DWORD;

    StackLimit: DWORD;

    SubSystemTib: DWORD;

    case Integer of

      0 : (

        FiberData: DWORD;

        ArbitraryUserPointer: DWORD;

        Self: DWORD;

      );

      1 : (

        Version: DWORD;

      );

  end;

  {$EXTERNALSYM NT_TIB32}

  PNT_TIB32 = ^NT_TIB32;

  {$EXTERNALSYM PNT_TIB32}



  NT_TIB64 = packed record

    ExceptionList: TJclAddr64;

    StackBase: TJclAddr64;

    StackLimit: TJclAddr64;

    SubSystemTib: TJclAddr64;

    case Integer of

      0 : (

        FiberData: TJclAddr64;

        ArbitraryUserPointer: TJclAddr64;

        Self: TJclAddr64;

      );

      1 : (

        Version: DWORD;

      );

  end;

  {$EXTERNALSYM NT_TIB64}

  PNT_TIB64 = ^NT_TIB64;

  {$EXTERNALSYM PNT_TIB64}



// line 2686



//

// Token information class structures

//



{$IFNDEF FPC}

type

  PTOKEN_USER = ^TOKEN_USER;

  {$EXTERNALSYM PTOKEN_USER}

  _TOKEN_USER = record

    User: SID_AND_ATTRIBUTES;

  end;

  {$EXTERNALSYM _TOKEN_USER}

  TOKEN_USER = _TOKEN_USER;

  {$EXTERNALSYM TOKEN_USER}

  TTokenUser = TOKEN_USER;

  PTokenUser = PTOKEN_USER;

{$ENDIF ~FPC}



// line 3858



//

// Define access rights to files and directories

//



//

// The FILE_READ_DATA and FILE_WRITE_DATA constants are also defined in

// devioctl.h as FILE_READ_ACCESS and FILE_WRITE_ACCESS. The values for these

// constants *MUST* always be in sync.

// The values are redefined in devioctl.h because they must be available to

// both DOS and NT.

//



const

  FILE_READ_DATA            = ($0001); // file & pipe

  {$EXTERNALSYM FILE_READ_DATA}

  FILE_LIST_DIRECTORY       = ($0001); // directory

  {$EXTERNALSYM FILE_LIST_DIRECTORY}



  FILE_WRITE_DATA           = ($0002); // file & pipe

  {$EXTERNALSYM FILE_WRITE_DATA}

  FILE_ADD_FILE             = ($0002); // directory

  {$EXTERNALSYM FILE_ADD_FILE}



  FILE_APPEND_DATA          = ($0004); // file

  {$EXTERNALSYM FILE_APPEND_DATA}

  FILE_ADD_SUBDIRECTORY     = ($0004); // directory

  {$EXTERNALSYM FILE_ADD_SUBDIRECTORY}

  FILE_CREATE_PIPE_INSTANCE = ($0004); // named pipe

  {$EXTERNALSYM FILE_CREATE_PIPE_INSTANCE}



  FILE_READ_EA = ($0008); // file & directory

  {$EXTERNALSYM FILE_READ_EA}



  FILE_WRITE_EA = ($0010); // file & directory

  {$EXTERNALSYM FILE_WRITE_EA}



  FILE_EXECUTE = ($0020); // file

  {$EXTERNALSYM FILE_EXECUTE}

  FILE_TRAVERSE = ($0020); // directory

  {$EXTERNALSYM FILE_TRAVERSE}



  FILE_DELETE_CHILD = ($0040); // directory

  {$EXTERNALSYM FILE_DELETE_CHILD}



  FILE_READ_ATTRIBUTES = ($0080); // all

  {$EXTERNALSYM FILE_READ_ATTRIBUTES}



  FILE_WRITE_ATTRIBUTES = ($0100); // all

  {$EXTERNALSYM FILE_WRITE_ATTRIBUTES}



  FILE_ALL_ACCESS = (STANDARD_RIGHTS_REQUIRED or SYNCHRONIZE or $1FF);

  {$EXTERNALSYM FILE_ALL_ACCESS}



  FILE_GENERIC_READ = (STANDARD_RIGHTS_READ or FILE_READ_DATA or

    FILE_READ_ATTRIBUTES or FILE_READ_EA or SYNCHRONIZE);

  {$EXTERNALSYM FILE_GENERIC_READ}



  FILE_GENERIC_WRITE = (STANDARD_RIGHTS_WRITE or FILE_WRITE_DATA or

    FILE_WRITE_ATTRIBUTES or FILE_WRITE_EA or FILE_APPEND_DATA or SYNCHRONIZE);

  {$EXTERNALSYM FILE_GENERIC_WRITE}



  FILE_GENERIC_EXECUTE = (STANDARD_RIGHTS_EXECUTE or FILE_READ_ATTRIBUTES or

    FILE_EXECUTE or SYNCHRONIZE);

  {$EXTERNALSYM FILE_GENERIC_EXECUTE}



  FILE_SHARE_READ                    = $00000001;

  {$EXTERNALSYM FILE_SHARE_READ}

  FILE_SHARE_WRITE                   = $00000002;

  {$EXTERNALSYM FILE_SHARE_WRITE}

  FILE_SHARE_DELETE                  = $00000004;

  {$EXTERNALSYM FILE_SHARE_DELETE}

  FILE_ATTRIBUTE_READONLY            = $00000001;

  {$EXTERNALSYM FILE_ATTRIBUTE_READONLY}

  FILE_ATTRIBUTE_HIDDEN              = $00000002;

  {$EXTERNALSYM FILE_ATTRIBUTE_HIDDEN}

  FILE_ATTRIBUTE_SYSTEM              = $00000004;

  {$EXTERNALSYM FILE_ATTRIBUTE_SYSTEM}

  FILE_ATTRIBUTE_DIRECTORY           = $00000010;

  {$EXTERNALSYM FILE_ATTRIBUTE_DIRECTORY}

  FILE_ATTRIBUTE_ARCHIVE             = $00000020;

  {$EXTERNALSYM FILE_ATTRIBUTE_ARCHIVE}

  FILE_ATTRIBUTE_DEVICE              = $00000040;

  {$EXTERNALSYM FILE_ATTRIBUTE_DEVICE}

  FILE_ATTRIBUTE_NORMAL              = $00000080;

  {$EXTERNALSYM FILE_ATTRIBUTE_NORMAL}

  FILE_ATTRIBUTE_TEMPORARY           = $00000100;

  {$EXTERNALSYM FILE_ATTRIBUTE_TEMPORARY}

  FILE_ATTRIBUTE_SPARSE_FILE         = $00000200;

  {$EXTERNALSYM FILE_ATTRIBUTE_SPARSE_FILE}

  FILE_ATTRIBUTE_REPARSE_POINT       = $00000400;

  {$EXTERNALSYM FILE_ATTRIBUTE_REPARSE_POINT}

  FILE_ATTRIBUTE_COMPRESSED          = $00000800;

  {$EXTERNALSYM FILE_ATTRIBUTE_COMPRESSED}

  FILE_ATTRIBUTE_OFFLINE             = $00001000;

  {$EXTERNALSYM FILE_ATTRIBUTE_OFFLINE}

  FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = $00002000;

  {$EXTERNALSYM FILE_ATTRIBUTE_NOT_CONTENT_INDEXED}

  FILE_ATTRIBUTE_ENCRYPTED           = $00004000;

  {$EXTERNALSYM FILE_ATTRIBUTE_ENCRYPTED}

  FILE_NOTIFY_CHANGE_FILE_NAME       = $00000001;

  {$EXTERNALSYM FILE_NOTIFY_CHANGE_FILE_NAME}

  FILE_NOTIFY_CHANGE_DIR_NAME        = $00000002;

  {$EXTERNALSYM FILE_NOTIFY_CHANGE_DIR_NAME}

  FILE_NOTIFY_CHANGE_ATTRIBUTES      = $00000004;

  {$EXTERNALSYM FILE_NOTIFY_CHANGE_ATTRIBUTES}

  FILE_NOTIFY_CHANGE_SIZE            = $00000008;

  {$EXTERNALSYM FILE_NOTIFY_CHANGE_SIZE}

  FILE_NOTIFY_CHANGE_LAST_WRITE      = $00000010;

  {$EXTERNALSYM FILE_NOTIFY_CHANGE_LAST_WRITE}

  FILE_NOTIFY_CHANGE_LAST_ACCESS     = $00000020;

  {$EXTERNALSYM FILE_NOTIFY_CHANGE_LAST_ACCESS}

  FILE_NOTIFY_CHANGE_CREATION        = $00000040;

  {$EXTERNALSYM FILE_NOTIFY_CHANGE_CREATION}

  FILE_NOTIFY_CHANGE_SECURITY        = $00000100;

  {$EXTERNALSYM FILE_NOTIFY_CHANGE_SECURITY}

  FILE_ACTION_ADDED                  = $00000001;

  {$EXTERNALSYM FILE_ACTION_ADDED}

  FILE_ACTION_REMOVED                = $00000002;

  {$EXTERNALSYM FILE_ACTION_REMOVED}

  FILE_ACTION_MODIFIED               = $00000003;

  {$EXTERNALSYM FILE_ACTION_MODIFIED}

  FILE_ACTION_RENAMED_OLD_NAME       = $00000004;

  {$EXTERNALSYM FILE_ACTION_RENAMED_OLD_NAME}

  FILE_ACTION_RENAMED_NEW_NAME       = $00000005;

  {$EXTERNALSYM FILE_ACTION_RENAMED_NEW_NAME}

  MAILSLOT_NO_MESSAGE                = DWORD(-1);

  {$EXTERNALSYM MAILSLOT_NO_MESSAGE}

  MAILSLOT_WAIT_FOREVER              = DWORD(-1);

  {$EXTERNALSYM MAILSLOT_WAIT_FOREVER}

  FILE_CASE_SENSITIVE_SEARCH         = $00000001;

  {$EXTERNALSYM FILE_CASE_SENSITIVE_SEARCH}

  FILE_CASE_PRESERVED_NAMES          = $00000002;

  {$EXTERNALSYM FILE_CASE_PRESERVED_NAMES}

  FILE_UNICODE_ON_DISK               = $00000004;

  {$EXTERNALSYM FILE_UNICODE_ON_DISK}

  FILE_PERSISTENT_ACLS               = $00000008;

  {$EXTERNALSYM FILE_PERSISTENT_ACLS}

  FILE_FILE_COMPRESSION              = $00000010;

  {$EXTERNALSYM FILE_FILE_COMPRESSION}

  FILE_VOLUME_QUOTAS                 = $00000020;

  {$EXTERNALSYM FILE_VOLUME_QUOTAS}

  FILE_SUPPORTS_SPARSE_FILES         = $00000040;

  {$EXTERNALSYM FILE_SUPPORTS_SPARSE_FILES}

  FILE_SUPPORTS_REPARSE_POINTS       = $00000080;

  {$EXTERNALSYM FILE_SUPPORTS_REPARSE_POINTS}

  FILE_SUPPORTS_REMOTE_STORAGE       = $00000100;

  {$EXTERNALSYM FILE_SUPPORTS_REMOTE_STORAGE}

  FILE_VOLUME_IS_COMPRESSED          = $00008000;

  {$EXTERNALSYM FILE_VOLUME_IS_COMPRESSED}

  FILE_SUPPORTS_OBJECT_IDS           = $00010000;

  {$EXTERNALSYM FILE_SUPPORTS_OBJECT_IDS}

  FILE_SUPPORTS_ENCRYPTION           = $00020000;

  {$EXTERNALSYM FILE_SUPPORTS_ENCRYPTION}

  FILE_NAMED_STREAMS                 = $00040000;

  {$EXTERNALSYM FILE_NAMED_STREAMS}

  FILE_READ_ONLY_VOLUME              = $00080000;

  {$EXTERNALSYM FILE_READ_ONLY_VOLUME}



// line 4052



//

// The reparse GUID structure is used by all 3rd party layered drivers to

// store data in a reparse point. For non-Microsoft tags, The GUID field

// cannot be GUID_NULL.

// The constraints on reparse tags are defined below.

// Microsoft tags can also be used with this format of the reparse point buffer.

//



type

  TGenericReparseBuffer = record

    DataBuffer: array [0..0] of BYTE;

  end;



  PREPARSE_GUID_DATA_BUFFER = ^REPARSE_GUID_DATA_BUFFER;

  {$EXTERNALSYM PREPARSE_GUID_DATA_BUFFER}

  _REPARSE_GUID_DATA_BUFFER = record

    ReparseTag: DWORD;

    ReparseDataLength: WORD;

    Reserved: WORD;

    ReparseGuid: TGUID;

    GenericReparseBuffer: TGenericReparseBuffer;

  end;

  {$EXTERNALSYM _REPARSE_GUID_DATA_BUFFER}

  REPARSE_GUID_DATA_BUFFER = _REPARSE_GUID_DATA_BUFFER;

  {$EXTERNALSYM REPARSE_GUID_DATA_BUFFER}

  TReparseGuidDataBuffer = REPARSE_GUID_DATA_BUFFER;

  PReparseGuidDataBuffer = PREPARSE_GUID_DATA_BUFFER;



const

  REPARSE_GUID_DATA_BUFFER_HEADER_SIZE = 24;

  {$EXTERNALSYM REPARSE_GUID_DATA_BUFFER_HEADER_SIZE}

//

// Maximum allowed size of the reparse data.

//



const

  MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 16 * 1024;

  {$EXTERNALSYM MAXIMUM_REPARSE_DATA_BUFFER_SIZE}



//

// Predefined reparse tags.

// These tags need to avoid conflicting with IO_REMOUNT defined in ntos\inc\io.h

//



  IO_REPARSE_TAG_RESERVED_ZERO = (0);

  {$EXTERNALSYM IO_REPARSE_TAG_RESERVED_ZERO}

  IO_REPARSE_TAG_RESERVED_ONE  = (1);

  {$EXTERNALSYM IO_REPARSE_TAG_RESERVED_ONE}



//

// The value of the following constant needs to satisfy the following conditions:

//  (1) Be at least as large as the largest of the reserved tags.

//  (2) Be strictly smaller than all the tags in use.

//



  IO_REPARSE_TAG_RESERVED_RANGE = IO_REPARSE_TAG_RESERVED_ONE;

  {$EXTERNALSYM IO_REPARSE_TAG_RESERVED_RANGE}



//

// The reparse tags are a DWORD. The 32 bits are laid out as follows:

//

//   3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1

//   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0

//  +-+-+-+-+-----------------------+-------------------------------+

//  |M|R|N|R|     Reserved bits     |       Reparse Tag Value       |

//  +-+-+-+-+-----------------------+-------------------------------+

//

// M is the Microsoft bit. When set to 1, it denotes a tag owned by Microsoft.

//   All ISVs must use a tag with a 0 in this position.

//   Note: If a Microsoft tag is used by non-Microsoft software, the

//   behavior is not defined.

//

// R is reserved.  Must be zero for non-Microsoft tags.

//

// N is name surrogate. When set to 1, the file represents another named

//   entity in the system.

//

// The M and N bits are OR-able.

// The following macros check for the M and N bit values:

//



//

// Macro to determine whether a reparse point tag corresponds to a tag

// owned by Microsoft.

//



function IsReparseTagMicrosoft(Tag: ULONG): Boolean;

{$EXTERNALSYM IsReparseTagMicrosoft}



//

// Macro to determine whether a reparse point tag corresponds to a file

// that is to be displayed with the slow icon overlay.

//



function IsReparseTagHighLatency(Tag: ULONG): Boolean;

{$EXTERNALSYM IsReparseTagHighLatency}



//

// Macro to determine whether a reparse point tag is a name surrogate

//



function IsReparseTagNameSurrogate(Tag: ULONG): Boolean;

{$EXTERNALSYM IsReparseTagNameSurrogate}



const

  IO_REPARSE_TAG_MOUNT_POINT = DWORD($A0000003);

  {$EXTERNALSYM IO_REPARSE_TAG_MOUNT_POINT}

  IO_REPARSE_TAG_HSM         = DWORD($C0000004);

  {$EXTERNALSYM IO_REPARSE_TAG_HSM}

  IO_REPARSE_TAG_SIS         = DWORD($80000007);

  {$EXTERNALSYM IO_REPARSE_TAG_SIS}

  IO_REPARSE_TAG_DFS         = DWORD($8000000A);

  {$EXTERNALSYM IO_REPARSE_TAG_DFS}

  IO_REPARSE_TAG_FILTER_MANAGER = DWORD($8000000B);

  {$EXTERNALSYM IO_REPARSE_TAG_FILTER_MANAGER}

  IO_COMPLETION_MODIFY_STATE = $0002;

  {$EXTERNALSYM IO_COMPLETION_MODIFY_STATE}

  IO_COMPLETION_ALL_ACCESS   = DWORD(STANDARD_RIGHTS_REQUIRED or SYNCHRONIZE or $3);

  {$EXTERNALSYM IO_COMPLETION_ALL_ACCESS}

  DUPLICATE_CLOSE_SOURCE     = $00000001;

  {$EXTERNALSYM DUPLICATE_CLOSE_SOURCE}

  DUPLICATE_SAME_ACCESS      = $00000002;

  {$EXTERNALSYM DUPLICATE_SAME_ACCESS}



// line 4763



//

// File header format.

//



{$IFNDEF FPC}

type

  PIMAGE_FILE_HEADER = ^IMAGE_FILE_HEADER;

  {$EXTERNALSYM PIMAGE_FILE_HEADER}

  _IMAGE_FILE_HEADER = record

    Machine: WORD;

    NumberOfSections: WORD;

    TimeDateStamp: DWORD;

    PointerToSymbolTable: DWORD;

    NumberOfSymbols: DWORD;

    SizeOfOptionalHeader: WORD;

    Characteristics: WORD;

  end;

  {$EXTERNALSYM _IMAGE_FILE_HEADER}

  IMAGE_FILE_HEADER = _IMAGE_FILE_HEADER;

  {$EXTERNALSYM IMAGE_FILE_HEADER}

  TImageFileHeader = IMAGE_FILE_HEADER;

  PImageFileHeader = PIMAGE_FILE_HEADER;

{$ENDIF ~FPC}



const

  IMAGE_SIZEOF_FILE_HEADER = 20;

  {$EXTERNALSYM IMAGE_SIZEOF_FILE_HEADER}



  IMAGE_FILE_RELOCS_STRIPPED         = $0001; // Relocation info stripped from file.

  {$EXTERNALSYM IMAGE_FILE_RELOCS_STRIPPED}

  IMAGE_FILE_EXECUTABLE_IMAGE        = $0002; // File is executable  (i.e. no unresolved externel references).

  {$EXTERNALSYM IMAGE_FILE_EXECUTABLE_IMAGE}

  IMAGE_FILE_LINE_NUMS_STRIPPED      = $0004; // Line nunbers stripped from file.

  {$EXTERNALSYM IMAGE_FILE_LINE_NUMS_STRIPPED}

  IMAGE_FILE_LOCAL_SYMS_STRIPPED     = $0008; // Local symbols stripped from file.

  {$EXTERNALSYM IMAGE_FILE_LOCAL_SYMS_STRIPPED}

  IMAGE_FILE_AGGRESIVE_WS_TRIM       = $0010; // Agressively trim working set

  {$EXTERNALSYM IMAGE_FILE_AGGRESIVE_WS_TRIM}

  IMAGE_FILE_LARGE_ADDRESS_AWARE     = $0020; // App can handle >2gb addresses

  {$EXTERNALSYM IMAGE_FILE_LARGE_ADDRESS_AWARE}

  IMAGE_FILE_BYTES_REVERSED_LO       = $0080; // Bytes of machine word are reversed.

  {$EXTERNALSYM IMAGE_FILE_BYTES_REVERSED_LO}

  IMAGE_FILE_32BIT_MACHINE           = $0100; // 32 bit word machine.

  {$EXTERNALSYM IMAGE_FILE_32BIT_MACHINE}

  IMAGE_FILE_DEBUG_STRIPPED          = $0200; // Debugging info stripped from file in .DBG file

  {$EXTERNALSYM IMAGE_FILE_DEBUG_STRIPPED}

  IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP = $0400; // If Image is on removable media, copy and run from the swap file.

  {$EXTERNALSYM IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP}

  IMA