ReactOS 0.4.15-dev-5895-g2687c1b
rtlfuncs.h
Go to the documentation of this file.
1/*++ NDK Version: 0098
2
3Copyright (c) Alex Ionescu. All rights reserved.
4
5Header Name:
6
7 rtlfuncs.h
8
9Abstract:
10
11 Function definitions for the Run-Time Library
12
13Author:
14
15 Alex Ionescu (alexi@tinykrnl.org) - Updated - 27-Feb-2006
16
17--*/
18
19#ifndef _RTLFUNCS_H
20#define _RTLFUNCS_H
21
22//
23// Dependencies
24//
25#include <umtypes.h>
26#include <ntnls.h>
27#include <rtltypes.h>
28#include <pstypes.h>
29#include <extypes.h>
30#include "in6addr.h"
31#include "inaddr.h"
32
33#ifdef __cplusplus
34extern "C" {
35#endif
36
37#ifdef NTOS_MODE_USER
38
39//
40// List Functions
41//
43VOID
45 _Out_ PLIST_ENTRY ListHead
46)
47{
48 ListHead->Flink = ListHead->Blink = ListHead;
49}
50
52VOID
54 _Inout_ PLIST_ENTRY ListHead,
56)
57{
58 PLIST_ENTRY OldFlink;
59 OldFlink = ListHead->Flink;
60 Entry->Flink = OldFlink;
61 Entry->Blink = ListHead;
62 OldFlink->Blink = Entry;
63 ListHead->Flink = Entry;
64}
65
67VOID
69 _Inout_ PLIST_ENTRY ListHead,
71)
72{
73 PLIST_ENTRY OldBlink;
74 OldBlink = ListHead->Blink;
75 Entry->Flink = ListHead;
76 Entry->Blink = OldBlink;
77 OldBlink->Flink = Entry;
78 ListHead->Blink = Entry;
79}
80
85 _In_ const LIST_ENTRY * ListHead
86)
87{
88 return (BOOLEAN)(ListHead->Flink == ListHead);
89}
90
95)
96{
97 PSINGLE_LIST_ENTRY FirstEntry;
98 FirstEntry = ListHead->Next;
99 if (FirstEntry != NULL) {
100 ListHead->Next = FirstEntry->Next;
101 }
102
103 return FirstEntry;
104}
105
107VOID
111)
112{
113 Entry->Next = ListHead->Next;
114 ListHead->Next = Entry;
115}
116
121{
122 PLIST_ENTRY OldFlink;
123 PLIST_ENTRY OldBlink;
124
125 OldFlink = Entry->Flink;
126 OldBlink = Entry->Blink;
127 OldFlink->Blink = OldBlink;
128 OldBlink->Flink = OldFlink;
129 return (BOOLEAN)(OldFlink == OldBlink);
130}
131
135 _Inout_ PLIST_ENTRY ListHead)
136{
137 PLIST_ENTRY Flink;
139
140 Entry = ListHead->Flink;
141 Flink = Entry->Flink;
142 ListHead->Flink = Flink;
143 Flink->Blink = ListHead;
144 return Entry;
145}
146
150 _Inout_ PLIST_ENTRY ListHead)
151{
152 PLIST_ENTRY Blink;
154
155 Entry = ListHead->Blink;
156 Blink = Entry->Blink;
157 ListHead->Blink = Blink;
158 Blink->Flink = ListHead;
159 return Entry;
160}
161
162//
163// Unicode string macros
164//
169VOID
170RtlInitEmptyUnicodeString(
174{
175 UnicodeString->Length = 0;
176 UnicodeString->MaximumLength = BufferSize;
177 UnicodeString->Buffer = Buffer;
178}
179
184VOID
185RtlInitEmptyAnsiString(
189{
190 AnsiString->Length = 0;
191 AnsiString->MaximumLength = BufferSize;
192 AnsiString->Buffer = Buffer;
193}
194
195//
196// LUID Macros
197//
198#define RtlEqualLuid(L1, L2) (((L1)->HighPart == (L2)->HighPart) && \
199 ((L1)->LowPart == (L2)->LowPart))
201LUID
205{
206 LUID TempLuid;
207
208 TempLuid.LowPart = Ulong;
209 TempLuid.HighPart = 0;
210 return TempLuid;
211}
212
213//
214// ASSERT Macros
215//
216#ifndef ASSERT
217#if DBG
218
219#define ASSERT( exp ) \
220 ((void)((!(exp)) ? \
221 (RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, NULL ),FALSE) : \
222 TRUE))
223
224#define ASSERTMSG( msg, exp ) \
225 ((void)((!(exp)) ? \
226 (RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, (PCHAR)msg ),FALSE) : \
227 TRUE))
228
229#else
230
231#define ASSERT( exp ) ((void) 0)
232#define ASSERTMSG( msg, exp ) ((void) 0)
233
234#endif
235#endif
236
237#ifdef NTOS_KERNEL_RUNTIME
238
239//
240// Executing RTL functions at DISPATCH_LEVEL or higher will result in a
241// bugcheck.
242//
243#define RTL_PAGED_CODE PAGED_CODE
244
245#else
246
247//
248// This macro does nothing in user mode
249//
250#define RTL_PAGED_CODE()
251
252#endif
253
254//
255// RTL Splay Tree Functions
256//
257#ifndef RTL_USE_AVL_TABLES
258
260VOID
261NTAPI
268);
269
271PVOID
272NTAPI
277 _Out_opt_ PBOOLEAN NewElement
278);
279
281PVOID
282NTAPI
287 _Out_opt_ PBOOLEAN NewElement,
288 _In_ PVOID NodeOrParent,
289 _In_ TABLE_SEARCH_RESULT SearchResult
290);
291
294NTAPI
298);
299
302PVOID
303NTAPI
307);
308
310PVOID
311NTAPI
315 _Out_ PVOID *NodeOrParent,
316 _Out_ TABLE_SEARCH_RESULT *SearchResult
317);
318
321PVOID
322NTAPI
326);
327
330PVOID
331NTAPI
334 _Inout_ PVOID *RestartKey
335);
336
339PVOID
340NTAPI
343 _In_ ULONG I
344);
345
347ULONG
348NTAPI
351);
352
356NTAPI
359);
360
361#endif /* !RTL_USE_AVL_TABLES */
362
365NTAPI
368);
369
372NTAPI
375);
376
378VOID
379NTAPI
383);
384
388NTAPI
391);
392
396NTAPI
399);
400
404NTAPI
407);
408
412NTAPI
415);
416
417#define RtlIsLeftChild(Links) \
418 (RtlLeftChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))
419
420#define RtlIsRightChild(Links) \
421 (RtlRightChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))
422
423#define RtlRightChild(Links) \
424 ((PRTL_SPLAY_LINKS)(Links))->RightChild
425
426#define RtlIsRoot(Links) \
427 (RtlParent(Links) == (PRTL_SPLAY_LINKS)(Links))
428
429#define RtlLeftChild(Links) \
430 ((PRTL_SPLAY_LINKS)(Links))->LeftChild
431
432#define RtlParent(Links) \
433 ((PRTL_SPLAY_LINKS)(Links))->Parent
434
435// FIXME: use inline function
436
437#define RtlInitializeSplayLinks(Links) \
438 { \
439 PRTL_SPLAY_LINKS _SplayLinks; \
440 _SplayLinks = (PRTL_SPLAY_LINKS)(Links); \
441 _SplayLinks->Parent = _SplayLinks; \
442 _SplayLinks->LeftChild = NULL; \
443 _SplayLinks->RightChild = NULL; \
444 }
445
446#define RtlInsertAsLeftChild(ParentLinks,ChildLinks) \
447 { \
448 PRTL_SPLAY_LINKS _SplayParent; \
449 PRTL_SPLAY_LINKS _SplayChild; \
450 _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
451 _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks); \
452 _SplayParent->LeftChild = _SplayChild; \
453 _SplayChild->Parent = _SplayParent; \
454 }
455
456#define RtlInsertAsRightChild(ParentLinks,ChildLinks) \
457 { \
458 PRTL_SPLAY_LINKS _SplayParent; \
459 PRTL_SPLAY_LINKS _SplayChild; \
460 _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
461 _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks); \
462 _SplayParent->RightChild = _SplayChild; \
463 _SplayChild->Parent = _SplayParent; \
464 }
465
466//
467// RTL AVL Tree Functions
468//
470VOID
471NTAPI
478);
479
481PVOID
482NTAPI
487 _Out_opt_ PBOOLEAN NewElement
488);
489
491PVOID
492NTAPI
497 _Out_opt_ PBOOLEAN NewElement,
498 _In_ PVOID NodeOrParent,
499 _In_ TABLE_SEARCH_RESULT SearchResult
500);
501
504NTAPI
508);
509
512PVOID
513NTAPI
517);
518
520PVOID
521NTAPI
525 _Out_ PVOID *NodeOrParent,
526 _Out_ TABLE_SEARCH_RESULT *SearchResult
527);
528
531PVOID
532NTAPI
536);
537
540PVOID
541NTAPI
544 _Inout_ PVOID *RestartKey
545);
546
549PVOID
550NTAPI
554 _Out_ PVOID *RestartKey
555);
556
559PVOID
560NTAPI
563 _In_opt_ PRTL_AVL_MATCH_FUNCTION MatchFunction,
565 _In_ ULONG NextFlag,
566 _Inout_ PVOID *RestartKey,
567 _Inout_ PULONG DeleteCount,
569);
570
573PVOID
574NTAPI
577 _In_ ULONG I
578);
579
581ULONG
582NTAPI
585);
586
590NTAPI
593);
594
595#ifdef RTL_USE_AVL_TABLES
596
597#define RtlInitializeGenericTable RtlInitializeGenericTableAvl
598#define RtlInsertElementGenericTable RtlInsertElementGenericTableAvl
599#define RtlInsertElementGenericTableFull RtlInsertElementGenericTableFullAvl
600#define RtlDeleteElementGenericTable RtlDeleteElementGenericTableAvl
601#define RtlLookupElementGenericTable RtlLookupElementGenericTableAvl
602#define RtlLookupElementGenericTableFull RtlLookupElementGenericTableFullAvl
603#define RtlEnumerateGenericTable RtlEnumerateGenericTableAvl
604#define RtlEnumerateGenericTableWithoutSplaying RtlEnumerateGenericTableWithoutSplayingAvl
605#define RtlGetElementGenericTable RtlGetElementGenericTableAvl
606#define RtlNumberGenericTableElements RtlNumberGenericTableElementsAvl
607#define RtlIsGenericTableEmpty RtlIsGenericTableEmptyAvl
608
609#endif /* RTL_USE_AVL_TABLES */
610
611//
612// Exception and Error Functions
613//
615PVOID
616NTAPI
618 _In_ ULONG FirstHandler,
619 _In_ PVECTORED_EXCEPTION_HANDLER VectoredHandler
620);
621
623ULONG
624NTAPI
626 _In_ PVOID VectoredHandlerHandle
627);
628
630PVOID
631NTAPI
633 _In_ ULONG FirstHandler,
634 _In_ PVECTORED_EXCEPTION_HANDLER VectoredHandler
635);
636
638ULONG
639NTAPI
641 _In_ PVOID VectoredHandlerHandle
642);
643
645VOID
646NTAPI
648 _In_ PRTLP_UNHANDLED_EXCEPTION_FILTER TopLevelExceptionFilter
649);
650
652LONG
653NTAPI
655 _In_ struct _EXCEPTION_POINTERS* ExceptionInfo
656);
657
660VOID
661NTAPI
663 _In_ PVOID FailedAssertion,
667);
668
670PVOID
671NTAPI
673 _In_ PVOID Pointer
674);
675
677PVOID
678NTAPI
680 _In_ PVOID Pointer
681);
682
684PVOID
685NTAPI
687 _In_ PVOID Pointer
688);
689
691PVOID
692NTAPI
694 _In_ PVOID Pointer
695);
696
699NTAPI
701 VOID
702);
703
705ULONG
706NTAPI
708 VOID
709);
710
712VOID
713NTAPI
715 _In_ ULONG LastError
716);
717
719VOID
720NTAPI
723);
724
727NTAPI
729 _In_ ULONG NewMode,
730 _Out_opt_ PULONG OldMode
731);
732
734ULONG
735NTAPI
737 VOID
738);
739
740#endif /* NTOS_MODE_USER */
741
743VOID
744NTAPI
747);
748
751NTAPI
753 _In_ PEXCEPTION_RECORD ExceptionRecord,
755);
756
759_When_(Status >= 0, _Out_range_(==, 0))
761ULONG
762NTAPI
765);
766
768_When_(Status >= 0, _Out_range_(==, 0))
770ULONG
771NTAPI
774);
775
778NTAPI
780 _In_ ULONG SecurityError
781);
782
784VOID
785NTAPI
787 _In_ PEXCEPTION_RECORD ExceptionRecord
788);
789
792VOID
793NTAPI
796);
797
799VOID
800NTAPI
802 _In_opt_ PVOID TargetFrame,
803 _In_opt_ PVOID TargetIp,
804 _In_opt_ PEXCEPTION_RECORD ExceptionRecord,
806);
807
808#define RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT 8
809
810#ifdef _M_AMD64
811
814NTAPI
816 _In_ DWORD64 ControlPc,
817 _Out_ PDWORD64 ImageBase,
818 _Inout_opt_ PUNWIND_HISTORY_TABLE HistoryTable
819);
820
823NTAPI
826 _In_ ULONG64 ImageBase,
827 _In_ ULONG64 ControlPc,
828 _In_ PRUNTIME_FUNCTION FunctionEntry,
830 _Outptr_ PVOID* HandlerData,
832 _Inout_opt_ PKNONVOLATILE_CONTEXT_POINTERS ContextPointers
833);
834
835#endif // _M_AMD64
836
837//
838// Tracing Functions
839//
841ULONG
842NTAPI
847);
848
850USHORT
851NTAPI
853 VOID
854);
855
856#ifdef NTOS_MODE_USER
857//
858// Heap Functions
859//
864PVOID
865NTAPI
867 _In_ PVOID HeapHandle,
870);
871
874PVOID
875NTAPI
879 _In_opt_ SIZE_T SizeToReserve,
880 _In_opt_ SIZE_T SizeToCommit,
883);
884
886ULONG
887NTAPI
889 _In_ HANDLE HeapHandle,
891 _In_opt_ PWSTR TagName,
892 _In_ PWSTR TagSubName
893);
894
895ULONG
896NTAPI
898 _In_ HANDLE Heap,
900);
901
904PVOID
905NTAPI
909 _In_opt_ SIZE_T SizeToReserve,
910 _In_opt_ SIZE_T SizeToCommit,
913);
914
916HANDLE
917NTAPI
920);
921
923ULONG
924NTAPI
926 _In_ HANDLE Heap,
928 _In_ PVOID P,
930);
931
932_Success_(return != 0)
935NTAPI
937 _In_ HANDLE HeapHandle,
940);
941
942ULONG
943NTAPI
945 _In_ ULONG HeapCount,
946 _Out_cap_(HeapCount) HANDLE *HeapArray
947);
948
949_Success_(return != 0)
951NTAPI
953 _In_ PVOID HeapHandle,
956 _Inout_opt_ PVOID *UserValue,
957 _Out_opt_ PULONG UserFlags
958);
959
961PVOID
962NTAPI
964 _In_ PVOID HeapHandle,
966);
967
970NTAPI
972 _In_ PVOID HeapHandle,
973 _In_ HEAP_INFORMATION_CLASS HeapInformationClass,
974 _Out_ PVOID HeapInformation,
975 _In_ SIZE_T HeapInformationLength,
978);
979
982PWSTR
983NTAPI
985 _In_ PVOID HeapHandle,
987 _In_ USHORT TagIndex,
988 _In_ BOOLEAN ResetCounters,
989 _Out_ PRTL_HEAP_TAG_INFO HeapTagInfo
990);
991
996PVOID
997NTAPI
999 _In_ HANDLE Heap,
1003);
1004
1007NTAPI
1009 _In_ PVOID HeapHandle,
1010 _In_ HEAP_INFORMATION_CLASS HeapInformationClass,
1011 _When_(HeapInformationClass==HeapCompatibilityInformation,_In_) PVOID HeapInformation,
1012 _In_ SIZE_T HeapInformationLength
1013);
1014
1016BOOLEAN
1017NTAPI
1019 _In_ HANDLE Heap
1020);
1021
1023ULONG
1024NTAPI
1026 _In_ HANDLE HeapHandle,
1031);
1032
1034ULONG
1035NTAPI
1037 _In_ HANDLE HeapHandle,
1040 _In_count_(Count) /* _Deref_ _Post_invalid_ */ PVOID * Array
1041);
1042
1045NTAPI
1047 _In_ HANDLE Heap,
1050);
1051
1053BOOLEAN
1054NTAPI
1056 _In_ HANDLE Heap
1057);
1058
1059BOOLEAN
1060NTAPI
1062 _In_ PVOID HeapHandle,
1065 _In_ PVOID UserValue
1066);
1067
1068BOOLEAN
1069NTAPI
1071 _In_ PVOID HeapHandle,
1074 _In_ ULONG UserFlagsReset,
1075 _In_ ULONG UserFlagsSet
1076);
1077
1079BOOLEAN
1080NTAPI
1082 _In_ HANDLE Heap,
1085);
1086
1089NTAPI
1091 _In_ HANDLE HeapHandle,
1092 _In_ PVOID HeapEntry
1093);
1094
1095#define RtlGetProcessHeap() (NtCurrentPeb()->ProcessHeap)
1096
1097#endif // NTOS_MODE_USER
1098
1099#define NtCurrentPeb() (NtCurrentTeb()->ProcessEnvironmentBlock)
1100
1102SIZE_T
1103NTAPI
1105 _In_ PVOID HeapHandle,
1107 _In_ PVOID MemoryPointer
1108);
1109
1110
1111//
1112// Security Functions
1113//
1117NTAPI
1122);
1123
1127NTAPI
1129 _Inout_ PACL Acl,
1133);
1134
1138NTAPI
1140 _Inout_ PACL pAcl,
1145);
1146
1149NTAPI
1151 _Inout_ PACL pAcl,
1155 _In_opt_ GUID *ObjectTypeGuid,
1156 _In_opt_ GUID *InheritedObjectTypeGuid,
1157 _In_ PSID pSid
1158);
1159
1162NTAPI
1164 _Inout_ PACL Acl,
1167 _In_ PSID Sid
1168);
1169
1172NTAPI
1174 _Inout_ PACL Acl,
1178 _In_ PSID Sid
1179);
1180
1183NTAPI
1185 _Inout_ PACL pAcl,
1189 _In_opt_ GUID *ObjectTypeGuid,
1190 _In_opt_ GUID *InheritedObjectTypeGuid,
1191 _In_ PSID pSid
1192);
1193
1196NTAPI
1198 _Inout_ PACL Acl,
1203);
1204
1207NTAPI
1209 _Inout_ PACL Acl,
1212 _In_ PSID Sid,
1214 _In_ BOOLEAN Failure
1215);
1216
1219NTAPI
1222 _In_ ULONG NumPriv,
1224 _Out_ PVOID *ReturnedState
1225);
1226
1229NTAPI
1231 _Inout_ PACL Acl,
1235 _In_ PSID Sid,
1237 _In_ BOOLEAN Failure
1238);
1239
1242NTAPI
1244 _Inout_ PACL Acl,
1248 _In_opt_ GUID *ObjectTypeGuid,
1249 _In_opt_ GUID *InheritedObjectTypeGuid,
1250 _In_ PSID Sid,
1252 _In_ BOOLEAN Failure
1253);
1254
1257NTAPI
1259 _Inout_ PACL Acl,
1262 _In_ ULONG MandatoryFlags,
1264 _In_ PSID LabelSid);
1265
1268NTAPI
1271 _In_ BOOLEAN NewValue,
1272 _In_ BOOLEAN ForThread,
1273 _Out_ PBOOLEAN OldValue
1274);
1275
1279NTAPI
1283 _In_ ULONG SubAuthority0,
1284 _In_ ULONG SubAuthority1,
1285 _In_ ULONG SubAuthority2,
1286 _In_ ULONG SubAuthority3,
1287 _In_ ULONG SubAuthority4,
1288 _In_ ULONG SubAuthority5,
1289 _In_ ULONG SubAuthority6,
1290 _In_ ULONG SubAuthority7,
1292);
1293
1295BOOLEAN
1296NTAPI
1300);
1301
1303BOOLEAN
1304NTAPI
1308);
1309
1312VOID
1313NTAPI
1315 _Out_ PLUID DestinationLuid,
1317 );
1318
1320VOID
1321NTAPI
1323 ULONG Count,
1326);
1327
1330NTAPI
1334 _In_ ULONG SidAreaSize,
1336 _In_ PSID SidArea,
1337 _Out_ PSID* RemainingSidArea,
1338 _Out_ PULONG RemainingSidAreaSize
1339);
1340
1344NTAPI
1347 _In_ PSID Sid,
1349);
1350
1354NTAPI
1356 _In_ ULONG DestinationSidLength,
1357 _Out_writes_bytes_(DestinationSidLength) PSID DestinationSid,
1359);
1360
1363NTAPI
1365 PACL Acl,
1366 ULONG AclSize,
1368);
1369
1372NTAPI
1376);
1377
1380NTAPI
1384);
1385
1388NTAPI
1390 _In_ PSECURITY_DESCRIPTOR pSourceSecurityDescriptor,
1391 _Out_ PSECURITY_DESCRIPTOR *pDestinationSecurityDescriptor
1392);
1393
1396NTAPI
1398 PACL Acl,
1400);
1401
1403BOOLEAN
1404NTAPI
1406 PSID Sid1,
1407 PSID Sid2
1408);
1409
1411BOOLEAN
1412NTAPI
1414 _In_ PSID Sid1,
1415 _In_ PSID Sid2
1416);
1417
1419BOOLEAN
1420NTAPI
1422 PACL Acl,
1423 PACE* Ace
1424);
1425
1427PVOID
1428NTAPI
1431);
1432
1435NTAPI
1437 PACL Acl,
1439 PVOID *Ace
1440);
1441
1444NTAPI
1449);
1450
1453NTAPI
1457 _Out_ PACL *Dacl,
1459);
1460
1463NTAPI
1467 _Out_ PACL* Sacl,
1469);
1470
1473NTAPI
1476 _Out_ PSID *Group,
1478);
1479
1482NTAPI
1485 _Out_ PSID *Owner,
1487);
1488
1490BOOLEAN
1491NTAPI
1494 _Out_ PUCHAR RMControl
1495);
1496
1499NTAPI
1501
1504NTAPI
1506
1510NTAPI
1512 _Out_ PSID Sid,
1515);
1516
1518ULONG
1519NTAPI
1521
1524ULONG
1525NTAPI
1528
1530ULONG
1531NTAPI
1533
1536NTAPI
1538 _In_ PSECURITY_DESCRIPTOR AbsoluteSD,
1539 _Out_ PSECURITY_DESCRIPTOR SelfRelativeSD,
1541
1543VOID
1544NTAPI
1548);
1549
1550#ifdef NTOS_MODE_USER
1551
1554NTAPI
1556 PACL Acl,
1558 ULONG InformationLength,
1560);
1561
1562#endif
1563
1565VOID
1566NTAPI
1568 _In_ PVOID ReturnedState
1569);
1570
1571#if (NTDDI_VERSION >= NTDDI_VISTA)
1572
1575NTAPI
1578 _In_reads_opt_(PrivilegeCount) _When_(PrivilegeCount != 0, _Notnull_)
1579 PULONG PrivilegesToKeep,
1580 _In_ ULONG PrivilegeCount
1581);
1582
1583#endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
1584
1588NTAPI
1601);
1602
1605NTAPI
1607 _Inout_ PSECURITY_DESCRIPTOR SelfRelativeSD,
1609);
1610
1613NTAPI
1618);
1619
1622NTAPI
1625 _In_ SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest,
1626 _In_ SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet
1627);
1628
1632NTAPI
1638);
1639
1643NTAPI
1648);
1649
1650#ifdef NTOS_MODE_USER
1651
1654NTAPI
1656 PACL Acl,
1658 ULONG InformationLength,
1660);
1661
1662#endif
1663
1667NTAPI
1672);
1673
1676NTAPI
1680 _In_ PACL Sacl,
1682);
1683
1685VOID
1686NTAPI
1689 _In_ PUCHAR RMControl
1690);
1691
1693PUCHAR
1694NTAPI
1696 _In_ PSID Sid
1697);
1698
1700PULONG
1701NTAPI
1703 _In_ PSID Sid,
1704 _In_ ULONG SubAuthority
1705);
1706
1710BOOLEAN
1711NTAPI
1716);
1717
1719BOOLEAN
1720NTAPI
1722
1724BOOLEAN
1725NTAPI
1727
1729BOOLEAN
1730NTAPI
1732
1735NTAPI
1737 _In_ PSECURITY_DESCRIPTOR *ObjectDescriptor
1738);
1739
1742NTAPI
1744 _In_ PSECURITY_DESCRIPTOR ParentDescriptor,
1745 _In_ PSECURITY_DESCRIPTOR CreatorDescriptor,
1750);
1751
1754NTAPI
1756 _In_ PSECURITY_DESCRIPTOR ObjectDescriptor,
1758 _Out_ PSECURITY_DESCRIPTOR ResultantDescriptor,
1759 _In_ ULONG DescriptorLength,
1761);
1762
1765NTAPI
1768 _In_ PSECURITY_DESCRIPTOR ModificationDescriptor,
1769 _Out_ PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor,
1772);
1773
1774//
1775// Single-Character Functions
1776//
1779NTAPI
1782 _In_ ULONG Base,
1785);
1786
1788CHAR
1789NTAPI
1791
1793WCHAR
1794NTAPI
1796
1798WCHAR
1799NTAPI
1801
1804NTAPI
1807 _In_ ULONG Base,
1810);
1811
1814NTAPI
1820);
1821
1823_At_(String->MaximumLength, _Const_)
1826NTAPI
1831);
1832
1835NTAPI
1837 PCSZ String,
1838 ULONG Base,
1840);
1841
1842//
1843// Byte Swap Functions
1844//
1845#ifdef NTOS_MODE_USER
1846
1847unsigned short __cdecl _byteswap_ushort(unsigned short);
1848unsigned long __cdecl _byteswap_ulong (unsigned long);
1849unsigned __int64 __cdecl _byteswap_uint64(unsigned __int64);
1850#ifdef _MSC_VER
1851#pragma intrinsic(_byteswap_ushort)
1852#pragma intrinsic(_byteswap_ulong)
1853#pragma intrinsic(_byteswap_uint64)
1854#endif // _MSC_VER
1855#define RtlUshortByteSwap(_x) _byteswap_ushort((USHORT)(_x))
1856#define RtlUlongByteSwap(_x) _byteswap_ulong((_x))
1857#define RtlUlonglongByteSwap(_x) _byteswap_uint64((_x))
1858
1859#endif // NTOS_MODE_USER
1860
1861//
1862// Unicode->Ansi String Functions
1863//
1865ULONG
1866NTAPI
1868
1869#ifdef NTOS_MODE_USER
1870
1871#define RtlUnicodeStringToAnsiSize(STRING) ( \
1872 NLS_MB_CODE_PAGE_TAG ? \
1873 RtlxUnicodeStringToAnsiSize(STRING) : \
1874 ((STRING)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
1875)
1876
1877#endif
1878
1881NTAPI
1886);
1887
1888//
1889// Unicode->OEM String Functions
1890//
1893NTAPI
1898);
1899
1902//_At_(DestinationString->Buffer, _Post_bytecount_(DestinationString->Length))
1905NTAPI
1912);
1913
1916NTAPI
1921);
1922
1927NTAPI
1928RtlUnicodeStringToCountedOemString(
1934);
1935
1938NTAPI
1941 ULONG OemSize,
1942 PULONG ResultSize,
1944 ULONG UnicodeSize
1945);
1946
1948ULONG
1949NTAPI
1951
1952#ifdef NTOS_MODE_USER
1953
1954#define RtlUnicodeStringToOemSize(STRING) ( \
1955 NLS_MB_OEM_CODE_PAGE_TAG ? \
1956 RtlxUnicodeStringToOemSize(STRING) : \
1957 ((STRING)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
1958)
1959
1960#define RtlUnicodeStringToCountedOemSize(STRING) ( \
1961 (ULONG)(RtlUnicodeStringToOemSize(STRING) - sizeof(ANSI_NULL)) \
1962)
1963
1964#endif
1965
1968NTAPI
1971 ULONG OemSize,
1972 PULONG ResultSize,
1974 ULONG UnicodeSize
1975);
1976
1977//
1978// Unicode->MultiByte String Functions
1979//
1982NTAPI
1984 PCHAR MbString,
1985 ULONG MbSize,
1986 PULONG ResultSize,
1988 ULONG UnicodeSize
1989);
1990
1993NTAPI
1995 PCHAR MbString,
1996 ULONG MbSize,
1997 PULONG ResultSize,
1999 ULONG UnicodeSize
2000);
2001
2004NTAPI
2006 PULONG MbSize,
2008 ULONG UnicodeSize
2009);
2010
2012ULONG
2013NTAPI
2015
2016//
2017// OEM to Unicode Functions
2018//
2021NTAPI
2026);
2027
2031NTAPI
2038);
2039
2040#ifdef NTOS_MODE_USER
2041
2042#define RtlOemStringToUnicodeSize(STRING) ( \
2043 NLS_MB_OEM_CODE_PAGE_TAG ? \
2044 RtlxOemStringToUnicodeSize(STRING) : \
2045 ((STRING)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR) \
2046)
2047
2048#define RtlOemStringToCountedUnicodeSize(STRING) ( \
2049 (ULONG)(RtlOemStringToUnicodeSize(STRING) - sizeof(UNICODE_NULL)) \
2050)
2051
2052#endif
2053
2054//
2055// Ansi->Unicode String Functions
2056//
2059WCHAR
2060NTAPI
2062 _Inout_ PUCHAR *SourceCharacter);
2063
2066NTAPI
2071);
2072
2074ULONG
2075NTAPI
2078);
2079
2080#ifdef NTOS_MODE_USER
2081
2082#define RtlAnsiStringToUnicodeSize(STRING) ( \
2083 NLS_MB_CODE_PAGE_TAG ? \
2084 RtlxAnsiStringToUnicodeSize(STRING) : \
2085 ((STRING)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR) \
2086)
2087
2088#endif
2089
2091BOOLEAN
2092NTAPI
2096);
2097
2098//
2099// Unicode String Functions
2100//
2103NTAPI
2107);
2108
2111NTAPI
2115);
2116
2118LONG
2119NTAPI
2121 PCUNICODE_STRING String1,
2124);
2125
2127VOID
2128NTAPI
2132);
2133
2135BOOLEAN
2136NTAPI
2140);
2141
2142#ifdef NTOS_MODE_USER
2143
2146NTAPI
2148 _Inout_ PUNICODE_STRING UniDest,
2149 _In_ PCUNICODE_STRING UniSource,
2151);
2152
2155NTAPI
2160);
2161
2164NTAPI
2167 _In_ PCUNICODE_STRING SearchString,
2168 _In_ PCUNICODE_STRING MatchString,
2170);
2171
2172//
2173// Memory Functions
2174//
2175#if defined(_M_AMD64)
2176
2178VOID
2182 _In_ ULONG Pattern)
2183{
2185 if ((Length /= 4) != 0) {
2186 if (((ULONG64)Address & 4) != 0) {
2187 *Address = Pattern;
2188 if ((Length -= 1) == 0) {
2189 return;
2190 }
2191 Address += 1;
2192 }
2193 __stosq((PULONG64)(Address), Pattern | ((ULONG64)Pattern << 32), Length / 2);
2194 if ((Length & 1) != 0) Address[Length - 1] = Pattern;
2195 }
2196 return;
2197}
2198
2199#define RtlFillMemoryUlonglong(Destination, Length, Pattern) \
2200 __stosq((PULONG64)(Destination), Pattern, (Length) / 8)
2201
2202#else
2203
2205VOID
2206NTAPI
2210 _In_ ULONG Pattern
2211);
2212
2214VOID
2215NTAPI
2219 _In_ ULONGLONG Pattern
2220);
2221
2222#endif
2223
2226NTAPI
2231);
2232
2234SIZE_T
2235NTAPI
2239 _In_ ULONG Pattern
2240);
2241
2242#ifndef RtlEqualMemory
2243#define RtlEqualMemory(Destination, Source, Length) \
2244 (!memcmp(Destination, Source, Length))
2245#endif
2246
2247#define RtlCopyBytes RtlCopyMemory
2248#define RtlFillBytes RtlFillMemory
2249#define RtlZeroBytes RtlZeroMemory
2250
2251#endif
2252
2254BOOLEAN
2255NTAPI
2257 PCUNICODE_STRING String1,
2260);
2261
2264VOID
2265NTAPI
2269);
2270
2272VOID
2273NTAPI
2276);
2277
2280NTAPI
2286);
2287
2297VOID
2298NTAPI
2302);
2303
2313VOID
2314NTAPI
2318);
2319
2323NTAPI
2327);
2328
2330BOOLEAN
2331NTAPI
2334 _In_ INT Size,
2336);
2337
2341BOOLEAN
2342NTAPI
2344 _In_ const STRING *String1,
2347);
2348
2352BOOLEAN
2353NTAPI
2355 _In_ PCUNICODE_STRING String1,
2358);
2359
2362VOID
2363NTAPI
2367);
2368
2372LONG
2373NTAPI
2375 _In_ const STRING *String1,
2378);
2379
2381VOID
2382NTAPI
2386);
2387
2391BOOLEAN
2392NTAPI
2394 _In_ const STRING *String1,
2397);
2398
2402NTAPI
2406);
2407
2412NTAPI
2419);
2420
2424NTAPI
2429);
2430
2433NTAPI
2437);
2438
2439#define RTL_SKIP_BUFFER_COPY 0x00000001
2440
2443NTAPI
2448);
2449
2450#ifdef NTOS_MODE_USER
2451
2453VOID
2454RtlInitBuffer(
2458)
2459{
2460 Buffer->Buffer = Buffer->StaticBuffer = Data;
2461 Buffer->Size = Buffer->StaticSize = DataSize;
2462 Buffer->ReservedForAllocatedSize = 0;
2463 Buffer->ReservedForIMalloc = NULL;
2464}
2465
2468RtlEnsureBufferSize(
2472)
2473{
2474 if (Buffer && RequiredSize <= Buffer->Size)
2475 return STATUS_SUCCESS;
2477}
2478
2480VOID
2481RtlFreeBuffer(
2483)
2484{
2485 if (Buffer->Buffer != Buffer->StaticBuffer && Buffer->Buffer)
2486 RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer->Buffer);
2487 Buffer->Buffer = Buffer->StaticBuffer;
2488 Buffer->Size = Buffer->StaticSize;
2489}
2490
2492VOID
2493NTAPI
2497);
2498
2500VOID
2501NTAPI
2503 _In_ UCHAR Hash,
2505);
2506
2507#endif /* NTOS_MODE_USER */
2508
2509//
2510// Ansi String Functions
2511//
2514VOID
2515NTAPI
2517 _Inout_ _At_(AnsiString->Buffer, __drv_freesMem(Mem))
2519);
2520
2523VOID
2524NTAPI
2528);
2529
2533NTAPI
2537);
2538
2539//
2540// OEM String Functions
2541//
2544VOID
2545NTAPI
2547 _Inout_ _At_(OemString->Buffer, __drv_freesMem(Mem))
2549);
2550
2551//
2552// MultiByte->Unicode String Functions
2553//
2557NTAPI
2564);
2565
2569NTAPI
2574);
2575
2576//
2577// Atom Functions
2578//
2581NTAPI
2583 _In_ PRTL_ATOM_TABLE AtomTable,
2584 _In_ PWSTR AtomName,
2586);
2587
2590NTAPI
2593 _Inout_ PRTL_ATOM_TABLE *AtomTable
2594);
2595
2598NTAPI
2600 _In_ PRTL_ATOM_TABLE AtomTable,
2602);
2603
2606NTAPI
2608
2611NTAPI
2613 _In_ PRTL_ATOM_TABLE AtomTable,
2615 _Out_opt_ PULONG RefCount,
2617 _Out_opt_z_bytecap_(*NameLength) PWSTR AtomName,
2618 _Inout_opt_ PULONG NameLength
2619);
2620
2623NTAPI
2625 _In_ PRTL_ATOM_TABLE AtomTable,
2627);
2628
2631NTAPI
2633 _In_ PRTL_ATOM_TABLE AtomTable,
2634 _In_ PWSTR AtomName,
2636);
2637
2638//
2639// Process Management Functions
2640//
2642PPEB
2643NTAPI
2645 VOID
2646);
2647
2649VOID
2650NTAPI
2652
2655NTAPI
2657 _Out_ PRTL_USER_PROCESS_PARAMETERS *ProcessParameters,
2658 _In_ PUNICODE_STRING ImagePathName,
2661 _In_opt_ PUNICODE_STRING CommandLine,
2663 _In_opt_ PUNICODE_STRING WindowTitle,
2664 _In_opt_ PUNICODE_STRING DesktopInfo,
2665 _In_opt_ PUNICODE_STRING ShellInfo,
2666 _In_opt_ PUNICODE_STRING RuntimeInfo
2667);
2668
2671NTAPI
2673 _In_ PUNICODE_STRING ImageFileName,
2675 _In_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters,
2676 _In_opt_ PSECURITY_DESCRIPTOR ProcessSecutityDescriptor,
2677 _In_opt_ PSECURITY_DESCRIPTOR ThreadSecurityDescriptor,
2678 _In_opt_ HANDLE ParentProcess,
2680 _In_opt_ HANDLE DebugPort,
2681 _In_opt_ HANDLE ExceptionPort,
2683);
2684
2685#if (NTDDI_VERSION >= NTDDI_WIN7)
2688NTAPI
2690 _In_ PVOID ThreadContext,
2691 _Out_ HANDLE *OutThreadHandle,
2697 _Reserved_ PVOID Reserved6,
2699 _Reserved_ PVOID Reserved8
2700);
2701#else
2704NTAPI
2708 _In_ BOOLEAN CreateSuspended,
2709 _In_ ULONG StackZeroBits,
2710 _In_ SIZE_T StackReserve,
2711 _In_ SIZE_T StackCommit,
2712 _In_ PTHREAD_START_ROUTINE StartAddress,
2714 _Out_opt_ PHANDLE ThreadHandle,
2716);
2717#endif
2718
2721NTAPI
2723 _In_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters);
2724
2727NTAPI
2729 _In_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters);
2730
2732VOID
2733NTAPI
2736
2738VOID
2739NTAPI
2742 _Out_ PCONTEXT ThreadContext,
2743 _In_opt_ PVOID ThreadStartParam,
2744 _In_ PTHREAD_START_ROUTINE ThreadStartAddress,
2745 _In_ PINITIAL_TEB InitialTeb
2746);
2747
2748#ifdef _M_AMD64
2749typedef struct _WOW64_CONTEXT *PWOW64_CONTEXT;
2750
2753NTAPI
2754RtlWow64GetThreadContext(
2755 _In_ HANDLE ThreadHandle,
2756 _Inout_ PWOW64_CONTEXT ThreadContext
2757);
2758
2759
2762NTAPI
2763RtlWow64SetThreadContext(
2764 _In_ HANDLE ThreadHandle,
2765 _In_ PWOW64_CONTEXT ThreadContext
2766);
2767#endif
2768
2770BOOLEAN
2771NTAPI
2773
2776NTAPI
2778 _In_ PRTL_USER_PROCESS_PARAMETERS ProcessParameters);
2779
2781VOID
2782NTAPI
2784
2787NTAPI
2791 _In_ PVOID CallSite,
2792 _In_ ULONG ArgumentCount,
2793 _In_ PULONG Arguments,
2794 _In_ BOOLEAN PassContext,
2795 _In_ BOOLEAN AlreadySuspended
2796);
2797
2800__cdecl
2802 _In_ BOOLEAN NewValue,
2803 _Out_opt_ PBOOLEAN OldValue,
2804 _In_ BOOLEAN NeedBreaks
2805);
2806
2809__cdecl
2811 _In_ BOOLEAN NewValue,
2812 _Out_opt_ PBOOLEAN OldValue,
2813 _In_ BOOLEAN NeedBreaks
2814);
2815
2817ULONG
2818NTAPI
2820 VOID
2821);
2822
2823
2824//
2825// Thread Pool Functions
2826//
2827//
2829NTAPI
2831 _In_ PRTL_START_POOL_THREAD StartPoolThread,
2832 _In_ PRTL_EXIT_POOL_THREAD ExitPoolThread
2833);
2834
2837NTAPI
2839 _In_ HANDLE hWaitHandle,
2840 _In_opt_ HANDLE hCompletionEvent
2841);
2842
2845NTAPI
2847 _In_ HANDLE hWaitHandle
2848);
2849
2852NTAPI
2857);
2858
2861NTAPI
2866);
2867
2870NTAPI
2872 _In_ PHANDLE phNewWaitObject,
2873 _In_ HANDLE hObject,
2875 _In_ PVOID pvContext,
2876 _In_ ULONG ulMilliseconds,
2877 _In_ ULONG ulFlags
2878);
2879
2880//
2881// Environment/Path Functions
2882//
2885NTAPI
2887 _In_ BOOLEAN Inherit,
2889);
2890
2893NTAPI
2895 _In_ PUNICODE_STRING DllName,
2896 _Inout_ PUNICODE_STRING RealName,
2897 _Inout_ PUNICODE_STRING LocalName
2898);
2899
2901VOID
2902NTAPI
2905);
2906
2908BOOLEAN
2909NTAPI
2912);
2913
2916NTAPI
2919);
2920
2922ULONG
2923NTAPI
2930 _Out_ PWSTR *PartName
2931);
2932
2935NTAPI
2938 _In_ PUNICODE_STRING PathString,
2939 _In_ PUNICODE_STRING FileNameString,
2940 _In_ PUNICODE_STRING ExtensionString,
2941 _In_ PUNICODE_STRING CallerBuffer,
2943 _Out_opt_ PUNICODE_STRING* FullNameOut,
2944 _Out_opt_ PSIZE_T FilePartSize,
2946);
2947
2949BOOLEAN
2950NTAPI
2952 _In_opt_z_ PCWSTR DosPathName,
2953 _Out_ PUNICODE_STRING NtPathName,
2954 _Out_opt_ PCWSTR *NtFileNamePart,
2955 _Out_opt_ PRTL_RELATIVE_NAME_U DirectoryInfo
2956);
2957
2958
2959#define RTL_UNCHANGED_UNK_PATH 1
2960#define RTL_CONVERTED_UNC_PATH 2
2961#define RTL_CONVERTED_NT_PATH 3
2962#define RTL_UNCHANGED_DOS_PATH 4
2963
2966NTAPI
2972);
2973
2974
2976BOOLEAN
2977NTAPI
2980 _Out_ PUNICODE_STRING NtName,
2981 _Out_ PCWSTR *PartName,
2982 _Out_ PRTL_RELATIVE_NAME_U RelativeName
2983);
2984
2988NTAPI
2994);
2995
2997ULONG
2998NTAPI
3002);
3003
3005ULONG
3006NTAPI
3009 _In_ ULONG Size,
3012);
3013
3014#if (NTDDI_VERSION >= NTDDI_WIN7)
3017NTAPI
3022 _Out_opt_ PWSTR *FilePart,
3023 _Out_opt_ RTL_PATH_TYPE *InputPathType
3024 );
3025#endif
3026
3028NTAPI
3034 _Out_opt_ PSIZE_T FilePartSize,
3038);
3039
3042NTAPI
3045 _In_ PCUNICODE_STRING PathString,
3047);
3048
3050ULONG
3051NTAPI
3053 VOID
3054);
3055
3057ULONG
3058NTAPI
3061);
3062
3064ULONG
3065NTAPI
3068);
3069
3073BOOLEAN
3074NTAPI
3079);
3080
3083NTAPI
3088);
3089
3090VOID
3091NTAPI
3093 _In_ PRTL_RELATIVE_NAME_U RelativeName
3094);
3095
3098NTAPI
3101);
3102
3105NTAPI
3110);
3111
3112//
3113// Critical Section/Resource Functions
3114//
3117NTAPI
3120);
3121
3124NTAPI
3127);
3128
3131NTAPI
3134);
3135
3138NTAPI
3141 _In_ ULONG SpinCount
3142);
3143
3145ULONG
3146NTAPI
3149);
3150
3152ULONG
3153NTAPI
3156);
3157
3160NTAPI
3163);
3164
3166BOOLEAN
3167NTAPI
3170);
3171
3173VOID
3174NTAPI
3177);
3178
3181NTAPI
3184);
3185
3187BOOLEAN
3188NTAPI
3192);
3193
3195BOOLEAN
3196NTAPI
3200);
3201
3203VOID
3204NTAPI
3207);
3208
3210VOID
3211NTAPI
3214);
3215
3217VOID
3218NTAPI
3221);
3222
3224VOID
3225NTAPI
3228);
3229
3231VOID
3232NTAPI
3235);
3236
3238VOID
3239NTAPI
3242);
3243
3244//
3245// Compression Functions
3246//
3247NTSYSAPI //NT_RTL_COMPRESS_API
3249NTAPI
3251 _In_ USHORT CompressionFormatAndEngine,
3256 _In_ ULONG UncompressedChunkSize,
3257 _Out_ PULONG FinalCompressedSize,
3259);
3260
3262NTSYSAPI //NT_RTL_COMPRESS_API
3264NTAPI
3266 _In_ USHORT CompressionFormat,
3272);
3273
3276NTAPI
3278 _In_ USHORT CompressionFormatAndEngine,
3279 _Out_ PULONG CompressBufferWorkSpaceSize,
3280 _Out_ PULONG CompressFragmentWorkSpaceSize
3281);
3282
3283//
3284// Frame Functions
3285//
3287VOID
3288NTAPI
3291);
3292
3294VOID
3295NTAPI
3298);
3299
3302NTAPI
3304 VOID
3305);
3306
3307//
3308// Debug Info Functions
3309//
3312NTAPI
3314 _In_ ULONG Size,
3315 _In_ BOOLEAN EventPair
3316);
3317
3320NTAPI
3322
3325NTAPI
3328 _In_ ULONG DebugInfoClassMask,
3330);
3331
3332//
3333// Bitmap Functions
3334//
3335#ifdef NTOS_MODE_USER
3336
3338BOOLEAN
3339NTAPI
3341 _In_ PRTL_BITMAP BitMapHeader,
3344);
3345
3347BOOLEAN
3348NTAPI
3350 _In_ PRTL_BITMAP BitMapHeader,
3353);
3354
3356VOID
3357NTAPI
3359 _In_ PRTL_BITMAP BitMapHeader
3360);
3361
3363VOID
3364NTAPI
3366 _In_ PRTL_BITMAP BitMapHeader,
3367 _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber
3368);
3369
3371VOID
3372NTAPI
3374 _In_ PRTL_BITMAP BitMapHeader,
3375 _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToClear) ULONG StartingIndex,
3376 _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToClear
3377);
3378
3380ULONG
3381NTAPI
3383 _In_ PRTL_BITMAP BitMapHeader,
3386);
3387
3389ULONG
3390NTAPI
3392 _In_ PRTL_BITMAP BitMapHeader,
3395);
3396
3398ULONG
3399NTAPI
3401 _In_ PRTL_BITMAP BitMapHeader,
3403);
3404
3406ULONG
3407NTAPI
3409 _In_ PRTL_BITMAP BitMapHeader,
3410 _Out_writes_to_(SizeOfRunArray, return) PRTL_BITMAP_RUN RunArray,
3411 _In_range_(>, 0) ULONG SizeOfRunArray,
3412 _In_ BOOLEAN LocateLongestRuns
3413);
3414
3416ULONG
3417NTAPI
3419 _In_ PRTL_BITMAP BitMapHeader,
3420 _In_ ULONG FromIndex,
3421 _Out_ PULONG StartingRunIndex
3422);
3423
3425CCHAR
3426NTAPI
3429);
3430
3432ULONG
3433NTAPI
3435 _In_ PRTL_BITMAP BitMapHeader,
3437);
3438
3440CCHAR
3441NTAPI
3444);
3445
3447ULONG
3448NTAPI
3450 _In_ PRTL_BITMAP BitMapHeader,
3451 _In_ ULONG FromIndex,
3452 _Out_ PULONG StartingRunIndex
3453);
3454
3456ULONG
3457NTAPI
3459 _In_ PRTL_BITMAP BitMapHeader,
3460 _In_ ULONG FromIndex,
3461 _Out_ PULONG StartingRunIndex
3462);
3463
3465ULONG
3466NTAPI
3468 _In_ PRTL_BITMAP BitMapHeader,
3471);
3472
3474ULONG
3475NTAPI
3477 _In_ PRTL_BITMAP BitMapHeader,
3480);
3481
3482#ifdef __REACTOS__ // ReactOS improvement
3483_At_(BitMapHeader->SizeOfBitMap, _Post_equal_to_(SizeOfBitMap))
3484_At_(BitMapHeader->Buffer, _Post_equal_to_(BitMapBuffer))
3485#endif
3487VOID
3488NTAPI
3490 _Out_ PRTL_BITMAP BitMapHeader,
3491 _In_opt_ __drv_aliasesMem PULONG BitMapBuffer,
3492 _In_opt_ ULONG SizeOfBitMap
3493);
3494
3496ULONG
3497NTAPI
3499 _In_ PRTL_BITMAP BitMapHeader
3500);
3501
3503ULONG
3504NTAPI
3506 _In_ PRTL_BITMAP BitMapHeader
3507);
3508
3510VOID
3511NTAPI
3512RtlSetBit(
3513 _In_ PRTL_BITMAP BitMapHeader,
3514 _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber
3515);
3516
3518VOID
3519NTAPI
3521 _In_ PRTL_BITMAP BitMapHeader,
3522 _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToSet) ULONG StartingIndex,
3523 _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToSet
3524);
3525
3527VOID
3528NTAPI
3530 _In_ PRTL_BITMAP BitMapHeader
3531);
3532
3535BOOLEAN
3536NTAPI
3538 _In_ PRTL_BITMAP BitMapHeader,
3539 _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber
3540);
3541
3542#if defined(_M_AMD64)
3545BOOLEAN
3547 _In_ PRTL_BITMAP BitMapHeader,
3548 _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitPosition)
3549{
3550 return BitTest64((LONG64 CONST*)BitMapHeader->Buffer, (LONG64)BitPosition);
3551}
3552#else
3553#define RtlCheckBit(BMH,BP) (((((PLONG)(BMH)->Buffer)[(BP)/32]) >> ((BP)%32)) & 0x1)
3554#endif /* defined(_M_AMD64) */
3555
3556#endif // NTOS_MODE_USER
3557
3558
3559//
3560// Timer Functions
3561//
3564NTAPI
3566 _In_ HANDLE TimerQueue,
3567 _In_ PHANDLE phNewTimer,
3573);
3574
3577NTAPI
3578RtlCreateTimerQueue(PHANDLE TimerQueue);
3579
3582NTAPI
3584 _In_ HANDLE TimerQueue,
3586 _In_ HANDLE CompletionEvent
3587);
3588
3591NTAPI
3593 _In_ HANDLE TimerQueue,
3597);
3598
3601NTAPI
3603 _In_ HANDLE TimerQueue,
3604 _In_opt_ HANDLE CompletionEvent
3605);
3606
3609NTAPI
3610RtlDeleteTimerQueue(HANDLE TimerQueue);
3611
3612//
3613// SList functions
3614//
3618 _Inout_ PSLIST_HEADER ListHead,
3622);
3623
3624//
3625// Range List functions
3626//
3628VOID
3629NTAPI
3631 _Out_ PRTL_RANGE_LIST RangeList
3632);
3633
3635VOID
3636NTAPI
3638 _In_ PRTL_RANGE_LIST RangeList
3639);
3640
3643NTAPI
3645 _Out_ PRTL_RANGE_LIST CopyRangeList,
3646 _In_ PRTL_RANGE_LIST RangeList
3647);
3648
3651NTAPI
3653 _Out_ PRTL_RANGE_LIST MergedRangeList,
3654 _In_ PRTL_RANGE_LIST RangeList1,
3655 _In_ PRTL_RANGE_LIST RangeList2,
3657);
3658
3661NTAPI
3663 _Out_ PRTL_RANGE_LIST InvertedRangeList,
3664 _In_ PRTL_RANGE_LIST RangeList
3665);
3666
3669NTAPI
3671 _Inout_ PRTL_RANGE_LIST RangeList,
3673 _In_ ULONGLONG End,
3678);
3679
3682NTAPI
3684 _Inout_ PRTL_RANGE_LIST RangeList,
3686 _In_ ULONGLONG End,
3688);
3689
3692NTAPI
3694 _Inout_ PRTL_RANGE_LIST RangeList,
3696);
3697
3700NTAPI
3702 _In_ PRTL_RANGE_LIST RangeList,
3703 _In_ ULONGLONG Minimum,
3704 _In_ ULONGLONG Maximum,
3708 _In_ UCHAR AttributeAvailableMask,
3712);
3713
3716NTAPI
3718 _In_ PRTL_RANGE_LIST RangeList,
3720 _In_ ULONGLONG End,
3722 _In_ UCHAR AttributeAvailableMask,
3725 _Out_ PBOOLEAN Available
3726);
3727
3730NTAPI
3732 _In_ PRTL_RANGE_LIST RangeList,
3735);
3736
3739NTAPI
3743 _In_ BOOLEAN MoveForwards
3744);
3745
3746//
3747// Debug Functions
3748//
3749ULONG
3750__cdecl
3753 ...
3754);
3755
3757ULONG
3758__cdecl
3763 ...
3764);
3765
3767ULONG
3768NTAPI
3770 _In_z_ PCCH Prompt,
3773);
3774
3775#undef DbgBreakPoint
3776VOID
3777NTAPI
3779 VOID
3780);
3781
3782VOID
3783NTAPI
3786 _In_ PVOID Base,
3788);
3789
3790VOID
3791NTAPI
3794 _In_ PVOID Base,
3796);
3797
3798VOID
3799NTAPI
3801 _In_ PCCH Name,
3803);
3804
3805//
3806// Generic Table Functions
3807//
3808#if defined(NTOS_MODE_USER) || defined(_NTIFS_)
3810PVOID
3811NTAPI
3816 _Out_opt_ PBOOLEAN NewElement
3817);
3818
3820PVOID
3821NTAPI
3826 _Out_opt_ PBOOLEAN NewElement,
3827 _In_ PVOID NodeOrParent,
3828 _In_ TABLE_SEARCH_RESULT SearchResult
3829);
3830
3832BOOLEAN
3833NTAPI
3836);
3837
3839PVOID
3840NTAPI
3844 _Out_ PVOID *NodeOrParent,
3845 _Out_ TABLE_SEARCH_RESULT *SearchResult
3846);
3847#endif
3848
3849//
3850// Handle Table Functions
3851//
3854NTAPI
3858);
3859
3861VOID
3862NTAPI
3865
3867BOOLEAN
3868NTAPI
3872);
3873
3875VOID
3876NTAPI
3879 _In_ ULONG HandleSize,
3881);
3882
3884BOOLEAN
3885NTAPI
3889);
3890
3891_Success_(return!=FALSE)
3893BOOLEAN
3894NTAPI
3899);
3900
3901//
3902// PE Functions
3903//
3906NTAPI
3909 _In_ ULONG Type,
3910 _In_ ULONG Language,
3911 _In_ ULONG MessageId,
3912 _Out_ PMESSAGE_RESOURCE_ENTRY *MessageResourceEntry
3913);
3914
3916ULONG
3917NTAPI
3919
3920_Success_(return!=NULL)
3922PVOID
3923NTAPI
3929);
3930
3932PVOID
3933NTAPI
3935 _In_ PIMAGE_NT_HEADERS NtHeader,
3937 _In_ ULONG Rva,
3938 _Inout_opt_ PIMAGE_SECTION_HEADER *SectionHeader
3939);
3940
3943NTAPI
3946
3949NTAPI
3954 _Out_ PIMAGE_NT_HEADERS *NtHeader
3955);
3956
3959NTAPI
3961 _In_ PIMAGE_NT_HEADERS NtHeader,
3963 _In_ ULONG Rva
3964);
3965
3967ULONG
3968NTAPI
3970 _In_ PVOID NewAddress,
3971 _In_ LONGLONG AdditionalBias,
3972 _In_ PCCH LoaderName,
3974 _In_ ULONG Conflict,
3976);
3977
3978//
3979// Activation Context Functions
3980//
3981#ifdef NTOS_MODE_USER
3984NTAPI
3987 _In_ PTEB Teb,
3990);
3991
3994NTAPI
3999);
4000
4002VOID
4003NTAPI
4006);
4007
4012 _In_ PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED Frame,
4014);
4015
4018NTAPI
4021);
4022
4025NTAPI
4028 _In_ PACTIVATION_CONTEXT_DATA ActivationContextData,
4029 _In_ ULONG ExtraBytes,
4030 _In_ PVOID NotificationRoutine,
4033);
4034
4037NTAPI
4040);
4041
4043VOID
4044NTAPI
4047);
4048
4051NTAPI
4054 _In_ ULONG_PTR ulCookie
4055);
4056
4058VOID
4059NTAPI
4062);
4063
4065VOID
4066NTAPI
4068
4073 _In_ PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED Frame
4074);
4075
4078NTAPI
4081 _In_ PUNICODE_STRING OriginalName,
4086 _In_ PULONG NewFlags,
4087 _In_ PSIZE_T FileNameSize,
4089);
4090
4093NTAPI
4096 _In_ const GUID *ExtensionGuid,
4097 _In_ ULONG SectionType,
4098 _In_ const UNICODE_STRING *SectionName,
4099 _Inout_ PVOID ReturnedData
4100);
4101
4104NTAPI
4108 _In_opt_ PVOID pvSubInstance,
4109 _In_ ULONG ulInfoClass,
4110 _Out_bytecap_(cbBuffer) PVOID pvBuffer,
4111 _In_opt_ SIZE_T cbBuffer,
4112 _Out_opt_ SIZE_T *pcbWrittenOrRequired
4113);
4114
4117NTAPI
4119 _In_ ULONG ulInfoClass,
4120 _Out_bytecap_(cbBuffer) PVOID pvBuffer,
4121 _In_opt_ SIZE_T cbBuffer,
4122 _Out_opt_ SIZE_T *pcbWrittenOrRequired
4123);
4124
4127NTAPI
4130);
4131
4132//
4133// WOW64 Functions
4134//
4137NTAPI
4139 _In_ BOOLEAN Wow64FsEnableRedirection
4140);
4141
4144NTAPI
4146 _In_ PVOID Wow64FsEnableRedirection,
4147 _Out_ PVOID *OldFsRedirectionLevel
4148);
4149
4150#endif
4151
4152//
4153// Registry Functions
4154//
4159NTAPI
4161 _In_ ULONG RelativeTo,
4163);
4164
4167NTAPI
4169 _In_ ULONG RelativeTo,
4171);
4172
4175NTAPI
4177 _Out_ _At_(KeyPath->Buffer, __drv_allocatesMem(Mem) _Post_bytecap_(KeyPath->MaximumLength) _Post_bytecount_(KeyPath->Length))
4178 PUNICODE_STRING KeyPath
4179);
4180
4183NTAPI
4187);
4188
4192NTAPI
4194 _In_ ULONG RelativeTo,
4196 _Inout_ _At_(*(*QueryTable).EntryContext, _Pre_unknown_)
4200);
4201
4205NTAPI
4207 _In_ ULONG RelativeTo,
4213);
4214
4215#ifdef NTOS_MODE_USER
4218NTAPI
4226);
4227
4230NTAPI
4236);
4237
4240NTAPI
4243);
4244
4247NTAPI
4253);
4254
4257NTAPI
4264);
4265
4268NTAPI
4271 _In_ ULONG Type,
4272 _In_ PVOID Data,
4274);
4275#endif
4276
4277//
4278// NLS Functions
4279//
4281VOID
4282NTAPI
4286);
4287
4289VOID
4290NTAPI
4292 _In_ PUSHORT AnsiTableBase,
4293 _In_ PUSHORT OemTableBase,
4294 _In_ PUSHORT CaseTableBase,
4295 _Out_ PNLSTABLEINFO NlsTable
4296);
4297
4300VOID
4301NTAPI
4303 _In_ PUSHORT TableBase,
4305);
4306
4308VOID
4309NTAPI
4311 _In_ PNLSTABLEINFO NlsTable);
4312
4313#if defined(NTOS_MODE_USER) && !defined(NO_RTL_INLINES)
4314
4315//
4316// Misc conversion functions
4317//
4318static __inline
4322 _In_ LONG SignedInteger
4323)
4324{
4326
4327 Result.QuadPart = SignedInteger;
4328 return Result;
4329}
4330
4331static __inline
4335 _In_ LONG Multiplicand,
4336 _In_ LONG Multiplier
4337)
4338{
4339 LARGE_INTEGER Product;
4340
4341 Product.QuadPart = (LONGLONG)Multiplicand * (ULONGLONG)Multiplier;
4342 return Product;
4343}
4344
4345static __inline
4346ULONG
4349 _In_ ULARGE_INTEGER Dividend,
4352)
4353{
4354 ULONG Quotient;
4355
4356 Quotient = (ULONG)(Dividend.QuadPart / Divisor);
4357 if (Remainder) {
4358 *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
4359 }
4360
4361 return Quotient;
4362}
4363
4364static __inline
4368 _In_ ULONG Multiplicand,
4369 _In_ ULONG Multiplier
4370)
4371{
4372 LARGE_INTEGER Product;
4373
4374 Product.QuadPart = (ULONGLONG)Multiplicand * (ULONGLONG)Multiplier;
4375 return Product;
4376}
4377
4378#if defined(_AMD64_) || defined(_IA64_)
4379static __inline
4383 _In_ LARGE_INTEGER Dividend,
4386{