projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[DDK]
[reactos.git] / reactos / include / xdk / rtlfuncs.h
1 /******************************************************************************
2 * Runtime Library Functions *
3 ******************************************************************************/
4
5 $if (_WDMDDK_)
6 #define FAST_FAIL_LEGACY_GS_VIOLATION 0
7 #define FAST_FAIL_VTGUARD_CHECK_FAILURE 1
8 #define FAST_FAIL_STACK_COOKIE_CHECK_FAILURE 2
9 #define FAST_FAIL_CORRUPT_LIST_ENTRY 3
10 #define FAST_FAIL_INCORRECT_STACK 4
11 #define FAST_FAIL_INVALID_ARG 5
12 #define FAST_FAIL_GS_COOKIE_INIT 6
13 #define FAST_FAIL_FATAL_APP_EXIT 7
14 #define FAST_FAIL_RANGE_CHECK_FAILURE 8
15 #define FAST_FAIL_UNSAFE_REGISTRY_ACCESS 9
16 #define FAST_FAIL_GUARD_ICALL_CHECK_FAILURE 10
17 #define FAST_FAIL_GUARD_WRITE_CHECK_FAILURE 11
18 #define FAST_FAIL_INVALID_FIBER_SWITCH 12
19 #define FAST_FAIL_INVALID_SET_OF_CONTEXT 13
20 #define FAST_FAIL_INVALID_REFERENCE_COUNT 14
21 #define FAST_FAIL_INVALID_JUMP_BUFFER 18
22 #define FAST_FAIL_MRDATA_MODIFIED 19
23 #define FAST_FAIL_INVALID_FAST_FAIL_CODE 0xFFFFFFFF
24
25 DECLSPEC_NORETURN
26 FORCEINLINE
27 VOID
28 RtlFailFast(
29 _In_ ULONG Code)
30 {
31 __fastfail(Code);
32 }
33
34 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS) && (defined(_M_CEE_PURE) || defined(_M_CEE_SAFE))
35 #define NO_KERNEL_LIST_ENTRY_CHECKS
36 #endif
37
38 #if !defined(MIDL_PASS) && !defined(SORTPP_PASS)
39
40 #define RTL_STATIC_LIST_HEAD(x) LIST_ENTRY x = { &x, &x }
41
42 FORCEINLINE
43 VOID
44 InitializeListHead(
45 _Out_ PLIST_ENTRY ListHead)
46 {
47 ListHead->Flink = ListHead->Blink = ListHead;
48 }
49
50 _Must_inspect_result_
51 FORCEINLINE
52 BOOLEAN
53 IsListEmpty(
54 _In_ const LIST_ENTRY * ListHead)
55 {
56 return (BOOLEAN)(ListHead->Flink == ListHead);
57 }
58
59 FORCEINLINE
60 BOOLEAN
61 RemoveEntryListUnsafe(
62 _In_ PLIST_ENTRY Entry)
63 {
64 PLIST_ENTRY OldFlink;
65 PLIST_ENTRY OldBlink;
66
67 OldFlink = Entry->Flink;
68 OldBlink = Entry->Blink;
69 OldFlink->Blink = OldBlink;
70 OldBlink->Flink = OldFlink;
71 return (BOOLEAN)(OldFlink == OldBlink);
72 }
73
74 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
75 FORCEINLINE
76 VOID
77 FatalListEntryError(
78 _In_ PVOID P1,
79 _In_ PVOID P2,
80 _In_ PVOID P3)
81 {
82 UNREFERENCED_PARAMETER(P1);
83 UNREFERENCED_PARAMETER(P2);
84 UNREFERENCED_PARAMETER(P3);
85
86 RtlFailFast(FAST_FAIL_CORRUPT_LIST_ENTRY);
87 }
88
89 FORCEINLINE
90 VOID
91 RtlpCheckListEntry(
92 _In_ PLIST_ENTRY Entry)
93 {
94 if (Entry->Flink->Blink != Entry || Entry->Blink->Flink != Entry)
95 FatalListEntryError(Entry->Blink, Entry, Entry->Flink);
96 }
97 #endif
98
99 FORCEINLINE
100 BOOLEAN
101 RemoveEntryList(
102 _In_ PLIST_ENTRY Entry)
103 {
104 PLIST_ENTRY OldFlink;
105 PLIST_ENTRY OldBlink;
106
107 OldFlink = Entry->Flink;
108 OldBlink = Entry->Blink;
109 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
110 if (OldFlink->Blink != Entry || OldBlink->Flink != Entry)
111 FatalListEntryError(OldBlink, Entry, OldFlink);
112 #endif
113 OldFlink->Blink = OldBlink;
114 OldBlink->Flink = OldFlink;
115 return (BOOLEAN)(OldFlink == OldBlink);
116 }
117
118 FORCEINLINE
119 PLIST_ENTRY
120 RemoveHeadList(
121 _Inout_ PLIST_ENTRY ListHead)
122 {
123 PLIST_ENTRY Flink;
124 PLIST_ENTRY Entry;
125
126 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS) && DBG
127 RtlpCheckListEntry(ListHead);
128 #endif
129 Entry = ListHead->Flink;
130 Flink = Entry->Flink;
131 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
132 if (Entry->Blink != ListHead || Flink->Blink != Entry)
133 FatalListEntryError(ListHead, Entry, Flink);
134 #endif
135 ListHead->Flink = Flink;
136 Flink->Blink = ListHead;
137 return Entry;
138 }
139
140 FORCEINLINE
141 PLIST_ENTRY
142 RemoveTailList(
143 _Inout_ PLIST_ENTRY ListHead)
144 {
145 PLIST_ENTRY Blink;
146 PLIST_ENTRY Entry;
147
148 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS) && DBG
149 RtlpCheckListEntry(ListHead);
150 #endif
151 Entry = ListHead->Blink;
152 Blink = Entry->Blink;
153 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
154 if (Blink->Flink != Entry || Entry->Flink != ListHead)
155 FatalListEntryError(Blink, Entry, ListHead);
156 #endif
157 ListHead->Blink = Blink;
158 Blink->Flink = ListHead;
159 return Entry;
160 }
161
162 FORCEINLINE
163 VOID
164 InsertTailList(
165 _Inout_ PLIST_ENTRY ListHead,
166 _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
167 {
168 PLIST_ENTRY OldBlink;
169 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS) && DBG
170 RtlpCheckListEntry(ListHead);
171 #endif
172 OldBlink = ListHead->Blink;
173 Entry->Flink = ListHead;
174 Entry->Blink = OldBlink;
175 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
176 if (OldBlink->Flink != ListHead)
177 FatalListEntryError(OldBlink->Blink, OldBlink, ListHead);
178 #endif
179 OldBlink->Flink = Entry;
180 ListHead->Blink = Entry;
181 }
182
183 FORCEINLINE
184 VOID
185 InsertHeadList(
186 _Inout_ PLIST_ENTRY ListHead,
187 _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
188 {
189 PLIST_ENTRY OldFlink;
190 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS) && DBG
191 RtlpCheckListEntry(ListHead);
192 #endif
193 OldFlink = ListHead->Flink;
194 Entry->Flink = OldFlink;
195 Entry->Blink = ListHead;
196 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
197 if (OldFlink->Blink != ListHead)
198 FatalListEntryError(ListHead, OldFlink, OldFlink->Flink);
199 #endif
200 OldFlink->Blink = Entry;
201 ListHead->Flink = Entry;
202 }
203
204 FORCEINLINE
205 VOID
206 AppendTailList(
207 _Inout_ PLIST_ENTRY ListHead,
208 _Inout_ PLIST_ENTRY ListToAppend)
209 {
210 PLIST_ENTRY ListEnd = ListHead->Blink;
211
212 #if !defined(NO_KERNEL_LIST_ENTRY_CHECKS)
213 RtlpCheckListEntry(ListHead);
214 RtlpCheckListEntry(ListToAppend);
215 #endif
216 ListHead->Blink->Flink = ListToAppend;
217 ListHead->Blink = ListToAppend->Blink;
218 ListToAppend->Blink->Flink = ListHead;
219 ListToAppend->Blink = ListEnd;
220 }
221
222 FORCEINLINE
223 PSINGLE_LIST_ENTRY
224 PopEntryList(
225 _Inout_ PSINGLE_LIST_ENTRY ListHead)
226 {
227 PSINGLE_LIST_ENTRY FirstEntry;
228 FirstEntry = ListHead->Next;
229 if (FirstEntry != NULL) {
230 ListHead->Next = FirstEntry->Next;
231 }
232 return FirstEntry;
233 }
234
235 FORCEINLINE
236 VOID
237 PushEntryList(
238 _Inout_ PSINGLE_LIST_ENTRY ListHead,
239 _Inout_ __drv_aliasesMem PSINGLE_LIST_ENTRY Entry)
240 {
241 Entry->Next = ListHead->Next;
242 ListHead->Next = Entry;
243 }
244
245 #endif /* !defined(MIDL_PASS) && !defined(SORTPP_PASS) */
246
247 __analysis_noreturn
248 NTSYSAPI
249 VOID
250 NTAPI
251 RtlAssert(
252 _In_ PVOID FailedAssertion,
253 _In_ PVOID FileName,
254 _In_ ULONG LineNumber,
255 _In_opt_z_ PSTR Message);
256
257 /* VOID
258 * RtlCopyMemory(
259 * IN VOID UNALIGNED *Destination,
260 * IN CONST VOID UNALIGNED *Source,
261 * IN SIZE_T Length)
262 */
263 #define RtlCopyMemory(Destination, Source, Length) \
264 memcpy(Destination, Source, Length)
265
266 #define RtlCopyBytes RtlCopyMemory
267
268 #if defined(_M_AMD64)
269 NTSYSAPI
270 VOID
271 NTAPI
272 RtlCopyMemoryNonTemporal(
273 _Out_writes_bytes_all_(Length) VOID UNALIGNED *Destination,
274 _In_reads_bytes_(Length) const VOID UNALIGNED *Source,
275 _In_ SIZE_T Length);
276 #else
277 #define RtlCopyMemoryNonTemporal RtlCopyMemory
278 #endif
279
280 /* BOOLEAN
281 * RtlEqualLuid(
282 * IN PLUID Luid1,
283 * IN PLUID Luid2)
284 */
285 #define RtlEqualLuid(Luid1, Luid2) \
286 (((Luid1)->LowPart == (Luid2)->LowPart) && ((Luid1)->HighPart == (Luid2)->HighPart))
287
288 /* LOGICAL
289 * RtlEqualMemory(
290 * IN VOID UNALIGNED *Destination,
291 * IN CONST VOID UNALIGNED *Source,
292 * IN SIZE_T Length)
293 */
294 #define RtlEqualMemory(Destination, Source, Length) \
295 (!memcmp(Destination, Source, Length))
296
297 /* VOID
298 * RtlFillMemory(
299 * IN VOID UNALIGNED *Destination,
300 * IN SIZE_T Length,
301 * IN UCHAR Fill)
302 */
303 #define RtlFillMemory(Destination, Length, Fill) \
304 memset(Destination, Fill, Length)
305
306 #define RtlFillBytes RtlFillMemory
307
308 _IRQL_requires_max_(PASSIVE_LEVEL)
309 NTSYSAPI
310 VOID
311 NTAPI
312 RtlFreeUnicodeString(
313 _Inout_ _At_(UnicodeString->Buffer, __drv_freesMem(Mem))
314 PUNICODE_STRING UnicodeString);
315
316 _IRQL_requires_max_(PASSIVE_LEVEL)
317 _Must_inspect_result_
318 NTSYSAPI
319 NTSTATUS
320 NTAPI
321 RtlGUIDFromString(
322 _In_ PUNICODE_STRING GuidString,
323 _Out_ GUID *Guid);
324
325 _IRQL_requires_max_(DISPATCH_LEVEL)
326 _At_(DestinationString->Buffer, _Post_equal_to_(SourceString))
327 _When_(SourceString != NULL,
328 _At_(DestinationString->Length, _Post_equal_to_(_String_length_(SourceString) * sizeof(WCHAR)))
329 _At_(DestinationString->MaximumLength, _Post_equal_to_(DestinationString->Length + sizeof(WCHAR))))
330 _When_(SourceString == NULL,
331 _At_(DestinationString->Length, _Post_equal_to_(0))
332 _At_(DestinationString->MaximumLength, _Post_equal_to_(0)))
333 NTSYSAPI
334 VOID
335 NTAPI
336 RtlInitUnicodeString(
337 _Out_ PUNICODE_STRING DestinationString,
338 _In_opt_z_ __drv_aliasesMem PCWSTR SourceString);
339
340 /* VOID
341 * RtlMoveMemory(
342 * IN VOID UNALIGNED *Destination,
343 * IN CONST VOID UNALIGNED *Source,
344 * IN SIZE_T Length)
345 */
346 #define RtlMoveMemory(Destination, Source, Length) \
347 memmove(Destination, Source, Length)
348
349 _IRQL_requires_max_(PASSIVE_LEVEL)
350 _Must_inspect_result_
351 NTSYSAPI
352 NTSTATUS
353 NTAPI
354 RtlStringFromGUID(
355 _In_ REFGUID Guid,
356 _Out_ _At_(GuidString->Buffer, __drv_allocatesMem(Mem))
357 PUNICODE_STRING GuidString);
358
359 /* VOID
360 * RtlZeroMemory(
361 * IN VOID UNALIGNED *Destination,
362 * IN SIZE_T Length)
363 */
364 #define RtlZeroMemory(Destination, Length) \
365 memset(Destination, 0, Length)
366
367 #define RtlZeroBytes RtlZeroMemory
368 $endif (_WDMDDK_)
369
370 #if (NTDDI_VERSION >= NTDDI_WIN2K)
371
372 $if (_WDMDDK_)
373 _Must_inspect_result_
374 NTSYSAPI
375 BOOLEAN
376 NTAPI
377 RtlAreBitsClear(
378 _In_ PRTL_BITMAP BitMapHeader,
379 _In_ ULONG StartingIndex,
380 _In_ ULONG Length);
381
382 _Must_inspect_result_
383 NTSYSAPI
384 BOOLEAN
385 NTAPI
386 RtlAreBitsSet(
387 _In_ PRTL_BITMAP BitMapHeader,
388 _In_ ULONG StartingIndex,
389 _In_ ULONG Length);
390
391 _IRQL_requires_max_(PASSIVE_LEVEL)
392 _Must_inspect_result_
393 NTSYSAPI
394 NTSTATUS
395 NTAPI
396 RtlAnsiStringToUnicodeString(
397 _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
398 _When_(!AllocateDestinationString, _Inout_)
399 PUNICODE_STRING DestinationString,
400 _In_ PANSI_STRING SourceString,
401 _In_ BOOLEAN AllocateDestinationString);
402
403 _IRQL_requires_max_(PASSIVE_LEVEL)
404 NTSYSAPI
405 ULONG
406 NTAPI
407 RtlxAnsiStringToUnicodeSize(
408 _In_ PCANSI_STRING AnsiString);
409
410 #define RtlAnsiStringToUnicodeSize(String) ( \
411 NLS_MB_CODE_PAGE_TAG ? \
412 RtlxAnsiStringToUnicodeSize(String) : \
413 ((String)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR) \
414 )
415
416 _Success_(1)
417 _Unchanged_(Destination->MaximumLength)
418 _Unchanged_(Destination->Buffer)
419 _When_(_Old_(Destination->Length) + Source->Length <= Destination->MaximumLength,
420 _At_(Destination->Length, _Post_equal_to_(_Old_(Destination->Length) + Source->Length))
421 _At_(return, _Out_range_(==, 0)))
422 _When_(_Old_(Destination->Length) + Source->Length > Destination->MaximumLength,
423 _Unchanged_(Destination->Length)
424 _At_(return, _Out_range_(<, 0)))
425 NTSYSAPI
426 NTSTATUS
427 NTAPI
428 RtlAppendUnicodeStringToString(
429 _Inout_ PUNICODE_STRING Destination,
430 _In_ PCUNICODE_STRING Source);
431
432 _Success_(1)
433 _Unchanged_(Destination->MaximumLength)
434 _Unchanged_(Destination->Buffer)
435 /* _When_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR) <= Destination->MaximumLength,
436 _At_(Destination->Length, _Post_equal_to_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR)))
437 _At_(return, _Out_range_(==, 0)))
438 _When_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR) > Destination->MaximumLength,
439 _Unchanged_(Destination->Length)
440 _At_(return, _Out_range_(<, 0))) */
441 NTSYSAPI
442 NTSTATUS
443 NTAPI
444 RtlAppendUnicodeToString(
445 _Inout_ PUNICODE_STRING Destination,
446 _In_opt_z_ PCWSTR Source);
447
448 _IRQL_requires_max_(PASSIVE_LEVEL)
449 _Must_inspect_result_
450 NTSYSAPI
451 NTSTATUS
452 NTAPI
453 RtlCheckRegistryKey(
454 _In_ ULONG RelativeTo,
455 _In_ PWSTR Path);
456
457 NTSYSAPI
458 VOID
459 NTAPI
460 RtlClearAllBits(
461 _In_ PRTL_BITMAP BitMapHeader);
462
463 NTSYSAPI
464 VOID
465 NTAPI
466 RtlClearBits(
467 _In_ PRTL_BITMAP BitMapHeader,
468 _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToClear) ULONG StartingIndex,
469 _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToClear);
470
471 _Must_inspect_result_
472 NTSYSAPI
473 SIZE_T
474 NTAPI
475 RtlCompareMemory(
476 _In_ const VOID *Source1,
477 _In_ const VOID *Source2,
478 _In_ SIZE_T Length);
479
480 _IRQL_requires_max_(PASSIVE_LEVEL)
481 _Must_inspect_result_
482 NTSYSAPI
483 LONG
484 NTAPI
485 RtlCompareUnicodeString(
486 _In_ PCUNICODE_STRING String1,
487 _In_ PCUNICODE_STRING String2,
488 _In_ BOOLEAN CaseInSensitive);
489
490 _IRQL_requires_max_(PASSIVE_LEVEL)
491 _Must_inspect_result_
492 NTSYSAPI
493 LONG
494 NTAPI
495 RtlCompareUnicodeStrings(
496 _In_reads_(String1Length) PCWCH String1,
497 _In_ SIZE_T String1Length,
498 _In_reads_(String2Length) PCWCH String2,
499 _In_ SIZE_T String2Length,
500 _In_ BOOLEAN CaseInSensitive);
501
502 _Unchanged_(DestinationString->Buffer)
503 _Unchanged_(DestinationString->MaximumLength)
504 _At_(DestinationString->Length,
505 _When_(SourceString->Length > DestinationString->MaximumLength,
506 _Post_equal_to_(DestinationString->MaximumLength))
507 _When_(SourceString->Length <= DestinationString->MaximumLength,
508 _Post_equal_to_(SourceString->Length)))
509 NTSYSAPI
510 VOID
511 NTAPI
512 RtlCopyUnicodeString(
513 _Inout_ PUNICODE_STRING DestinationString,
514 _In_opt_ PCUNICODE_STRING SourceString);
515
516 _IRQL_requires_max_(PASSIVE_LEVEL)
517 NTSYSAPI
518 NTSTATUS
519 NTAPI
520 RtlCreateRegistryKey(
521 _In_ ULONG RelativeTo,
522 _In_ PWSTR Path);
523
524 _IRQL_requires_max_(APC_LEVEL)
525 NTSYSAPI
526 NTSTATUS
527 NTAPI
528 RtlCreateSecurityDescriptor(
529 _Out_ PSECURITY_DESCRIPTOR SecurityDescriptor,
530 _In_ ULONG Revision);
531
532 _IRQL_requires_max_(PASSIVE_LEVEL)
533 NTSYSAPI
534 NTSTATUS
535 NTAPI
536 RtlDeleteRegistryValue(
537 _In_ ULONG RelativeTo,
538 _In_ PCWSTR Path,
539 _In_z_ PCWSTR ValueName);
540
541 _IRQL_requires_max_(PASSIVE_LEVEL)
542 _Must_inspect_result_
543 NTSYSAPI
544 BOOLEAN
545 NTAPI
546 RtlEqualUnicodeString(
547 _In_ CONST UNICODE_STRING *String1,
548 _In_ CONST UNICODE_STRING *String2,
549 _In_ BOOLEAN CaseInSensitive);
550
551 #if !defined(_AMD64_) && !defined(_IA64_)
552 NTSYSAPI
553 LARGE_INTEGER
554 NTAPI
555 RtlExtendedIntegerMultiply(
556 _In_ LARGE_INTEGER Multiplicand,
557 _In_ LONG Multiplier);
558
559 NTSYSAPI
560 LARGE_INTEGER
561 NTAPI
562 RtlExtendedLargeIntegerDivide(
563 _In_ LARGE_INTEGER Dividend,
564 _In_ ULONG Divisor,
565 _Out_opt_ PULONG Remainder);
566 #endif
567
568 #if defined(_X86_) || defined(_IA64_)
569 NTSYSAPI
570 LARGE_INTEGER
571 NTAPI
572 RtlExtendedMagicDivide(
573 _In_ LARGE_INTEGER Dividend,
574 _In_ LARGE_INTEGER MagicDivisor,
575 _In_ CCHAR ShiftCount);
576 #endif
577
578 _IRQL_requires_max_(PASSIVE_LEVEL)
579 NTSYSAPI
580 VOID
581 NTAPI
582 RtlFreeAnsiString(
583 _Inout_ _At_(AnsiString->Buffer, __drv_freesMem(Mem))
584 PANSI_STRING AnsiString);
585
586 _Success_(return != -1)
587 _Must_inspect_result_
588 NTSYSAPI
589 ULONG
590 NTAPI
591 RtlFindClearBits(
592 _In_ PRTL_BITMAP BitMapHeader,
593 _In_ ULONG NumberToFind,
594 _In_ ULONG HintIndex);
595
596 _Success_(return != -1)
597 NTSYSAPI
598 ULONG
599 NTAPI
600 RtlFindClearBitsAndSet(
601 _In_ PRTL_BITMAP BitMapHeader,
602 _In_ ULONG NumberToFind,
603 _In_ ULONG HintIndex);
604
605 NTSYSAPI
606 ULONG
607 NTAPI
608 RtlFindFirstRunClear(
609 _In_ PRTL_BITMAP BitMapHeader,
610 _Out_ PULONG StartingIndex);
611
612 NTSYSAPI
613 ULONG
614 NTAPI
615 RtlFindClearRuns(
616 _In_ PRTL_BITMAP BitMapHeader,
617 _Out_writes_to_(SizeOfRunArray, return) PRTL_BITMAP_RUN RunArray,
618 _In_range_(>, 0) ULONG SizeOfRunArray,
619 _In_ BOOLEAN LocateLongestRuns);
620
621 NTSYSAPI
622 ULONG
623 NTAPI
624 RtlFindLastBackwardRunClear(
625 _In_ PRTL_BITMAP BitMapHeader,
626 _In_ ULONG FromIndex,
627 _Out_ PULONG StartingRunIndex);
628
629 _Success_(return != -1)
630 _Must_inspect_result_
631 NTSYSAPI
632 CCHAR
633 NTAPI
634 RtlFindLeastSignificantBit(
635 _In_ ULONGLONG Set);
636
637 NTSYSAPI
638 ULONG
639 NTAPI
640 RtlFindLongestRunClear(
641 _In_ PRTL_BITMAP BitMapHeader,
642 _Out_ PULONG StartingIndex);
643
644 _Success_(return != -1)
645 _Must_inspect_result_
646 NTSYSAPI
647 CCHAR
648 NTAPI
649 RtlFindMostSignificantBit(
650 _In_ ULONGLONG Set);
651
652 NTSYSAPI
653 ULONG
654 NTAPI
655 RtlFindNextForwardRunClear(
656 _In_ PRTL_BITMAP BitMapHeader,
657 _In_ ULONG FromIndex,
658 _Out_ PULONG StartingRunIndex);
659
660 _Success_(return != -1)
661 _Must_inspect_result_
662 NTSYSAPI
663 ULONG
664 NTAPI
665 RtlFindSetBits(
666 _In_ PRTL_BITMAP BitMapHeader,
667 _In_ ULONG NumberToFind,
668 _In_ ULONG HintIndex);
669
670 _Success_(return != -1)
671 NTSYSAPI
672 ULONG
673 NTAPI
674 RtlFindSetBitsAndClear(
675 _In_ PRTL_BITMAP BitMapHeader,
676 _In_ ULONG NumberToFind,
677 _In_ ULONG HintIndex);
678
679 _IRQL_requires_max_(DISPATCH_LEVEL)
680 NTSYSAPI
681 VOID
682 NTAPI
683 RtlInitAnsiString(
684 _Out_ PANSI_STRING DestinationString,
685 _In_opt_z_ __drv_aliasesMem PCSZ SourceString);
686
687 _At_(BitMapHeader->SizeOfBitMap, _Post_equal_to_(SizeOfBitMap))
688 _At_(BitMapHeader->Buffer, _Post_equal_to_(BitMapBuffer))
689 NTSYSAPI
690 VOID
691 NTAPI
692 RtlInitializeBitMap(
693 _Out_ PRTL_BITMAP BitMapHeader,
694 _In_opt_ __drv_aliasesMem PULONG BitMapBuffer,
695 _In_opt_ ULONG SizeOfBitMap);
696
697 _IRQL_requires_max_(DISPATCH_LEVEL)
698 NTSYSAPI
699 VOID
700 NTAPI
701 RtlInitString(
702 _Out_ PSTRING DestinationString,
703 _In_opt_z_ __drv_aliasesMem PCSZ SourceString);
704
705 _IRQL_requires_max_(PASSIVE_LEVEL)
706 _At_(String->MaximumLength, _Const_)
707 NTSYSAPI
708 NTSTATUS
709 NTAPI
710 RtlIntegerToUnicodeString(
711 _In_ ULONG Value,
712 _In_opt_ ULONG Base,
713 _Inout_ PUNICODE_STRING String);
714
715 _IRQL_requires_max_(PASSIVE_LEVEL)
716 _At_(String->MaximumLength, _Const_)
717 NTSYSAPI
718 NTSTATUS
719 NTAPI
720 RtlInt64ToUnicodeString(
721 _In_ ULONGLONG Value,
722 _In_opt_ ULONG Base,
723 _Inout_ PUNICODE_STRING String);
724
725 #ifdef _WIN64
726 #define RtlIntPtrToUnicodeString(Value, Base, String) \
727 RtlInt64ToUnicodeString(Value, Base, String)
728 #else
729 #define RtlIntPtrToUnicodeString(Value, Base, String) \
730 RtlIntegerToUnicodeString(Value, Base, String)
731 #endif
732
733 /* BOOLEAN
734 * RtlIsZeroLuid(
735 * IN PLUID L1);
736 */
737 #define RtlIsZeroLuid(_L1) \
738 ((BOOLEAN) ((!(_L1)->LowPart) && (!(_L1)->HighPart)))
739
740 _IRQL_requires_max_(APC_LEVEL)
741 NTSYSAPI
742 ULONG
743 NTAPI
744 RtlLengthSecurityDescriptor(
745 _In_ PSECURITY_DESCRIPTOR SecurityDescriptor);
746
747 NTSYSAPI
748 ULONG
749 NTAPI
750 RtlNumberOfClearBits(
751 _In_ PRTL_BITMAP BitMapHeader);
752
753 NTSYSAPI
754 ULONG
755 NTAPI
756 RtlNumberOfSetBits(
757 _In_ PRTL_BITMAP BitMapHeader);
758
759 _IRQL_requires_max_(PASSIVE_LEVEL)
760 NTSYSAPI
761 NTSTATUS
762 NTAPI
763 RtlQueryRegistryValues(
764 _In_ ULONG RelativeTo,
765 _In_ PCWSTR Path,
766 _Inout_ _At_(*(*QueryTable).EntryContext, _Pre_unknown_)
767 PRTL_QUERY_REGISTRY_TABLE QueryTable,
768 _In_opt_ PVOID Context,
769 _In_opt_ PVOID Environment);
770
771 #define SHORT_SIZE (sizeof(USHORT))
772 #define SHORT_MASK (SHORT_SIZE - 1)
773 #define LONG_SIZE (sizeof(LONG))
774 #define LONGLONG_SIZE (sizeof(LONGLONG))
775 #define LONG_MASK (LONG_SIZE - 1)
776 #define LONGLONG_MASK (LONGLONG_SIZE - 1)
777 #define LOWBYTE_MASK 0x00FF
778
779 #define FIRSTBYTE(VALUE) ((VALUE) & LOWBYTE_MASK)
780 #define SECONDBYTE(VALUE) (((VALUE) >> 8) & LOWBYTE_MASK)
781 #define THIRDBYTE(VALUE) (((VALUE) >> 16) & LOWBYTE_MASK)
782 #define FOURTHBYTE(VALUE) (((VALUE) >> 24) & LOWBYTE_MASK)
783
784 NTSYSAPI
785 VOID
786 NTAPI
787 RtlSetAllBits(
788 _In_ PRTL_BITMAP BitMapHeader);
789
790 NTSYSAPI
791 VOID
792 NTAPI
793 RtlSetBits(
794 _In_ PRTL_BITMAP BitMapHeader,
795 _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToSet) ULONG StartingIndex,
796 _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToSet);
797
798 _IRQL_requires_max_(APC_LEVEL)
799 NTSYSAPI
800 NTSTATUS
801 NTAPI
802 RtlSetDaclSecurityDescriptor(
803 _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
804 _In_ BOOLEAN DaclPresent,
805 _In_opt_ PACL Dacl,
806 _In_opt_ BOOLEAN DaclDefaulted);
807
808 #if defined(_AMD64_)
809
810 /* VOID
811 * RtlStoreUlong(
812 * IN PULONG Address,
813 * IN ULONG Value);
814 */
815 #define RtlStoreUlong(Address,Value) \
816 *(ULONG UNALIGNED *)(Address) = (Value)
817
818 /* VOID
819 * RtlStoreUlonglong(
820 * IN OUT PULONGLONG Address,
821 * ULONGLONG Value);
822 */
823 #define RtlStoreUlonglong(Address,Value) \
824 *(ULONGLONG UNALIGNED *)(Address) = (Value)
825
826 /* VOID
827 * RtlStoreUshort(
828 * IN PUSHORT Address,
829 * IN USHORT Value);
830 */
831 #define RtlStoreUshort(Address,Value) \
832 *(USHORT UNALIGNED *)(Address) = (Value)
833
834 /* VOID
835 * RtlRetrieveUshort(
836 * PUSHORT DestinationAddress,
837 * PUSHORT SourceAddress);
838 */
839 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
840 *(USHORT UNALIGNED *)(DestAddress) = *(USHORT)(SrcAddress)
841
842 /* VOID
843 * RtlRetrieveUlong(
844 * PULONG DestinationAddress,
845 * PULONG SourceAddress);
846 */
847 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
848 *(ULONG UNALIGNED *)(DestAddress) = *(PULONG)(SrcAddress)
849
850 #else
851
852 #define RtlStoreUlong(Address,Value) \
853 if ((ULONG_PTR)(Address) & LONG_MASK) { \
854 ((PUCHAR) (Address))[LONG_LEAST_SIGNIFICANT_BIT] = (UCHAR)(FIRSTBYTE(Value)); \
855 ((PUCHAR) (Address))[LONG_3RD_MOST_SIGNIFICANT_BIT] = (UCHAR)(SECONDBYTE(Value)); \
856 ((PUCHAR) (Address))[LONG_2ND_MOST_SIGNIFICANT_BIT] = (UCHAR)(THIRDBYTE(Value)); \
857 ((PUCHAR) (Address))[LONG_MOST_SIGNIFICANT_BIT] = (UCHAR)(FOURTHBYTE(Value)); \
858 } \
859 else { \
860 *((PULONG)(Address)) = (ULONG) (Value); \
861 }
862
863 #define RtlStoreUlonglong(Address,Value) \
864 if ((ULONG_PTR)(Address) & LONGLONG_MASK) { \
865 RtlStoreUlong((ULONG_PTR)(Address), \
866 (ULONGLONG)(Value) & 0xFFFFFFFF); \
867 RtlStoreUlong((ULONG_PTR)(Address)+sizeof(ULONG), \
868 (ULONGLONG)(Value) >> 32); \
869 } else { \
870 *((PULONGLONG)(Address)) = (ULONGLONG)(Value); \
871 }
872
873 #define RtlStoreUshort(Address,Value) \
874 if ((ULONG_PTR)(Address) & SHORT_MASK) { \
875 ((PUCHAR) (Address))[SHORT_LEAST_SIGNIFICANT_BIT] = (UCHAR)(FIRSTBYTE(Value)); \
876 ((PUCHAR) (Address))[SHORT_MOST_SIGNIFICANT_BIT ] = (UCHAR)(SECONDBYTE(Value)); \
877 } \
878 else { \
879 *((PUSHORT) (Address)) = (USHORT)Value; \
880 }
881
882 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
883 if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
884 { \
885 ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
886 ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
887 } \
888 else \
889 { \
890 *((PUSHORT)(DestAddress))=*((PUSHORT)(SrcAddress)); \
891 }
892
893 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
894 if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
895 { \
896 ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
897 ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
898 ((PUCHAR)(DestAddress))[2]=((PUCHAR)(SrcAddress))[2]; \
899 ((PUCHAR)(DestAddress))[3]=((PUCHAR)(SrcAddress))[3]; \
900 } \
901 else \
902 { \
903 *((PULONG)(DestAddress))=*((PULONG)(SrcAddress)); \
904 }
905
906 #endif /* defined(_AMD64_) */
907
908 #ifdef _WIN64
909 /* VOID
910 * RtlStoreUlongPtr(
911 * IN OUT PULONG_PTR Address,
912 * IN ULONG_PTR Value);
913 */
914 #define RtlStoreUlongPtr(Address,Value) RtlStoreUlonglong(Address,Value)
915 #else
916 #define RtlStoreUlongPtr(Address,Value) RtlStoreUlong(Address,Value)
917 #endif /* _WIN64 */
918
919 _Success_(return!=FALSE)
920 _Must_inspect_result_
921 NTSYSAPI
922 BOOLEAN
923 NTAPI
924 RtlTimeFieldsToTime(
925 _In_ PTIME_FIELDS TimeFields,
926 _Out_ PLARGE_INTEGER Time);
927
928 NTSYSAPI
929 VOID
930 NTAPI
931 RtlTimeToTimeFields(
932 _In_ PLARGE_INTEGER Time,
933 _Out_ PTIME_FIELDS TimeFields);
934
935 NTSYSAPI
936 ULONG
937 FASTCALL
938 RtlUlongByteSwap(
939 _In_ ULONG Source);
940
941 NTSYSAPI
942 ULONGLONG
943 FASTCALL
944 RtlUlonglongByteSwap(
945 _In_ ULONGLONG Source);
946
947 _When_(AllocateDestinationString,
948 _At_(DestinationString->MaximumLength,
949 _Out_range_(<=, (SourceString->MaximumLength / sizeof(WCHAR)))))
950 _When_(!AllocateDestinationString,
951 _At_(DestinationString->Buffer, _Const_)
952 _At_(DestinationString->MaximumLength, _Const_))
953 _IRQL_requires_max_(PASSIVE_LEVEL)
954 _When_(AllocateDestinationString, _Must_inspect_result_)
955 NTSYSAPI
956 NTSTATUS
957 NTAPI
958 RtlUnicodeStringToAnsiString(
959 _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
960 _When_(!AllocateDestinationString, _Inout_)
961 PANSI_STRING DestinationString,
962 _In_ PCUNICODE_STRING SourceString,
963 _In_ BOOLEAN AllocateDestinationString);
964
965 _IRQL_requires_max_(PASSIVE_LEVEL)
966 NTSYSAPI
967 ULONG
968 NTAPI
969 RtlxUnicodeStringToAnsiSize(
970 _In_ PCUNICODE_STRING UnicodeString);
971
972 #define RtlUnicodeStringToAnsiSize(String) ( \
973 NLS_MB_CODE_PAGE_TAG ? \
974 RtlxUnicodeStringToAnsiSize(String) : \
975 ((String)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
976 )
977
978 _IRQL_requires_max_(PASSIVE_LEVEL)
979 NTSYSAPI
980 NTSTATUS
981 NTAPI
982 RtlUnicodeStringToInteger(
983 _In_ PCUNICODE_STRING String,
984 _In_opt_ ULONG Base,
985 _Out_ PULONG Value);
986
987 _IRQL_requires_max_(PASSIVE_LEVEL)
988 NTSYSAPI
989 WCHAR
990 NTAPI
991 RtlUpcaseUnicodeChar(
992 _In_ WCHAR SourceCharacter);
993
994 NTSYSAPI
995 USHORT
996 FASTCALL
997 RtlUshortByteSwap(
998 _In_ USHORT Source);
999
1000 _IRQL_requires_max_(APC_LEVEL)
1001 _Must_inspect_result_
1002 NTSYSAPI
1003 BOOLEAN
1004 NTAPI
1005 RtlValidRelativeSecurityDescriptor(
1006 _In_reads_bytes_(SecurityDescriptorLength) PSECURITY_DESCRIPTOR SecurityDescriptorInput,
1007 _In_ ULONG SecurityDescriptorLength,
1008 _In_ SECURITY_INFORMATION RequiredInformation);
1009
1010 _IRQL_requires_max_(APC_LEVEL)
1011 _Must_inspect_result_
1012 NTSYSAPI
1013 BOOLEAN
1014 NTAPI
1015 RtlValidSecurityDescriptor(
1016 _In_ PSECURITY_DESCRIPTOR SecurityDescriptor);
1017
1018 _IRQL_requires_max_(PASSIVE_LEVEL)
1019 NTSYSAPI
1020 NTSTATUS
1021 NTAPI
1022 RtlGetVersion(
1023 _Out_
1024 _At_(lpVersionInformation->dwOSVersionInfoSize, _Pre_ _Valid_)
1025 _When_(lpVersionInformation->dwOSVersionInfoSize == sizeof(RTL_OSVERSIONINFOEXW),
1026 _At_((PRTL_OSVERSIONINFOEXW)lpVersionInformation, _Out_))
1027 PRTL_OSVERSIONINFOW lpVersionInformation);
1028
1029 _IRQL_requires_max_(PASSIVE_LEVEL)
1030 _Must_inspect_result_
1031 NTSYSAPI
1032 NTSTATUS
1033 NTAPI
1034 RtlVerifyVersionInfo(
1035 _In_ PRTL_OSVERSIONINFOEXW VersionInfo,
1036 _In_ ULONG TypeMask,
1037 _In_ ULONGLONG ConditionMask);
1038
1039 _IRQL_requires_max_(PASSIVE_LEVEL)
1040 NTSYSAPI
1041 NTSTATUS
1042 NTAPI
1043 RtlWriteRegistryValue(
1044 _In_ ULONG RelativeTo,
1045 _In_ PCWSTR Path,
1046 _In_z_ PCWSTR ValueName,
1047 _In_ ULONG ValueType,
1048 _In_reads_bytes_opt_(ValueLength) PVOID ValueData,
1049 _In_ ULONG ValueLength);
1050
1051 $endif (_WDMDDK_)
1052 $if (_NTDDK_)
1053
1054 #ifndef RTL_USE_AVL_TABLES
1055
1056 NTSYSAPI
1057 VOID
1058 NTAPI
1059 RtlInitializeGenericTable(
1060 _Out_ PRTL_GENERIC_TABLE Table,
1061 _In_ PRTL_GENERIC_COMPARE_ROUTINE CompareRoutine,
1062 _In_ PRTL_GENERIC_ALLOCATE_ROUTINE AllocateRoutine,
1063 _In_ PRTL_GENERIC_FREE_ROUTINE FreeRoutine,
1064 _In_opt_ PVOID TableContext);
1065
1066 NTSYSAPI
1067 PVOID
1068 NTAPI
1069 RtlInsertElementGenericTable(
1070 _In_ PRTL_GENERIC_TABLE Table,
1071 _In_reads_bytes_(BufferSize) PVOID Buffer,
1072 _In_ CLONG BufferSize,
1073 _Out_opt_ PBOOLEAN NewElement);
1074
1075 NTSYSAPI
1076 PVOID
1077 NTAPI
1078 RtlInsertElementGenericTableFull(
1079 _In_ PRTL_GENERIC_TABLE Table,
1080 _In_reads_bytes_(BufferSize) PVOID Buffer,
1081 _In_ CLONG BufferSize,
1082 _Out_opt_ PBOOLEAN NewElement,
1083 _In_ PVOID NodeOrParent,
1084 _In_ TABLE_SEARCH_RESULT SearchResult);
1085
1086 NTSYSAPI
1087 BOOLEAN
1088 NTAPI
1089 RtlDeleteElementGenericTable(
1090 _In_ PRTL_GENERIC_TABLE Table,
1091 _In_ PVOID Buffer);
1092
1093 _Must_inspect_result_
1094 NTSYSAPI
1095 PVOID
1096 NTAPI
1097 RtlLookupElementGenericTable(
1098 _In_ PRTL_GENERIC_TABLE Table,
1099 _In_ PVOID Buffer);
1100
1101 NTSYSAPI
1102 PVOID
1103 NTAPI
1104 RtlLookupElementGenericTableFull(
1105 _In_ PRTL_GENERIC_TABLE Table,
1106 _In_ PVOID Buffer,
1107 _Out_ PVOID *NodeOrParent,
1108 _Out_ TABLE_SEARCH_RESULT *SearchResult);
1109
1110 _Must_inspect_result_
1111 NTSYSAPI
1112 PVOID
1113 NTAPI
1114 RtlEnumerateGenericTable(
1115 _In_ PRTL_GENERIC_TABLE Table,
1116 _In_ BOOLEAN Restart);
1117
1118 _Must_inspect_result_
1119 NTSYSAPI
1120 PVOID
1121 NTAPI
1122 RtlEnumerateGenericTableWithoutSplaying(
1123 _In_ PRTL_GENERIC_TABLE Table,
1124 _Inout_ PVOID *RestartKey);
1125
1126 _Must_inspect_result_
1127 NTSYSAPI
1128 PVOID
1129 NTAPI
1130 RtlGetElementGenericTable(
1131 _In_ PRTL_GENERIC_TABLE Table,
1132 _In_ ULONG I);
1133
1134 NTSYSAPI
1135 ULONG
1136 NTAPI
1137 RtlNumberGenericTableElements(
1138 _In_ PRTL_GENERIC_TABLE Table);
1139
1140 _Must_inspect_result_
1141 NTSYSAPI
1142 BOOLEAN
1143 NTAPI
1144 RtlIsGenericTableEmpty(
1145 _In_ PRTL_GENERIC_TABLE Table);
1146
1147 #endif /* !RTL_USE_AVL_TABLES */
1148
1149 #define RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT 8
1150
1151 NTSYSAPI
1152 PRTL_SPLAY_LINKS
1153 NTAPI
1154 RtlSplay(
1155 _Inout_ PRTL_SPLAY_LINKS Links);
1156
1157 NTSYSAPI
1158 PRTL_SPLAY_LINKS
1159 NTAPI
1160 RtlDelete(
1161 _In_ PRTL_SPLAY_LINKS Links);
1162
1163 NTSYSAPI
1164 VOID
1165 NTAPI
1166 RtlDeleteNoSplay(
1167 _In_ PRTL_SPLAY_LINKS Links,
1168 _Inout_ PRTL_SPLAY_LINKS *Root);
1169
1170 _Must_inspect_result_
1171 NTSYSAPI
1172 PRTL_SPLAY_LINKS
1173 NTAPI
1174 RtlSubtreeSuccessor(
1175 _In_ PRTL_SPLAY_LINKS Links);
1176
1177 _Must_inspect_result_
1178 NTSYSAPI
1179 PRTL_SPLAY_LINKS
1180 NTAPI
1181 RtlSubtreePredecessor(
1182 _In_ PRTL_SPLAY_LINKS Links);
1183
1184 _Must_inspect_result_
1185 NTSYSAPI
1186 PRTL_SPLAY_LINKS
1187 NTAPI
1188 RtlRealSuccessor(
1189 _In_ PRTL_SPLAY_LINKS Links);
1190
1191 _Must_inspect_result_
1192 NTSYSAPI
1193 PRTL_SPLAY_LINKS
1194 NTAPI
1195 RtlRealPredecessor(
1196 _In_ PRTL_SPLAY_LINKS Links);
1197
1198 _IRQL_requires_max_(PASSIVE_LEVEL)
1199 _Must_inspect_result_
1200 NTSYSAPI
1201 BOOLEAN
1202 NTAPI
1203 RtlPrefixUnicodeString(
1204 _In_ PCUNICODE_STRING String1,
1205 _In_ PCUNICODE_STRING String2,
1206 _In_ BOOLEAN CaseInSensitive);
1207
1208 _IRQL_requires_max_(PASSIVE_LEVEL)
1209 NTSYSAPI
1210 VOID
1211 NTAPI
1212 RtlUpperString(
1213 _Inout_ PSTRING DestinationString,
1214 _In_ const STRING *SourceString);
1215
1216 _IRQL_requires_max_(PASSIVE_LEVEL)
1217 _When_(AllocateDestinationString, _Must_inspect_result_)
1218 NTSYSAPI
1219 NTSTATUS
1220 NTAPI
1221 RtlUpcaseUnicodeString(
1222 _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
1223 _When_(!AllocateDestinationString, _Inout_)
1224 PUNICODE_STRING DestinationString,
1225 _In_ PCUNICODE_STRING SourceString,
1226 _In_ BOOLEAN AllocateDestinationString);
1227
1228 _IRQL_requires_max_(APC_LEVEL)
1229 NTSYSAPI
1230 VOID
1231 NTAPI
1232 RtlMapGenericMask(
1233 _Inout_ PACCESS_MASK AccessMask,
1234 _In_ PGENERIC_MAPPING GenericMapping);
1235
1236 _IRQL_requires_max_(PASSIVE_LEVEL)
1237 NTSYSAPI
1238 NTSTATUS
1239 NTAPI
1240 RtlVolumeDeviceToDosName(
1241 _In_ PVOID VolumeDeviceObject,
1242 _Out_ PUNICODE_STRING DosName);
1243
1244 _IRQL_requires_max_(PASSIVE_LEVEL)
1245 _Must_inspect_result_
1246 NTSYSAPI
1247 LONG
1248 NTAPI
1249 RtlCompareString(
1250 _In_ const STRING *String1,
1251 _In_ const STRING *String2,
1252 _In_ BOOLEAN CaseInSensitive);
1253
1254 NTSYSAPI
1255 VOID
1256 NTAPI
1257 RtlCopyString(
1258 _Out_ PSTRING DestinationString,
1259 _In_opt_ const STRING *SourceString);
1260
1261 _IRQL_requires_max_(PASSIVE_LEVEL)
1262 _Must_inspect_result_
1263 NTSYSAPI
1264 BOOLEAN
1265 NTAPI
1266 RtlEqualString(
1267 _In_ const STRING *String1,
1268 _In_ const STRING *String2,
1269 _In_ BOOLEAN CaseInSensitive);
1270
1271 _IRQL_requires_max_(PASSIVE_LEVEL)
1272 NTSYSAPI
1273 NTSTATUS
1274 NTAPI
1275 RtlCharToInteger(
1276 _In_z_ PCSZ String,
1277 _In_opt_ ULONG Base,
1278 _Out_ PULONG Value);
1279
1280 _IRQL_requires_max_(PASSIVE_LEVEL)
1281 NTSYSAPI
1282 CHAR
1283 NTAPI
1284 RtlUpperChar(
1285 _In_ CHAR Character);
1286
1287 NTSYSAPI
1288 ULONG
1289 NTAPI
1290 RtlWalkFrameChain(
1291 _Out_writes_(Count - (Flags >> RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT))
1292 PVOID *Callers,
1293 _In_ ULONG Count,
1294 _In_ ULONG Flags);
1295
1296 $endif (_NTDDK_)
1297 $if (_NTIFS_)
1298
1299 _Must_inspect_result_
1300 _Ret_maybenull_
1301 _Post_writable_byte_size_(Size)
1302 NTSYSAPI
1303 PVOID
1304 NTAPI
1305 RtlAllocateHeap(
1306 _In_ HANDLE HeapHandle,
1307 _In_opt_ ULONG Flags,
1308 _In_ SIZE_T Size);
1309
1310 _Success_(return != 0)
1311 NTSYSAPI
1312 BOOLEAN
1313 NTAPI
1314 RtlFreeHeap(
1315 _In_ PVOID HeapHandle,
1316 _In_opt_ ULONG Flags,
1317 _In_ _Post_invalid_ PVOID BaseAddress);
1318
1319 NTSYSAPI
1320 VOID
1321 NTAPI
1322 RtlCaptureContext(
1323 _Out_ PCONTEXT ContextRecord);
1324
1325 _Ret_range_(<, MAXLONG)
1326 NTSYSAPI
1327 ULONG
1328 NTAPI
1329 RtlRandom(
1330 _Inout_ PULONG Seed);
1331
1332 _IRQL_requires_max_(APC_LEVEL)
1333 _Success_(return != 0)
1334 _Must_inspect_result_
1335 NTSYSAPI
1336 BOOLEAN
1337 NTAPI
1338 RtlCreateUnicodeString(
1339 _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem))
1340 PUNICODE_STRING DestinationString,
1341 _In_z_ PCWSTR SourceString);
1342
1343 _IRQL_requires_max_(PASSIVE_LEVEL)
1344 _Must_inspect_result_
1345 NTSYSAPI
1346 BOOLEAN
1347 NTAPI
1348 RtlPrefixString(
1349 _In_ const STRING *String1,
1350 _In_ const STRING *String2,
1351 _In_ BOOLEAN CaseInsensitive);
1352
1353 _IRQL_requires_max_(APC_LEVEL)
1354 NTSYSAPI
1355 NTSTATUS
1356 NTAPI
1357 RtlAppendStringToString(
1358 _Inout_ PSTRING Destination,
1359 _In_ const STRING *Source);
1360
1361 _IRQL_requires_max_(PASSIVE_LEVEL)
1362 _Must_inspect_result_
1363 NTSYSAPI
1364 NTSTATUS
1365 NTAPI
1366 RtlOemStringToUnicodeString(
1367 _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
1368 _When_(!AllocateDestinationString, _Inout_)
1369 PUNICODE_STRING DestinationString,
1370 _In_ PCOEM_STRING SourceString,
1371 _In_ BOOLEAN AllocateDestinationString);
1372
1373 _IRQL_requires_max_(PASSIVE_LEVEL)
1374 _Must_inspect_result_
1375 NTSYSAPI
1376 NTSTATUS
1377 NTAPI
1378 RtlUnicodeStringToOemString(
1379 _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
1380 _When_(!AllocateDestinationString, _Inout_)
1381 POEM_STRING DestinationString,
1382 _In_ PCUNICODE_STRING SourceString,
1383 _In_ BOOLEAN AllocateDestinationString);
1384
1385 _IRQL_requires_max_(PASSIVE_LEVEL)
1386 _Must_inspect_result_
1387 NTSYSAPI
1388 NTSTATUS
1389 NTAPI
1390 RtlUpcaseUnicodeStringToOemString(
1391 _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
1392 _When_(!AllocateDestinationString, _Inout_)
1393 POEM_STRING DestinationString,
1394 _In_ PCUNICODE_STRING SourceString,
1395 _In_ BOOLEAN AllocateDestinationString);
1396
1397 _IRQL_requires_max_(PASSIVE_LEVEL)
1398 _Must_inspect_result_
1399 NTSYSAPI
1400 NTSTATUS
1401 NTAPI
1402 RtlOemStringToCountedUnicodeString(
1403 _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
1404 _When_(!AllocateDestinationString, _Inout_)
1405 PUNICODE_STRING DestinationString,
1406 _In_ PCOEM_STRING SourceString,
1407 _In_ BOOLEAN AllocateDestinationString);
1408
1409 _IRQL_requires_max_(PASSIVE_LEVEL)
1410 _Must_inspect_result_
1411 NTSYSAPI
1412 NTSTATUS
1413 NTAPI
1414 RtlUnicodeStringToCountedOemString(
1415 _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
1416 _When_(!AllocateDestinationString, _Inout_)
1417 POEM_STRING DestinationString,
1418 _In_ PCUNICODE_STRING SourceString,
1419 _In_ BOOLEAN AllocateDestinationString);
1420
1421 _IRQL_requires_max_(PASSIVE_LEVEL)
1422 _Must_inspect_result_
1423 NTSYSAPI
1424 NTSTATUS
1425 NTAPI
1426 RtlUpcaseUnicodeStringToCountedOemString(
1427 _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
1428 _When_(!AllocateDestinationString, _Inout_)
1429 POEM_STRING DestinationString,
1430 _In_ PCUNICODE_STRING SourceString,
1431 _In_ BOOLEAN AllocateDestinationString);
1432
1433 _IRQL_requires_max_(PASSIVE_LEVEL)
1434 _When_(AllocateDestinationString, _Must_inspect_result_)
1435 NTSYSAPI
1436 NTSTATUS
1437 NTAPI
1438 RtlDowncaseUnicodeString(
1439 _When_(AllocateDestinationString, _Out_ _At_(UniDest->Buffer, __drv_allocatesMem(Mem)))
1440 _When_(!AllocateDestinationString, _Inout_)
1441 PUNICODE_STRING UniDest,
1442 _In_ PCUNICODE_STRING UniSource,
1443 _In_ BOOLEAN AllocateDestinationString);
1444
1445 _IRQL_requires_max_(PASSIVE_LEVEL)
1446 NTSYSAPI
1447 VOID
1448 NTAPI
1449 RtlFreeOemString(
1450 _Inout_ _At_(OemString->Buffer, __drv_freesMem(Mem)) POEM_STRING OemString);
1451
1452 _IRQL_requires_max_(PASSIVE_LEVEL)
1453 NTSYSAPI
1454 ULONG
1455 NTAPI
1456 RtlxUnicodeStringToOemSize(
1457 _In_ PCUNICODE_STRING UnicodeString);
1458
1459 _IRQL_requires_max_(PASSIVE_LEVEL)
1460 NTSYSAPI
1461 ULONG
1462 NTAPI
1463 RtlxOemStringToUnicodeSize(
1464 _In_ PCOEM_STRING OemString);
1465
1466 _IRQL_requires_max_(PASSIVE_LEVEL)
1467 NTSYSAPI
1468 NTSTATUS
1469 NTAPI
1470 RtlMultiByteToUnicodeN(
1471 _Out_writes_bytes_to_(MaxBytesInUnicodeString, *BytesInUnicodeString) PWCH UnicodeString,
1472 _In_ ULONG MaxBytesInUnicodeString,
1473 _Out_opt_ PULONG BytesInUnicodeString,
1474 _In_reads_bytes_(BytesInMultiByteString) const CHAR *MultiByteString,
1475 _In_ ULONG BytesInMultiByteString);
1476
1477 _IRQL_requires_max_(PASSIVE_LEVEL)
1478 NTSYSAPI
1479 NTSTATUS
1480 NTAPI
1481 RtlMultiByteToUnicodeSize(
1482 _Out_ PULONG BytesInUnicodeString,
1483 _In_reads_bytes_(BytesInMultiByteString) const CHAR *MultiByteString,
1484 _In_ ULONG BytesInMultiByteString);
1485
1486 _IRQL_requires_max_(PASSIVE_LEVEL)
1487 NTSYSAPI
1488 NTSTATUS
1489 NTAPI
1490 RtlUnicodeToMultiByteSize(
1491 _Out_ PULONG BytesInMultiByteString,
1492 _In_reads_bytes_(BytesInUnicodeString) PCWCH UnicodeString,
1493 _In_ ULONG BytesInUnicodeString);
1494
1495 _IRQL_requires_max_(PASSIVE_LEVEL)
1496 NTSYSAPI
1497 NTSTATUS
1498 NTAPI
1499 RtlUnicodeToMultiByteN(
1500 _Out_writes_bytes_to_(MaxBytesInMultiByteString, *BytesInMultiByteString) PCHAR MultiByteString,
1501 _In_ ULONG MaxBytesInMultiByteString,
1502 _Out_opt_ PULONG BytesInMultiByteString,
1503 _In_reads_bytes_(BytesInUnicodeString) PCWCH UnicodeString,
1504 _In_ ULONG BytesInUnicodeString);
1505
1506 _IRQL_requires_max_(PASSIVE_LEVEL)
1507 NTSYSAPI
1508 NTSTATUS
1509 NTAPI
1510 RtlUpcaseUnicodeToMultiByteN(
1511 _Out_writes_bytes_to_(MaxBytesInMultiByteString, *BytesInMultiByteString) PCHAR MultiByteString,
1512 _In_ ULONG MaxBytesInMultiByteString,
1513 _Out_opt_ PULONG BytesInMultiByteString,
1514 _In_reads_bytes_(BytesInUnicodeString) PCWCH UnicodeString,
1515 _In_ ULONG BytesInUnicodeString);
1516
1517 _IRQL_requires_max_(PASSIVE_LEVEL)
1518 NTSYSAPI
1519 NTSTATUS
1520 NTAPI
1521 RtlOemToUnicodeN(
1522 _Out_writes_bytes_to_(MaxBytesInUnicodeString, *BytesInUnicodeString) PWSTR UnicodeString,
1523 _In_ ULONG MaxBytesInUnicodeString,
1524 _Out_opt_ PULONG BytesInUnicodeString,
1525 _In_reads_bytes_(BytesInOemString) PCCH OemString,
1526 _In_ ULONG BytesInOemString);
1527
1528 _IRQL_requires_max_(PASSIVE_LEVEL)
1529 NTSYSAPI
1530 NTSTATUS
1531 NTAPI
1532 RtlUnicodeToOemN(
1533 _Out_writes_bytes_to_(MaxBytesInOemString, *BytesInOemString) PCHAR OemString,
1534 _In_ ULONG MaxBytesInOemString,
1535 _Out_opt_ PULONG BytesInOemString,
1536 _In_reads_bytes_(BytesInUnicodeString) PCWCH UnicodeString,
1537 _In_ ULONG BytesInUnicodeString);
1538
1539 _IRQL_requires_max_(PASSIVE_LEVEL)
1540 NTSYSAPI
1541 NTSTATUS
1542 NTAPI
1543 RtlUpcaseUnicodeToOemN(
1544 _Out_writes_bytes_to_(MaxBytesInOemString, *BytesInOemString) PCHAR OemString,
1545 _In_ ULONG MaxBytesInOemString,
1546 _Out_opt_ PULONG BytesInOemString,
1547 _In_reads_bytes_(BytesInUnicodeString) PCWCH UnicodeString,
1548 _In_ ULONG BytesInUnicodeString);
1549
1550 #if (NTDDI_VERSION >= NTDDI_VISTASP1)
1551 _IRQL_requires_max_(PASSIVE_LEVEL)
1552 NTSYSAPI
1553 NTSTATUS
1554 NTAPI
1555 RtlGenerate8dot3Name(
1556 _In_ PCUNICODE_STRING Name,
1557 _In_ BOOLEAN AllowExtendedCharacters,
1558 _Inout_ PGENERATE_NAME_CONTEXT Context,
1559 _Inout_ PUNICODE_STRING Name8dot3);
1560 #else
1561 _IRQL_requires_max_(PASSIVE_LEVEL)
1562 NTSYSAPI
1563 VOID
1564 NTAPI
1565 RtlGenerate8dot3Name(
1566 _In_ PCUNICODE_STRING Name,
1567 _In_ BOOLEAN AllowExtendedCharacters,
1568 _Inout_ PGENERATE_NAME_CONTEXT Context,
1569 _Inout_ PUNICODE_STRING Name8dot3);
1570 #endif
1571
1572 _IRQL_requires_max_(PASSIVE_LEVEL)
1573 _Must_inspect_result_
1574 NTSYSAPI
1575 BOOLEAN
1576 NTAPI
1577 RtlIsNameLegalDOS8Dot3(
1578 _In_ PCUNICODE_STRING Name,
1579 _Inout_opt_ POEM_STRING OemName,
1580 _Out_opt_ PBOOLEAN NameContainsSpaces);
1581
1582 _IRQL_requires_max_(PASSIVE_LEVEL)
1583 _Must_inspect_result_
1584 NTSYSAPI
1585 BOOLEAN
1586 NTAPI
1587 RtlIsValidOemCharacter(
1588 _Inout_ PWCHAR Char);
1589
1590 _IRQL_requires_max_(PASSIVE_LEVEL)
1591 NTSYSAPI
1592 VOID
1593 NTAPI
1594 PfxInitialize(
1595 _Out_ PPREFIX_TABLE PrefixTable);
1596
1597 _IRQL_requires_max_(PASSIVE_LEVEL)
1598 NTSYSAPI
1599 BOOLEAN
1600 NTAPI
1601 PfxInsertPrefix(
1602 _In_ PPREFIX_TABLE PrefixTable,
1603 _In_ __drv_aliasesMem PSTRING Prefix,
1604 _Out_ PPREFIX_TABLE_ENTRY PrefixTableEntry);
1605
1606 _IRQL_requires_max_(PASSIVE_LEVEL)
1607 NTSYSAPI
1608 VOID
1609 NTAPI
1610 PfxRemovePrefix(
1611 _In_ PPREFIX_TABLE PrefixTable,
1612 _In_ PPREFIX_TABLE_ENTRY PrefixTableEntry);
1613
1614 _IRQL_requires_max_(PASSIVE_LEVEL)
1615 _Must_inspect_result_
1616 NTSYSAPI
1617 PPREFIX_TABLE_ENTRY
1618 NTAPI
1619 PfxFindPrefix(
1620 _In_ PPREFIX_TABLE PrefixTable,
1621 _In_ PSTRING FullName);
1622
1623 _IRQL_requires_max_(PASSIVE_LEVEL)
1624 NTSYSAPI
1625 VOID
1626 NTAPI
1627 RtlInitializeUnicodePrefix(
1628 _Out_ PUNICODE_PREFIX_TABLE PrefixTable);
1629
1630 _IRQL_requires_max_(PASSIVE_LEVEL)
1631 NTSYSAPI
1632 BOOLEAN
1633 NTAPI
1634 RtlInsertUnicodePrefix(
1635 _In_ PUNICODE_PREFIX_TABLE PrefixTable,
1636 _In_ __drv_aliasesMem PUNICODE_STRING Prefix,
1637 _Out_ PUNICODE_PREFIX_TABLE_ENTRY PrefixTableEntry);
1638
1639 _IRQL_requires_max_(PASSIVE_LEVEL)
1640 NTSYSAPI
1641 VOID
1642 NTAPI
1643 RtlRemoveUnicodePrefix(
1644 _In_ PUNICODE_PREFIX_TABLE PrefixTable,
1645 _In_ PUNICODE_PREFIX_TABLE_ENTRY PrefixTableEntry);
1646
1647 _IRQL_requires_max_(PASSIVE_LEVEL)
1648 _Must_inspect_result_
1649 NTSYSAPI
1650 PUNICODE_PREFIX_TABLE_ENTRY
1651 NTAPI
1652 RtlFindUnicodePrefix(
1653 _In_ PUNICODE_PREFIX_TABLE PrefixTable,
1654 _In_ PUNICODE_STRING FullName,
1655 _In_ ULONG CaseInsensitiveIndex);
1656
1657 _IRQL_requires_max_(PASSIVE_LEVEL)
1658 _Must_inspect_result_
1659 NTSYSAPI
1660 PUNICODE_PREFIX_TABLE_ENTRY
1661 NTAPI
1662 RtlNextUnicodePrefix(
1663 _In_ PUNICODE_PREFIX_TABLE PrefixTable,
1664 _In_ BOOLEAN Restart);
1665
1666 _Must_inspect_result_
1667 NTSYSAPI
1668 SIZE_T
1669 NTAPI
1670 RtlCompareMemoryUlong(
1671 _In_reads_bytes_(Length) PVOID Source,
1672 _In_ SIZE_T Length,
1673 _In_ ULONG Pattern);
1674
1675 _Success_(return != 0)
1676 NTSYSAPI
1677 BOOLEAN
1678 NTAPI
1679 RtlTimeToSecondsSince1980(
1680 _In_ PLARGE_INTEGER Time,
1681 _Out_ PULONG ElapsedSeconds);
1682
1683 NTSYSAPI
1684 VOID
1685 NTAPI
1686 RtlSecondsSince1980ToTime(
1687 _In_ ULONG ElapsedSeconds,
1688 _Out_ PLARGE_INTEGER Time);
1689
1690 _Success_(return != 0)
1691 _Must_inspect_result_
1692 NTSYSAPI
1693 BOOLEAN
1694 NTAPI
1695 RtlTimeToSecondsSince1970(
1696 _In_ PLARGE_INTEGER Time,
1697 _Out_ PULONG ElapsedSeconds);
1698
1699 NTSYSAPI
1700 VOID
1701 NTAPI
1702 RtlSecondsSince1970ToTime(
1703 _In_ ULONG ElapsedSeconds,
1704 _Out_ PLARGE_INTEGER Time);
1705
1706 _IRQL_requires_max_(APC_LEVEL)
1707 _Must_inspect_result_
1708 NTSYSAPI
1709 BOOLEAN
1710 NTAPI
1711 RtlValidSid(
1712 _In_ PSID Sid);
1713
1714 _Must_inspect_result_
1715 NTSYSAPI
1716 BOOLEAN
1717 NTAPI
1718 RtlEqualSid(
1719 _In_ PSID Sid1,
1720 _In_ PSID Sid2);
1721
1722 _IRQL_requires_max_(APC_LEVEL)
1723 _Must_inspect_result_
1724 NTSYSAPI
1725 BOOLEAN
1726 NTAPI
1727 RtlEqualPrefixSid(
1728 _In_ PSID Sid1,
1729 _In_ PSID Sid2);
1730
1731 _IRQL_requires_max_(APC_LEVEL)
1732 NTSYSAPI
1733 ULONG
1734 NTAPI
1735 RtlLengthRequiredSid(
1736 _In_ ULONG SubAuthorityCount);
1737
1738 NTSYSAPI
1739 PVOID
1740 NTAPI
1741 RtlFreeSid(
1742 _In_ _Post_invalid_ PSID Sid);
1743
1744 _Must_inspect_result_
1745 NTSYSAPI
1746 NTSTATUS
1747 NTAPI
1748 RtlAllocateAndInitializeSid(
1749 _In_ PSID_IDENTIFIER_AUTHORITY IdentifierAuthority,
1750 _In_ UCHAR SubAuthorityCount,
1751 _In_ ULONG SubAuthority0,
1752 _In_ ULONG SubAuthority1,
1753 _In_ ULONG SubAuthority2,
1754 _In_ ULONG SubAuthority3,
1755 _In_ ULONG SubAuthority4,
1756 _In_ ULONG SubAuthority5,
1757 _In_ ULONG SubAuthority6,
1758 _In_ ULONG SubAuthority7,
1759 _Outptr_ PSID *Sid);
1760
1761 _IRQL_requires_max_(APC_LEVEL)
1762 NTSYSAPI
1763 NTSTATUS
1764 NTAPI
1765 RtlInitializeSid(
1766 _Out_ PSID Sid,
1767 _In_ PSID_IDENTIFIER_AUTHORITY IdentifierAuthority,
1768 _In_ UCHAR SubAuthorityCount);
1769
1770 NTSYSAPI
1771 PULONG
1772 NTAPI
1773 RtlSubAuthoritySid(
1774 _In_ PSID Sid,
1775 _In_ ULONG SubAuthority);
1776
1777 _Post_satisfies_(return >= 8 && return <= SECURITY_MAX_SID_SIZE)
1778 NTSYSAPI
1779 ULONG
1780 NTAPI
1781 RtlLengthSid(
1782 _In_ PSID Sid);
1783
1784 _IRQL_requires_max_(APC_LEVEL)
1785 NTSYSAPI
1786 NTSTATUS
1787 NTAPI
1788 RtlCopySid(
1789 _In_ ULONG DestinationSidLength,
1790 _Out_writes_bytes_(DestinationSidLength) PSID DestinationSid,
1791 _In_ PSID SourceSid);
1792
1793 _IRQL_requires_max_(APC_LEVEL)
1794 NTSYSAPI
1795 NTSTATUS
1796 NTAPI
1797 RtlConvertSidToUnicodeString(
1798 _Inout_ PUNICODE_STRING UnicodeString,
1799 _In_ PSID Sid,
1800 _In_ BOOLEAN AllocateDestinationString);
1801
1802 _IRQL_requires_max_(APC_LEVEL)
1803 NTSYSAPI
1804 VOID
1805 NTAPI
1806 RtlCopyLuid(
1807 _Out_ PLUID DestinationLuid,
1808 _In_ PLUID SourceLuid);
1809
1810 _IRQL_requires_max_(APC_LEVEL)
1811 NTSYSAPI
1812 NTSTATUS
1813 NTAPI
1814 RtlCreateAcl(
1815 _Out_writes_bytes_(AclLength) PACL Acl,
1816 _In_ ULONG AclLength,
1817 _In_ ULONG AclRevision);
1818
1819 _IRQL_requires_max_(APC_LEVEL)
1820 NTSYSAPI
1821 NTSTATUS
1822 NTAPI
1823 RtlAddAce(
1824 _Inout_ PACL Acl,
1825 _In_ ULONG AceRevision,
1826 _In_ ULONG StartingAceIndex,
1827 _In_reads_bytes_(AceListLength) PVOID AceList,
1828 _In_ ULONG AceListLength);
1829
1830 _IRQL_requires_max_(APC_LEVEL)
1831 NTSYSAPI
1832 NTSTATUS
1833 NTAPI
1834 RtlDeleteAce(
1835 _Inout_ PACL Acl,
1836 _In_ ULONG AceIndex);
1837
1838 NTSYSAPI
1839 NTSTATUS
1840 NTAPI
1841 RtlGetAce(
1842 _In_ PACL Acl,
1843 _In_ ULONG AceIndex,
1844 _Outptr_ PVOID *Ace);
1845
1846 _IRQL_requires_max_(APC_LEVEL)
1847 NTSYSAPI
1848 NTSTATUS
1849 NTAPI
1850 RtlAddAccessAllowedAce(
1851 _Inout_ PACL Acl,
1852 _In_ ULONG AceRevision,
1853 _In_ ACCESS_MASK AccessMask,
1854 _In_ PSID Sid);
1855
1856 _IRQL_requires_max_(APC_LEVEL)
1857 NTSYSAPI
1858 NTSTATUS
1859 NTAPI
1860 RtlAddAccessAllowedAceEx(
1861 _Inout_ PACL Acl,
1862 _In_ ULONG AceRevision,
1863 _In_ ULONG AceFlags,
1864 _In_ ACCESS_MASK AccessMask,
1865 _In_ PSID Sid);
1866
1867 _IRQL_requires_max_(APC_LEVEL)
1868 NTSYSAPI
1869 NTSTATUS
1870 NTAPI
1871 RtlCreateSecurityDescriptorRelative(
1872 _Out_ PISECURITY_DESCRIPTOR_RELATIVE SecurityDescriptor,
1873 _In_ ULONG Revision);
1874
1875 NTSYSAPI
1876 NTSTATUS
1877 NTAPI
1878 RtlGetDaclSecurityDescriptor(
1879 _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
1880 _Out_ PBOOLEAN DaclPresent,
1881 _Out_ PACL *Dacl,
1882 _Out_ PBOOLEAN DaclDefaulted);
1883
1884 _IRQL_requires_max_(APC_LEVEL)
1885 NTSYSAPI
1886 NTSTATUS
1887 NTAPI
1888 RtlSetOwnerSecurityDescriptor(
1889 _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
1890 _In_opt_ PSID Owner,
1891 _In_opt_ BOOLEAN OwnerDefaulted);
1892
1893 _IRQL_requires_max_(APC_LEVEL)
1894 NTSYSAPI
1895 NTSTATUS
1896 NTAPI
1897 RtlGetOwnerSecurityDescriptor(
1898 _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
1899 _Out_ PSID *Owner,
1900 _Out_ PBOOLEAN OwnerDefaulted);
1901
1902 _IRQL_requires_max_(APC_LEVEL)
1903 _When_(Status < 0, _Out_range_(>, 0))
1904 _When_(Status >= 0, _Out_range_(==, 0))
1905 NTSYSAPI
1906 ULONG
1907 NTAPI
1908 RtlNtStatusToDosError(
1909 _In_ NTSTATUS Status);
1910
1911 _IRQL_requires_max_(PASSIVE_LEVEL)
1912 NTSYSAPI
1913 NTSTATUS
1914 NTAPI
1915 RtlCustomCPToUnicodeN(
1916 _In_ PCPTABLEINFO CustomCP,
1917 _Out_writes_bytes_to_(MaxBytesInUnicodeString, *BytesInUnicodeString) PWCH UnicodeString,
1918 _In_ ULONG MaxBytesInUnicodeString,
1919 _Out_opt_ PULONG BytesInUnicodeString,
1920 _In_reads_bytes_(BytesInCustomCPString) PCH CustomCPString,
1921 _In_ ULONG BytesInCustomCPString);
1922
1923 _IRQL_requires_max_(PASSIVE_LEVEL)
1924 NTSYSAPI
1925 NTSTATUS
1926 NTAPI
1927 RtlUnicodeToCustomCPN(
1928 _In_ PCPTABLEINFO CustomCP,
1929 _Out_writes_bytes_to_(MaxBytesInCustomCPString, *BytesInCustomCPString) PCH CustomCPString,
1930 _In_ ULONG MaxBytesInCustomCPString,
1931 _Out_opt_ PULONG BytesInCustomCPString,
1932 _In_reads_bytes_(BytesInUnicodeString) PWCH UnicodeString,
1933 _In_ ULONG BytesInUnicodeString);
1934
1935 _IRQL_requires_max_(PASSIVE_LEVEL)
1936 NTSYSAPI
1937 NTSTATUS
1938 NTAPI
1939 RtlUpcaseUnicodeToCustomCPN(
1940 _In_ PCPTABLEINFO CustomCP,
1941 _Out_writes_bytes_to_(MaxBytesInCustomCPString, *BytesInCustomCPString) PCH CustomCPString,
1942 _In_ ULONG MaxBytesInCustomCPString,
1943 _Out_opt_ PULONG BytesInCustomCPString,
1944 _In_reads_bytes_(BytesInUnicodeString) PWCH UnicodeString,
1945 _In_ ULONG BytesInUnicodeString);
1946
1947 _IRQL_requires_max_(PASSIVE_LEVEL)
1948 NTSYSAPI
1949 VOID
1950 NTAPI
1951 RtlInitCodePageTable(
1952 _In_ PUSHORT TableBase,
1953 _Out_ PCPTABLEINFO CodePageTable);
1954
1955 $endif (_NTIFS_)
1956
1957 #endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */
1958
1959 $if (_WDMDDK_)
1960
1961 #if (NTDDI_VERSION >= NTDDI_WIN2KSP3)
1962 NTSYSAPI
1963 VOID
1964 FASTCALL
1965 RtlPrefetchMemoryNonTemporal(
1966 _In_ PVOID Source,
1967 _In_ SIZE_T Length);
1968 #endif
1969
1970 $endif (_WDMDDK_)
1971
1972 #if (NTDDI_VERSION >= NTDDI_WINXP)
1973
1974 $if (_WDMDDK_)
1975
1976 NTSYSAPI
1977 VOID
1978 NTAPI
1979 RtlClearBit(
1980 _In_ PRTL_BITMAP BitMapHeader,
1981 _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber);
1982
1983 _IRQL_requires_max_(PASSIVE_LEVEL)
1984 NTSYSAPI
1985 WCHAR
1986 NTAPI
1987 RtlDowncaseUnicodeChar(
1988 _In_ WCHAR SourceCharacter);
1989
1990 NTSYSAPI
1991 VOID
1992 NTAPI
1993 RtlSetBit(
1994 _In_ PRTL_BITMAP BitMapHeader,
1995 _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber);
1996
1997 _Must_inspect_result_
1998 NTSYSAPI
1999 BOOLEAN
2000 NTAPI
2001 RtlTestBit(
2002 _In_ PRTL_BITMAP BitMapHeader,
2003 _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber);
2004
2005 _IRQL_requires_max_(PASSIVE_LEVEL)
2006 NTSYSAPI
2007 NTSTATUS
2008 NTAPI
2009 RtlHashUnicodeString(
2010 _In_ CONST UNICODE_STRING *String,
2011 _In_ BOOLEAN CaseInSensitive,
2012 _In_ ULONG HashAlgorithm,
2013 _Out_ PULONG HashValue);
2014
2015 $endif (_WDMDDK_)
2016
2017 $if (_NTDDK_)
2018
2019 NTSYSAPI
2020 VOID
2021 NTAPI
2022 RtlInitializeGenericTableAvl(
2023 _Out_ PRTL_AVL_TABLE Table,
2024 _In_ PRTL_AVL_COMPARE_ROUTINE CompareRoutine,
2025 _In_opt_ PRTL_AVL_ALLOCATE_ROUTINE AllocateRoutine,
2026 _In_opt_ PRTL_AVL_FREE_ROUTINE FreeRoutine,
2027 _In_opt_ PVOID TableContext);
2028
2029 NTSYSAPI
2030 PVOID
2031 NTAPI
2032 RtlInsertElementGenericTableAvl(
2033 _In_ PRTL_AVL_TABLE Table,
2034 _In_reads_bytes_(BufferSize) PVOID Buffer,
2035 _In_ CLONG BufferSize,
2036 _Out_opt_ PBOOLEAN NewElement);
2037
2038 NTSYSAPI
2039 PVOID
2040 NTAPI
2041 RtlInsertElementGenericTableFullAvl(
2042 _In_ PRTL_AVL_TABLE Table,
2043 _In_reads_bytes_(BufferSize) PVOID Buffer,
2044 _In_ CLONG BufferSize,
2045 _Out_opt_ PBOOLEAN NewElement,
2046 _In_ PVOID NodeOrParent,
2047 _In_ TABLE_SEARCH_RESULT SearchResult);
2048
2049 NTSYSAPI
2050 BOOLEAN
2051 NTAPI
2052 RtlDeleteElementGenericTableAvl(
2053 _In_ PRTL_AVL_TABLE Table,
2054 _In_ PVOID Buffer);
2055
2056 _Must_inspect_result_
2057 NTSYSAPI
2058 PVOID
2059 NTAPI
2060 RtlLookupElementGenericTableAvl(
2061 _In_ PRTL_AVL_TABLE Table,
2062 _In_ PVOID Buffer);
2063
2064 NTSYSAPI
2065 PVOID
2066 NTAPI
2067 RtlLookupElementGenericTableFullAvl(
2068 _In_ PRTL_AVL_TABLE Table,
2069 _In_ PVOID Buffer,
2070 _Out_ PVOID *NodeOrParent,
2071 _Out_ TABLE_SEARCH_RESULT *SearchResult);
2072
2073 _Must_inspect_result_
2074 NTSYSAPI
2075 PVOID
2076 NTAPI
2077 RtlEnumerateGenericTableAvl(
2078 _In_ PRTL_AVL_TABLE Table,
2079 _In_ BOOLEAN Restart);
2080
2081 _Must_inspect_result_
2082 NTSYSAPI
2083 PVOID
2084 NTAPI
2085 RtlEnumerateGenericTableWithoutSplayingAvl(
2086 _In_ PRTL_AVL_TABLE Table,
2087 _Inout_ PVOID *RestartKey);
2088
2089 _Must_inspect_result_
2090 NTSYSAPI
2091 PVOID
2092 NTAPI
2093 RtlLookupFirstMatchingElementGenericTableAvl(
2094 _In_ PRTL_AVL_TABLE Table,
2095 _In_ PVOID Buffer,
2096 _Out_ PVOID *RestartKey);
2097
2098 _Must_inspect_result_
2099 NTSYSAPI
2100 PVOID
2101 NTAPI
2102 RtlEnumerateGenericTableLikeADirectory(
2103 _In_ PRTL_AVL_TABLE Table,
2104 _In_opt_ PRTL_AVL_MATCH_FUNCTION MatchFunction,
2105 _In_opt_ PVOID MatchData,
2106 _In_ ULONG NextFlag,
2107 _Inout_ PVOID *RestartKey,
2108 _Inout_ PULONG DeleteCount,
2109 _In_ PVOID Buffer);
2110
2111 _Must_inspect_result_
2112 NTSYSAPI
2113 PVOID
2114 NTAPI
2115 RtlGetElementGenericTableAvl(
2116 _In_ PRTL_AVL_TABLE Table,
2117 _In_ ULONG I);
2118
2119 NTSYSAPI
2120 ULONG
2121 NTAPI
2122 RtlNumberGenericTableElementsAvl(
2123 _In_ PRTL_AVL_TABLE Table);
2124
2125 _Must_inspect_result_
2126 NTSYSAPI
2127 BOOLEAN
2128 NTAPI
2129 RtlIsGenericTableEmptyAvl(
2130 _In_ PRTL_AVL_TABLE Table);
2131
2132 $endif (_NTDDK_)
2133 $if (_NTIFS_)
2134
2135 _Must_inspect_result_
2136 NTSYSAPI
2137 PVOID
2138 NTAPI
2139 RtlCreateHeap(
2140 _In_ ULONG Flags,
2141 _In_opt_ PVOID HeapBase,
2142 _In_opt_ SIZE_T ReserveSize,
2143 _In_opt_ SIZE_T CommitSize,
2144 _In_opt_ PVOID Lock,
2145 _In_opt_ PRTL_HEAP_PARAMETERS Parameters);
2146
2147 NTSYSAPI
2148 PVOID
2149 NTAPI
2150 RtlDestroyHeap(
2151 _In_ _Post_invalid_ PVOID HeapHandle);
2152
2153 NTSYSAPI
2154 USHORT
2155 NTAPI
2156 RtlCaptureStackBackTrace(
2157 _In_ ULONG FramesToSkip,
2158 _In_ ULONG FramesToCapture,
2159 _Out_writes_to_(FramesToCapture, return) PVOID *BackTrace,
2160 _Out_opt_ PULONG BackTraceHash);
2161
2162 _Ret_range_(<, MAXLONG)
2163 NTSYSAPI
2164 ULONG
2165 NTAPI
2166 RtlRandomEx(
2167 _Inout_ PULONG Seed);
2168
2169 _IRQL_requires_max_(DISPATCH_LEVEL)
2170 NTSYSAPI
2171 NTSTATUS
2172 NTAPI
2173 RtlInitUnicodeStringEx(
2174 _Out_ PUNICODE_STRING DestinationString,
2175 _In_opt_z_ __drv_aliasesMem PCWSTR SourceString);
2176
2177 _Must_inspect_result_
2178 NTSYSAPI
2179 NTSTATUS
2180 NTAPI
2181 RtlValidateUnicodeString(
2182 _In_ ULONG Flags,
2183 _In_ PCUNICODE_STRING String);
2184
2185 _IRQL_requires_max_(PASSIVE_LEVEL)
2186 _Must_inspect_result_
2187 NTSYSAPI
2188 NTSTATUS
2189 NTAPI
2190 RtlDuplicateUnicodeString(
2191 _In_ ULONG Flags,
2192 _In_ PCUNICODE_STRING SourceString,
2193 _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)) PUNICODE_STRING DestinationString);
2194
2195 NTSYSAPI
2196 NTSTATUS
2197 NTAPI
2198 RtlGetCompressionWorkSpaceSize(
2199 _In_ USHORT CompressionFormatAndEngine,
2200 _Out_ PULONG CompressBufferWorkSpaceSize,
2201 _Out_ PULONG CompressFragmentWorkSpaceSize);
2202
2203 NTSYSAPI
2204 NTSTATUS
2205 NTAPI
2206 RtlCompressBuffer(
2207 _In_ USHORT CompressionFormatAndEngine,
2208 _In_reads_bytes_(UncompressedBufferSize) PUCHAR UncompressedBuffer,
2209 _In_ ULONG UncompressedBufferSize,
2210 _Out_writes_bytes_to_(CompressedBufferSize, *FinalCompressedSize) PUCHAR CompressedBuffer,
2211 _In_ ULONG CompressedBufferSize,
2212 _In_ ULONG UncompressedChunkSize,
2213 _Out_ PULONG FinalCompressedSize,
2214 _In_ PVOID WorkSpace);
2215
2216 _IRQL_requires_max_(APC_LEVEL)
2217 NTSYSAPI
2218 NTSTATUS
2219 NTAPI
2220 RtlDecompressBuffer(
2221 _In_ USHORT CompressionFormat,
2222 _Out_writes_bytes_to_(UncompressedBufferSize, *FinalUncompressedSize) PUCHAR UncompressedBuffer,
2223 _In_ ULONG UncompressedBufferSize,
2224 _In_reads_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer,
2225 _In_ ULONG CompressedBufferSize,
2226 _Out_ PULONG FinalUncompressedSize);
2227
2228 _IRQL_requires_max_(APC_LEVEL)
2229 NTSYSAPI
2230 NTSTATUS
2231 NTAPI
2232 RtlDecompressFragment(
2233 _In_ USHORT CompressionFormat,
2234 _Out_writes_bytes_to_(UncompressedFragmentSize, *FinalUncompressedSize) PUCHAR UncompressedFragment,
2235 _In_ ULONG UncompressedFragmentSize,
2236 _In_reads_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer,
2237 _In_ ULONG CompressedBufferSize,
2238 _In_range_(<, CompressedBufferSize) ULONG FragmentOffset,
2239 _Out_ PULONG FinalUncompressedSize,
2240 _In_ PVOID WorkSpace);
2241
2242 _IRQL_requires_max_(APC_LEVEL)
2243 NTSYSAPI
2244 NTSTATUS
2245 NTAPI
2246 RtlDescribeChunk(
2247 _In_ USHORT CompressionFormat,
2248 _Inout_ PUCHAR *CompressedBuffer,
2249 _In_ PUCHAR EndOfCompressedBufferPlus1,
2250 _Out_ PUCHAR *ChunkBuffer,
2251 _Out_ PULONG ChunkSize);
2252
2253 _IRQL_requires_max_(APC_LEVEL)
2254 NTSYSAPI
2255 NTSTATUS
2256 NTAPI
2257 RtlReserveChunk(
2258 _In_ USHORT CompressionFormat,
2259 _Inout_ PUCHAR *CompressedBuffer,
2260 _In_ PUCHAR EndOfCompressedBufferPlus1,
2261 _Out_ PUCHAR *ChunkBuffer,
2262 _In_ ULONG ChunkSize);
2263
2264 _IRQL_requires_max_(APC_LEVEL)
2265 NTSYSAPI
2266 NTSTATUS
2267 NTAPI
2268 RtlDecompressChunks(
2269 _Out_writes_bytes_(UncompressedBufferSize) PUCHAR UncompressedBuffer,
2270 _In_ ULONG UncompressedBufferSize,
2271 _In_reads_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer,
2272 _In_ ULONG CompressedBufferSize,
2273 _In_reads_bytes_(CompressedTailSize) PUCHAR CompressedTail,
2274 _In_ ULONG CompressedTailSize,
2275 _In_ PCOMPRESSED_DATA_INFO CompressedDataInfo);
2276
2277 _IRQL_requires_max_(APC_LEVEL)
2278 NTSYSAPI
2279 NTSTATUS
2280 NTAPI
2281 RtlCompressChunks(
2282 _In_reads_bytes_(UncompressedBufferSize) PUCHAR UncompressedBuffer,
2283 _In_ ULONG UncompressedBufferSize,
2284 _Out_writes_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer,
2285 _In_range_(>=, (UncompressedBufferSize - (UncompressedBufferSize / 16))) ULONG CompressedBufferSize,
2286 _Inout_updates_bytes_(CompressedDataInfoLength) PCOMPRESSED_DATA_INFO CompressedDataInfo,
2287 _In_range_(>, sizeof(COMPRESSED_DATA_INFO)) ULONG CompressedDataInfoLength,
2288 _In_ PVOID WorkSpace);
2289
2290 _IRQL_requires_max_(APC_LEVEL)
2291 NTSYSAPI
2292 PSID_IDENTIFIER_AUTHORITY
2293 NTAPI
2294 RtlIdentifierAuthoritySid(
2295 _In_ PSID Sid);
2296
2297 NTSYSAPI
2298 PUCHAR
2299 NTAPI
2300 RtlSubAuthorityCountSid(
2301 _In_ PSID Sid);
2302
2303 _When_(Status < 0, _Out_range_(>, 0))
2304 _When_(Status >= 0, _Out_range_(==, 0))
2305 NTSYSAPI
2306 ULONG
2307 NTAPI
2308 RtlNtStatusToDosErrorNoTeb(
2309 _In_ NTSTATUS Status);
2310
2311 _IRQL_requires_max_(PASSIVE_LEVEL)
2312 NTSYSAPI
2313 NTSTATUS
2314 NTAPI
2315 RtlCreateSystemVolumeInformationFolder(
2316 _In_ PCUNICODE_STRING VolumeRootPath);
2317
2318 #if defined(_M_AMD64)
2319
2320 FORCEINLINE
2321 VOID
2322 RtlFillMemoryUlong(
2323 _Out_writes_bytes_all_(Length) PVOID Destination,
2324 _In_ SIZE_T Length,
2325 _In_ ULONG Pattern)
2326 {
2327 PULONG Address = (PULONG)Destination;
2328 if ((Length /= 4) != 0) {
2329 if (((ULONG64)Address & 4) != 0) {
2330 *Address = Pattern;
2331 if ((Length -= 1) == 0) {
2332 return;
2333 }
2334 Address += 1;
2335 }
2336 __stosq((PULONG64)(Address), Pattern | ((ULONG64)Pattern << 32), Length / 2);
2337 if ((Length & 1) != 0) Address[Length - 1] = Pattern;
2338 }
2339 return;
2340 }
2341
2342 #define RtlFillMemoryUlonglong(Destination, Length, Pattern) \
2343 __stosq((PULONG64)(Destination), Pattern, (Length) / 8)
2344
2345 #else
2346
2347 NTSYSAPI
2348 VOID
2349 NTAPI
2350 RtlFillMemoryUlong(
2351 OUT PVOID Destination,
2352 IN SIZE_T Length,
2353 IN ULONG Pattern);
2354
2355 NTSYSAPI
2356 VOID
2357 NTAPI
2358 RtlFillMemoryUlonglong(
2359 _Out_writes_bytes_all_(Length) PVOID Destination,
2360 _In_ SIZE_T Length,
2361 _In_ ULONGLONG Pattern);
2362
2363 #endif /* defined(_M_AMD64) */
2364 $endif (_NTIFS_)
2365
2366 #endif /* (NTDDI_VERSION >= NTDDI_WINXP) */
2367
2368 $if (_NTIFS_)
2369 #if (NTDDI_VERSION >= NTDDI_WS03)
2370 _IRQL_requires_max_(DISPATCH_LEVEL)
2371 NTSYSAPI
2372 NTSTATUS
2373 NTAPI
2374 RtlInitAnsiStringEx(
2375 _Out_ PANSI_STRING DestinationString,
2376 _In_opt_z_ __drv_aliasesMem PCSZ SourceString);
2377 #endif
2378
2379 #if (NTDDI_VERSION >= NTDDI_WS03SP1)
2380
2381 _IRQL_requires_max_(APC_LEVEL)
2382 NTSYSAPI
2383 NTSTATUS
2384 NTAPI
2385 RtlGetSaclSecurityDescriptor(
2386 _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
2387 _Out_ PBOOLEAN SaclPresent,
2388 _Out_ PACL *Sacl,
2389 _Out_ PBOOLEAN SaclDefaulted);
2390
2391 _IRQL_requires_max_(APC_LEVEL)
2392 NTSYSAPI
2393 NTSTATUS
2394 NTAPI
2395 RtlSetGroupSecurityDescriptor(
2396 _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
2397 _In_opt_ PSID Group,
2398 _In_opt_ BOOLEAN GroupDefaulted);
2399
2400 _IRQL_requires_max_(APC_LEVEL)
2401 NTSYSAPI
2402 NTSTATUS
2403 NTAPI
2404 RtlGetGroupSecurityDescriptor(
2405 _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
2406 _Out_ PSID *Group,
2407 _Out_ PBOOLEAN GroupDefaulted);
2408
2409 _IRQL_requires_max_(APC_LEVEL)
2410 NTSYSAPI
2411 NTSTATUS
2412 NTAPI
2413 RtlAbsoluteToSelfRelativeSD(
2414 _In_ PSECURITY_DESCRIPTOR AbsoluteSecurityDescriptor,
2415 _Out_writes_bytes_to_opt_(*BufferLength, *BufferLength) PSECURITY_DESCRIPTOR SelfRelativeSecurityDescriptor,
2416 _Inout_ PULONG BufferLength);
2417
2418 _IRQL_requires_max_(APC_LEVEL)
2419 NTSYSAPI
2420 NTSTATUS
2421 NTAPI
2422 RtlSelfRelativeToAbsoluteSD(
2423 _In_ PSECURITY_DESCRIPTOR SelfRelativeSecurityDescriptor,
2424 _Out_writes_bytes_to_opt_(*AbsoluteSecurityDescriptorSize, *AbsoluteSecurityDescriptorSize) PSECURITY_DESCRIPTOR AbsoluteSecurityDescriptor,
2425 _Inout_ PULONG AbsoluteSecurityDescriptorSize,
2426 _Out_writes_bytes_to_opt_(*DaclSize, *DaclSize) PACL Dacl,
2427 _Inout_ PULONG DaclSize,
2428 _Out_writes_bytes_to_opt_(*SaclSize, *SaclSize) PACL Sacl,
2429 _Inout_ PULONG SaclSize,
2430 _Out_writes_bytes_to_opt_(*OwnerSize, *OwnerSize) PSID Owner,
2431 _Inout_ PULONG OwnerSize,
2432 _Out_writes_bytes_to_opt_(*PrimaryGroupSize, *PrimaryGroupSize) PSID PrimaryGroup,
2433 _Inout_ PULONG PrimaryGroupSize);
2434
2435 #endif /* (NTDDI_VERSION >= NTDDI_WS03SP1) */
2436 $endif (_NTIFS_)
2437
2438 #if (NTDDI_VERSION >= NTDDI_VISTA)
2439
2440 $if (_WDMDDK_)
2441 NTSYSAPI
2442 ULONG
2443 NTAPI
2444 RtlNumberOfSetBitsUlongPtr(
2445 _In_ ULONG_PTR Target);
2446
2447 NTSYSAPI
2448 ULONGLONG
2449 NTAPI
2450 RtlIoDecodeMemIoResource(
2451 _In_ struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
2452 _Out_opt_ PULONGLONG Alignment,
2453 _Out_opt_ PULONGLONG MinimumAddress,
2454 _Out_opt_ PULONGLONG MaximumAddress);
2455
2456 NTSYSAPI
2457 NTSTATUS
2458 NTAPI
2459 RtlIoEncodeMemIoResource(
2460 _In_ struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
2461 _In_ UCHAR Type,
2462 _In_ ULONGLONG Length,
2463 _In_ ULONGLONG Alignment,
2464 _In_ ULONGLONG MinimumAddress,
2465 _In_ ULONGLONG MaximumAddress);
2466
2467 NTSYSAPI
2468 ULONGLONG
2469 NTAPI
2470 RtlCmDecodeMemIoResource(
2471 _In_ struct _CM_PARTIAL_RESOURCE_DESCRIPTOR *Descriptor,
2472 _Out_opt_ PULONGLONG Start);
2473
2474 NTSYSAPI
2475 NTSTATUS
2476 NTAPI
2477 RtlFindClosestEncodableLength(
2478 _In_ ULONGLONG SourceLength,
2479 _Out_ PULONGLONG TargetLength);
2480
2481 NTSYSAPI
2482 NTSTATUS
2483 NTAPI
2484 RtlCmEncodeMemIoResource(
2485 _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor,
2486 _In_ UCHAR Type,
2487 _In_ ULONGLONG Length,
2488 _In_ ULONGLONG Start);
2489
2490 $endif (_WDMDDK_)
2491 $if (_NTDDK_)
2492
2493 _IRQL_requires_max_(APC_LEVEL)
2494 NTSYSAPI
2495 VOID
2496 NTAPI
2497 RtlRunOnceInitialize(
2498 _Out_ PRTL_RUN_ONCE RunOnce);
2499
2500 _IRQL_requires_max_(APC_LEVEL)
2501 _Maybe_raises_SEH_exception_
2502 NTSYSAPI
2503 NTSTATUS
2504 NTAPI
2505 RtlRunOnceExecuteOnce(
2506 _Inout_ PRTL_RUN_ONCE RunOnce,
2507 _In_ __inner_callback PRTL_RUN_ONCE_INIT_FN InitFn,
2508 _Inout_opt_ PVOID Parameter,
2509 _Outptr_opt_result_maybenull_ PVOID *Context);
2510
2511 _IRQL_requires_max_(APC_LEVEL)
2512 _Must_inspect_result_
2513 NTSYSAPI
2514 NTSTATUS
2515 NTAPI
2516 RtlRunOnceBeginInitialize(
2517 _Inout_ PRTL_RUN_ONCE RunOnce,
2518 _In_ ULONG Flags,
2519 _Outptr_opt_result_maybenull_ PVOID *Context);
2520
2521 _IRQL_requires_max_(APC_LEVEL)
2522 NTSYSAPI
2523 NTSTATUS
2524 NTAPI
2525 RtlRunOnceComplete(
2526 _Inout_ PRTL_RUN_ONCE RunOnce,
2527 _In_ ULONG Flags,
2528 _In_opt_ PVOID Context);
2529
2530 NTSYSAPI
2531 BOOLEAN
2532 NTAPI
2533 RtlGetProductInfo(
2534 _In_ ULONG OSMajorVersion,
2535 _In_ ULONG OSMinorVersion,
2536 _In_ ULONG SpMajorVersion,
2537 _In_ ULONG SpMinorVersion,
2538 _Out_ PULONG ReturnedProductType);
2539
2540 $endif (_NTDDK_)
2541 $if (_NTIFS_)
2542 NTSYSAPI
2543 NTSTATUS
2544 NTAPI
2545 RtlNormalizeString(
2546 _In_ ULONG NormForm,
2547 _In_ PCWSTR SourceString,
2548 _In_ LONG SourceStringLength,
2549 _Out_writes_to_(*DestinationStringLength, *DestinationStringLength) PWSTR DestinationString,
2550 _Inout_ PLONG DestinationStringLength);
2551
2552 NTSYSAPI
2553 NTSTATUS
2554 NTAPI
2555 RtlIsNormalizedString(
2556 _In_ ULONG NormForm,
2557 _In_ PCWSTR SourceString,
2558 _In_ LONG SourceStringLength,
2559 _Out_ PBOOLEAN Normalized);
2560
2561 NTSYSAPI
2562 NTSTATUS
2563 NTAPI
2564 RtlIdnToAscii(
2565 _In_ ULONG Flags,
2566 _In_ PCWSTR SourceString,
2567 _In_ LONG SourceStringLength,
2568 _Out_writes_to_(*DestinationStringLength, *DestinationStringLength) PWSTR DestinationString,
2569 _Inout_ PLONG DestinationStringLength);
2570
2571 NTSYSAPI
2572 NTSTATUS
2573 NTAPI
2574 RtlIdnToUnicode(
2575 IN ULONG Flags,
2576 IN PCWSTR SourceString,
2577 IN LONG SourceStringLength,
2578 OUT PWSTR DestinationString,
2579 IN OUT PLONG DestinationStringLength);
2580
2581 NTSYSAPI
2582 NTSTATUS
2583 NTAPI
2584 RtlIdnToNameprepUnicode(
2585 _In_ ULONG Flags,
2586 _In_ PCWSTR SourceString,
2587 _In_ LONG SourceStringLength,
2588 _Out_writes_to_(*DestinationStringLength, *DestinationStringLength) PWSTR DestinationString,
2589 _Inout_ PLONG DestinationStringLength);
2590
2591 NTSYSAPI
2592 NTSTATUS
2593 NTAPI
2594 RtlCreateServiceSid(
2595 _In_ PUNICODE_STRING ServiceName,
2596 _Out_writes_bytes_opt_(*ServiceSidLength) PSID ServiceSid,
2597 _Inout_ PULONG ServiceSidLength);
2598
2599 NTSYSAPI
2600 LONG
2601 NTAPI
2602 RtlCompareAltitudes(
2603 _In_ PCUNICODE_STRING Altitude1,
2604 _In_ PCUNICODE_STRING Altitude2);
2605
2606 $endif (_NTIFS_)
2607
2608 #endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
2609
2610 #if (NTDDI_VERSION >= NTDDI_WIN7)
2611
2612 $if (_WDMDDK_)
2613 _IRQL_requires_max_(PASSIVE_LEVEL)
2614 _Must_inspect_result_
2615 NTSYSAPI
2616 NTSTATUS
2617 NTAPI
2618 RtlUnicodeToUTF8N(
2619 _Out_writes_bytes_to_(UTF8StringMaxByteCount, *UTF8StringActualByteCount)
2620 PCHAR UTF8StringDestination,
2621 _In_ ULONG UTF8StringMaxByteCount,
2622 _Out_ PULONG UTF8StringActualByteCount,
2623 _In_reads_bytes_(UnicodeStringByteCount) PCWCH UnicodeStringSource,
2624 _In_ ULONG UnicodeStringByteCount);
2625
2626 _IRQL_requires_max_(PASSIVE_LEVEL)
2627 _Must_inspect_result_
2628 NTSYSAPI
2629 NTSTATUS
2630 NTAPI
2631 RtlUTF8ToUnicodeN(
2632 _Out_writes_bytes_to_(UnicodeStringMaxByteCount, *UnicodeStringActualByteCount)
2633 PWSTR UnicodeStringDestination,
2634 _In_ ULONG UnicodeStringMaxByteCount,
2635 _Out_ PULONG UnicodeStringActualByteCount,
2636 _In_reads_bytes_(UTF8StringByteCount) PCCH UTF8StringSource,
2637 _In_ ULONG UTF8StringByteCount);
2638
2639 NTSYSAPI
2640 ULONG64
2641 NTAPI
2642 RtlGetEnabledExtendedFeatures(
2643 IN ULONG64 FeatureMask);
2644
2645 $endif (_WDMDDK_)
2646 $if (_NTDDK_)
2647
2648 _Must_inspect_result_
2649 NTSYSAPI
2650 BOOLEAN
2651 NTAPI
2652 RtlCreateHashTable(
2653 _Inout_ _When_(NULL == *HashTable, __drv_allocatesMem(Mem))
2654 PRTL_DYNAMIC_HASH_TABLE *HashTable,
2655 _In_ ULONG Shift,
2656 _In_ _Reserved_ ULONG Flags);
2657
2658 NTSYSAPI
2659 VOID
2660 NTAPI
2661 RtlDeleteHashTable(
2662 _In_ _When_((HashTable->Flags & RTL_HASH_ALLOCATED_HEADER), __drv_freesMem(Mem) _Post_invalid_)
2663 PRTL_DYNAMIC_HASH_TABLE HashTable);
2664
2665 NTSYSAPI
2666 BOOLEAN
2667 NTAPI
2668 RtlInsertEntryHashTable(
2669 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2670 _In_ __drv_aliasesMem PRTL_DYNAMIC_HASH_TABLE_ENTRY Entry,
2671 _In_ ULONG_PTR Signature,
2672 _Inout_opt_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context);
2673
2674 NTSYSAPI
2675 BOOLEAN
2676 NTAPI
2677 RtlRemoveEntryHashTable(
2678 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2679 _In_ PRTL_DYNAMIC_HASH_TABLE_ENTRY Entry,
2680 _Inout_opt_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context);
2681
2682 _Must_inspect_result_
2683 NTSYSAPI
2684 PRTL_DYNAMIC_HASH_TABLE_ENTRY
2685 NTAPI
2686 RtlLookupEntryHashTable(
2687 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2688 _In_ ULONG_PTR Signature,
2689 _Out_opt_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context);
2690
2691 _Must_inspect_result_
2692 NTSYSAPI
2693 PRTL_DYNAMIC_HASH_TABLE_ENTRY
2694 NTAPI
2695 RtlGetNextEntryHashTable(
2696 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2697 _In_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context);
2698
2699 NTSYSAPI
2700 BOOLEAN
2701 NTAPI
2702 RtlInitEnumerationHashTable(
2703 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2704 _Out_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
2705
2706 _Must_inspect_result_
2707 NTSYSAPI
2708 PRTL_DYNAMIC_HASH_TABLE_ENTRY
2709 NTAPI
2710 RtlEnumerateEntryHashTable(
2711 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2712 _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
2713
2714 NTSYSAPI
2715 VOID
2716 NTAPI
2717 RtlEndEnumerationHashTable(
2718 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2719 _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
2720
2721 NTSYSAPI
2722 BOOLEAN
2723 NTAPI
2724 RtlInitWeakEnumerationHashTable(
2725 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2726 _Out_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
2727
2728 _Must_inspect_result_
2729 NTSYSAPI
2730 PRTL_DYNAMIC_HASH_TABLE_ENTRY
2731 NTAPI
2732 RtlWeaklyEnumerateEntryHashTable(
2733 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2734 _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
2735
2736 NTSYSAPI
2737 VOID
2738 NTAPI
2739 RtlEndWeakEnumerationHashTable(
2740 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
2741 _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
2742
2743 NTSYSAPI
2744 BOOLEAN
2745 NTAPI
2746 RtlExpandHashTable(
2747 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable);
2748
2749 NTSYSAPI
2750 BOOLEAN
2751 NTAPI
2752 RtlContractHashTable(
2753 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable);
2754
2755 $endif (_NTDDK_)
2756 $if (_NTIFS_)
2757 _IRQL_requires_max_(PASSIVE_LEVEL)
2758 _Must_inspect_result_
2759 NTSYSAPI
2760 NTSTATUS
2761 NTAPI
2762 RtlUnicodeToUTF8N(
2763 _Out_writes_bytes_to_(UTF8StringMaxByteCount, *UTF8StringActualByteCount) PCHAR UTF8StringDestination,
2764 _In_ ULONG UTF8StringMaxByteCount,
2765 _Out_ PULONG UTF8StringActualByteCount,
2766 _In_reads_bytes_(UnicodeStringByteCount) PCWCH UnicodeStringSource,
2767 _In_ ULONG UnicodeStringByteCount);
2768
2769 _IRQL_requires_max_(PASSIVE_LEVEL)
2770 _Must_inspect_result_
2771 NTSYSAPI
2772 NTSTATUS
2773 NTAPI
2774 RtlUTF8ToUnicodeN(
2775 _Out_writes_bytes_to_(UnicodeStringMaxByteCount, *UnicodeStringActualByteCount) PWSTR UnicodeStringDestination,
2776 _In_ ULONG UnicodeStringMaxByteCount,
2777 _Out_ PULONG UnicodeStringActualByteCount,
2778 _In_reads_bytes_(UTF8StringByteCount) PCCH UTF8StringSource,
2779 _In_ ULONG UTF8StringByteCount);
2780
2781 _IRQL_requires_max_(APC_LEVEL)
2782 NTSYSAPI
2783 NTSTATUS
2784 NTAPI
2785 RtlReplaceSidInSd(
2786 _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
2787 _In_ PSID OldSid,
2788 _In_ PSID NewSid,
2789 _Out_ ULONG *NumChanges);
2790
2791 NTSYSAPI
2792 NTSTATUS
2793 NTAPI
2794 RtlCreateVirtualAccountSid(
2795 _In_ PCUNICODE_STRING Name,
2796 _In_ ULONG BaseSubAuthority,
2797 _Out_writes_bytes_(*SidLength) PSID Sid,
2798 _Inout_ PULONG SidLength);
2799 $endif (_NTIFS_)
2800
2801 #endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
2802
2803 $if (_WDMDDK_)
2804
2805 #if !defined(MIDL_PASS)
2806 /* inline funftions */
2807 //DECLSPEC_DEPRECATED_DDK_WINXP
2808 static __inline
2809 LARGE_INTEGER
2810 NTAPI_INLINE
2811 RtlConvertLongToLargeInteger(
2812 _In_ LONG SignedInteger)
2813 {
2814 LARGE_INTEGER ret;
2815 ret.QuadPart = SignedInteger;
2816 return ret;
2817 }
2818
2819 //DECLSPEC_DEPRECATED_DDK_WINXP
2820 static __inline
2821 LARGE_INTEGER
2822 NTAPI_INLINE
2823 RtlConvertUlongToLargeInteger(
2824 _In_ ULONG UnsignedInteger)
2825 {
2826 LARGE_INTEGER ret;
2827 ret.QuadPart = UnsignedInteger;
2828 return ret;
2829 }
2830
2831 //DECLSPEC_DEPRECATED_DDK_WINXP
2832 static __inline
2833 LARGE_INTEGER
2834 NTAPI_INLINE
2835 RtlLargeIntegerShiftLeft(
2836 _In_ LARGE_INTEGER LargeInteger,
2837 _In_ CCHAR ShiftCount)
2838 {
2839 LARGE_INTEGER Result;
2840
2841 Result.QuadPart = LargeInteger.QuadPart << ShiftCount;
2842 return Result;
2843 }
2844
2845 //DECLSPEC_DEPRECATED_DDK_WINXP
2846 static __inline
2847 LARGE_INTEGER
2848 NTAPI_INLINE
2849 RtlLargeIntegerShiftRight(
2850 _In_ LARGE_INTEGER LargeInteger,
2851 _In_ CCHAR ShiftCount)
2852 {
2853 LARGE_INTEGER Result;
2854
2855 Result.QuadPart = (ULONG64)LargeInteger.QuadPart >> ShiftCount;
2856 return Result;
2857 }
2858
2859 //DECLSPEC_DEPRECATED_DDK
2860 static __inline
2861 ULONG
2862 NTAPI_INLINE
2863 RtlEnlargedUnsignedDivide(
2864 _In_ ULARGE_INTEGER Dividend,
2865 _In_ ULONG Divisor,
2866 _Out_opt_ PULONG Remainder)
2867 {
2868 if (Remainder)
2869 *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
2870 return (ULONG)(Dividend.QuadPart / Divisor);
2871 }
2872
2873 //DECLSPEC_DEPRECATED_DDK
2874 static __inline
2875 LARGE_INTEGER
2876 NTAPI_INLINE
2877 RtlLargeIntegerNegate(
2878 _In_ LARGE_INTEGER Subtrahend)
2879 {
2880 LARGE_INTEGER Difference;
2881
2882 Difference.QuadPart = -Subtrahend.QuadPart;
2883 return Difference;
2884 }
2885
2886 //DECLSPEC_DEPRECATED_DDK
2887 static __inline
2888 LARGE_INTEGER
2889 NTAPI_INLINE
2890 RtlLargeIntegerSubtract(
2891 _In_ LARGE_INTEGER Minuend,
2892 _In_ LARGE_INTEGER Subtrahend)
2893 {
2894 LARGE_INTEGER Difference;
2895
2896 Difference.QuadPart = Minuend.QuadPart - Subtrahend.QuadPart;
2897 return Difference;
2898 }
2899
2900 //DECLSPEC_DEPRECATED_DDK
2901 static __inline
2902 LARGE_INTEGER
2903 NTAPI_INLINE
2904 RtlEnlargedUnsignedMultiply(
2905 _In_ ULONG Multiplicand,
2906 _In_ ULONG Multiplier)
2907 {
2908 LARGE_INTEGER ret;
2909 ret.QuadPart = (ULONGLONG)Multiplicand * (ULONGLONG)Multiplier;
2910 return ret;
2911 }
2912
2913 //DECLSPEC_DEPRECATED_DDK
2914 static __inline
2915 LARGE_INTEGER
2916 NTAPI_INLINE
2917 RtlEnlargedIntegerMultiply(
2918 _In_ LONG Multiplicand,
2919 _In_ LONG Multiplier)
2920 {
2921 LARGE_INTEGER ret;
2922 ret.QuadPart = (LONGLONG)Multiplicand * (ULONGLONG)Multiplier;
2923 return ret;
2924 }
2925
2926 _At_(AnsiString->Buffer, _Post_equal_to_(Buffer))
2927 _At_(AnsiString->Length, _Post_equal_to_(0))
2928 _At_(AnsiString->MaximumLength, _Post_equal_to_(BufferSize))
2929 FORCEINLINE
2930 VOID
2931 RtlInitEmptyAnsiString(
2932 _Out_ PANSI_STRING AnsiString,
2933 _Pre_maybenull_ _Pre_readable_size_(BufferSize) __drv_aliasesMem PCHAR Buffer,
2934 _In_ USHORT BufferSize)
2935 {
2936 AnsiString->Length = 0;
2937 AnsiString->MaximumLength = BufferSize;
2938 AnsiString->Buffer = Buffer;
2939 }
2940
2941 _At_(UnicodeString->Buffer, _Post_equal_to_(Buffer))
2942 _At_(UnicodeString->Length, _Post_equal_to_(0))
2943 _At_(UnicodeString->MaximumLength, _Post_equal_to_(BufferSize))
2944 FORCEINLINE
2945 VOID
2946 RtlInitEmptyUnicodeString(
2947 _Out_ PUNICODE_STRING UnicodeString,
2948 _Writable_bytes_(BufferSize)
2949 _When_(BufferSize != 0, _Notnull_)
2950 __drv_aliasesMem PWSTR Buffer,
2951 _In_ USHORT BufferSize)
2952 {
2953 UnicodeString->Length = 0;
2954 UnicodeString->MaximumLength = BufferSize;
2955 UnicodeString->Buffer = Buffer;
2956 }
2957 $endif (_WDMDDK_)
2958
2959 #if defined(_AMD64_) || defined(_IA64_)
2960
2961 $if (_WDMDDK_)
2962
2963 static __inline
2964 LARGE_INTEGER
2965 NTAPI_INLINE
2966 RtlExtendedIntegerMultiply(
2967 _In_ LARGE_INTEGER Multiplicand,
2968 _In_ LONG Multiplier)
2969 {
2970 LARGE_INTEGER ret;
2971 ret.QuadPart = Multiplicand.QuadPart * Multiplier;
2972 return ret;
2973 }
2974
2975 static __inline
2976 LARGE_INTEGER
2977 NTAPI_INLINE
2978 RtlExtendedLargeIntegerDivide(
2979 _In_ LARGE_INTEGER Dividend,
2980 _In_ ULONG Divisor,
2981 _Out_opt_ PULONG Remainder)
2982 {
2983 LARGE_INTEGER ret;
2984 ret.QuadPart = (ULONG64)Dividend.QuadPart / Divisor;
2985 if (Remainder)
2986 *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
2987 return ret;
2988 }
2989
2990 $endif (_WDMDDK_)
2991
2992 $if (_NTDDK_)
2993
2994 //DECLSPEC_DEPRECATED_DDK_WINXP
2995 FORCEINLINE
2996 LARGE_INTEGER
2997 NTAPI_INLINE
2998 RtlLargeIntegerDivide(
2999 _In_ LARGE_INTEGER Dividend,
3000 _In_ LARGE_INTEGER Divisor,
3001 _Out_opt_ PLARGE_INTEGER Remainder)
3002 {
3003 LARGE_INTEGER ret;
3004 ret.QuadPart = Dividend.QuadPart / Divisor.QuadPart;
3005 if (Remainder)
3006 Remainder->QuadPart = Dividend.QuadPart % Divisor.QuadPart;
3007 return ret;
3008 }
3009
3010 #else
3011
3012 #if (NTDDI_VERSION >= NTDDI_WIN2K)
3013 NTSYSAPI
3014 LARGE_INTEGER
3015 NTAPI
3016 RtlLargeIntegerDivide(
3017 _In_ LARGE_INTEGER Dividend,
3018 _In_ LARGE_INTEGER Divisor,
3019 _Out_opt_ PLARGE_INTEGER Remainder);
3020 #endif
3021
3022 $endif (_NTDDK_)
3023
3024 #endif /* defined(_AMD64_) || defined(_IA64_) */
3025
3026 $if (_WDMDDK_)
3027
3028 #if defined(_AMD64_)
3029
3030 #define MultiplyHigh __mulh
3031 #define UnsignedMultiplyHigh __umulh
3032
3033 //DECLSPEC_DEPRECATED_DDK
3034 static __inline
3035 LARGE_INTEGER
3036 NTAPI_INLINE
3037 RtlExtendedMagicDivide(
3038 _In_ LARGE_INTEGER Dividend,
3039 _In_ LARGE_INTEGER MagicDivisor,
3040 _In_ CCHAR ShiftCount)
3041 {
3042 LARGE_INTEGER ret;
3043 ULONG64 ret64;
3044 BOOLEAN Pos;
3045 Pos = (Dividend.QuadPart >= 0);
3046 ret64 = UnsignedMultiplyHigh(Pos ? Dividend.QuadPart : -Dividend.QuadPart,
3047 MagicDivisor.QuadPart);
3048 ret64 >>= ShiftCount;
3049 ret.QuadPart = Pos ? ret64 : -(LONG64)ret64;
3050 return ret;
3051 }
3052 #endif
3053
3054 //DECLSPEC_DEPRECATED_DDK
3055 static __inline
3056 LARGE_INTEGER
3057 NTAPI_INLINE
3058 RtlLargeIntegerAdd(
3059 _In_ LARGE_INTEGER Addend1,
3060 _In_ LARGE_INTEGER Addend2)
3061 {
3062 LARGE_INTEGER ret;
3063 ret.QuadPart = Addend1.QuadPart + Addend2.QuadPart;
3064 return ret;
3065 }
3066
3067 /* VOID
3068 * RtlLargeIntegerAnd(
3069 * IN OUT LARGE_INTEGER Result,
3070 * IN LARGE_INTEGER Source,
3071 * IN LARGE_INTEGER Mask);
3072 */
3073 #define RtlLargeIntegerAnd(Result, Source, Mask) \
3074 Result.QuadPart = Source.QuadPart & Mask.QuadPart
3075
3076 //DECLSPEC_DEPRECATED_DDK
3077 static __inline
3078 LARGE_INTEGER
3079 NTAPI_INLINE
3080 RtlLargeIntegerArithmeticShift(
3081 _In_ LARGE_INTEGER LargeInteger,
3082 _In_ CCHAR ShiftCount)
3083 {
3084 LARGE_INTEGER ret;
3085 ret.QuadPart = LargeInteger.QuadPart >> ShiftCount;
3086 return ret;
3087 }
3088
3089 /* BOOLEAN
3090 * RtlLargeIntegerEqualTo(
3091 * IN LARGE_INTEGER Operand1,
3092 * IN LARGE_INTEGER Operand2);
3093 */
3094 #define RtlLargeIntegerEqualTo(X,Y) \
3095 (!(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
3096
3097 FORCEINLINE
3098 PVOID
3099 RtlSecureZeroMemory(
3100 _Out_writes_bytes_all_(Size) PVOID Pointer,
3101 _In_ SIZE_T Size)
3102 {
3103 volatile char* vptr = (volatile char*)Pointer;
3104 #if defined(_M_AMD64)
3105 __stosb((PUCHAR)vptr, 0, Size);
3106 #else
3107 char * endptr = (char *)vptr + Size;
3108 while (vptr < endptr) {
3109 *vptr = 0; vptr++;
3110 }
3111 #endif
3112 return Pointer;
3113 }
3114
3115 #if defined(_M_AMD64)
3116 _Must_inspect_result_
3117 FORCEINLINE
3118 BOOLEAN
3119 RtlCheckBit(
3120 _In_ PRTL_BITMAP BitMapHeader,
3121 _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitPosition)
3122 {
3123 return BitTest64((LONG64 CONST*)BitMapHeader->Buffer, (LONG64)BitPosition);
3124 }
3125 #else
3126 #define RtlCheckBit(BMH,BP) (((((PLONG)(BMH)->Buffer)[(BP)/32]) >> ((BP)%32)) & 0x1)
3127 #endif /* defined(_M_AMD64) */
3128
3129 #define RtlLargeIntegerGreaterThan(X,Y) ( \
3130 (((X).HighPart == (Y).HighPart) && ((X).LowPart > (Y).LowPart)) || \
3131 ((X).HighPart > (Y).HighPart) \
3132 )
3133
3134 #define RtlLargeIntegerGreaterThanOrEqualTo(X,Y) ( \
3135 (((X).HighPart == (Y).HighPart) && ((X).LowPart >= (Y).LowPart)) || \
3136 ((X).HighPart > (Y).HighPart) \
3137 )
3138
3139 #define RtlLargeIntegerNotEqualTo(X,Y) ( \
3140 (((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)) \
3141 )
3142
3143 #define RtlLargeIntegerLessThan(X,Y) ( \
3144 (((X).HighPart == (Y).HighPart) && ((X).LowPart < (Y).LowPart)) || \
3145 ((X).HighPart < (Y).HighPart) \
3146 )
3147
3148 #define RtlLargeIntegerLessThanOrEqualTo(X,Y) ( \
3149 (((X).HighPart == (Y).HighPart) && ((X).LowPart <= (Y).LowPart)) || \
3150 ((X).HighPart < (Y).HighPart) \
3151 )
3152
3153 #define RtlLargeIntegerGreaterThanZero(X) ( \
3154 (((X).HighPart == 0) && ((X).LowPart > 0)) || \
3155 ((X).HighPart > 0 ) \
3156 )
3157
3158 #define RtlLargeIntegerGreaterOrEqualToZero(X) ( (X).HighPart >= 0 )
3159
3160 #define RtlLargeIntegerEqualToZero(X) ( !((X).LowPart | (X).HighPart) )
3161
3162 #define RtlLargeIntegerNotEqualToZero(X) ( ((X).LowPart | (X).HighPart) )
3163
3164 #define RtlLargeIntegerLessThanZero(X) ( ((X).HighPart < 0) )
3165
3166 #define RtlLargeIntegerLessOrEqualToZero(X) ( ((X).HighPart < 0) || !((X).LowPart | (X).HighPart) )
3167
3168 #endif /* !defined(MIDL_PASS) */
3169
3170 /* Byte Swap Functions */
3171 #if (defined(_M_IX86) && (_MSC_FULL_VER > 13009037 || defined(__GNUC__))) || \
3172 ((defined(_M_AMD64) || defined(_M_IA64)) \
3173 && (_MSC_FULL_VER > 13009175 || defined(__GNUC__)))
3174
3175 #define RtlUshortByteSwap(_x) _byteswap_ushort((USHORT)(_x))
3176 #define RtlUlongByteSwap(_x) _byteswap_ulong((_x))
3177 #define RtlUlonglongByteSwap(_x) _byteswap_uint64((_x))
3178
3179 #endif
3180
3181 #if DBG
3182
3183 #define RTL_VERIFY(exp) \
3184 ((!(exp)) ? \
3185 RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, NULL ), FALSE : TRUE)
3186
3187 #define RTL_VERIFYMSG(msg, exp) \
3188 ((!(exp)) ? \
3189 RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, (PCHAR)msg ), FALSE : TRUE)
3190
3191 #define RTL_SOFT_VERIFY(exp) \
3192 ((!(exp)) ? \
3193 DbgPrint("%s(%d): Soft assertion failed\n Expression: %s\n", __FILE__, __LINE__, #exp), FALSE : TRUE)
3194
3195 #define RTL_SOFT_VERIFYMSG(msg, exp) \
3196 ((!(exp)) ? \
3197 DbgPrint("%s(%d): Soft assertion failed\n Expression: %s\n Message: %s\n", __FILE__, __LINE__, #exp, (msg)), FALSE : TRUE)
3198
3199 /* The ASSERTs must be cast to void to avoid warnings about unused results.
3200 * We also cannot invoke the VERIFY versions because the indirection messes
3201 * with stringify. */
3202 #define ASSERT(exp) \
3203 ((VOID)((!(exp)) ? \
3204 RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, NULL ), FALSE : TRUE))
3205
3206 #define ASSERTMSG(msg, exp) \
3207 ((VOID)((!(exp)) ? \
3208 RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, (PCHAR)msg ), FALSE : TRUE))
3209
3210 #define RTL_SOFT_ASSERT(exp) \
3211 ((VOID)((!(exp)) ? \
3212 DbgPrint("%s(%d): Soft assertion failed\n Expression: %s\n", __FILE__, __LINE__, #exp), FALSE : TRUE))
3213
3214 #define RTL_SOFT_ASSERTMSG(msg, exp) \
3215 ((VOID)((!(exp)) ? \
3216 DbgPrint("%s(%d): Soft assertion failed\n Expression: %s\n Message: %s\n", __FILE__, __LINE__, #exp, (msg)), FALSE : TRUE))
3217
3218 #if defined(_MSC_VER)
3219 # define __assert_annotationA(msg) __annotation(L"Debug", L"AssertFail", L ## msg)
3220 # define __assert_annotationW(msg) __annotation(L"Debug", L"AssertFail", msg)
3221 #else
3222 # define __assert_annotationA(msg) \
3223 DbgPrint("Assertion failed at %s(%d): %s\n", __FILE__, __LINE__, msg)
3224 # define __assert_annotationW(msg) \
3225 DbgPrint("Assertion failed at %s(%d): %S\n", __FILE__, __LINE__, msg)
3226 #endif
3227
3228 #define NT_VERIFY(exp) \
3229 ((!(exp)) ? \
3230 (__assert_annotationA(#exp), \
3231 DbgRaiseAssertionFailure(), FALSE) : TRUE)
3232
3233 #define NT_VERIFYMSG(msg, exp) \
3234 ((!(exp)) ? \
3235 (__assert_annotationA(msg), \
3236 DbgRaiseAssertionFailure(), FALSE) : TRUE)
3237
3238 #define NT_VERIFYMSGW(msg, exp) \
3239 ((!(exp)) ? \
3240 (__assert_annotationW(msg), \
3241 DbgRaiseAssertionFailure(), FALSE) : TRUE)
3242
3243 /* Can't reuse verify, see above */
3244 #define NT_ASSERT(exp) \
3245 ((VOID)((!(exp)) ? \
3246 (__assert_annotationA(#exp), \
3247 DbgRaiseAssertionFailure(), FALSE) : TRUE))
3248
3249 #define NT_ASSERTMSG(msg, exp) \
3250 ((VOID)((!(exp)) ? \
3251 (__assert_annotationA(msg), \
3252 DbgRaiseAssertionFailure(), FALSE) : TRUE))
3253
3254 #define NT_ASSERTMSGW(msg, exp) \
3255 ((VOID)((!(exp)) ? \
3256 (__assert_annotationW(msg), \
3257 DbgRaiseAssertionFailure(), FALSE) : TRUE))
3258
3259 #else /* !DBG */
3260
3261 #define ASSERT(exp) ((VOID) 0)
3262 #define ASSERTMSG(msg, exp) ((VOID) 0)
3263
3264 #define RTL_SOFT_ASSERT(exp) ((VOID) 0)
3265 #define RTL_SOFT_ASSERTMSG(msg, exp) ((VOID) 0)
3266
3267 #define RTL_VERIFY(exp) ((exp) ? TRUE : FALSE)
3268 #define RTL_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)
3269
3270 #define RTL_SOFT_VERIFY(exp) ((exp) ? TRUE : FALSE)
3271 #define RTL_SOFT_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)
3272
3273 #define NT_ASSERT(exp) ((VOID)0)
3274 #define NT_ASSERTMSG(msg, exp) ((VOID)0)
3275 #define NT_ASSERTMSGW(msg, exp) ((VOID)0)
3276
3277 #define NT_VERIFY(_exp) ((_exp) ? TRUE : FALSE)
3278 #define NT_VERIFYMSG(_msg, _exp ) ((_exp) ? TRUE : FALSE)
3279 #define NT_VERIFYMSGW(_msg, _exp) ((_exp) ? TRUE : FALSE)
3280
3281 #endif /* DBG */
3282
3283 #define InitializeListHead32(ListHead) (\
3284 (ListHead)->Flink = (ListHead)->Blink = PtrToUlong((ListHead)))
3285
3286 #if !defined(_WINBASE_)
3287
3288 #if defined(_WIN64) && (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_NTOSP_))
3289
3290 NTKERNELAPI
3291 VOID
3292 InitializeSListHead(
3293 _Out_ PSLIST_HEADER SListHead);
3294
3295 #else
3296
3297 FORCEINLINE
3298 VOID
3299 InitializeSListHead(
3300 _Out_ PSLIST_HEADER SListHead)
3301 {
3302 #if defined(_IA64_)
3303 ULONG64 FeatureBits;
3304 #endif
3305
3306 #if defined(_WIN64)
3307 if (((ULONG_PTR)SListHead & 0xf) != 0) {
3308 RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT);
3309 }
3310 #endif
3311 RtlZeroMemory(SListHead, sizeof(SLIST_HEADER));
3312 #if defined(_IA64_)
3313 FeatureBits = __getReg(CV_IA64_CPUID4);
3314 if ((FeatureBits & KF_16BYTE_INSTR) != 0) {
3315 SListHead->Header16.HeaderType = 1;
3316 SListHead->Header16.Init = 1;
3317 }
3318 #endif
3319 }
3320
3321 #endif
3322
3323 #if defined(_WIN64)
3324
3325 #define InterlockedPopEntrySList(Head) \
3326 ExpInterlockedPopEntrySList(Head)
3327
3328 #define InterlockedPushEntrySList(Head, Entry) \
3329 ExpInterlockedPushEntrySList(Head, Entry)
3330
3331 #define InterlockedFlushSList(Head) \
3332 ExpInterlockedFlushSList(Head)
3333
3334 #define QueryDepthSList(Head) \
3335 ExQueryDepthSList(Head)
3336
3337 #else /* !defined(_WIN64) */
3338
3339 NTKERNELAPI
3340 PSLIST_ENTRY
3341 FASTCALL
3342 InterlockedPopEntrySList(
3343 _Inout_ PSLIST_HEADER ListHead);
3344
3345 NTKERNELAPI
3346 PSLIST_ENTRY
3347 FASTCALL
3348 InterlockedPushEntrySList(
3349 _Inout_ PSLIST_HEADER ListHead,
3350 _Inout_ __drv_aliasesMem PSLIST_ENTRY ListEntry);
3351
3352 #define InterlockedFlushSList(ListHead) \
3353 ExInterlockedFlushSList(ListHead)
3354
3355 #define QueryDepthSList(Head) \
3356 ExQueryDepthSList(Head)
3357
3358 #endif /* !defined(_WIN64) */
3359
3360 #endif /* !defined(_WINBASE_) */
3361
3362 #define RTL_CONTEXT_EX_OFFSET(ContextEx, Chunk) ((ContextEx)->Chunk.Offset)
3363 #define RTL_CONTEXT_EX_LENGTH(ContextEx, Chunk) ((ContextEx)->Chunk.Length)
3364 #define RTL_CONTEXT_EX_CHUNK(Base, Layout, Chunk) \
3365 ((PVOID)((PCHAR)(Base) + RTL_CONTEXT_EX_OFFSET(Layout, Chunk)))
3366 #define RTL_CONTEXT_OFFSET(Context, Chunk) \
3367 RTL_CONTEXT_EX_OFFSET((PCONTEXT_EX)(Context + 1), Chunk)
3368 #define RTL_CONTEXT_LENGTH(Context, Chunk) \
3369 RTL_CONTEXT_EX_LENGTH((PCONTEXT_EX)(Context + 1), Chunk)
3370 #define RTL_CONTEXT_CHUNK(Context, Chunk) \
3371 RTL_CONTEXT_EX_CHUNK((PCONTEXT_EX)(Context + 1), \
3372 (PCONTEXT_EX)(Context + 1), \
3373 Chunk)
3374
3375 BOOLEAN
3376 RTLVERLIB_DDI(RtlIsNtDdiVersionAvailable)(
3377 _In_ ULONG Version);
3378
3379 BOOLEAN
3380 RTLVERLIB_DDI(RtlIsServicePackVersionInstalled)(
3381 _In_ ULONG Version);
3382
3383 #ifndef RtlIsNtDdiVersionAvailable
3384 #define RtlIsNtDdiVersionAvailable WdmlibRtlIsNtDdiVersionAvailable
3385 #endif
3386
3387 #ifndef RtlIsServicePackVersionInstalled
3388 #define RtlIsServicePackVersionInstalled WdmlibRtlIsServicePackVersionInstalled
3389 #endif
3390
3391 #define RtlInterlockedSetBits(Flags, Flag) \
3392 InterlockedOr((PLONG)(Flags), Flag)
3393
3394 #define RtlInterlockedAndBits(Flags, Flag) \
3395 InterlockedAnd((PLONG)(Flags), Flag)
3396
3397 #define RtlInterlockedClearBits(Flags, Flag) \
3398 RtlInterlockedAndBits(Flags, ~(Flag))
3399
3400 #define RtlInterlockedXorBits(Flags, Flag) \
3401 InterlockedXor(Flags, Flag)
3402
3403 #define RtlInterlockedSetBitsDiscardReturn(Flags, Flag) \
3404 (VOID) RtlInterlockedSetBits(Flags, Flag)
3405
3406 #define RtlInterlockedAndBitsDiscardReturn(Flags, Flag) \
3407 (VOID) RtlInterlockedAndBits(Flags, Flag)
3408
3409 #define RtlInterlockedClearBitsDiscardReturn(Flags, Flag) \
3410 RtlInterlockedAndBitsDiscardReturn(Flags, ~(Flag))
3411
3412 $endif (_WDMDDK_)
3413
3414 $if (_NTDDK_)
3415
3416 #ifdef RTL_USE_AVL_TABLES
3417
3418 #define RtlInitializeGenericTable RtlInitializeGenericTableAvl
3419 #define RtlInsertElementGenericTable RtlInsertElementGenericTableAvl
3420 #define RtlInsertElementGenericTableFull RtlInsertElementGenericTableFullAvl
3421 #define RtlDeleteElementGenericTable RtlDeleteElementGenericTableAvl
3422 #define RtlLookupElementGenericTable RtlLookupElementGenericTableAvl
3423 #define RtlLookupElementGenericTableFull RtlLookupElementGenericTableFullAvl
3424 #define RtlEnumerateGenericTable RtlEnumerateGenericTableAvl
3425 #define RtlEnumerateGenericTableWithoutSplaying RtlEnumerateGenericTableWithoutSplayingAvl
3426 #define RtlGetElementGenericTable RtlGetElementGenericTableAvl
3427 #define RtlNumberGenericTableElements RtlNumberGenericTableElementsAvl
3428 #define RtlIsGenericTableEmpty RtlIsGenericTableEmptyAvl
3429
3430 #endif /* RTL_USE_AVL_TABLES */
3431
3432 #define RtlInitializeSplayLinks(Links) { \
3433 PRTL_SPLAY_LINKS _SplayLinks; \
3434 _SplayLinks = (PRTL_SPLAY_LINKS)(Links); \
3435 _SplayLinks->Parent = _SplayLinks; \
3436 _SplayLinks->LeftChild = NULL; \
3437 _SplayLinks->RightChild = NULL; \
3438 }
3439
3440 #define RtlIsLeftChild(Links) \
3441 (RtlLeftChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))
3442
3443 #define RtlIsRightChild(Links) \
3444 (RtlRightChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))
3445
3446 #define RtlRightChild(Links) \
3447 ((PRTL_SPLAY_LINKS)(Links))->RightChild
3448
3449 #define RtlIsRoot(Links) \
3450 (RtlParent(Links) == (PRTL_SPLAY_LINKS)(Links))
3451
3452 #define RtlLeftChild(Links) \
3453 ((PRTL_SPLAY_LINKS)(Links))->LeftChild
3454
3455 #define RtlParent(Links) \
3456 ((PRTL_SPLAY_LINKS)(Links))->Parent
3457
3458 #define RtlInsertAsLeftChild(ParentLinks,ChildLinks) \
3459 { \
3460 PRTL_SPLAY_LINKS _SplayParent; \
3461 PRTL_SPLAY_LINKS _SplayChild; \
3462 _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
3463 _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks); \
3464 _SplayParent->LeftChild = _SplayChild; \
3465 _SplayChild->Parent = _SplayParent; \
3466 }
3467
3468 #define RtlInsertAsRightChild(ParentLinks,ChildLinks) \
3469 { \
3470 PRTL_SPLAY_LINKS _SplayParent; \
3471 PRTL_SPLAY_LINKS _SplayChild; \
3472 _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
3473 _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks); \
3474 _SplayParent->RightChild = _SplayChild; \
3475 _SplayChild->Parent = _SplayParent; \
3476 }
3477
3478 #if !defined(MIDL_PASS)
3479
3480 FORCEINLINE
3481 LUID
3482 NTAPI_INLINE
3483 RtlConvertLongToLuid(
3484 _In_ LONG Val)
3485 {
3486 LUID Luid;
3487 LARGE_INTEGER Temp;
3488
3489 Temp.QuadPart = Val;
3490 Luid.LowPart = Temp.u.LowPart;
3491 Luid.HighPart = Temp.u.HighPart;
3492 return Luid;
3493 }
3494
3495 FORCEINLINE
3496 LUID
3497 NTAPI_INLINE
3498 RtlConvertUlongToLuid(
3499 _In_ ULONG Val)
3500 {
3501 LUID Luid;
3502
3503 Luid.LowPart = Val;
3504 Luid.HighPart = 0;
3505 return Luid;
3506 }
3507
3508 #endif /* !defined(MIDL_PASS) */
3509
3510 #if (defined(_M_AMD64) || defined(_M_IA64)) && !defined(_REALLY_GET_CALLERS_CALLER_)
3511 #define RtlGetCallersAddress(CallersAddress, CallersCaller) \
3512 *CallersAddress = (PVOID)_ReturnAddress(); \
3513 *CallersCaller = NULL;
3514 #else
3515 #if (NTDDI_VERSION >= NTDDI_WIN2K)
3516 NTSYSAPI
3517 VOID
3518 NTAPI
3519 RtlGetCallersAddress(
3520 _Out_ PVOID *CallersAddress,
3521 _Out_ PVOID *CallersCaller);
3522 #endif
3523 #endif
3524
3525 #if !defined(MIDL_PASS) && !defined(SORTPP_PASS)
3526
3527 #if (NTDDI_VERSION >= NTDDI_WIN7)
3528
3529 FORCEINLINE
3530 VOID
3531 NTAPI
3532 RtlInitHashTableContext(
3533 _Inout_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context)
3534 {
3535 Context->ChainHead = NULL;
3536 Context->PrevLinkage = NULL;
3537 }
3538
3539 FORCEINLINE
3540 VOID
3541 NTAPI
3542 RtlInitHashTableContextFromEnumerator(
3543 _Inout_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context,
3544 _In_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator)
3545 {
3546 Context->ChainHead = Enumerator->ChainHead;
3547 Context->PrevLinkage = Enumerator->HashEntry.Linkage.Blink;
3548 }
3549
3550 FORCEINLINE
3551 VOID
3552 NTAPI
3553 RtlReleaseHashTableContext(
3554 _Inout_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context)
3555 {
3556 UNREFERENCED_PARAMETER(Context);
3557 return;
3558 }
3559
3560 FORCEINLINE
3561 ULONG
3562 NTAPI
3563 RtlTotalBucketsHashTable(
3564 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable)
3565 {
3566 return HashTable->TableSize;
3567 }
3568
3569 FORCEINLINE
3570 ULONG
3571 NTAPI
3572 RtlNonEmptyBucketsHashTable(
3573 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable)
3574 {
3575 return HashTable->NonEmptyBuckets;
3576 }
3577
3578 FORCEINLINE
3579 ULONG
3580 NTAPI
3581 RtlEmptyBucketsHashTable(
3582 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable)
3583 {
3584 return HashTable->TableSize - HashTable->NonEmptyBuckets;
3585 }
3586
3587 FORCEINLINE
3588 ULONG
3589 NTAPI
3590 RtlTotalEntriesHashTable(
3591 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable)
3592 {
3593 return HashTable->NumEntries;
3594 }
3595
3596 FORCEINLINE
3597 ULONG
3598 NTAPI
3599 RtlActiveEnumeratorsHashTable(
3600 _In_ PRTL_DYNAMIC_HASH_TABLE HashTable)
3601 {
3602 return HashTable->NumEnumerators;
3603 }
3604
3605 #endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
3606
3607 #endif /* !defined(MIDL_PASS) && !defined(SORTPP_PASS) */
3608
3609 $endif (_NTDDK_)
3610 $if (_NTIFS_)
3611
3612 #define RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE 1
3613 #define RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING 2
3614
3615 #define RtlUnicodeStringToOemSize(STRING) (NLS_MB_OEM_CODE_PAGE_TAG ? \
3616 RtlxUnicodeStringToOemSize(STRING) : \
3617 ((STRING)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
3618 )
3619
3620 #define RtlOemStringToUnicodeSize(STRING) ( \
3621 NLS_MB_OEM_CODE_PAGE_TAG ? \
3622 RtlxOemStringToUnicodeSize(STRING) : \
3623 ((STRING)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR) \
3624 )
3625
3626 #define RtlOemStringToCountedUnicodeSize(STRING) ( \
3627 (ULONG)(RtlOemStringToUnicodeSize(STRING) - sizeof(UNICODE_NULL)) \
3628 )
3629
3630 #define RtlOffsetToPointer(B,O) ((PCHAR)(((PCHAR)(B)) + ((ULONG_PTR)(O))))
3631 #define RtlPointerToOffset(B,P) ((ULONG)(((PCHAR)(P)) - ((PCHAR)(B))))
3632 $endif (_NTIFS_)
A free Windows-compatible Operating System