source: trunk/include/win/ntddk.h@ 6908

Last change on this file since 6908 was 6371, checked in by sandervl, 24 years ago

header updates
File size: 18.4 KB
Line 
1/*
2 this file defines interfaces mainly exposed to device drivers and
3 native nt dll's
4
5*/
6#ifndef __WINE_NTDDK_H
7#define __WINE_NTDDK_H
8
9#include "ntdef.h"
10#include "winnt.h"
11#include "winbase.h" /* fixme: should be taken out sometimes */
12
13#ifdef __cplusplus
14extern "C" {
15#endif
16
17/******************
18 * asynchronous I/O
19 */
20#undef Status /* conflict with X11-includes*/
21
22typedef struct _IO_STATUS_BLOCK
23{
24 union {
25 NTSTATUS Status;
26 PVOID Pointer;
27 } DUMMYUNIONNAME;
28 ULONG_PTR Information;
29} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
30
31typedef VOID (* NTAPI PIO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
32
33typedef enum _KEY_INFORMATION_CLASS {
34 KeyBasicInformation,
35 KeyNodeInformation,
36 KeyFullInformation
37} KEY_INFORMATION_CLASS;
38
39typedef enum _KEY_VALUE_INFORMATION_CLASS {
40 KeyValueBasicInformation,
41 KeyValueFullInformation,
42 KeyValuePartialInformation,
43 KeyValueFullInformationAlign64,
44 KeyValuePartialInformationAlign64
45} KEY_VALUE_INFORMATION_CLASS;
46
47typedef enum _THREADINFOCLASS
48{ ThreadBasicInformation,
49 ThreadTimes,
50 ThreadPriority,
51 ThreadBasePriority,
52 ThreadAffinityMask,
53 ThreadImpersonationToken,
54 ThreadDescriptorTableEntry,
55 ThreadEnableAlignmentFaultFixup,
56 ThreadEventPair_Reusable,
57 ThreadQuerySetWin32StartAddress,
58 ThreadZeroTlsCell,
59 ThreadPerformanceCount,
60 ThreadAmILastThread,
61 ThreadIdealProcessor,
62 ThreadPriorityBoost,
63 ThreadSetTlsArrayAddress,
64 ThreadIsIoPending,
65 MaxThreadInfoClass
66} THREADINFOCLASS;
67
68typedef enum _FILE_INFORMATION_CLASS {
69 FileDirectoryInformation = 1,
70 FileFullDirectoryInformation,
71 FileBothDirectoryInformation,
72 FileBasicInformation,
73 FileStandardInformation,
74 FileInternalInformation,
75 FileEaInformation,
76 FileAccessInformation,
77 FileNameInformation,
78 FileRenameInformation,
79 FileLinkInformation,
80 FileNamesInformation,
81 FileDispositionInformation,
82 FilePositionInformation,
83 FileFullEaInformation,
84 FileModeInformation,
85 FileAlignmentInformation,
86 FileAllInformation,
87 FileAllocationInformation,
88 FileEndOfFileInformation,
89 FileAlternateNameInformation,
90 FileStreamInformation,
91 FilePipeInformation,
92 FilePipeLocalInformation,
93 FilePipeRemoteInformation,
94 FileMailslotQueryInformation,
95 FileMailslotSetInformation,
96 FileCompressionInformation,
97 FileObjectIdInformation,
98 FileCompletionInformation,
99 FileMoveClusterInformation,
100 FileQuotaInformation,
101 FileReparsePointInformation,
102 FileNetworkOpenInformation,
103 FileAttributeTagInformation,
104 FileTrackingInformation,
105 FileMaximumInformation
106} FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
107
108typedef enum _FSINFOCLASS {
109 FileFsVolumeInformation = 1,
110 FileFsLabelInformation,
111 FileFsSizeInformation,
112 FileFsDeviceInformation,
113 FileFsAttributeInformation,
114 FileFsControlInformation,
115 FileFsFullSizeInformation,
116 FileFsObjectIdInformation,
117 FileFsMaximumInformation
118} FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
119
120typedef enum _SECTION_INHERIT
121{
122 ViewShare = 1,
123 ViewUnmap = 2
124
125} SECTION_INHERIT;
126
127/*
128 placeholder
129*/
130typedef enum _OBJECT_INFORMATION_CLASS
131{
132 DunnoTheConstants1
133
134} OBJECT_INFORMATION_CLASS, *POBJECT_INFORMATION_CLASS;
135
136
137/*
138 * NtQuerySystemInformation
139 */
140
141typedef enum SYSTEM_INFORMATION_CLASS
142{ Unknown1 = 1,
143 Unknown2,
144 Unknown3,
145 Unknown4,
146 SystemPerformanceInformation
147} SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS;
148
149/* reading coffee grounds... */
150typedef struct _THREAD_INFO
151{ DWORD Unknown1[6];
152 DWORD ThreadID;
153 DWORD Unknown2[3];
154 DWORD Status;
155 DWORD WaitReason;
156 DWORD Unknown3[4];
157} THREAD_INFO, PTHREAD_INFO;
158
159typedef struct _VM_COUNTERS_
160{ ULONG PeakVirtualSize;
161 ULONG VirtualSize;
162 ULONG PageFaultCount;
163 ULONG PeakWorkingSetSize;
164 ULONG WorkingSetSize;
165 ULONG QuotaPeakPagedPoolUsage;
166 ULONG QuotaPagedPoolUsage;
167 ULONG QuotaPeakNonPagedPoolUsage;
168 ULONG QuotaNonPagedPoolUsage;
169 ULONG PagefileUsage;
170 ULONG PeakPagefileUsage;
171} VM_COUNTERS, *PVM_COUNTERS;
172
173typedef struct _PROCESS_INFO
174{ DWORD Offset; /* 00 offset to next PROCESS_INFO ok*/
175 DWORD ThreadCount; /* 04 number of ThreadInfo member ok */
176 DWORD Unknown1[6];
177 FILETIME CreationTime; /* 20 */
178 DWORD Unknown2[5];
179 PWCHAR ProcessName; /* 3c ok */
180 DWORD BasePriority;
181 DWORD ProcessID; /* 44 ok*/
182 DWORD ParentProcessID;
183 DWORD HandleCount;
184 DWORD Unknown3[2]; /* 50 */
185 ULONG PeakVirtualSize;
186 ULONG VirtualSize;
187 ULONG PageFaultCount;
188 ULONG PeakWorkingSetSize;
189 ULONG WorkingSetSize;
190 ULONG QuotaPeakPagedPoolUsage;
191 ULONG QuotaPagedPoolUsage;
192 ULONG QuotaPeakNonPagedPoolUsage;
193 ULONG QuotaNonPagedPoolUsage;
194 ULONG PagefileUsage;
195 ULONG PeakPagefileUsage;
196 DWORD PrivateBytes;
197 DWORD Unknown6[4];
198 THREAD_INFO ati[ANYSIZE_ARRAY]; /* 94 size=0x40*/
199} PROCESS_INFO, PPROCESS_INFO;
200
201NTSTATUS WINAPI NtQuerySystemInformation(
202 IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
203 OUT PVOID SystemInformation,
204 IN ULONG Length,
205 OUT PULONG ResultLength);
206
207/*
208 * system configuration
209 */
210
211
212typedef struct _SYSTEM_TIME_ADJUSTMENT
213{
214 ULONG TimeAdjustment;
215 BOOLEAN TimeAdjustmentDisabled;
216
217} SYSTEM_TIME_ADJUSTMENT, *PSYSTEM_TIME_ADJUSTMENT;
218
219typedef struct _SYSTEM_CONFIGURATION_INFO
220{
221 union
222 { ULONG OemId;
223 struct
224 { WORD ProcessorArchitecture;
225 WORD Reserved;
226 } tag1;
227 } tag2;
228 ULONG PageSize;
229 PVOID MinimumApplicationAddress;
230 PVOID MaximumApplicationAddress;
231 ULONG ActiveProcessorMask;
232 ULONG NumberOfProcessors;
233 ULONG ProcessorType;
234 ULONG AllocationGranularity;
235 WORD ProcessorLevel;
236 WORD ProcessorRevision;
237
238} SYSTEM_CONFIGURATION_INFO, *PSYSTEM_CONFIGURATION_INFO;
239
240
241typedef struct _SYSTEM_CACHE_INFORMATION
242{
243 ULONG CurrentSize;
244 ULONG PeakSize;
245 ULONG PageFaultCount;
246 ULONG MinimumWorkingSet;
247 ULONG MaximumWorkingSet;
248 ULONG Unused[4];
249
250} SYSTEM_CACHE_INFORMATION;
251
252/*
253 * NtQueryProcessInformation
254 */
255
256/* parameter ProcessInformationClass */
257
258typedef enum _PROCESSINFOCLASS
259{ ProcessBasicInformation,
260 ProcessQuotaLimits,
261 ProcessIoCounters,
262 ProcessVmCounters,
263 ProcessTimes,
264 ProcessBasePriority,
265 ProcessRaisePriority,
266 ProcessDebugPort,
267 ProcessExceptionPort,
268 ProcessAccessToken,
269 ProcessLdtInformation,
270 ProcessLdtSize,
271 ProcessDefaultHardErrorMode,
272 ProcessIoPortHandlers,
273 ProcessPooledUsageAndLimits,
274 ProcessWorkingSetWatch,
275 ProcessUserModeIOPL,
276 ProcessEnableAlignmentFaultFixup,
277 ProcessPriorityClass,
278 ProcessWx86Information,
279 ProcessHandleCount,
280 ProcessAffinityMask,
281 ProcessPriorityBoost,
282 ProcessDeviceMap,
283 ProcessSessionInformation,
284 ProcessForegroundInformation,
285 ProcessWow64Information,
286 MaxProcessInfoClass
287} PROCESSINFOCLASS;
288
289/* parameter ProcessInformation (depending on ProcessInformationClass) */
290
291typedef struct _PROCESS_BASIC_INFORMATION
292{ DWORD ExitStatus;
293 DWORD PebBaseAddress;
294 DWORD AffinityMask;
295 DWORD BasePriority;
296 ULONG UniqueProcessId;
297 ULONG InheritedFromUniqueProcessId;
298} PROCESS_BASIC_INFORMATION;
299
300NTSTATUS WINAPI NtQueryInformationProcess(
301 IN HANDLE ProcessHandle,
302 IN PROCESSINFOCLASS ProcessInformationClass,
303 OUT PVOID ProcessInformation,
304 IN ULONG ProcessInformationLength,
305 OUT PULONG ReturnLength);
306
307#define NtCurrentProcess() ( (HANDLE) -1 )
308
309/*
310 * timer
311 */
312
313typedef enum _TIMER_TYPE
314{
315 NotificationTimer,
316 SynchronizationTimer
317
318} TIMER_TYPE;
319
320/*
321 * token functions
322 */
323
324NTSTATUS WINAPI NtOpenProcessToken(
325 HANDLE ProcessHandle,
326 DWORD DesiredAccess,
327 HANDLE *TokenHandle);
328
329NTSTATUS WINAPI NtOpenThreadToken(
330 HANDLE ThreadHandle,
331 DWORD DesiredAccess,
332 BOOLEAN OpenAsSelf,
333 HANDLE *TokenHandle);
334
335NTSTATUS WINAPI NtAdjustPrivilegesToken(
336 IN HANDLE TokenHandle,
337 IN BOOLEAN DisableAllPrivileges,
338 IN PTOKEN_PRIVILEGES NewState,
339 IN DWORD BufferLength,
340 OUT PTOKEN_PRIVILEGES PreviousState,
341 OUT PDWORD ReturnLength);
342
343NTSTATUS WINAPI NtQueryInformationToken(
344 HANDLE token,
345 DWORD tokeninfoclass,
346 LPVOID tokeninfo,
347 DWORD tokeninfolength,
348 LPDWORD retlen );
349
350/*
351 * sid functions
352 */
353
354BOOLEAN WINAPI RtlAllocateAndInitializeSid (
355 PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
356 DWORD nSubAuthorityCount,
357 DWORD x3,
358 DWORD x4,
359 DWORD x5,
360 DWORD x6,
361 DWORD x7,
362 DWORD x8,
363 DWORD x9,
364 DWORD x10,
365 PSID *pSid);
366
367DWORD WINAPI RtlEqualSid(PSID pSid1, PSID pSid2);
368DWORD WINAPI RtlEqualPrefixSid (PSID pSid1, PSID pSid2);
369DWORD WINAPI RtlValidSid( PSID pSid );
370DWORD WINAPI RtlFreeSid(PSID x1);
371DWORD WINAPI RtlLengthRequiredSid(DWORD nrofsubauths);
372DWORD WINAPI RtlLengthSid(PSID sid);
373DWORD WINAPI RtlInitializeSid(PSID PSID,PSID_IDENTIFIER_AUTHORITY PSIDauth, DWORD c);
374LPDWORD WINAPI RtlSubAuthoritySid(PSID PSID,DWORD nr);
375LPBYTE WINAPI RtlSubAuthorityCountSid(PSID PSID);
376DWORD WINAPI RtlCopySid(DWORD len,PSID to,PSID from);
377PSID_IDENTIFIER_AUTHORITY WINAPI RtlIdentifierAuthoritySid( PSID pSid );
378
379/*
380 * security descriptor functions
381 */
382
383NTSTATUS WINAPI RtlCreateSecurityDescriptor(
384 PSECURITY_DESCRIPTOR lpsd,
385 DWORD rev);
386
387NTSTATUS WINAPI RtlValidSecurityDescriptor(
388 PSECURITY_DESCRIPTOR SecurityDescriptor);
389
390ULONG WINAPI RtlLengthSecurityDescriptor(
391 PSECURITY_DESCRIPTOR SecurityDescriptor);
392
393NTSTATUS WINAPI RtlGetDaclSecurityDescriptor(
394 IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
395 OUT PBOOLEAN lpbDaclPresent,
396 OUT PACL *pDacl,
397 OUT PBOOLEAN lpbDaclDefaulted);
398
399NTSTATUS WINAPI RtlSetDaclSecurityDescriptor (
400 PSECURITY_DESCRIPTOR lpsd,
401 BOOLEAN daclpresent,
402 PACL dacl,
403 BOOLEAN dacldefaulted );
404
405NTSTATUS WINAPI RtlGetSaclSecurityDescriptor(
406 IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
407 OUT PBOOLEAN lpbSaclPresent,
408 OUT PACL *pSacl,
409 OUT PBOOLEAN lpbSaclDefaulted);
410
411NTSTATUS WINAPI RtlSetSaclSecurityDescriptor (
412 PSECURITY_DESCRIPTOR lpsd,
413 BOOLEAN saclpresent,
414 PACL sacl,
415 BOOLEAN sacldefaulted);
416
417NTSTATUS WINAPI RtlGetOwnerSecurityDescriptor(
418 PSECURITY_DESCRIPTOR SecurityDescriptor,
419 PSID *Owner,
420 PBOOLEAN OwnerDefaulted);
421
422NTSTATUS WINAPI RtlSetOwnerSecurityDescriptor(
423 PSECURITY_DESCRIPTOR lpsd,
424 PSID owner,
425 BOOLEAN ownerdefaulted);
426
427NTSTATUS WINAPI RtlSetGroupSecurityDescriptor (
428 PSECURITY_DESCRIPTOR lpsd,
429 PSID group,
430 BOOLEAN groupdefaulted);
431
432NTSTATUS WINAPI RtlGetGroupSecurityDescriptor(
433 PSECURITY_DESCRIPTOR SecurityDescriptor,
434 PSID *Group,
435 PBOOLEAN GroupDefaulted);
436
437/* ##############################
438 ###### ACL FUNCTIONS ######
439 ##############################
440*/
441
442DWORD WINAPI RtlCreateAcl(PACL acl,DWORD size,DWORD rev);
443
444BOOLEAN WINAPI RtlFirstFreeAce(
445 PACL acl,
446 PACE_HEADER *x);
447
448NTSTATUS WINAPI RtlAddAce(
449 PACL acl,
450 DWORD rev,
451 DWORD xnrofaces,
452 PACE_HEADER acestart,
453 DWORD acelen);
454
455NTSTATUS WINAPI RtlAddAccessAllowedAce(IN OUT PACL pAcl, IN DWORD dwAceRevision,
456 IN DWORD AccessMask, IN PSID pSid);
457NTSTATUS WINAPI RtlGetAce(PACL pAcl,DWORD dwAceIndex,LPVOID *pAce );
458
459/*
460 * string functions
461 */
462
463NTSTATUS WINAPI RtlAnsiStringToUnicodeString( UNICODE_STRING *uni,
464 const STRING *ansi,
465 BOOLEAN doalloc );
466NTSTATUS WINAPI RtlOemStringToUnicodeString( UNICODE_STRING *uni,
467 const STRING *oem,
468 BOOLEAN doalloc );
469NTSTATUS WINAPI RtlMultiByteToUnicodeN( LPWSTR dst, DWORD dstlen, LPDWORD reslen,
470 LPCSTR src, DWORD srclen );
471NTSTATUS WINAPI RtlOemToUnicodeN( LPWSTR dst, DWORD dstlen, LPDWORD reslen,
472 LPCSTR src, DWORD srclen );
473VOID WINAPI RtlInitAnsiString(PANSI_STRING target,LPCSTR source);
474VOID WINAPI RtlInitString(PSTRING target,LPCSTR source);
475VOID WINAPI RtlInitUnicodeString(PUNICODE_STRING target,LPCWSTR source);
476VOID WINAPI RtlFreeUnicodeString(PUNICODE_STRING str);
477VOID WINAPI RtlFreeAnsiString(PANSI_STRING AnsiString);
478NTSTATUS WINAPI RtlUnicodeToOemN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
479 LPCWSTR src, DWORD srclen );
480NTSTATUS WINAPI RtlUnicodeToMultiByteN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
481 LPCWSTR src, DWORD srclen );
482NTSTATUS WINAPI RtlUnicodeStringToOemString( STRING *oem,
483 const UNICODE_STRING *uni,
484 BOOLEAN doalloc );
485NTSTATUS WINAPI RtlUnicodeStringToAnsiString( STRING *ansi,
486 const UNICODE_STRING *uni,
487 BOOLEAN doalloc );
488BOOLEAN WINAPI RtlEqualUnicodeString( const UNICODE_STRING *s1, const UNICODE_STRING *s2,
489 BOOLEAN CaseInsensitive );
490NTSTATUS WINAPI RtlUpcaseUnicodeString( UNICODE_STRING *dest,
491 const UNICODE_STRING *src,
492 BOOLEAN doalloc );
493NTSTATUS WINAPI RtlUpcaseUnicodeStringToAnsiString( STRING *dst,
494 const UNICODE_STRING *src,
495 BOOLEAN doalloc );
496NTSTATUS WINAPI RtlUpcaseUnicodeStringToOemString( STRING *dst,
497 const UNICODE_STRING *src,
498 BOOLEAN doalloc );
499NTSTATUS WINAPI RtlUpcaseUnicodeToMultiByteN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
500 LPCWSTR src, DWORD srclen );
501NTSTATUS WINAPI RtlUpcaseUnicodeToOemN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
502 LPCWSTR src, DWORD srclen );
503NTSTATUS WINAPI RtlMultiByteToUnicodeSize( DWORD *size, LPCSTR str, UINT len );
504NTSTATUS WINAPI RtlUnicodeToMultiByteSize( DWORD *size, LPCWSTR str, UINT len );
505
506UINT WINAPI RtlxOemStringToUnicodeSize(PSTRING str);
507DWORD WINAPI RtlUnicodeStringToOemSize( const UNICODE_STRING *str );
508DWORD WINAPI RtlUnicodeStringToAnsiSize( const UNICODE_STRING *str );
509UINT WINAPI RtlxAnsiStringToUnicodeSize(PANSI_STRING str);
510DWORD WINAPI RtlIsTextUnicode(LPVOID buf, DWORD len, DWORD *pf);
511LONG WINAPI RtlCompareUnicodeString( const UNICODE_STRING *s1, const UNICODE_STRING *s2,
512 BOOLEAN CaseInsensitive );
513
514NTSTATUS WINAPI RtlAppendStringToString( STRING *dst, const STRING *src );
515NTSTATUS WINAPI RtlAppendAsciizToString( STRING *dst, LPCSTR src );
516NTSTATUS WINAPI RtlAppendUnicodeToString( UNICODE_STRING *dst, LPCWSTR src );
517NTSTATUS WINAPI RtlAppendUnicodeStringToString( UNICODE_STRING *dst, const UNICODE_STRING *src );
518
519
520/*
521 * resource functions
522 */
523
524typedef struct _RTL_RWLOCK {
525 CRITICAL_SECTION rtlCS;
526 HANDLE hSharedReleaseSemaphore;
527 UINT uSharedWaiters;
528 HANDLE hExclusiveReleaseSemaphore;
529 UINT uExclusiveWaiters;
530 INT iNumberActive;
531 HANDLE hOwningThreadId;
532 DWORD dwTimeoutBoost;
533 PVOID pDebugInfo;
534} RTL_RWLOCK, *LPRTL_RWLOCK;
535
536VOID WINAPI RtlInitializeResource(
537 LPRTL_RWLOCK);
538
539VOID WINAPI RtlDeleteResource(
540 LPRTL_RWLOCK);
541
542BYTE WINAPI RtlAcquireResourceExclusive(
543 LPRTL_RWLOCK, BYTE fWait);
544
545BYTE WINAPI RtlAcquireResourceShared(
546 LPRTL_RWLOCK, BYTE fWait);
547
548VOID WINAPI RtlReleaseResource(
549 LPRTL_RWLOCK);
550
551VOID WINAPI RtlDumpResource(
552 LPRTL_RWLOCK);
553
554/*
555 time functions
556 */
557
558typedef struct _TIME_FIELDS
559{ CSHORT Year;
560 CSHORT Month;
561 CSHORT Day;
562 CSHORT Hour;
563 CSHORT Minute;
564 CSHORT Second;
565 CSHORT Milliseconds;
566 CSHORT Weekday;
567} TIME_FIELDS;
568
569typedef TIME_FIELDS *PTIME_FIELDS;
570
571VOID WINAPI RtlSystemTimeToLocalTime(
572 IN PLARGE_INTEGER SystemTime,
573 OUT PLARGE_INTEGER LocalTime);
574
575VOID WINAPI RtlTimeToTimeFields(
576 PLARGE_INTEGER liTime,
577 PTIME_FIELDS TimeFields);
578
579BOOLEAN WINAPI RtlTimeFieldsToTime(
580 PTIME_FIELDS tfTimeFields,
581 PLARGE_INTEGER Time);
582
583VOID WINAPI RtlTimeToElapsedTimeFields(
584 PLARGE_INTEGER liTime,
585 PTIME_FIELDS TimeFields);
586
587BOOLEAN WINAPI RtlTimeToSecondsSince1980(
588 LPFILETIME ft,
589 LPDWORD timeret);
590
591BOOLEAN WINAPI RtlTimeToSecondsSince1970(
592 LPFILETIME ft,
593 LPDWORD timeret);
594
595/*
596 heap functions
597*/
598
599/* Data structure for heap definition. This includes various
600 sizing parameters and callback routines, which, if left NULL,
601 result in default behavior */
602
603typedef struct
604{ ULONG Length; /* = sizeof(RTL_HEAP_DEFINITION) */
605 ULONG Unknown[11];
606} RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
607
608HANDLE WINAPI RtlCreateHeap(
609 ULONG Flags,
610 PVOID BaseAddress,
611 ULONG SizeToReserve,
612 ULONG SizeToCommit,
613 PVOID Unknown,
614 PRTL_HEAP_DEFINITION Definition);
615
616PVOID WINAPI RtlAllocateHeap(
617 HANDLE Heap,
618 ULONG Flags,
619 ULONG Size);
620
621
622BOOLEAN WINAPI RtlFreeHeap(
623 HANDLE Heap,
624 ULONG Flags,
625 PVOID Address);
626
627/*
628 * misc
629 */
630void WINAPIV DbgPrint(LPCSTR fmt, ...);
631void WINAPI NtRaiseException(PEXCEPTION_RECORD,PCONTEXT,BOOL);
632void WINAPI RtlRaiseException(PEXCEPTION_RECORD);
633void WINAPI RtlRaiseStatus(NTSTATUS);
634void WINAPI RtlUnwind(PEXCEPTION_FRAME,LPVOID,PEXCEPTION_RECORD,DWORD);
635VOID WINAPI RtlAcquirePebLock(void);
636VOID WINAPI RtlReleasePebLock(void);
637DWORD WINAPI RtlAdjustPrivilege(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
638DWORD WINAPI RtlIntegerToChar(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
639DWORD WINAPI RtlSetEnvironmentVariable(DWORD x1,PUNICODE_STRING key,PUNICODE_STRING val);
640DWORD WINAPI RtlNewSecurityObject(DWORD x1,DWORD x2,DWORD x3,DWORD x4,DWORD x5,DWORD x6);
641DWORD WINAPI RtlDeleteSecurityObject(DWORD x1);
642LPVOID WINAPI RtlNormalizeProcessParams(LPVOID x);
643DWORD WINAPI RtlNtStatusToDosError(DWORD error);
644BOOLEAN WINAPI RtlGetNtProductType(LPDWORD type);
645LONGLONG WINAPI RtlExtendedLargeIntegerDivide(LONGLONG dividend, INT divisor, INT *rest);
646LONGLONG WINAPI RtlExtendedIntegerMultiply(LONGLONG factor1,INT factor2);
647DWORD WINAPI RtlFormatCurrentUserKeyPath(PUNICODE_STRING String);
648DWORD WINAPI RtlOpenCurrentUser(DWORD x1, DWORD *x2);
649BOOLEAN WINAPI RtlDosPathNameToNtPathName_U( LPWSTR from,PUNICODE_STRING us,DWORD x2,DWORD x3);
650DWORD WINAPI RtlCreateEnvironment(DWORD x1,DWORD x2);
651DWORD WINAPI RtlDestroyEnvironment(DWORD x);
652DWORD WINAPI RtlQueryEnvironmentVariable_U(DWORD x1,PUNICODE_STRING key,PUNICODE_STRING val) ;
653
654BOOL WINAPI IsValidSid(PSID);
655BOOL WINAPI EqualSid(PSID,PSID);
656BOOL WINAPI EqualPrefixSid(PSID,PSID);
657DWORD WINAPI GetSidLengthRequired(BYTE);
658BOOL WINAPI AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,
659 DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,
660 DWORD,PSID*);
661VOID* WINAPI FreeSid(PSID);
662BOOL WINAPI InitializeSecurityDescriptor(SECURITY_DESCRIPTOR*,DWORD);
663BOOL WINAPI InitializeSid(PSID,PSID_IDENTIFIER_AUTHORITY,BYTE);
664DWORD* WINAPI GetSidSubAuthority(PSID,DWORD);
665BYTE * WINAPI GetSidSubAuthorityCount(PSID);
666DWORD WINAPI GetLengthSid(PSID);
667BOOL WINAPI CopySid(DWORD,PSID,PSID);
668BOOL WINAPI LookupAccountSidA(LPCSTR,PSID,LPSTR,LPDWORD,LPSTR,LPDWORD,
669 PSID_NAME_USE);
670BOOL WINAPI LookupAccountSidW(LPCWSTR,PSID,LPWSTR,LPDWORD,LPWSTR,LPDWORD,
671 PSID_NAME_USE);
672PSID_IDENTIFIER_AUTHORITY WINAPI GetSidIdentifierAuthority(PSID);
673
674#ifdef __cplusplus
675}
676#endif
677
678#endif
Note: See TracBrowser for help on using the repository browser.