Ignore:
Timestamp:
Nov 30, 1999, 8:38:24 PM (26 years ago)
Author:
sandervl
Message:

Wine header updates

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/win/ntddk.h

    r31 r1890  
    1 /* $Id: ntddk.h,v 1.2 1999-06-01 21:57:25 phaller Exp $ */
    2 
    3 /*
    4    this file defines interfaces mainly exposed to device drivers and
    5    native nt dll's
     1/* $Id: ntddk.h,v 1.3 1999-11-30 19:38:23 sandervl Exp $ */
     2/*
     3        this file defines interfaces mainly exposed to device drivers and
     4        native nt dll's
    65
    76*/
    … …  
    98#define __WINE_NTDDK_H
    109
    11 #include <ntdef.h>
    12 #include <winnt.h>
    13 #include "winbase.h"                     /* fixme: should be taken out sometimes */
     10#include "ntdef.h"
     11#include "winnt.h"
     12#include "winbase.h"    /* fixme: should be taken out sometimes */
    1413
    1514#ifdef __cplusplus
    … …  
    1716#endif
    1817
    19 /******************
    20  * asynchronous I/O
    21  */
    22 #undef Status  /* conflict with X11-includes*/
    23 
    24 typedef struct _IO_STATUS_BLOCK
    25 {  union
    26    { NTSTATUS Status;
    27      PVOID Pointer;
    28    } u;
    29    ULONG_PTR Information;
    30 } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
    31 
    32 typedef VOID (NTAPI IO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
    33 typedef IO_APC_ROUTINE *PIO_APIO_APC_ROUTINE;
    34 
     18/******************
     19 * asynchronous I/O
     20 */
     21#undef Status   /* conflict with X11-includes*/
     22
     23typedef struct _IO_STATUS_BLOCK
     24{
     25        union {
     26          NTSTATUS Status;
     27          PVOID Pointer;
     28        } DUMMYUNIONNAME;
     29        ULONG_PTR Information;
     30} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;   
     31
     32typedef VOID (NTAPI *PIO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
    3533
    3634typedef enum _KEY_INFORMATION_CLASS {
    37    KeyBasicInformation,
    38    KeyNodeInformation,
    39    KeyFullInformation
     35        KeyBasicInformation,
     36        KeyNodeInformation,
     37        KeyFullInformation
    4038} KEY_INFORMATION_CLASS;
    4139
    4240typedef enum _KEY_VALUE_INFORMATION_CLASS {
    43    KeyValueBasicInformation,
    44    KeyValueFullInformation,
    45    KeyValuePartialInformation,
    46    KeyValueFullInformationAlign64,
    47    KeyValuePartialInformationAlign64
     41        KeyValueBasicInformation,
     42        KeyValueFullInformation,
     43        KeyValuePartialInformation,
     44        KeyValueFullInformationAlign64,
     45        KeyValuePartialInformationAlign64
    4846} KEY_VALUE_INFORMATION_CLASS;
    4947
    50 typedef enum _THREADINFOCLASS
    51 {  ThreadBasicInformation,
    52    ThreadTimes,
    53    ThreadPriority,
    54    ThreadBasePriority,
    55    ThreadAffinityMask,
    56    ThreadImpersonationToken,
    57    ThreadDescriptorTableEntry,
    58    ThreadEnableAlignmentFaultFixup,
    59    ThreadEventPair_Reusable,
    60    ThreadQuerySetWin32StartAddress,
    61    ThreadZeroTlsCell,
    62    ThreadPerformanceCount,
    63    ThreadAmILastThread,
    64    ThreadIdealProcessor,
    65    ThreadPriorityBoost,
    66    ThreadSetTlsArrayAddress,
    67    ThreadIsIoPending,
    68    MaxThreadInfoClass
     48typedef enum _THREADINFOCLASS 
     49{       ThreadBasicInformation,
     50        ThreadTimes,
     51        ThreadPriority,
     52        ThreadBasePriority,
     53        ThreadAffinityMask,
     54        ThreadImpersonationToken,
     55        ThreadDescriptorTableEntry,
     56        ThreadEnableAlignmentFaultFixup,
     57        ThreadEventPair_Reusable,
     58        ThreadQuerySetWin32StartAddress,
     59        ThreadZeroTlsCell,
     60        ThreadPerformanceCount,
     61        ThreadAmILastThread,
     62        ThreadIdealProcessor,
     63        ThreadPriorityBoost,
     64        ThreadSetTlsArrayAddress,
     65        ThreadIsIoPending,
     66        MaxThreadInfoClass
    6967} THREADINFOCLASS;
    7068
    7169typedef enum _FILE_INFORMATION_CLASS {
    72    FileDirectoryInformation = 1,
    73    FileFullDirectoryInformation,
    74    FileBothDirectoryInformation,
    75    FileBasicInformation,
    76    FileStandardInformation,
    77    FileInternalInformation,
    78    FileEaInformation,
    79    FileAccessInformation,
    80    FileNameInformation,
    81    FileRenameInformation,
    82    FileLinkInformation,
    83    FileNamesInformation,
    84    FileDispositionInformation,
    85    FilePositionInformation,
    86    FileFullEaInformation,
    87    FileModeInformation,
    88    FileAlignmentInformation,
    89    FileAllInformation,
    90    FileAllocationInformation,
    91    FileEndOfFileInformation,
    92    FileAlternateNameInformation,
    93    FileStreamInformation,
    94    FilePipeInformation,
    95    FilePipeLocalInformation,
    96    FilePipeRemoteInformation,
    97    FileMailslotQueryInformation,
    98    FileMailslotSetInformation,
    99    FileCompressionInformation,
    100    FileObjectIdInformation,
    101    FileCompletionInformation,
    102    FileMoveClusterInformation,
    103    FileQuotaInformation,
    104    FileReparsePointInformation,
    105    FileNetworkOpenInformation,
    106    FileAttributeTagInformation,
    107    FileTrackingInformation,
    108    FileMaximumInformation
     70        FileDirectoryInformation = 1,
     71        FileFullDirectoryInformation,
     72        FileBothDirectoryInformation,
     73        FileBasicInformation,
     74        FileStandardInformation,
     75        FileInternalInformation,
     76        FileEaInformation,
     77        FileAccessInformation,
     78        FileNameInformation,
     79        FileRenameInformation,
     80        FileLinkInformation,
     81        FileNamesInformation,
     82        FileDispositionInformation,
     83        FilePositionInformation,
     84        FileFullEaInformation,
     85        FileModeInformation,
     86        FileAlignmentInformation,
     87        FileAllInformation,
     88        FileAllocationInformation,
     89        FileEndOfFileInformation,
     90        FileAlternateNameInformation,
     91        FileStreamInformation,
     92        FilePipeInformation,
     93        FilePipeLocalInformation,
     94        FilePipeRemoteInformation,
     95        FileMailslotQueryInformation,
     96        FileMailslotSetInformation,
     97        FileCompressionInformation,
     98        FileObjectIdInformation,
     99        FileCompletionInformation,
     100        FileMoveClusterInformation,
     101        FileQuotaInformation,
     102        FileReparsePointInformation,
     103        FileNetworkOpenInformation,
     104        FileAttributeTagInformation,
     105        FileTrackingInformation,
     106        FileMaximumInformation
    109107} FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
    110108
    111 typedef enum _SECTION_INHERIT
     109typedef enum _FSINFOCLASS {
     110        FileFsVolumeInformation = 1,
     111        FileFsLabelInformation,
     112        FileFsSizeInformation,
     113        FileFsDeviceInformation,
     114        FileFsAttributeInformation,
     115        FileFsControlInformation,
     116        FileFsFullSizeInformation,
     117        FileFsObjectIdInformation,
     118        FileFsMaximumInformation
     119} FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
     120
     121typedef enum _SECTION_INHERIT
    112122{
    113    ViewShare = 1,
    114    ViewUnmap = 2
     123        ViewShare = 1,
     124        ViewUnmap = 2
    115125
    116126} SECTION_INHERIT;
    117 
    118 /*
    119    placeholder
     127 
     128/*
     129        placeholder
    120130*/
    121131typedef enum _OBJECT_INFORMATION_CLASS
    122132{
    123    DunnoTheConstants1
     133        DunnoTheConstants1
    124134
    125135} OBJECT_INFORMATION_CLASS, *POBJECT_INFORMATION_CLASS;
    … …  
    127137
    128138/*
    129  * NtQuerySystemInformation
     139 *      NtQuerySystemInformation
    130140 */
    131141
    132142typedef enum SYSTEM_INFORMATION_CLASS
    133 {  Unknown1 = 1,
    134    Unknown2,
    135    Unknown3,
    136    Unknown4,
    137    SystemPerformanceInformation
     143{       Unknown1 = 1,
     144        Unknown2,
     145        Unknown3,
     146        Unknown4,
     147        SystemPerformanceInformation
    138148} SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS;
    139149
    140150/* reading coffee grounds... */
    141151typedef struct _THREAD_INFO
    142 {  DWORD Unknown1[6];
    143    DWORD ThreadID;
    144    DWORD Unknown2[3];
    145    DWORD Status;
    146    DWORD WaitReason;
    147    DWORD Unknown3[4];
     152{       DWORD   Unknown1[6];
     153        DWORD   ThreadID;
     154        DWORD   Unknown2[3];
     155        DWORD   Status;
     156        DWORD   WaitReason;
     157        DWORD   Unknown3[4];
    148158} THREAD_INFO, PTHREAD_INFO;
    149159
    150160typedef struct _VM_COUNTERS_
    151 {  ULONG PeakVirtualSize;
    152    ULONG VirtualSize;
    153    ULONG PageFaultCount;
    154    ULONG PeakWorkingSetSize;
    155    ULONG WorkingSetSize;
    156    ULONG QuotaPeakPagedPoolUsage;
    157    ULONG QuotaPagedPoolUsage;
    158    ULONG QuotaPeakNonPagedPoolUsage;
    159    ULONG QuotaNonPagedPoolUsage;
    160    ULONG PagefileUsage;
    161    ULONG PeakPagefileUsage;
     161{       ULONG PeakVirtualSize;
     162        ULONG VirtualSize;
     163        ULONG PageFaultCount;
     164        ULONG PeakWorkingSetSize;
     165        ULONG WorkingSetSize;
     166        ULONG QuotaPeakPagedPoolUsage;
     167        ULONG QuotaPagedPoolUsage;
     168        ULONG QuotaPeakNonPagedPoolUsage;
     169        ULONG QuotaNonPagedPoolUsage;
     170        ULONG PagefileUsage;
     171        ULONG PeakPagefileUsage;
    162172} VM_COUNTERS, *PVM_COUNTERS;
    163173
    164174typedef struct _PROCESS_INFO
    165 {  DWORD    Offset;                         /* 00 offset to next PROCESS_INFO ok*/
    166    DWORD    ThreadCount;                 /* 04 number of ThreadInfo member ok */
    167    DWORD    Unknown1[6];
    168    FILETIME CreationTime;                /* 20 */
    169    DWORD    Unknown2[5];
    170    PWCHAR      ProcessName;              /* 3c ok */
    171    DWORD    BasePriority;
    172    DWORD    ProcessID;                   /* 44 ok*/
    173    DWORD    ParentProcessID;
    174    DWORD    HandleCount;
    175    DWORD    Unknown3[2];                 /* 50 */
    176    ULONG    PeakVirtualSize;
    177    ULONG    VirtualSize;
    178    ULONG    PageFaultCount;
    179    ULONG    PeakWorkingSetSize;
    180    ULONG    WorkingSetSize;
    181    ULONG    QuotaPeakPagedPoolUsage;
    182    ULONG    QuotaPagedPoolUsage;
    183    ULONG    QuotaPeakNonPagedPoolUsage;
    184    ULONG    QuotaNonPagedPoolUsage;
    185    ULONG    PagefileUsage;
    186    ULONG    PeakPagefileUsage;
    187    DWORD    PrivateBytes;
    188    DWORD    Unknown6[4];
    189    THREAD_INFO    ati[ANYSIZE_ARRAY];    /* 94 size=0x40*/
     175{       DWORD           Offset;         /* 00 offset to next PROCESS_INFO ok*/
     176        DWORD           ThreadCount;    /* 04 number of ThreadInfo member ok */
     177        DWORD           Unknown1[6];
     178        FILETIME        CreationTime;   /* 20 */
     179        DWORD           Unknown2[5];
     180        PWCHAR          ProcessName;    /* 3c ok */
     181        DWORD           BasePriority;
     182        DWORD           ProcessID;      /* 44 ok*/
     183        DWORD           ParentProcessID;
     184        DWORD           HandleCount;
     185        DWORD           Unknown3[2];    /* 50 */
     186        ULONG           PeakVirtualSize;
     187        ULONG           VirtualSize;
     188        ULONG           PageFaultCount;
     189        ULONG           PeakWorkingSetSize;
     190        ULONG           WorkingSetSize;
     191        ULONG           QuotaPeakPagedPoolUsage;
     192        ULONG           QuotaPagedPoolUsage;
     193        ULONG           QuotaPeakNonPagedPoolUsage;
     194        ULONG           QuotaNonPagedPoolUsage;
     195        ULONG           PagefileUsage;
     196        ULONG           PeakPagefileUsage;
     197        DWORD           PrivateBytes;
     198        DWORD           Unknown6[4];
     199        THREAD_INFO     ati[ANYSIZE_ARRAY];     /* 94 size=0x40*/
    190200} PROCESS_INFO, PPROCESS_INFO;
    191201
    192202NTSTATUS WINAPI NtQuerySystemInformation(
    193    IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
    194    OUT PVOID SystemInformation,
    195    IN ULONG Length,
    196    OUT PULONG ResultLength);
    197 
    198 /*
    199  * system configuration
     203        IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
     204        OUT PVOID SystemInformation,
     205        IN ULONG Length,
     206        OUT PULONG ResultLength);
     207
     208/*
     209 *      system configuration
    200210 */
    201211
    … …  
    203213typedef struct _SYSTEM_TIME_ADJUSTMENT
    204214{
    205    ULONG TimeAdjustment;
    206    BOOLEAN  TimeAdjustmentDisabled;
     215        ULONG   TimeAdjustment;
     216        BOOLEAN TimeAdjustmentDisabled;
    207217
    208218} SYSTEM_TIME_ADJUSTMENT, *PSYSTEM_TIME_ADJUSTMENT;
    209219
    210 typedef struct _SYSTEM_CONFIGURATION_INFO
     220typedef struct _SYSTEM_CONFIGURATION_INFO 
    211221{
    212    union
    213    { ULONG  OemId;
    214      struct
    215      { WORD ProcessorArchitecture;
    216        WORD Reserved;
    217      } tag1;
    218    } tag2;
    219    ULONG PageSize;
    220    PVOID MinimumApplicationAddress;
    221    PVOID MaximumApplicationAddress;
    222    ULONG ActiveProcessorMask;
    223    ULONG NumberOfProcessors;
    224    ULONG ProcessorType;
    225    ULONG AllocationGranularity;
    226    WORD  ProcessorLevel;
    227    WORD  ProcessorRevision;
     222        union
     223        { ULONG OemId;
     224          struct
     225          { WORD        ProcessorArchitecture;
     226            WORD        Reserved;
     227          } tag1;
     228        } tag2;
     229        ULONG   PageSize;
     230        PVOID   MinimumApplicationAddress;
     231        PVOID   MaximumApplicationAddress;
     232        ULONG   ActiveProcessorMask;
     233        ULONG   NumberOfProcessors;
     234        ULONG   ProcessorType;
     235        ULONG   AllocationGranularity;
     236        WORD    ProcessorLevel;
     237        WORD    ProcessorRevision;
    228238
    229239} SYSTEM_CONFIGURATION_INFO, *PSYSTEM_CONFIGURATION_INFO;
    230240
    231241
    232 typedef struct _SYSTEM_CACHE_INFORMATION
     242typedef struct _SYSTEM_CACHE_INFORMATION 
    233243{
    234    ULONG CurrentSize;
    235    ULONG PeakSize;
    236    ULONG PageFaultCount;
    237    ULONG MinimumWorkingSet;
    238    ULONG MaximumWorkingSet;
    239    ULONG Unused[4];
     244        ULONG   CurrentSize;
     245        ULONG   PeakSize;
     246        ULONG   PageFaultCount;
     247        ULONG   MinimumWorkingSet;
     248        ULONG   MaximumWorkingSet;
     249        ULONG   Unused[4];
    240250
    241251} SYSTEM_CACHE_INFORMATION;
    242252
    243253/*
    244  * NtQueryProcessInformation
     254 *      NtQueryProcessInformation
    245255 */
    246256
    247257/* parameter ProcessInformationClass */
    248258
    249 typedef enum _PROCESSINFOCLASS
    250 {  ProcessBasicInformation,
    251    ProcessQuotaLimits,
    252    ProcessIoCounters,
    253    ProcessVmCounters,
    254    ProcessTimes,
    255    ProcessBasePriority,
    256    ProcessRaisePriority,
    257    ProcessDebugPort,
    258    ProcessExceptionPort,
    259    ProcessAccessToken,
    260    ProcessLdtInformation,
    261    ProcessLdtSize,
    262    ProcessDefaultHardErrorMode,
    263    ProcessIoPortHandlers,
    264    ProcessPooledUsageAndLimits,
    265    ProcessWorkingSetWatch,
    266    ProcessUserModeIOPL,
    267    ProcessEnableAlignmentFaultFixup,
    268    ProcessPriorityClass,
    269    ProcessWx86Information,
    270    ProcessHandleCount,
    271    ProcessAffinityMask,
    272    ProcessPriorityBoost,
    273    ProcessDeviceMap,
    274    ProcessSessionInformation,
    275    ProcessForegroundInformation,
    276    ProcessWow64Information,
    277    MaxProcessInfoClass
     259typedef enum _PROCESSINFOCLASS 
     260{       ProcessBasicInformation,
     261        ProcessQuotaLimits,
     262        ProcessIoCounters,
     263        ProcessVmCounters,
     264        ProcessTimes,
     265        ProcessBasePriority,
     266        ProcessRaisePriority,
     267        ProcessDebugPort,
     268        ProcessExceptionPort,
     269        ProcessAccessToken,
     270        ProcessLdtInformation,
     271        ProcessLdtSize,
     272        ProcessDefaultHardErrorMode,
     273        ProcessIoPortHandlers,
     274        ProcessPooledUsageAndLimits,
     275        ProcessWorkingSetWatch,
     276        ProcessUserModeIOPL,
     277        ProcessEnableAlignmentFaultFixup,
     278        ProcessPriorityClass,
     279        ProcessWx86Information,
     280        ProcessHandleCount,
     281        ProcessAffinityMask,
     282        ProcessPriorityBoost,
     283        ProcessDeviceMap,
     284        ProcessSessionInformation,
     285        ProcessForegroundInformation,
     286        ProcessWow64Information,
     287        MaxProcessInfoClass
    278288} PROCESSINFOCLASS;
    279289
    280290/* parameter ProcessInformation (depending on ProcessInformationClass) */
    281291
    282 typedef struct _PROCESS_BASIC_INFORMATION
    283 {  DWORD ExitStatus;
    284    DWORD PebBaseAddress;
    285    DWORD AffinityMask;
    286    DWORD BasePriority;
    287    ULONG UniqueProcessId;
    288    ULONG InheritedFromUniqueProcessId;
     292typedef struct _PROCESS_BASIC_INFORMATION 
     293{       DWORD   ExitStatus;
     294        DWORD   PebBaseAddress;
     295        DWORD   AffinityMask;
     296        DWORD   BasePriority;
     297        ULONG   UniqueProcessId;
     298        ULONG   InheritedFromUniqueProcessId;
    289299} PROCESS_BASIC_INFORMATION;
    290300
    291301NTSTATUS WINAPI NtQueryInformationProcess(
    292    IN HANDLE ProcessHandle,
    293    IN PROCESSINFOCLASS ProcessInformationClass,
    294    OUT PVOID ProcessInformation,
    295    IN ULONG ProcessInformationLength,
    296    OUT PULONG ReturnLength);
     302        IN HANDLE ProcessHandle,
     303        IN PROCESSINFOCLASS ProcessInformationClass,
     304        OUT PVOID ProcessInformation,
     305        IN ULONG ProcessInformationLength,
     306        OUT PULONG ReturnLength);
    297307
    298308#define NtCurrentProcess() ( (HANDLE) -1 )
    299309
    300310/*
    301  * timer
    302  */
    303 
    304 typedef enum _TIMER_TYPE
     311 *      timer
     312 */
     313
     314typedef enum _TIMER_TYPE 
    305315{
    306    NotificationTimer,
    307    SynchronizationTimer
     316        NotificationTimer,
     317        SynchronizationTimer
    308318
    309319} TIMER_TYPE;
    310320
    311321/*
    312  * token functions
    313  */
    314 
     322 *      token functions
     323 */
     324 
    315325NTSTATUS WINAPI NtOpenProcessToken(
    316    HANDLE ProcessHandle,
    317    DWORD DesiredAccess,
    318    HANDLE *TokenHandle);
    319 
     326        HANDLE ProcessHandle,
     327        DWORD DesiredAccess,
     328        HANDLE *TokenHandle);
     329       
    320330NTSTATUS WINAPI NtOpenThreadToken(
    321    HANDLE ThreadHandle,
    322    DWORD DesiredAccess,
    323    BOOLEAN OpenAsSelf,
    324    HANDLE *TokenHandle);
     331        HANDLE ThreadHandle,
     332        DWORD DesiredAccess,
     333        BOOLEAN OpenAsSelf,
     334        HANDLE *TokenHandle);
    325335
    326336NTSTATUS WINAPI NtAdjustPrivilegesToken(
    327    IN HANDLE TokenHandle,
    328    IN BOOLEAN DisableAllPrivileges,
    329    IN PTOKEN_PRIVILEGES NewState,
    330    IN DWORD BufferLength,
    331    OUT PTOKEN_PRIVILEGES PreviousState,
    332    OUT PDWORD ReturnLength);
     337        IN HANDLE TokenHandle,
     338        IN BOOLEAN DisableAllPrivileges,
     339        IN PTOKEN_PRIVILEGES NewState,
     340        IN DWORD BufferLength,
     341        OUT PTOKEN_PRIVILEGES PreviousState,
     342        OUT PDWORD ReturnLength);
    333343
    334344NTSTATUS WINAPI NtQueryInformationToken(
    335    HANDLE token,
    336    DWORD tokeninfoclass,
    337    LPVOID tokeninfo,
    338    DWORD tokeninfolength,
    339    LPDWORD retlen );
    340 
    341 /*
    342  * sid functions
     345        HANDLE token,
     346        DWORD tokeninfoclass,
     347        LPVOID tokeninfo,
     348        DWORD tokeninfolength,
     349        LPDWORD retlen );
     350
     351/*
     352 *      sid functions
    343353 */
    344354
    345355BOOLEAN WINAPI RtlAllocateAndInitializeSid (
    346    PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
    347    DWORD nSubAuthorityCount,
    348    DWORD x3,
    349    DWORD x4,
    350    DWORD x5,
    351    DWORD x6,
    352    DWORD x7,
    353    DWORD x8,
    354    DWORD x9,
    355    DWORD x10,
    356    PSID pSid);
    357 
     356        PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
     357        DWORD nSubAuthorityCount,
     358        DWORD x3,
     359        DWORD x4,
     360        DWORD x5,
     361        DWORD x6,
     362        DWORD x7,
     363        DWORD x8,
     364        DWORD x9,
     365        DWORD x10,
     366        PSID pSid);
     367       
    358368DWORD WINAPI RtlEqualSid(DWORD x1,DWORD x2);
    359369DWORD WINAPI RtlFreeSid(DWORD x1);
    … …  
    366376
    367377/*
    368  * security descriptor functions
     378 *      security descriptor functions
    369379 */
    370380
    371381NTSTATUS WINAPI RtlCreateSecurityDescriptor(
    372    PSECURITY_DESCRIPTOR lpsd,
    373    DWORD rev);
     382        PSECURITY_DESCRIPTOR lpsd,
     383        DWORD rev);
    374384
    375385NTSTATUS WINAPI RtlValidSecurityDescriptor(
    376    PSECURITY_DESCRIPTOR SecurityDescriptor);
     386        PSECURITY_DESCRIPTOR SecurityDescriptor);
    377387
    378388ULONG WINAPI RtlLengthSecurityDescriptor(
    379    PSECURITY_DESCRIPTOR SecurityDescriptor);
     389        PSECURITY_DESCRIPTOR SecurityDescriptor);
    380390
    381391NTSTATUS WINAPI RtlGetDaclSecurityDescriptor(
    382    IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
    383    OUT PBOOLEAN lpbDaclPresent,
    384    OUT PACL *pDacl,
    385    OUT PBOOLEAN lpbDaclDefaulted);
     392        IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
     393        OUT PBOOLEAN lpbDaclPresent,
     394        OUT PACL *pDacl,
     395        OUT PBOOLEAN lpbDaclDefaulted);
    386396
    387397NTSTATUS WINAPI RtlSetDaclSecurityDescriptor (
    388    PSECURITY_DESCRIPTOR lpsd,
    389    BOOLEAN daclpresent,
    390    PACL dacl,
    391    BOOLEAN dacldefaulted );
     398        PSECURITY_DESCRIPTOR lpsd,
     399        BOOLEAN daclpresent,
     400        PACL dacl,
     401        BOOLEAN dacldefaulted );
    392402
    393403NTSTATUS WINAPI RtlGetSaclSecurityDescriptor(
    394    IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
    395    OUT PBOOLEAN lpbSaclPresent,
    396    OUT PACL *pSacl,
    397    OUT PBOOLEAN lpbSaclDefaulted);
     404        IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
     405        OUT PBOOLEAN lpbSaclPresent,
     406        OUT PACL *pSacl,
     407        OUT PBOOLEAN lpbSaclDefaulted);
    398408
    399409NTSTATUS WINAPI RtlSetSaclSecurityDescriptor (
    400    PSECURITY_DESCRIPTOR lpsd,
    401    BOOLEAN saclpresent,
    402    PACL sacl,
    403    BOOLEAN sacldefaulted);
     410        PSECURITY_DESCRIPTOR lpsd,
     411        BOOLEAN saclpresent,
     412        PACL sacl,
     413        BOOLEAN sacldefaulted);
    404414
    405415NTSTATUS WINAPI RtlGetOwnerSecurityDescriptor(
    406    PSECURITY_DESCRIPTOR SecurityDescriptor,
    407    PSID *Owner,
    408    PBOOLEAN OwnerDefaulted);
     416        PSECURITY_DESCRIPTOR SecurityDescriptor,
     417        PSID *Owner,
     418        PBOOLEAN OwnerDefaulted);
    409419
    410420NTSTATUS WINAPI RtlSetOwnerSecurityDescriptor(
    411    PSECURITY_DESCRIPTOR lpsd,
    412    PSID owner,
    413    BOOLEAN ownerdefaulted);
     421        PSECURITY_DESCRIPTOR lpsd,
     422        PSID owner,
     423        BOOLEAN ownerdefaulted);
    414424
    415425NTSTATUS WINAPI RtlSetGroupSecurityDescriptor (
    416    PSECURITY_DESCRIPTOR lpsd,
    417    PSID group,
    418    BOOLEAN groupdefaulted);
     426        PSECURITY_DESCRIPTOR lpsd,
     427        PSID group,
     428        BOOLEAN groupdefaulted);
    419429
    420430NTSTATUS WINAPI RtlGetGroupSecurityDescriptor(
    421    PSECURITY_DESCRIPTOR SecurityDescriptor,
    422    PSID *Group,
    423    PBOOLEAN GroupDefaulted);
    424 
    425 /* ##############################
    426    ######   ACL FUNCTIONS                ######
    427    ##############################
     431        PSECURITY_DESCRIPTOR SecurityDescriptor,
     432        PSID *Group,
     433        PBOOLEAN GroupDefaulted);
     434
     435/*      ##############################
     436        ######  ACL FUNCTIONS   ######
     437        ##############################
    428438*/
    429439
    … …  
    431441
    432442BOOLEAN WINAPI RtlFirstFreeAce(
    433    PACL acl,
    434    PACE_HEADER *x);
     443        PACL acl,
     444        PACE_HEADER *x);
    435445
    436446NTSTATUS WINAPI RtlAddAce(
    437    PACL acl,
    438    DWORD rev,
    439    DWORD xnrofaces,
    440    PACE_HEADER acestart,
    441    DWORD acelen);
    442 
     447        PACL acl,
     448        DWORD rev,
     449        DWORD xnrofaces,
     450        PACE_HEADER acestart,
     451        DWORD acelen);
     452       
    443453DWORD WINAPI RtlAddAccessAllowedAce(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
    444454DWORD WINAPI RtlGetAce(PACL pAcl,DWORD dwAceIndex,LPVOID *pAce );
    445455
    446456/*
    447  * string functions
     457 *      string functions
    448458 */
    449459
    … …  
    468478
    469479/*
    470  * resource functions
     480 *      resource functions
    471481 */
    472482
    473483typedef struct _RTL_RWLOCK {
    474    CRITICAL_SECTION                      rtlCS;
    475    HANDLE      hSharedReleaseSemaphore;
    476    UINT        uSharedWaiters;
    477    HANDLE      hExclusiveReleaseSemaphore;
    478    UINT        uExclusiveWaiters;
    479    INT         iNumberActive;
    480    HANDLE      hOwningThreadId;
    481    DWORD       dwTimeoutBoost;
    482    PVOID       pDebugInfo;
     484        CRITICAL_SECTION        rtlCS;
     485        HANDLE          hSharedReleaseSemaphore;
     486        UINT                    uSharedWaiters;
     487        HANDLE          hExclusiveReleaseSemaphore;
     488        UINT                    uExclusiveWaiters;
     489        INT                     iNumberActive;
     490        HANDLE          hOwningThreadId;
     491        DWORD                   dwTimeoutBoost;
     492        PVOID                   pDebugInfo;
    483493} RTL_RWLOCK, *LPRTL_RWLOCK;
    484494
    485495VOID   WINAPI RtlInitializeResource(
    486    LPRTL_RWLOCK);
    487 
     496        LPRTL_RWLOCK);
     497       
    488498VOID   WINAPI RtlDeleteResource(
    489    LPRTL_RWLOCK);
    490 
     499        LPRTL_RWLOCK);
     500       
    491501BYTE   WINAPI RtlAcquireResourceExclusive(
    492    LPRTL_RWLOCK, BYTE fWait);
    493 
     502        LPRTL_RWLOCK, BYTE fWait);
     503       
    494504BYTE   WINAPI RtlAcquireResourceShared(
    495    LPRTL_RWLOCK, BYTE fWait);
    496 
     505        LPRTL_RWLOCK, BYTE fWait);
     506       
    497507VOID   WINAPI RtlReleaseResource(
    498    LPRTL_RWLOCK);
    499 
     508        LPRTL_RWLOCK);
     509       
    500510VOID   WINAPI RtlDumpResource(
    501    LPRTL_RWLOCK);
    502 
    503 /*
    504    time functions
    505  */
    506 
    507 typedef struct _TIME_FIELDS
     511        LPRTL_RWLOCK);
     512
     513/*
     514        time functions
     515 */
     516
     517typedef struct _TIME_FIELDS 
    508518{   CSHORT Year;
    509519    CSHORT Month;
    … …  
    519529
    520530VOID WINAPI RtlSystemTimeToLocalTime(
    521    IN  PLARGE_INTEGER SystemTime,
    522    OUT PLARGE_INTEGER LocalTime);
     531        IN  PLARGE_INTEGER SystemTime,
     532        OUT PLARGE_INTEGER LocalTime);
    523533
    524534VOID WINAPI RtlTimeToTimeFields(
    525    PLARGE_INTEGER liTime,
    526    PTIME_FIELDS TimeFields);
     535        PLARGE_INTEGER liTime,
     536        PTIME_FIELDS TimeFields);
    527537
    528538BOOLEAN WINAPI RtlTimeFieldsToTime(
    529    PTIME_FIELDS tfTimeFields,
    530    PLARGE_INTEGER Time);
    531 
     539        PTIME_FIELDS tfTimeFields,
     540        PLARGE_INTEGER Time);
     541       
    532542VOID WINAPI RtlTimeToElapsedTimeFields(
    533    PLARGE_INTEGER liTime,
    534    PTIME_FIELDS TimeFields);
    535 
     543        PLARGE_INTEGER liTime,
     544        PTIME_FIELDS TimeFields);
     545       
    536546BOOLEAN WINAPI RtlTimeToSecondsSince1980(
    537    LPFILETIME ft,
    538    LPDWORD timeret);
     547        LPFILETIME ft,
     548        LPDWORD timeret);
    539549
    540550BOOLEAN WINAPI RtlTimeToSecondsSince1970(
    541    LPFILETIME ft,
    542    LPDWORD timeret);
    543 
    544 /*
    545    heap functions
     551        LPFILETIME ft,
     552        LPDWORD timeret);
     553
     554/*
     555        heap functions
    546556*/
    547557
    … …  
    551561
    552562typedef struct
    553 {  ULONG Length;                         /* = sizeof(RTL_HEAP_DEFINITION) */
    554    ULONG Unknown[11];
     563{       ULONG   Length;         /* = sizeof(RTL_HEAP_DEFINITION) */
     564        ULONG   Unknown[11];
    555565} RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
    556566
    557567HANDLE WINAPI RtlCreateHeap(
    558    ULONG Flags,
    559    PVOID BaseAddress,
    560    ULONG SizeToReserve,
    561    ULONG SizeToCommit,
    562    PVOID Unknown,
    563    PRTL_HEAP_DEFINITION Definition);
     568        ULONG Flags,
     569        PVOID BaseAddress,
     570        ULONG SizeToReserve,
     571        ULONG SizeToCommit,
     572        PVOID Unknown,
     573        PRTL_HEAP_DEFINITION Definition);
    564574
    565575PVOID WINAPI RtlAllocateHeap(
    566    HANDLE Heap,
    567    ULONG Flags,
    568    ULONG Size);
     576        HANDLE Heap,
     577        ULONG Flags,
     578        ULONG Size);
    569579
    570580
    571581BOOLEAN WINAPI RtlFreeHeap(
    572    HANDLE Heap,
    573    ULONG Flags,
    574    PVOID Address);
    575 
    576 /*
    577  * misc
    578  */
    579 void __cdecl DbgPrint(LPCSTR fmt,LPVOID args);
    580 DWORD NtRaiseException ( DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD nNumberOfArguments,CONST ULONG_PTR *lpArguments);
    581 DWORD RtlRaiseException ( DWORD x);
     582        HANDLE Heap,
     583        ULONG Flags,
     584        PVOID Address);
     585
     586/*
     587 *      misc
     588 */
     589void WINAPIV DbgPrint(LPCSTR fmt, ...);
     590void WINAPI NtRaiseException(PEXCEPTION_RECORD,PCONTEXT,BOOL);
     591void WINAPI RtlRaiseException(PEXCEPTION_RECORD);
     592void WINAPI RtlRaiseStatus(NTSTATUS);
     593void WINAPI RtlUnwind(PEXCEPTION_FRAME,LPVOID,PEXCEPTION_RECORD,DWORD);
    582594VOID WINAPI RtlAcquirePebLock(void);
    583595VOID WINAPI RtlReleasePebLock(void);
    … …  
    591603BOOLEAN WINAPI RtlGetNtProductType(LPDWORD type);
    592604INT WINAPI RtlExtendedLargeIntegerDivide(LARGE_INTEGER dividend, DWORD divisor, LPDWORD rest);
    593 long long WINAPI RtlExtendedIntegerMultiply(LARGE_INTEGER factor1,INT factor2);
    594 DWORD WINAPI RtlFormatCurrentUserKeyPath(DWORD x);
     605LARGE_INTEGER WINAPI RtlExtendedIntegerMultiply(LARGE_INTEGER factor1,INT factor2);
     606DWORD WINAPI RtlFormatCurrentUserKeyPath(PUNICODE_STRING String);
    595607DWORD WINAPI RtlOpenCurrentUser(DWORD x1, DWORD *x2);
    596608BOOLEAN WINAPI RtlDosPathNameToNtPathName_U( LPWSTR from,PUNICODE_STRING us,DWORD x2,DWORD x3);
Note: See TracChangeset for help on using the changeset viewer.