Changeset 31 for trunk/include


Ignore:
Timestamp:
Jun 1, 1999, 11:57:25 PM (26 years ago)
Author:
phaller
Message:

Fix: few more header fixes

Location:
trunk/include
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/odin.h

    r18 r31  
    1414 */
    1515
     16#ifdef CDECL
     17#  undef CDECL
     18#endif
     19
     20#ifdef EXPORT
     21#  undef EXPORT
     22#endif
     23
     24#ifdef WIN32API
     25#  undef WIN32API
     26#endif
     27
     28#ifdef SYSTEM
     29#  undef SYSTEM
     30#endif
     31
     32#ifdef PASCAL
     33#  undef PASCAL
     34#endif
     35
     36#ifdef UNALIGNED
     37#  undef UNALIGNED
     38#endif
     39
     40
    1641/* ---------- WATCOM C ---------- */
    1742#ifdef __WATCOMC__
    … …  
    2045  #define WIN32API  __stdcall
    2146  #define SYSTEM    __stdcall
     47  #define PASCAL    _Pascal
     48  #define UNALIGNED
    2249#else
    2350
    … …  
    2855  #define WIN32API  __stdcall
    2956  #define SYSTEM    __stdcall
     57  #define PASCAL    _Pascal
     58  #define UNALIGNED
    3059#else
    3160
    … …  
    4877
    4978/* map WINE to ODIN */
     79#ifdef WINAPI
     80#  undef WINAPI
     81#endif
    5082#define WINAPI WIN32API
    5183

  • trunk/include/win/ntddk.h

    r4 r31  
    1 /* $Id: ntddk.h,v 1.1 1999-05-24 20:19:15 ktk 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.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
    66
    77*/
    … …  
    1111#include <ntdef.h>
    1212#include <winnt.h>
    13 #include "winbase.h"    /* fixme: should be taken out sometimes */
     13#include "winbase.h"                     /* fixme: should be taken out sometimes */
    1414
    1515#ifdef __cplusplus
    … …  
    1717#endif
    1818
    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 *PIO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
     19/******************
     20 * asynchronous I/O
     21 */
     22#undef Status  /* conflict with X11-includes*/
     23
     24typedef 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
     32typedef VOID (NTAPI IO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
     33typedef IO_APC_ROUTINE *PIO_APIO_APC_ROUTINE;
     34
    3335
    3436typedef enum _KEY_INFORMATION_CLASS {
    35         KeyBasicInformation,
    36         KeyNodeInformation,
    37         KeyFullInformation
     37   KeyBasicInformation,
     38   KeyNodeInformation,
     39   KeyFullInformation
    3840} KEY_INFORMATION_CLASS;
    3941
    4042typedef enum _KEY_VALUE_INFORMATION_CLASS {
    41         KeyValueBasicInformation,
    42         KeyValueFullInformation,
    43         KeyValuePartialInformation,
    44         KeyValueFullInformationAlign64,
    45         KeyValuePartialInformationAlign64
     43   KeyValueBasicInformation,
     44   KeyValueFullInformation,
     45   KeyValuePartialInformation,
     46   KeyValueFullInformationAlign64,
     47   KeyValuePartialInformationAlign64
    4648} KEY_VALUE_INFORMATION_CLASS;
    4749
    48 typedef 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
     50typedef 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
    6769} THREADINFOCLASS;
    6870
    6971typedef enum _FILE_INFORMATION_CLASS {
    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
     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
    107109} FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
    108110
    109 typedef enum _SECTION_INHERIT 
     111typedef enum _SECTION_INHERIT
    110112{
    111         ViewShare = 1,
    112         ViewUnmap = 2
     113   ViewShare = 1,
     114   ViewUnmap = 2
    113115
    114116} SECTION_INHERIT;
    115  
    116 /*
    117         placeholder
     117
     118/*
     119   placeholder
    118120*/
    119121typedef enum _OBJECT_INFORMATION_CLASS
    120122{
    121         DunnoTheConstants1
     123   DunnoTheConstants1
    122124
    123125} OBJECT_INFORMATION_CLASS, *POBJECT_INFORMATION_CLASS;
    … …  
    125127
    126128/*
    127  *      NtQuerySystemInformation
     129 * NtQuerySystemInformation
    128130 */
    129131
    130132typedef enum SYSTEM_INFORMATION_CLASS
    131 {       Unknown1 = 1,
    132         Unknown2,
    133         Unknown3,
    134         Unknown4,
    135         SystemPerformanceInformation
     133{  Unknown1 = 1,
     134   Unknown2,
     135   Unknown3,
     136   Unknown4,
     137   SystemPerformanceInformation
    136138} SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS;
    137139
    138140/* reading coffee grounds... */
    139141typedef struct _THREAD_INFO
    140 {       DWORD   Unknown1[6];
    141         DWORD   ThreadID;
    142         DWORD   Unknown2[3];
    143         DWORD   Status;
    144         DWORD   WaitReason;
    145         DWORD   Unknown3[4];
     142{  DWORD Unknown1[6];
     143   DWORD ThreadID;
     144   DWORD Unknown2[3];
     145   DWORD Status;
     146   DWORD WaitReason;
     147   DWORD Unknown3[4];
    146148} THREAD_INFO, PTHREAD_INFO;
    147149
    148150typedef struct _VM_COUNTERS_
    149 {       ULONG PeakVirtualSize;
    150         ULONG VirtualSize;
    151         ULONG PageFaultCount;
    152         ULONG PeakWorkingSetSize;
    153         ULONG WorkingSetSize;
    154         ULONG QuotaPeakPagedPoolUsage;
    155         ULONG QuotaPagedPoolUsage;
    156         ULONG QuotaPeakNonPagedPoolUsage;
    157         ULONG QuotaNonPagedPoolUsage;
    158         ULONG PagefileUsage;
    159         ULONG PeakPagefileUsage;
     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;
    160162} VM_COUNTERS, *PVM_COUNTERS;
    161163
    162164typedef struct _PROCESS_INFO
    163 {       DWORD           Offset;         /* 00 offset to next PROCESS_INFO ok*/
    164         DWORD           ThreadCount;    /* 04 number of ThreadInfo member ok */
    165         DWORD           Unknown1[6];
    166         FILETIME        CreationTime;   /* 20 */
    167         DWORD           Unknown2[5];
    168         PWCHAR          ProcessName;    /* 3c ok */
    169         DWORD           BasePriority;
    170         DWORD           ProcessID;      /* 44 ok*/
    171         DWORD           ParentProcessID;
    172         DWORD           HandleCount;
    173         DWORD           Unknown3[2];    /* 50 */
    174         ULONG           PeakVirtualSize;
    175         ULONG           VirtualSize;
    176         ULONG           PageFaultCount;
    177         ULONG           PeakWorkingSetSize;
    178         ULONG           WorkingSetSize;
    179         ULONG           QuotaPeakPagedPoolUsage;
    180         ULONG           QuotaPagedPoolUsage;
    181         ULONG           QuotaPeakNonPagedPoolUsage;
    182         ULONG           QuotaNonPagedPoolUsage;
    183         ULONG           PagefileUsage;
    184         ULONG           PeakPagefileUsage;
    185         DWORD           PrivateBytes;
    186         DWORD           Unknown6[4];
    187         THREAD_INFO     ati[ANYSIZE_ARRAY];     /* 94 size=0x40*/
     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*/
    188190} PROCESS_INFO, PPROCESS_INFO;
    189191
    190192NTSTATUS WINAPI NtQuerySystemInformation(
    191         IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
    192         OUT PVOID SystemInformation,
    193         IN ULONG Length,
    194         OUT PULONG ResultLength);
    195 
    196 /*
    197  *      system configuration
     193   IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
     194   OUT PVOID SystemInformation,
     195   IN ULONG Length,
     196   OUT PULONG ResultLength);
     197
     198/*
     199 * system configuration
    198200 */
    199201
    … …  
    201203typedef struct _SYSTEM_TIME_ADJUSTMENT
    202204{
    203         ULONG   TimeAdjustment;
    204         BOOLEAN TimeAdjustmentDisabled;
     205   ULONG TimeAdjustment;
     206   BOOLEAN  TimeAdjustmentDisabled;
    205207
    206208} SYSTEM_TIME_ADJUSTMENT, *PSYSTEM_TIME_ADJUSTMENT;
    207209
    208 typedef struct _SYSTEM_CONFIGURATION_INFO 
     210typedef struct _SYSTEM_CONFIGURATION_INFO
    209211{
    210         union
    211         { ULONG OemId;
    212           struct
    213           { WORD        ProcessorArchitecture;
    214             WORD        Reserved;
    215           } tag1;
    216         } tag2;
    217         ULONG   PageSize;
    218         PVOID   MinimumApplicationAddress;
    219         PVOID   MaximumApplicationAddress;
    220         ULONG   ActiveProcessorMask;
    221         ULONG   NumberOfProcessors;
    222         ULONG   ProcessorType;
    223         ULONG   AllocationGranularity;
    224         WORD    ProcessorLevel;
    225         WORD    ProcessorRevision;
     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;
    226228
    227229} SYSTEM_CONFIGURATION_INFO, *PSYSTEM_CONFIGURATION_INFO;
    228230
    229231
    230 typedef struct _SYSTEM_CACHE_INFORMATION 
     232typedef struct _SYSTEM_CACHE_INFORMATION
    231233{
    232         ULONG   CurrentSize;
    233         ULONG   PeakSize;
    234         ULONG   PageFaultCount;
    235         ULONG   MinimumWorkingSet;
    236         ULONG   MaximumWorkingSet;
    237         ULONG   Unused[4];
     234   ULONG CurrentSize;
     235   ULONG PeakSize;
     236   ULONG PageFaultCount;
     237   ULONG MinimumWorkingSet;
     238   ULONG MaximumWorkingSet;
     239   ULONG Unused[4];
    238240
    239241} SYSTEM_CACHE_INFORMATION;
    240242
    241243/*
    242  *      NtQueryProcessInformation
     244 * NtQueryProcessInformation
    243245 */
    244246
    245247/* parameter ProcessInformationClass */
    246248
    247 typedef enum _PROCESSINFOCLASS 
    248 {       ProcessBasicInformation,
    249         ProcessQuotaLimits,
    250         ProcessIoCounters,
    251         ProcessVmCounters,
    252         ProcessTimes,
    253         ProcessBasePriority,
    254         ProcessRaisePriority,
    255         ProcessDebugPort,
    256         ProcessExceptionPort,
    257         ProcessAccessToken,
    258         ProcessLdtInformation,
    259         ProcessLdtSize,
    260         ProcessDefaultHardErrorMode,
    261         ProcessIoPortHandlers,
    262         ProcessPooledUsageAndLimits,
    263         ProcessWorkingSetWatch,
    264         ProcessUserModeIOPL,
    265         ProcessEnableAlignmentFaultFixup,
    266         ProcessPriorityClass,
    267         ProcessWx86Information,
    268         ProcessHandleCount,
    269         ProcessAffinityMask,
    270         ProcessPriorityBoost,
    271         ProcessDeviceMap,
    272         ProcessSessionInformation,
    273         ProcessForegroundInformation,
    274         ProcessWow64Information,
    275         MaxProcessInfoClass
     249typedef 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
    276278} PROCESSINFOCLASS;
    277279
    278280/* parameter ProcessInformation (depending on ProcessInformationClass) */
    279281
    280 typedef struct _PROCESS_BASIC_INFORMATION 
    281 {       DWORD   ExitStatus;
    282         DWORD   PebBaseAddress;
    283         DWORD   AffinityMask;
    284         DWORD   BasePriority;
    285         ULONG   UniqueProcessId;
    286         ULONG   InheritedFromUniqueProcessId;
     282typedef struct _PROCESS_BASIC_INFORMATION
     283{  DWORD ExitStatus;
     284   DWORD PebBaseAddress;
     285   DWORD AffinityMask;
     286   DWORD BasePriority;
     287   ULONG UniqueProcessId;
     288   ULONG InheritedFromUniqueProcessId;
    287289} PROCESS_BASIC_INFORMATION;
    288290
    289291NTSTATUS WINAPI NtQueryInformationProcess(
    290         IN HANDLE ProcessHandle,
    291         IN PROCESSINFOCLASS ProcessInformationClass,
    292         OUT PVOID ProcessInformation,
    293         IN ULONG ProcessInformationLength,
    294         OUT PULONG ReturnLength);
     292   IN HANDLE ProcessHandle,
     293   IN PROCESSINFOCLASS ProcessInformationClass,
     294   OUT PVOID ProcessInformation,
     295   IN ULONG ProcessInformationLength,
     296   OUT PULONG ReturnLength);
    295297
    296298#define NtCurrentProcess() ( (HANDLE) -1 )
    297299
    298300/*
    299  *      timer
    300  */
    301 
    302 typedef enum _TIMER_TYPE 
     301 * timer
     302 */
     303
     304typedef enum _TIMER_TYPE
    303305{
    304         NotificationTimer,
    305         SynchronizationTimer
     306   NotificationTimer,
     307   SynchronizationTimer
    306308
    307309} TIMER_TYPE;
    308310
    309311/*
    310  *      token functions
    311  */
    312  
     312 * token functions
     313 */
     314
    313315NTSTATUS WINAPI NtOpenProcessToken(
    314         HANDLE ProcessHandle,
    315         DWORD DesiredAccess,
    316         HANDLE *TokenHandle);
    317        
     316   HANDLE ProcessHandle,
     317   DWORD DesiredAccess,
     318   HANDLE *TokenHandle);
     319
    318320NTSTATUS WINAPI NtOpenThreadToken(
    319         HANDLE ThreadHandle,
    320         DWORD DesiredAccess,
    321         BOOLEAN OpenAsSelf,
    322         HANDLE *TokenHandle);
     321   HANDLE ThreadHandle,
     322   DWORD DesiredAccess,
     323   BOOLEAN OpenAsSelf,
     324   HANDLE *TokenHandle);
    323325
    324326NTSTATUS WINAPI NtAdjustPrivilegesToken(
    325         IN HANDLE TokenHandle,
    326         IN BOOLEAN DisableAllPrivileges,
    327         IN PTOKEN_PRIVILEGES NewState,
    328         IN DWORD BufferLength,
    329         OUT PTOKEN_PRIVILEGES PreviousState,
    330         OUT PDWORD ReturnLength);
     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);
    331333
    332334NTSTATUS WINAPI NtQueryInformationToken(
    333         HANDLE token,
    334         DWORD tokeninfoclass,
    335         LPVOID tokeninfo,
    336         DWORD tokeninfolength,
    337         LPDWORD retlen );
    338 
    339 /*
    340  *      sid functions
     335   HANDLE token,
     336   DWORD tokeninfoclass,
     337   LPVOID tokeninfo,
     338   DWORD tokeninfolength,
     339   LPDWORD retlen );
     340
     341/*
     342 * sid functions
    341343 */
    342344
    343345BOOLEAN WINAPI RtlAllocateAndInitializeSid (
    344         PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
    345         DWORD nSubAuthorityCount,
    346         DWORD x3,
    347         DWORD x4,
    348         DWORD x5,
    349         DWORD x6,
    350         DWORD x7,
    351         DWORD x8,
    352         DWORD x9,
    353         DWORD x10,
    354         PSID pSid);
    355        
     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
    356358DWORD WINAPI RtlEqualSid(DWORD x1,DWORD x2);
    357359DWORD WINAPI RtlFreeSid(DWORD x1);
    … …  
    364366
    365367/*
    366  *      security descriptor functions
     368 * security descriptor functions
    367369 */
    368370
    369371NTSTATUS WINAPI RtlCreateSecurityDescriptor(
    370         PSECURITY_DESCRIPTOR lpsd,
    371         DWORD rev);
     372   PSECURITY_DESCRIPTOR lpsd,
     373   DWORD rev);
    372374
    373375NTSTATUS WINAPI RtlValidSecurityDescriptor(
    374         PSECURITY_DESCRIPTOR SecurityDescriptor);
     376   PSECURITY_DESCRIPTOR SecurityDescriptor);
    375377
    376378ULONG WINAPI RtlLengthSecurityDescriptor(
    377         PSECURITY_DESCRIPTOR SecurityDescriptor);
     379   PSECURITY_DESCRIPTOR SecurityDescriptor);
    378380
    379381NTSTATUS WINAPI RtlGetDaclSecurityDescriptor(
    380         IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
    381         OUT PBOOLEAN lpbDaclPresent,
    382         OUT PACL *pDacl,
    383         OUT PBOOLEAN lpbDaclDefaulted);
     382   IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
     383   OUT PBOOLEAN lpbDaclPresent,
     384   OUT PACL *pDacl,
     385   OUT PBOOLEAN lpbDaclDefaulted);
    384386
    385387NTSTATUS WINAPI RtlSetDaclSecurityDescriptor (
    386         PSECURITY_DESCRIPTOR lpsd,
    387         BOOLEAN daclpresent,
    388         PACL dacl,
    389         BOOLEAN dacldefaulted );
     388   PSECURITY_DESCRIPTOR lpsd,
     389   BOOLEAN daclpresent,
     390   PACL dacl,
     391   BOOLEAN dacldefaulted );
    390392
    391393NTSTATUS WINAPI RtlGetSaclSecurityDescriptor(
    392         IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
    393         OUT PBOOLEAN lpbSaclPresent,
    394         OUT PACL *pSacl,
    395         OUT PBOOLEAN lpbSaclDefaulted);
     394   IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
     395   OUT PBOOLEAN lpbSaclPresent,
     396   OUT PACL *pSacl,
     397   OUT PBOOLEAN lpbSaclDefaulted);
    396398
    397399NTSTATUS WINAPI RtlSetSaclSecurityDescriptor (
    398         PSECURITY_DESCRIPTOR lpsd,
    399         BOOLEAN saclpresent,
    400         PACL sacl,
    401         BOOLEAN sacldefaulted);
     400   PSECURITY_DESCRIPTOR lpsd,
     401   BOOLEAN saclpresent,
     402   PACL sacl,
     403   BOOLEAN sacldefaulted);
    402404
    403405NTSTATUS WINAPI RtlGetOwnerSecurityDescriptor(
    404         PSECURITY_DESCRIPTOR SecurityDescriptor,
    405         PSID *Owner,
    406         PBOOLEAN OwnerDefaulted);
     406   PSECURITY_DESCRIPTOR SecurityDescriptor,
     407   PSID *Owner,
     408   PBOOLEAN OwnerDefaulted);
    407409
    408410NTSTATUS WINAPI RtlSetOwnerSecurityDescriptor(
    409         PSECURITY_DESCRIPTOR lpsd,
    410         PSID owner,
    411         BOOLEAN ownerdefaulted);
     411   PSECURITY_DESCRIPTOR lpsd,
     412   PSID owner,
     413   BOOLEAN ownerdefaulted);
    412414
    413415NTSTATUS WINAPI RtlSetGroupSecurityDescriptor (
    414         PSECURITY_DESCRIPTOR lpsd,
    415         PSID group,
    416         BOOLEAN groupdefaulted);
     416   PSECURITY_DESCRIPTOR lpsd,
     417   PSID group,
     418   BOOLEAN groupdefaulted);
    417419
    418420NTSTATUS WINAPI RtlGetGroupSecurityDescriptor(
    419         PSECURITY_DESCRIPTOR SecurityDescriptor,
    420         PSID *Group,
    421         PBOOLEAN GroupDefaulted);
    422 
    423 /*      ##############################
    424         ######  ACL FUNCTIONS   ######
    425         ##############################
     421   PSECURITY_DESCRIPTOR SecurityDescriptor,
     422   PSID *Group,
     423   PBOOLEAN GroupDefaulted);
     424
     425/* ##############################
     426   ######   ACL FUNCTIONS                ######
     427   ##############################
    426428*/
    427429
    … …  
    429431
    430432BOOLEAN WINAPI RtlFirstFreeAce(
    431         PACL acl,
    432         PACE_HEADER *x);
     433   PACL acl,
     434   PACE_HEADER *x);
    433435
    434436NTSTATUS WINAPI RtlAddAce(
    435         PACL acl,
    436         DWORD rev,
    437         DWORD xnrofaces,
    438         PACE_HEADER acestart,
    439         DWORD acelen);
    440        
     437   PACL acl,
     438   DWORD rev,
     439   DWORD xnrofaces,
     440   PACE_HEADER acestart,
     441   DWORD acelen);
     442
    441443DWORD WINAPI RtlAddAccessAllowedAce(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
    442444DWORD WINAPI RtlGetAce(PACL pAcl,DWORD dwAceIndex,LPVOID *pAce );
    443445
    444446/*
    445  *      string functions
     447 * string functions
    446448 */
    447449
    … …  
    466468
    467469/*
    468  *      resource functions
     470 * resource functions
    469471 */
    470472
    471473typedef struct _RTL_RWLOCK {
    472         CRITICAL_SECTION        rtlCS;
    473         HANDLE          hSharedReleaseSemaphore;
    474         UINT                    uSharedWaiters;
    475         HANDLE          hExclusiveReleaseSemaphore;
    476         UINT                    uExclusiveWaiters;
    477         INT                     iNumberActive;
    478         HANDLE          hOwningThreadId;
    479         DWORD                   dwTimeoutBoost;
    480         PVOID                   pDebugInfo;
     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;
    481483} RTL_RWLOCK, *LPRTL_RWLOCK;
    482484
    483485VOID   WINAPI RtlInitializeResource(
    484         LPRTL_RWLOCK);
    485        
     486   LPRTL_RWLOCK);
     487
    486488VOID   WINAPI RtlDeleteResource(
    487         LPRTL_RWLOCK);
    488        
     489   LPRTL_RWLOCK);
     490
    489491BYTE   WINAPI RtlAcquireResourceExclusive(
    490         LPRTL_RWLOCK, BYTE fWait);
    491        
     492   LPRTL_RWLOCK, BYTE fWait);
     493
    492494BYTE   WINAPI RtlAcquireResourceShared(
    493         LPRTL_RWLOCK, BYTE fWait);
    494        
     495   LPRTL_RWLOCK, BYTE fWait);
     496
    495497VOID   WINAPI RtlReleaseResource(
    496         LPRTL_RWLOCK);
    497        
     498   LPRTL_RWLOCK);
     499
    498500VOID   WINAPI RtlDumpResource(
    499         LPRTL_RWLOCK);
    500 
    501 /*
    502         time functions
    503  */
    504 
    505 typedef struct _TIME_FIELDS 
     501   LPRTL_RWLOCK);
     502
     503/*
     504   time functions
     505 */
     506
     507typedef struct _TIME_FIELDS
    506508{   CSHORT Year;
    507509    CSHORT Month;
    … …  
    517519
    518520VOID WINAPI RtlSystemTimeToLocalTime(
    519         IN  PLARGE_INTEGER SystemTime,
    520         OUT PLARGE_INTEGER LocalTime);
     521   IN  PLARGE_INTEGER SystemTime,
     522   OUT PLARGE_INTEGER LocalTime);
    521523
    522524VOID WINAPI RtlTimeToTimeFields(
    523         PLARGE_INTEGER liTime,
    524         PTIME_FIELDS TimeFields);
     525   PLARGE_INTEGER liTime,
     526   PTIME_FIELDS TimeFields);
    525527
    526528BOOLEAN WINAPI RtlTimeFieldsToTime(
    527         PTIME_FIELDS tfTimeFields,
    528         PLARGE_INTEGER Time);
    529        
     529   PTIME_FIELDS tfTimeFields,
     530   PLARGE_INTEGER Time);
     531
    530532VOID WINAPI RtlTimeToElapsedTimeFields(
    531         PLARGE_INTEGER liTime,
    532         PTIME_FIELDS TimeFields);
    533        
     533   PLARGE_INTEGER liTime,
     534   PTIME_FIELDS TimeFields);
     535
    534536BOOLEAN WINAPI RtlTimeToSecondsSince1980(
    535         LPFILETIME ft,
    536         LPDWORD timeret);
     537   LPFILETIME ft,
     538   LPDWORD timeret);
    537539
    538540BOOLEAN WINAPI RtlTimeToSecondsSince1970(
    539         LPFILETIME ft,
    540         LPDWORD timeret);
    541 
    542 /*
    543         heap functions
     541   LPFILETIME ft,
     542   LPDWORD timeret);
     543
     544/*
     545   heap functions
    544546*/
    545547
    … …  
    549551
    550552typedef struct
    551 {       ULONG   Length;         /* = sizeof(RTL_HEAP_DEFINITION) */
    552         ULONG   Unknown[11];
     553{  ULONG Length;                         /* = sizeof(RTL_HEAP_DEFINITION) */
     554   ULONG Unknown[11];
    553555} RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
    554556
    555557HANDLE WINAPI RtlCreateHeap(
    556         ULONG Flags,
    557         PVOID BaseAddress,
    558         ULONG SizeToReserve,
    559         ULONG SizeToCommit,
    560         PVOID Unknown,
    561         PRTL_HEAP_DEFINITION Definition);
     558   ULONG Flags,
     559   PVOID BaseAddress,
     560   ULONG SizeToReserve,
     561   ULONG SizeToCommit,
     562   PVOID Unknown,
     563   PRTL_HEAP_DEFINITION Definition);
    562564
    563565PVOID WINAPI RtlAllocateHeap(
    564         HANDLE Heap,
    565         ULONG Flags,
    566         ULONG Size);
     566   HANDLE Heap,
     567   ULONG Flags,
     568   ULONG Size);
    567569
    568570
    569571BOOLEAN WINAPI RtlFreeHeap(
    570         HANDLE Heap,
    571         ULONG Flags,
    572         PVOID Address);
    573 
    574 /*
    575  *      misc
     572   HANDLE Heap,
     573   ULONG Flags,
     574   PVOID Address);
     575
     576/*
     577 * misc
    576578 */
    577579void __cdecl DbgPrint(LPCSTR fmt,LPVOID args);
Note: See TracChangeset for help on using the changeset viewer.