ReactOS Fundraising Campaign 2012
 
€ 4,410 / € 30,000

Information | Donate

Home | Info | Community | Development | myReactOS | Contact Us

Navigation
  1. Home
  2. Community
  3. Development
  4. myReactOS
  5. Fundraiser 2012

Doxygen
  1. Main Page
  2. Alphabetical List
  3. Data Structures
  4. Directories
  5. File List
  6. Data Fields
  7. Globals
  8. Related Pages

Search

ReactOS Development > Doxygen

rtlfuncs.h
Go to the documentation of this file.
00001 /******************************************************************************
00002  *                         Runtime Library Functions                          *
00003  ******************************************************************************/
00004 
00005 $if (_WDMDDK_)
00006 
00007 #if !defined(MIDL_PASS) && !defined(SORTPP_PASS)
00008 
00009 #define RTL_STATIC_LIST_HEAD(x) LIST_ENTRY x = { &x, &x }
00010 
00011 FORCEINLINE
00012 VOID
00013 InitializeListHead(
00014   _Out_ PLIST_ENTRY ListHead)
00015 {
00016   ListHead->Flink = ListHead->Blink = ListHead;
00017 }
00018 
00019 _Must_inspect_result_
00020 FORCEINLINE
00021 BOOLEAN
00022 IsListEmpty(
00023   _In_ const LIST_ENTRY * ListHead)
00024 {
00025   return (BOOLEAN)(ListHead->Flink == ListHead);
00026 }
00027 
00028 FORCEINLINE
00029 BOOLEAN
00030 RemoveEntryList(
00031   _In_ PLIST_ENTRY Entry)
00032 {
00033   PLIST_ENTRY OldFlink;
00034   PLIST_ENTRY OldBlink;
00035 
00036   OldFlink = Entry->Flink;
00037   OldBlink = Entry->Blink;
00038   OldFlink->Blink = OldBlink;
00039   OldBlink->Flink = OldFlink;
00040   return (BOOLEAN)(OldFlink == OldBlink);
00041 }
00042 
00043 FORCEINLINE
00044 PLIST_ENTRY
00045 RemoveHeadList(
00046   _Inout_ PLIST_ENTRY ListHead)
00047 {
00048   PLIST_ENTRY Flink;
00049   PLIST_ENTRY Entry;
00050 
00051   Entry = ListHead->Flink;
00052   Flink = Entry->Flink;
00053   ListHead->Flink = Flink;
00054   Flink->Blink = ListHead;
00055   return Entry;
00056 }
00057 
00058 FORCEINLINE
00059 PLIST_ENTRY
00060 RemoveTailList(
00061   _Inout_ PLIST_ENTRY ListHead)
00062 {
00063   PLIST_ENTRY Blink;
00064   PLIST_ENTRY Entry;
00065 
00066   Entry = ListHead->Blink;
00067   Blink = Entry->Blink;
00068   ListHead->Blink = Blink;
00069   Blink->Flink = ListHead;
00070   return Entry;
00071 }
00072 
00073 FORCEINLINE
00074 VOID
00075 InsertTailList(
00076   _Inout_ PLIST_ENTRY ListHead,
00077   _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
00078 {
00079   PLIST_ENTRY OldBlink;
00080   OldBlink = ListHead->Blink;
00081   Entry->Flink = ListHead;
00082   Entry->Blink = OldBlink;
00083   OldBlink->Flink = Entry;
00084   ListHead->Blink = Entry;
00085 }
00086 
00087 FORCEINLINE
00088 VOID
00089 InsertHeadList(
00090   _Inout_ PLIST_ENTRY ListHead,
00091   _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
00092 {
00093   PLIST_ENTRY OldFlink;
00094   OldFlink = ListHead->Flink;
00095   Entry->Flink = OldFlink;
00096   Entry->Blink = ListHead;
00097   OldFlink->Blink = Entry;
00098   ListHead->Flink = Entry;
00099 }
00100 
00101 FORCEINLINE
00102 VOID
00103 AppendTailList(
00104   _Inout_ PLIST_ENTRY ListHead,
00105   _Inout_ PLIST_ENTRY ListToAppend)
00106 {
00107   PLIST_ENTRY ListEnd = ListHead->Blink;
00108 
00109   ListHead->Blink->Flink = ListToAppend;
00110   ListHead->Blink = ListToAppend->Blink;
00111   ListToAppend->Blink->Flink = ListHead;
00112   ListToAppend->Blink = ListEnd;
00113 }
00114 
00115 FORCEINLINE
00116 PSINGLE_LIST_ENTRY
00117 PopEntryList(
00118   _Inout_ PSINGLE_LIST_ENTRY ListHead)
00119 {
00120   PSINGLE_LIST_ENTRY FirstEntry;
00121   FirstEntry = ListHead->Next;
00122   if (FirstEntry != NULL) {
00123     ListHead->Next = FirstEntry->Next;
00124   }
00125   return FirstEntry;
00126 }
00127 
00128 FORCEINLINE
00129 VOID
00130 PushEntryList(
00131   _Inout_ PSINGLE_LIST_ENTRY ListHead,
00132   _Inout_ __drv_aliasesMem PSINGLE_LIST_ENTRY Entry)
00133 {
00134   Entry->Next = ListHead->Next;
00135   ListHead->Next = Entry;
00136 }
00137 
00138 #endif /* !defined(MIDL_PASS) && !defined(SORTPP_PASS) */
00139 
00140 __analysis_noreturn
00141 NTSYSAPI
00142 VOID
00143 NTAPI
00144 RtlAssert(
00145   _In_ PVOID FailedAssertion,
00146   _In_ PVOID FileName,
00147   _In_ ULONG LineNumber,
00148   _In_opt_ PSTR Message);
00149 
00150 /* VOID
00151  * RtlCopyMemory(
00152  *     IN VOID UNALIGNED *Destination,
00153  *     IN CONST VOID UNALIGNED *Source,
00154  *     IN SIZE_T Length)
00155  */
00156 #define RtlCopyMemory(Destination, Source, Length) \
00157     memcpy(Destination, Source, Length)
00158 
00159 #define RtlCopyBytes RtlCopyMemory
00160 
00161 #if defined(_M_AMD64)
00162 NTSYSAPI
00163 VOID
00164 NTAPI
00165 RtlCopyMemoryNonTemporal(
00166   _Out_writes_bytes_all_(Length) VOID UNALIGNED *Destination,
00167   _In_reads_bytes_(Length) const VOID UNALIGNED *Source,
00168   _In_ SIZE_T Length);
00169 #else
00170 #define RtlCopyMemoryNonTemporal RtlCopyMemory
00171 #endif
00172 
00173 /* BOOLEAN
00174  * RtlEqualLuid(
00175  *     IN PLUID Luid1,
00176  *     IN PLUID Luid2)
00177  */
00178 #define RtlEqualLuid(Luid1, Luid2) \
00179     (((Luid1)->LowPart == (Luid2)->LowPart) && ((Luid1)->HighPart == (Luid2)->HighPart))
00180 
00181 /* LOGICAL
00182  * RtlEqualMemory(
00183  *     IN VOID UNALIGNED *Destination,
00184  *     IN CONST VOID UNALIGNED *Source,
00185  *     IN SIZE_T Length)
00186  */
00187 #define RtlEqualMemory(Destination, Source, Length) \
00188     (!memcmp(Destination, Source, Length))
00189 
00190 /* VOID
00191  * RtlFillMemory(
00192  *     IN VOID UNALIGNED *Destination,
00193  *     IN SIZE_T Length,
00194  *     IN UCHAR Fill)
00195  */
00196 #define RtlFillMemory(Destination, Length, Fill) \
00197     memset(Destination, Fill, Length)
00198 
00199 #define RtlFillBytes RtlFillMemory
00200 
00201 _IRQL_requires_max_(PASSIVE_LEVEL)
00202 NTSYSAPI
00203 VOID
00204 NTAPI
00205 RtlFreeUnicodeString(
00206   _Inout_ _At_(UnicodeString->Buffer, __drv_freesMem(Mem))
00207     PUNICODE_STRING UnicodeString);
00208 
00209 _IRQL_requires_max_(PASSIVE_LEVEL)
00210 _Must_inspect_result_
00211 NTSYSAPI
00212 NTSTATUS
00213 NTAPI
00214 RtlGUIDFromString(
00215   _In_ PUNICODE_STRING GuidString,
00216   _Out_ GUID *Guid);
00217 
00218 _IRQL_requires_max_(DISPATCH_LEVEL)
00219 _At_(DestinationString->Buffer, _Post_equal_to_(SourceString))
00220 //_At_(DestinationString->Length, _Post_equal_to_(_String_length_(SourceString) * sizeof(WCHAR)))
00221 _At_(DestinationString->MaximumLength, _Post_equal_to_(DestinationString->Length + sizeof(WCHAR)))
00222 NTSYSAPI
00223 VOID
00224 NTAPI
00225 RtlInitUnicodeString(
00226   _Out_ PUNICODE_STRING DestinationString,
00227   _In_opt_z_ __drv_aliasesMem PCWSTR SourceString);
00228 
00229 /* VOID
00230  * RtlMoveMemory(
00231  *    IN VOID UNALIGNED *Destination,
00232  *    IN CONST VOID UNALIGNED *Source,
00233  *    IN SIZE_T Length)
00234  */
00235 #define RtlMoveMemory(Destination, Source, Length) \
00236     memmove(Destination, Source, Length)
00237 
00238 _IRQL_requires_max_(PASSIVE_LEVEL)
00239 _Must_inspect_result_
00240 NTSYSAPI
00241 NTSTATUS
00242 NTAPI
00243 RtlStringFromGUID(
00244   _In_ REFGUID Guid,
00245   _Out_ _At_(GuidString->Buffer, __drv_allocatesMem(Mem))
00246     PUNICODE_STRING GuidString);
00247 
00248 /* VOID
00249  * RtlZeroMemory(
00250  *     IN VOID UNALIGNED *Destination,
00251  *     IN SIZE_T Length)
00252  */
00253 #define RtlZeroMemory(Destination, Length) \
00254     memset(Destination, 0, Length)
00255 
00256 #define RtlZeroBytes RtlZeroMemory
00257 $endif (_WDMDDK_)
00258 
00259 #if (NTDDI_VERSION >= NTDDI_WIN2K)
00260 
00261 $if (_WDMDDK_)
00262 _Must_inspect_result_
00263 NTSYSAPI
00264 BOOLEAN
00265 NTAPI
00266 RtlAreBitsClear(
00267   _In_ PRTL_BITMAP BitMapHeader,
00268   _In_ ULONG StartingIndex,
00269   _In_ ULONG Length);
00270 
00271 _Must_inspect_result_
00272 NTSYSAPI
00273 BOOLEAN
00274 NTAPI
00275 RtlAreBitsSet(
00276   _In_ PRTL_BITMAP BitMapHeader,
00277   _In_ ULONG StartingIndex,
00278   _In_ ULONG Length);
00279 
00280 _IRQL_requires_max_(PASSIVE_LEVEL)
00281 _Must_inspect_result_
00282 NTSYSAPI
00283 NTSTATUS
00284 NTAPI
00285 RtlAnsiStringToUnicodeString(
00286   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
00287   _When_(!AllocateDestinationString, _Inout_)
00288     PUNICODE_STRING DestinationString,
00289   _In_ PANSI_STRING SourceString,
00290   _In_ BOOLEAN AllocateDestinationString);
00291 
00292 _IRQL_requires_max_(PASSIVE_LEVEL)
00293 NTSYSAPI
00294 ULONG
00295 NTAPI
00296 RtlxAnsiStringToUnicodeSize(
00297   _In_ PCANSI_STRING AnsiString);
00298 
00299 #define RtlAnsiStringToUnicodeSize(String) (               \
00300   NLS_MB_CODE_PAGE_TAG ?                                   \
00301   RtlxAnsiStringToUnicodeSize(String) :                    \
00302   ((String)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR)   \
00303 )
00304 
00305 _Success_(1)
00306 _Unchanged_(Destination->MaximumLength)
00307 _Unchanged_(Destination->Buffer)
00308 _When_(_Old_(Destination->Length) + Source->Length <= Destination->MaximumLength,
00309   _At_(Destination->Length, _Post_equal_to_(_Old_(Destination->Length) + Source->Length))
00310   _At_(return, _Out_range_(==, 0)))
00311 _When_(_Old_(Destination->Length) + Source->Length > Destination->MaximumLength,
00312   _Unchanged_(Destination->Length)
00313   _At_(return, _Out_range_(<, 0)))
00314 NTSYSAPI
00315 NTSTATUS
00316 NTAPI
00317 RtlAppendUnicodeStringToString(
00318   _Inout_ PUNICODE_STRING Destination,
00319   _In_ PCUNICODE_STRING Source);
00320 
00321 _Success_(1)
00322 _Unchanged_(Destination->MaximumLength)
00323 _Unchanged_(Destination->Buffer)
00324 /* _When_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR) <= Destination->MaximumLength,
00325   _At_(Destination->Length, _Post_equal_to_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR)))
00326   _At_(return, _Out_range_(==, 0)))
00327 _When_(_Old_(Destination->Length) + _String_length_(Source) * sizeof(WCHAR) > Destination->MaximumLength,
00328   _Unchanged_(Destination->Length)
00329   _At_(return, _Out_range_(<, 0))) */
00330 NTSYSAPI
00331 NTSTATUS
00332 NTAPI
00333 RtlAppendUnicodeToString(
00334   _Inout_ PUNICODE_STRING Destination,
00335   _In_opt_z_ PCWSTR Source);
00336 
00337 _IRQL_requires_max_(PASSIVE_LEVEL)
00338 _Must_inspect_result_
00339 NTSYSAPI
00340 NTSTATUS
00341 NTAPI
00342 RtlCheckRegistryKey(
00343   _In_ ULONG RelativeTo,
00344   _In_ PWSTR Path);
00345 
00346 NTSYSAPI
00347 VOID
00348 NTAPI
00349 RtlClearAllBits(
00350   _In_ PRTL_BITMAP BitMapHeader);
00351 
00352 NTSYSAPI
00353 VOID
00354 NTAPI
00355 RtlClearBits(
00356   _In_ PRTL_BITMAP BitMapHeader,
00357   _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToClear) ULONG StartingIndex,
00358   _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToClear);
00359 
00360 _Must_inspect_result_
00361 NTSYSAPI
00362 SIZE_T
00363 NTAPI
00364 RtlCompareMemory(
00365   _In_ const VOID *Source1,
00366   _In_ const VOID *Source2,
00367   _In_ SIZE_T Length);
00368 
00369 _IRQL_requires_max_(PASSIVE_LEVEL)
00370 _Must_inspect_result_
00371 NTSYSAPI
00372 LONG
00373 NTAPI
00374 RtlCompareUnicodeString(
00375   _In_ PCUNICODE_STRING String1,
00376   _In_ PCUNICODE_STRING String2,
00377   _In_ BOOLEAN CaseInSensitive);
00378 
00379 _IRQL_requires_max_(PASSIVE_LEVEL)
00380 _Must_inspect_result_
00381 NTSYSAPI
00382 LONG
00383 NTAPI
00384 RtlCompareUnicodeStrings(
00385   _In_reads_(String1Length) PCWCH String1,
00386   _In_ SIZE_T String1Length,
00387   _In_reads_(String2Length) PCWCH String2,
00388   _In_ SIZE_T String2Length,
00389   _In_ BOOLEAN CaseInSensitive);
00390 
00391 _Unchanged_(DestinationString->Buffer)
00392 _Unchanged_(DestinationString->MaximumLength)
00393 _At_(DestinationString->Length,
00394   _When_(SourceString->Length > DestinationString->MaximumLength,
00395     _Post_equal_to_(DestinationString->MaximumLength))
00396   _When_(SourceString->Length <= DestinationString->MaximumLength,
00397     _Post_equal_to_(SourceString->Length)))
00398 NTSYSAPI
00399 VOID
00400 NTAPI
00401 RtlCopyUnicodeString(
00402   _Inout_ PUNICODE_STRING DestinationString,
00403   _In_opt_ PCUNICODE_STRING SourceString);
00404 
00405 _IRQL_requires_max_(PASSIVE_LEVEL)
00406 NTSYSAPI
00407 NTSTATUS
00408 NTAPI
00409 RtlCreateRegistryKey(
00410   _In_ ULONG RelativeTo,
00411   _In_ PWSTR Path);
00412 
00413 _IRQL_requires_max_(APC_LEVEL)
00414 NTSYSAPI
00415 NTSTATUS
00416 NTAPI
00417 RtlCreateSecurityDescriptor(
00418   _Out_ PSECURITY_DESCRIPTOR SecurityDescriptor,
00419   _In_ ULONG Revision);
00420 
00421 _IRQL_requires_max_(PASSIVE_LEVEL)
00422 NTSYSAPI
00423 NTSTATUS
00424 NTAPI
00425 RtlDeleteRegistryValue(
00426   _In_ ULONG RelativeTo,
00427   _In_ PCWSTR Path,
00428   _In_z_ PCWSTR ValueName);
00429 
00430 _IRQL_requires_max_(PASSIVE_LEVEL)
00431 _Must_inspect_result_
00432 NTSYSAPI
00433 BOOLEAN
00434 NTAPI
00435 RtlEqualUnicodeString(
00436   _In_ CONST UNICODE_STRING *String1,
00437   _In_ CONST UNICODE_STRING *String2,
00438   _In_ BOOLEAN CaseInSensitive);
00439 
00440 #if !defined(_AMD64_) && !defined(_IA64_)
00441 NTSYSAPI
00442 LARGE_INTEGER
00443 NTAPI
00444 RtlExtendedIntegerMultiply(
00445   _In_ LARGE_INTEGER Multiplicand,
00446   _In_ LONG Multiplier);
00447 
00448 NTSYSAPI
00449 LARGE_INTEGER
00450 NTAPI
00451 RtlExtendedLargeIntegerDivide(
00452   _In_ LARGE_INTEGER Dividend,
00453   _In_ ULONG Divisor,
00454   _Out_opt_ PULONG Remainder);
00455 #endif
00456 
00457 #if defined(_X86_) || defined(_IA64_)
00458 NTSYSAPI
00459 LARGE_INTEGER
00460 NTAPI
00461 RtlExtendedMagicDivide(
00462     _In_ LARGE_INTEGER Dividend,
00463     _In_ LARGE_INTEGER MagicDivisor,
00464     _In_ CCHAR  ShiftCount);
00465 #endif
00466 
00467 _IRQL_requires_max_(PASSIVE_LEVEL)
00468 NTSYSAPI
00469 VOID
00470 NTAPI
00471 RtlFreeAnsiString(
00472   _Inout_ _At_(AnsiString->Buffer, __drv_freesMem(Mem))
00473     PANSI_STRING AnsiString);
00474 
00475 _Success_(return != -1)
00476 _Must_inspect_result_
00477 NTSYSAPI
00478 ULONG
00479 NTAPI
00480 RtlFindClearBits(
00481   _In_ PRTL_BITMAP BitMapHeader,
00482   _In_ ULONG NumberToFind,
00483   _In_ ULONG HintIndex);
00484 
00485 _Success_(return != -1)
00486 NTSYSAPI
00487 ULONG
00488 NTAPI
00489 RtlFindClearBitsAndSet(
00490   _In_ PRTL_BITMAP BitMapHeader,
00491   _In_ ULONG NumberToFind,
00492   _In_ ULONG HintIndex);
00493 
00494 NTSYSAPI
00495 ULONG
00496 NTAPI
00497 RtlFindFirstRunClear(
00498   _In_ PRTL_BITMAP BitMapHeader,
00499   _Out_ PULONG StartingIndex);
00500 
00501 NTSYSAPI
00502 ULONG
00503 NTAPI
00504 RtlFindClearRuns(
00505   _In_ PRTL_BITMAP BitMapHeader,
00506   _Out_writes_to_(SizeOfRunArray, return) PRTL_BITMAP_RUN RunArray,
00507   _In_range_(>, 0) ULONG SizeOfRunArray,
00508   _In_ BOOLEAN LocateLongestRuns);
00509 
00510 NTSYSAPI
00511 ULONG
00512 NTAPI
00513 RtlFindLastBackwardRunClear(
00514   _In_ PRTL_BITMAP BitMapHeader,
00515   _In_ ULONG FromIndex,
00516   _Out_ PULONG StartingRunIndex);
00517 
00518 _Success_(return != -1)
00519 _Must_inspect_result_
00520 NTSYSAPI
00521 CCHAR
00522 NTAPI
00523 RtlFindLeastSignificantBit(
00524   _In_ ULONGLONG Set);
00525 
00526 NTSYSAPI
00527 ULONG
00528 NTAPI
00529 RtlFindLongestRunClear(
00530   _In_ PRTL_BITMAP BitMapHeader,
00531   _Out_ PULONG StartingIndex);
00532 
00533 _Success_(return != -1)
00534 _Must_inspect_result_
00535 NTSYSAPI
00536 CCHAR
00537 NTAPI
00538 RtlFindMostSignificantBit(
00539   _In_ ULONGLONG Set);
00540 
00541 NTSYSAPI
00542 ULONG
00543 NTAPI
00544 RtlFindNextForwardRunClear(
00545   _In_ PRTL_BITMAP BitMapHeader,
00546   _In_ ULONG FromIndex,
00547   _Out_ PULONG StartingRunIndex);
00548 
00549 _Success_(return != -1)
00550 _Must_inspect_result_
00551 NTSYSAPI
00552 ULONG
00553 NTAPI
00554 RtlFindSetBits(
00555   _In_ PRTL_BITMAP BitMapHeader,
00556   _In_ ULONG NumberToFind,
00557   _In_ ULONG HintIndex);
00558 
00559 _Success_(return != -1)
00560 NTSYSAPI
00561 ULONG
00562 NTAPI
00563 RtlFindSetBitsAndClear(
00564   _In_ PRTL_BITMAP BitMapHeader,
00565   _In_ ULONG NumberToFind,
00566   _In_ ULONG HintIndex);
00567 
00568 _IRQL_requires_max_(DISPATCH_LEVEL)
00569 NTSYSAPI
00570 VOID
00571 NTAPI
00572 RtlInitAnsiString(
00573   _Out_ PANSI_STRING DestinationString,
00574   _In_opt_z_ __drv_aliasesMem PCSZ SourceString);
00575 
00576 NTSYSAPI
00577 VOID
00578 NTAPI
00579 RtlInitializeBitMap(
00580   _Out_ PRTL_BITMAP BitMapHeader,
00581   _In_ __drv_aliasesMem PULONG BitMapBuffer,
00582   _In_ ULONG SizeOfBitMap);
00583 
00584 _IRQL_requires_max_(DISPATCH_LEVEL)
00585 NTSYSAPI
00586 VOID
00587 NTAPI
00588 RtlInitString(
00589   _Out_ PSTRING DestinationString,
00590   _In_opt_z_ __drv_aliasesMem PCSZ SourceString);
00591 
00592 _IRQL_requires_max_(PASSIVE_LEVEL)
00593 _At_(String->MaximumLength, _Const_)
00594 NTSYSAPI
00595 NTSTATUS
00596 NTAPI
00597 RtlIntegerToUnicodeString(
00598   _In_ ULONG Value,
00599   _In_opt_ ULONG Base,
00600   _Inout_ PUNICODE_STRING String);
00601 
00602 _IRQL_requires_max_(PASSIVE_LEVEL)
00603 _At_(String->MaximumLength, _Const_)
00604 NTSYSAPI
00605 NTSTATUS
00606 NTAPI
00607 RtlInt64ToUnicodeString(
00608   _In_ ULONGLONG Value,
00609   _In_opt_ ULONG Base,
00610   _Inout_ PUNICODE_STRING String);
00611 
00612 #ifdef _WIN64
00613 #define RtlIntPtrToUnicodeString(Value, Base, String) \
00614     RtlInt64ToUnicodeString(Value, Base, String)
00615 #else
00616 #define RtlIntPtrToUnicodeString(Value, Base, String) \
00617     RtlIntegerToUnicodeString(Value, Base, String)
00618 #endif
00619 
00620 /* BOOLEAN
00621  * RtlIsZeroLuid(
00622  *     IN PLUID L1);
00623  */
00624 #define RtlIsZeroLuid(_L1) \
00625     ((BOOLEAN) ((!(_L1)->LowPart) && (!(_L1)->HighPart)))
00626 
00627 _IRQL_requires_max_(APC_LEVEL)
00628 NTSYSAPI
00629 ULONG
00630 NTAPI
00631 RtlLengthSecurityDescriptor(
00632   _In_ PSECURITY_DESCRIPTOR SecurityDescriptor);
00633 
00634 NTSYSAPI
00635 ULONG
00636 NTAPI
00637 RtlNumberOfClearBits(
00638   _In_ PRTL_BITMAP BitMapHeader);
00639 
00640 NTSYSAPI
00641 ULONG
00642 NTAPI
00643 RtlNumberOfSetBits(
00644   _In_ PRTL_BITMAP BitMapHeader);
00645 
00646 _IRQL_requires_max_(PASSIVE_LEVEL)
00647 NTSYSAPI
00648 NTSTATUS
00649 NTAPI
00650 RtlQueryRegistryValues(
00651   _In_ ULONG RelativeTo,
00652   _In_ PCWSTR Path,
00653   _Inout_ _At_(*(*QueryTable).EntryContext, _Post_valid_)
00654     PRTL_QUERY_REGISTRY_TABLE QueryTable,
00655   _In_opt_ PVOID Context,
00656   _In_opt_ PVOID Environment);
00657 
00658 #define SHORT_SIZE  (sizeof(USHORT))
00659 #define SHORT_MASK  (SHORT_SIZE - 1)
00660 #define LONG_SIZE (sizeof(LONG))
00661 #define LONGLONG_SIZE   (sizeof(LONGLONG))
00662 #define LONG_MASK (LONG_SIZE - 1)
00663 #define LONGLONG_MASK   (LONGLONG_SIZE - 1)
00664 #define LOWBYTE_MASK 0x00FF
00665 
00666 #define FIRSTBYTE(VALUE)  ((VALUE) & LOWBYTE_MASK)
00667 #define SECONDBYTE(VALUE) (((VALUE) >> 8) & LOWBYTE_MASK)
00668 #define THIRDBYTE(VALUE)  (((VALUE) >> 16) & LOWBYTE_MASK)
00669 #define FOURTHBYTE(VALUE) (((VALUE) >> 24) & LOWBYTE_MASK)
00670 
00671 NTSYSAPI
00672 VOID
00673 NTAPI
00674 RtlSetAllBits(
00675   _In_ PRTL_BITMAP BitMapHeader);
00676 
00677 NTSYSAPI
00678 VOID
00679 NTAPI
00680 RtlSetBits(
00681   _In_ PRTL_BITMAP BitMapHeader,
00682   _In_range_(0, BitMapHeader->SizeOfBitMap - NumberToSet) ULONG StartingIndex,
00683   _In_range_(0, BitMapHeader->SizeOfBitMap - StartingIndex) ULONG NumberToSet);
00684 
00685 _IRQL_requires_max_(APC_LEVEL)
00686 NTSYSAPI
00687 NTSTATUS
00688 NTAPI
00689 RtlSetDaclSecurityDescriptor(
00690   _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
00691   _In_ BOOLEAN DaclPresent,
00692   _In_opt_ PACL Dacl,
00693   _In_opt_ BOOLEAN DaclDefaulted);
00694 
00695 #if defined(_AMD64_)
00696 
00697 /* VOID
00698  * RtlStoreUlong(
00699  *     IN PULONG Address,
00700  *     IN ULONG Value);
00701  */
00702 #define RtlStoreUlong(Address,Value) \
00703     *(ULONG UNALIGNED *)(Address) = (Value)
00704 
00705 /* VOID
00706  * RtlStoreUlonglong(
00707  *     IN OUT PULONGLONG Address,
00708  *     ULONGLONG Value);
00709  */
00710 #define RtlStoreUlonglong(Address,Value) \
00711     *(ULONGLONG UNALIGNED *)(Address) = (Value)
00712 
00713 /* VOID
00714  * RtlStoreUshort(
00715  *     IN PUSHORT Address,
00716  *     IN USHORT Value);
00717  */
00718 #define RtlStoreUshort(Address,Value) \
00719     *(USHORT UNALIGNED *)(Address) = (Value)
00720 
00721 /* VOID
00722  * RtlRetrieveUshort(
00723  *     PUSHORT DestinationAddress,
00724  *    PUSHORT SourceAddress);
00725  */
00726 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
00727     *(USHORT UNALIGNED *)(DestAddress) = *(USHORT)(SrcAddress)
00728 
00729 /* VOID
00730  * RtlRetrieveUlong(
00731  *    PULONG DestinationAddress,
00732  *    PULONG SourceAddress);
00733  */
00734 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
00735     *(ULONG UNALIGNED *)(DestAddress) = *(PULONG)(SrcAddress)
00736 
00737 #else
00738 
00739 #define RtlStoreUlong(Address,Value)                      \
00740     if ((ULONG_PTR)(Address) & LONG_MASK) { \
00741         ((PUCHAR) (Address))[LONG_LEAST_SIGNIFICANT_BIT]    = (UCHAR)(FIRSTBYTE(Value)); \
00742         ((PUCHAR) (Address))[LONG_3RD_MOST_SIGNIFICANT_BIT] = (UCHAR)(SECONDBYTE(Value)); \
00743         ((PUCHAR) (Address))[LONG_2ND_MOST_SIGNIFICANT_BIT] = (UCHAR)(THIRDBYTE(Value)); \
00744         ((PUCHAR) (Address))[LONG_MOST_SIGNIFICANT_BIT]     = (UCHAR)(FOURTHBYTE(Value)); \
00745     } \
00746     else { \
00747         *((PULONG)(Address)) = (ULONG) (Value); \
00748     }
00749 
00750 #define RtlStoreUlonglong(Address,Value) \
00751     if ((ULONG_PTR)(Address) & LONGLONG_MASK) { \
00752         RtlStoreUlong((ULONG_PTR)(Address), \
00753                       (ULONGLONG)(Value) & 0xFFFFFFFF); \
00754         RtlStoreUlong((ULONG_PTR)(Address)+sizeof(ULONG), \
00755                       (ULONGLONG)(Value) >> 32); \
00756     } else { \
00757         *((PULONGLONG)(Address)) = (ULONGLONG)(Value); \
00758     }
00759 
00760 #define RtlStoreUshort(Address,Value) \
00761     if ((ULONG_PTR)(Address) & SHORT_MASK) { \
00762         ((PUCHAR) (Address))[SHORT_LEAST_SIGNIFICANT_BIT] = (UCHAR)(FIRSTBYTE(Value)); \
00763         ((PUCHAR) (Address))[SHORT_MOST_SIGNIFICANT_BIT ] = (UCHAR)(SECONDBYTE(Value)); \
00764     } \
00765     else { \
00766         *((PUSHORT) (Address)) = (USHORT)Value; \
00767     }
00768 
00769 #define RtlRetrieveUshort(DestAddress,SrcAddress) \
00770     if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
00771     { \
00772         ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
00773         ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
00774     } \
00775     else \
00776     { \
00777         *((PUSHORT)(DestAddress))=*((PUSHORT)(SrcAddress)); \
00778     }
00779 
00780 #define RtlRetrieveUlong(DestAddress,SrcAddress) \
00781     if ((ULONG_PTR)(SrcAddress) & LONG_MASK) \
00782     { \
00783         ((PUCHAR)(DestAddress))[0]=((PUCHAR)(SrcAddress))[0]; \
00784         ((PUCHAR)(DestAddress))[1]=((PUCHAR)(SrcAddress))[1]; \
00785         ((PUCHAR)(DestAddress))[2]=((PUCHAR)(SrcAddress))[2]; \
00786         ((PUCHAR)(DestAddress))[3]=((PUCHAR)(SrcAddress))[3]; \
00787     } \
00788     else \
00789     { \
00790         *((PULONG)(DestAddress))=*((PULONG)(SrcAddress)); \
00791     }
00792 
00793 #endif /* defined(_AMD64_) */
00794 
00795 #ifdef _WIN64
00796 /* VOID
00797  * RtlStoreUlongPtr(
00798  *     IN OUT PULONG_PTR Address,
00799  *     IN ULONG_PTR Value);
00800  */
00801 #define RtlStoreUlongPtr(Address,Value) RtlStoreUlonglong(Address,Value)
00802 #else
00803 #define RtlStoreUlongPtr(Address,Value) RtlStoreUlong(Address,Value)
00804 #endif /* _WIN64 */
00805 
00806 _Success_(return != 0)
00807 NTSYSAPI
00808 BOOLEAN
00809 NTAPI
00810 RtlTimeFieldsToTime(
00811   _In_ PTIME_FIELDS TimeFields,
00812   _Out_ PLARGE_INTEGER Time);
00813 
00814 NTSYSAPI
00815 VOID
00816 NTAPI
00817 RtlTimeToTimeFields(
00818   _In_ PLARGE_INTEGER Time,
00819   _Out_ PTIME_FIELDS TimeFields);
00820 
00821 NTSYSAPI
00822 ULONG
00823 FASTCALL
00824 RtlUlongByteSwap(
00825   _In_ ULONG Source);
00826 
00827 NTSYSAPI
00828 ULONGLONG
00829 FASTCALL
00830 RtlUlonglongByteSwap(
00831   _In_ ULONGLONG Source);
00832 
00833 _When_(AllocateDestinationString,
00834   _At_(DestinationString->MaximumLength,
00835     _Out_range_(<=, (SourceString->MaximumLength / sizeof(WCHAR)))))
00836 _When_(!AllocateDestinationString,
00837   _At_(DestinationString->Buffer, _Const_)
00838   _At_(DestinationString->MaximumLength, _Const_))
00839 _IRQL_requires_max_(PASSIVE_LEVEL)
00840 _When_(AllocateDestinationString, _Must_inspect_result_)
00841 NTSYSAPI
00842 NTSTATUS
00843 NTAPI
00844 RtlUnicodeStringToAnsiString(
00845   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
00846   _When_(!AllocateDestinationString, _Inout_)
00847     PANSI_STRING DestinationString,
00848   _In_ PCUNICODE_STRING SourceString,
00849   _In_ BOOLEAN AllocateDestinationString);
00850 
00851 _IRQL_requires_max_(PASSIVE_LEVEL)
00852 NTSYSAPI
00853 ULONG
00854 NTAPI
00855 RtlxUnicodeStringToAnsiSize(
00856   _In_ PCUNICODE_STRING UnicodeString);
00857 
00858 #define RtlUnicodeStringToAnsiSize(String) (                  \
00859     NLS_MB_CODE_PAGE_TAG ?                                    \
00860     RtlxUnicodeStringToAnsiSize(String) :                     \
00861     ((String)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
00862 )
00863 
00864 _IRQL_requires_max_(PASSIVE_LEVEL)
00865 NTSYSAPI
00866 NTSTATUS
00867 NTAPI
00868 RtlUnicodeStringToInteger(
00869   _In_ PCUNICODE_STRING String,
00870   _In_opt_ ULONG Base,
00871   _Out_ PULONG Value);
00872 
00873 _IRQL_requires_max_(PASSIVE_LEVEL)
00874 NTSYSAPI
00875 WCHAR
00876 NTAPI
00877 RtlUpcaseUnicodeChar(
00878   _In_ WCHAR SourceCharacter);
00879 
00880 NTSYSAPI
00881 USHORT
00882 FASTCALL
00883 RtlUshortByteSwap(
00884   _In_ USHORT Source);
00885 
00886 _IRQL_requires_max_(APC_LEVEL)
00887 _Must_inspect_result_
00888 NTSYSAPI
00889 BOOLEAN
00890 NTAPI
00891 RtlValidRelativeSecurityDescriptor(
00892   _In_reads_bytes_(SecurityDescriptorLength) PSECURITY_DESCRIPTOR SecurityDescriptorInput,
00893   _In_ ULONG SecurityDescriptorLength,
00894   _In_ SECURITY_INFORMATION RequiredInformation);
00895 
00896 _IRQL_requires_max_(APC_LEVEL)
00897 _Must_inspect_result_
00898 NTSYSAPI
00899 BOOLEAN
00900 NTAPI
00901 RtlValidSecurityDescriptor(
00902   _In_ PSECURITY_DESCRIPTOR SecurityDescriptor);
00903 
00904 _IRQL_requires_max_(PASSIVE_LEVEL)
00905 NTSYSAPI
00906 NTSTATUS
00907 NTAPI
00908 RtlWriteRegistryValue(
00909   _In_ ULONG RelativeTo,
00910   _In_ PCWSTR Path,
00911   _In_z_ PCWSTR ValueName,
00912   _In_ ULONG ValueType,
00913   _In_reads_bytes_opt_(ValueLength) PVOID ValueData,
00914   _In_ ULONG ValueLength);
00915 
00916 $endif (_WDMDDK_)
00917 $if (_NTDDK_)
00918 
00919 #ifndef RTL_USE_AVL_TABLES
00920 
00921 NTSYSAPI
00922 VOID
00923 NTAPI
00924 RtlInitializeGenericTable(
00925   _Out_ PRTL_GENERIC_TABLE Table,
00926   _In_ PRTL_GENERIC_COMPARE_ROUTINE CompareRoutine,
00927   _In_ PRTL_GENERIC_ALLOCATE_ROUTINE AllocateRoutine,
00928   _In_ PRTL_GENERIC_FREE_ROUTINE FreeRoutine,
00929   _In_opt_ PVOID TableContext);
00930 
00931 NTSYSAPI
00932 PVOID
00933 NTAPI
00934 RtlInsertElementGenericTable(
00935   _In_ PRTL_GENERIC_TABLE Table,
00936   _In_reads_bytes_(BufferSize) PVOID Buffer,
00937   _In_ CLONG BufferSize,
00938   _Out_opt_ PBOOLEAN NewElement);
00939 
00940 NTSYSAPI
00941 PVOID
00942 NTAPI
00943 RtlInsertElementGenericTableFull(
00944   _In_ PRTL_GENERIC_TABLE Table,
00945   _In_reads_bytes_(BufferSize) PVOID Buffer,
00946   _In_ CLONG BufferSize,
00947   _Out_opt_ PBOOLEAN NewElement,
00948   _In_ PVOID NodeOrParent,
00949   _In_ TABLE_SEARCH_RESULT SearchResult);
00950 
00951 NTSYSAPI
00952 BOOLEAN
00953 NTAPI
00954 RtlDeleteElementGenericTable(
00955   _In_ PRTL_GENERIC_TABLE Table,
00956   _In_ PVOID Buffer);
00957 
00958 _Must_inspect_result_
00959 NTSYSAPI
00960 PVOID
00961 NTAPI
00962 RtlLookupElementGenericTable(
00963   _In_ PRTL_GENERIC_TABLE Table,
00964   _In_ PVOID Buffer);
00965 
00966 NTSYSAPI
00967 PVOID
00968 NTAPI
00969 RtlLookupElementGenericTableFull(
00970   _In_ PRTL_GENERIC_TABLE Table,
00971   _In_ PVOID Buffer,
00972   _Out_ PVOID *NodeOrParent,
00973   _Out_ TABLE_SEARCH_RESULT *SearchResult);
00974 
00975 _Must_inspect_result_
00976 NTSYSAPI
00977 PVOID
00978 NTAPI
00979 RtlEnumerateGenericTable(
00980   _In_ PRTL_GENERIC_TABLE Table,
00981   _In_ BOOLEAN Restart);
00982 
00983 _Must_inspect_result_
00984 NTSYSAPI
00985 PVOID
00986 NTAPI
00987 RtlEnumerateGenericTableWithoutSplaying(
00988   _In_ PRTL_GENERIC_TABLE Table,
00989   _Inout_ PVOID *RestartKey);
00990 
00991 _Must_inspect_result_
00992 NTSYSAPI
00993 PVOID
00994 NTAPI
00995 RtlGetElementGenericTable(
00996   _In_ PRTL_GENERIC_TABLE Table,
00997   _In_ ULONG I);
00998 
00999 NTSYSAPI
01000 ULONG
01001 NTAPI
01002 RtlNumberGenericTableElements(
01003   _In_ PRTL_GENERIC_TABLE Table);
01004 
01005 _Must_inspect_result_
01006 NTSYSAPI
01007 BOOLEAN
01008 NTAPI
01009 RtlIsGenericTableEmpty(
01010   _In_ PRTL_GENERIC_TABLE Table);
01011 
01012 #endif /* !RTL_USE_AVL_TABLES */
01013 
01014 #define RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT     8
01015 
01016 NTSYSAPI
01017 PRTL_SPLAY_LINKS
01018 NTAPI
01019 RtlSplay(
01020   _Inout_ PRTL_SPLAY_LINKS Links);
01021 
01022 NTSYSAPI
01023 PRTL_SPLAY_LINKS
01024 NTAPI
01025 RtlDelete(
01026   _In_ PRTL_SPLAY_LINKS Links);
01027 
01028 NTSYSAPI
01029 VOID
01030 NTAPI
01031 RtlDeleteNoSplay(
01032   _In_ PRTL_SPLAY_LINKS Links,
01033   _Inout_ PRTL_SPLAY_LINKS *Root);
01034 
01035 _Must_inspect_result_
01036 NTSYSAPI
01037 PRTL_SPLAY_LINKS
01038 NTAPI
01039 RtlSubtreeSuccessor(
01040   _In_ PRTL_SPLAY_LINKS Links);
01041 
01042 _Must_inspect_result_
01043 NTSYSAPI
01044 PRTL_SPLAY_LINKS
01045 NTAPI
01046 RtlSubtreePredecessor(
01047   _In_ PRTL_SPLAY_LINKS Links);
01048 
01049 _Must_inspect_result_
01050 NTSYSAPI
01051 PRTL_SPLAY_LINKS
01052 NTAPI
01053 RtlRealSuccessor(
01054   _In_ PRTL_SPLAY_LINKS Links);
01055 
01056 _Must_inspect_result_
01057 NTSYSAPI
01058 PRTL_SPLAY_LINKS
01059 NTAPI
01060 RtlRealPredecessor(
01061   _In_ PRTL_SPLAY_LINKS Links);
01062 
01063 _IRQL_requires_max_(PASSIVE_LEVEL)
01064 _Must_inspect_result_
01065 NTSYSAPI
01066 BOOLEAN
01067 NTAPI
01068 RtlPrefixUnicodeString(
01069   _In_ PCUNICODE_STRING String1,
01070   _In_ PCUNICODE_STRING String2,
01071   _In_ BOOLEAN CaseInSensitive);
01072 
01073 _IRQL_requires_max_(PASSIVE_LEVEL)
01074 NTSYSAPI
01075 VOID
01076 NTAPI
01077 RtlUpperString(
01078   _Inout_ PSTRING DestinationString,
01079   _In_ const PSTRING SourceString);
01080 
01081 _IRQL_requires_max_(PASSIVE_LEVEL)
01082 _When_(AllocateDestinationString, _Must_inspect_result_)
01083 NTSYSAPI
01084 NTSTATUS
01085 NTAPI
01086 RtlUpcaseUnicodeString(
01087   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
01088   _When_(!AllocateDestinationString, _Inout_)
01089     PUNICODE_STRING DestinationString,
01090   _In_ PCUNICODE_STRING SourceString,
01091   _In_ BOOLEAN AllocateDestinationString);
01092 
01093 _IRQL_requires_max_(APC_LEVEL)
01094 NTSYSAPI
01095 VOID
01096 NTAPI
01097 RtlMapGenericMask(
01098   _Inout_ PACCESS_MASK AccessMask,
01099   _In_ PGENERIC_MAPPING GenericMapping);
01100 
01101 _IRQL_requires_max_(PASSIVE_LEVEL)
01102 NTSYSAPI
01103 NTSTATUS
01104 NTAPI
01105 RtlVolumeDeviceToDosName(
01106   _In_ PVOID VolumeDeviceObject,
01107   _Out_ PUNICODE_STRING DosName);
01108 
01109 NTSYSAPI
01110 NTSTATUS
01111 NTAPI
01112 RtlGetVersion(
01113   IN OUT PRTL_OSVERSIONINFOW lpVersionInformation);
01114 
01115 NTSYSAPI
01116 NTSTATUS
01117 NTAPI
01118 RtlVerifyVersionInfo(
01119   IN PRTL_OSVERSIONINFOEXW VersionInfo,
01120   IN ULONG TypeMask,
01121   IN ULONGLONG ConditionMask);
01122 
01123 _IRQL_requires_max_(PASSIVE_LEVEL)
01124 _Must_inspect_result_
01125 NTSYSAPI
01126 LONG
01127 NTAPI
01128 RtlCompareString(
01129   _In_ const PSTRING String1,
01130   _In_ const PSTRING String2,
01131   _In_ BOOLEAN CaseInSensitive);
01132 
01133 NTSYSAPI
01134 VOID
01135 NTAPI
01136 RtlCopyString(
01137   _Out_ PSTRING DestinationString,
01138   _In_opt_ const PSTRING SourceString);
01139 
01140 _IRQL_requires_max_(PASSIVE_LEVEL)
01141 _Must_inspect_result_
01142 NTSYSAPI
01143 BOOLEAN
01144 NTAPI
01145 RtlEqualString(
01146   _In_ const PSTRING String1,
01147   _In_ const PSTRING String2,
01148   _In_ BOOLEAN CaseInSensitive);
01149 
01150 _IRQL_requires_max_(PASSIVE_LEVEL)
01151 NTSYSAPI
01152 NTSTATUS
01153 NTAPI
01154 RtlCharToInteger(
01155   _In_z_ PCSZ String,
01156   _In_opt_ ULONG Base,
01157   _Out_ PULONG Value);
01158 
01159 _IRQL_requires_max_(PASSIVE_LEVEL)
01160 NTSYSAPI
01161 CHAR
01162 NTAPI
01163 RtlUpperChar(
01164   _In_ CHAR Character);
01165 
01166 NTSYSAPI
01167 ULONG
01168 NTAPI
01169 RtlWalkFrameChain(
01170   _Out_writes_(Count - (Flags >> RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT))
01171     PVOID *Callers,
01172   _In_ ULONG Count,
01173   _In_ ULONG Flags);
01174 
01175 $endif (_NTDDK_)
01176 $if (_NTIFS_)
01177 
01178 _Must_inspect_result_
01179 _Ret_maybenull_
01180 _Post_writable_byte_size_(Size)
01181 NTSYSAPI
01182 PVOID
01183 NTAPI
01184 RtlAllocateHeap(
01185   _In_ HANDLE HeapHandle,
01186   _In_opt_ ULONG Flags,
01187   _In_ SIZE_T Size);
01188 
01189 _Success_(return != 0)
01190 NTSYSAPI
01191 BOOLEAN
01192 NTAPI
01193 RtlFreeHeap(
01194   _In_ PVOID HeapHandle,
01195   _In_opt_ ULONG Flags,
01196   _In_ _Post_invalid_ PVOID BaseAddress);
01197 
01198 NTSYSAPI
01199 VOID
01200 NTAPI
01201 RtlCaptureContext(
01202   _Out_ PCONTEXT ContextRecord);
01203 
01204 _Ret_range_(<, MAXLONG)
01205 NTSYSAPI
01206 ULONG
01207 NTAPI
01208 RtlRandom(
01209   _Inout_ PULONG Seed);
01210 
01211 _IRQL_requires_max_(APC_LEVEL)
01212 _Success_(return != 0)
01213 _Must_inspect_result_
01214 NTSYSAPI
01215 BOOLEAN
01216 NTAPI
01217 RtlCreateUnicodeString(
01218   _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem))
01219     PUNICODE_STRING DestinationString,
01220   _In_z_ PCWSTR SourceString);
01221 
01222 _IRQL_requires_max_(APC_LEVEL)
01223 NTSYSAPI
01224 NTSTATUS
01225 NTAPI
01226 RtlAppendStringToString(
01227   _Inout_ PSTRING Destination,
01228   _In_ const STRING *Source);
01229 
01230 _IRQL_requires_max_(PASSIVE_LEVEL)
01231 _Must_inspect_result_
01232 NTSYSAPI
01233 NTSTATUS
01234 NTAPI
01235 RtlOemStringToUnicodeString(
01236   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
01237   _When_(!AllocateDestinationString, _Inout_)
01238     PUNICODE_STRING DestinationString,
01239   _In_ PCOEM_STRING SourceString,
01240   _In_ BOOLEAN AllocateDestinationString);
01241 
01242 _IRQL_requires_max_(PASSIVE_LEVEL)
01243 _Must_inspect_result_
01244 NTSYSAPI
01245 NTSTATUS
01246 NTAPI
01247 RtlUnicodeStringToOemString(
01248   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
01249   _When_(!AllocateDestinationString, _Inout_)
01250     POEM_STRING DestinationString,
01251   _In_ PCUNICODE_STRING SourceString,
01252   _In_ BOOLEAN AllocateDestinationString);
01253 
01254 _IRQL_requires_max_(PASSIVE_LEVEL)
01255 _Must_inspect_result_
01256 NTSYSAPI
01257 NTSTATUS
01258 NTAPI
01259 RtlUpcaseUnicodeStringToOemString(
01260   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
01261   _When_(!AllocateDestinationString, _Inout_)
01262     POEM_STRING DestinationString,
01263   _In_ PCUNICODE_STRING SourceString,
01264   _In_ BOOLEAN AllocateDestinationString);
01265 
01266 _IRQL_requires_max_(PASSIVE_LEVEL)
01267 _Must_inspect_result_
01268 NTSYSAPI
01269 NTSTATUS
01270 NTAPI
01271 RtlOemStringToCountedUnicodeString(
01272   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
01273   _When_(!AllocateDestinationString, _Inout_)
01274     PUNICODE_STRING DestinationString,
01275   _In_ PCOEM_STRING SourceString,
01276   _In_ BOOLEAN AllocateDestinationString);
01277 
01278 _IRQL_requires_max_(PASSIVE_LEVEL)
01279 _Must_inspect_result_
01280 NTSYSAPI
01281 NTSTATUS
01282 NTAPI
01283 RtlUnicodeStringToCountedOemString(
01284   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
01285   _When_(!AllocateDestinationString, _Inout_)
01286     POEM_STRING DestinationString,
01287   _In_ PCUNICODE_STRING SourceString,
01288   _In_ BOOLEAN AllocateDestinationString);
01289 
01290 _IRQL_requires_max_(PASSIVE_LEVEL)
01291 _Must_inspect_result_
01292 NTSYSAPI
01293 NTSTATUS
01294 NTAPI
01295 RtlUpcaseUnicodeStringToCountedOemString(
01296   _When_(AllocateDestinationString, _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)))
01297   _When_(!AllocateDestinationString, _Inout_)
01298     POEM_STRING DestinationString,
01299   _In_ PCUNICODE_STRING SourceString,
01300   _In_ BOOLEAN AllocateDestinationString);
01301 
01302 _IRQL_requires_max_(PASSIVE_LEVEL)
01303 _When_(AllocateDestinationString, _Must_inspect_result_)
01304 NTSYSAPI
01305 NTSTATUS
01306 NTAPI
01307 RtlDowncaseUnicodeString(
01308   _When_(AllocateDestinationString, _Out_ _At_(UniDest->Buffer, __drv_allocatesMem(Mem)))
01309   _When_(!AllocateDestinationString, _Inout_)
01310     PUNICODE_STRING UniDest,
01311   _In_ PCUNICODE_STRING UniSource,
01312   _In_ BOOLEAN AllocateDestinationString);
01313 
01314 _IRQL_requires_max_(PASSIVE_LEVEL)
01315 NTSYSAPI
01316 VOID
01317 NTAPI
01318 RtlFreeOemString(
01319   _Inout_ _At_(OemString->Buffer, __drv_freesMem(Mem)) POEM_STRING OemString);
01320 
01321 _IRQL_requires_max_(PASSIVE_LEVEL)
01322 NTSYSAPI
01323 ULONG
01324 NTAPI
01325 RtlxUnicodeStringToOemSize(
01326   _In_ PCUNICODE_STRING UnicodeString);
01327 
01328 _IRQL_requires_max_(PASSIVE_LEVEL)
01329 NTSYSAPI
01330 ULONG
01331 NTAPI
01332 RtlxOemStringToUnicodeSize(
01333   _In_ PCOEM_STRING OemString);
01334 
01335 _IRQL_requires_max_(PASSIVE_LEVEL)
01336 NTSYSAPI
01337 NTSTATUS
01338 NTAPI
01339 RtlMultiByteToUnicodeN(
01340   _Out_writes_bytes_to_(MaxBytesInUnicodeString, *BytesInUnicodeString) PWCH UnicodeString,
01341   _In_ ULONG MaxBytesInUnicodeString,
01342   _Out_opt_ PULONG BytesInUnicodeString,
01343   _In_reads_bytes_(BytesInMultiByteString) const CHAR *MultiByteString,
01344   _In_ ULONG BytesInMultiByteString);
01345 
01346 _IRQL_requires_max_(PASSIVE_LEVEL)
01347 NTSYSAPI
01348 NTSTATUS
01349 NTAPI
01350 RtlMultiByteToUnicodeSize(
01351   _Out_ PULONG BytesInUnicodeString,
01352   _In_reads_bytes_(BytesInMultiByteString) const CHAR *MultiByteString,
01353   _In_ ULONG BytesInMultiByteString);
01354 
01355 _IRQL_requires_max_(PASSIVE_LEVEL)
01356 NTSYSAPI
01357 NTSTATUS
01358 NTAPI
01359 RtlUnicodeToMultiByteSize(
01360   _Out_ PULONG BytesInMultiByteString,
01361   _In_reads_bytes_(BytesInUnicodeString) PCWCH UnicodeString,
01362   _In_ ULONG BytesInUnicodeString);
01363 
01364 _IRQL_requires_max_(PASSIVE_LEVEL)
01365 NTSYSAPI
01366 NTSTATUS
01367 NTAPI
01368 RtlUnicodeToMultiByteN(
01369   _Out_writes_bytes_to_(MaxBytesInMultiByteString, *BytesInMultiByteString) PCHAR MultiByteString,
01370   _In_ ULONG MaxBytesInMultiByteString,
01371   _Out_opt_ PULONG BytesInMultiByteString,
01372   _In_reads_bytes_(BytesInUnicodeString) PCWCH UnicodeString,
01373   _In_ ULONG BytesInUnicodeString);
01374 
01375 _IRQL_requires_max_(PASSIVE_LEVEL)
01376 NTSYSAPI
01377 NTSTATUS
01378 NTAPI
01379 RtlUpcaseUnicodeToMultiByteN(
01380   _Out_writes_bytes_to_(MaxBytesInMultiByteString, *BytesInMultiByteString) PCHAR MultiByteString,
01381   _In_ ULONG MaxBytesInMultiByteString,
01382   _Out_opt_ PULONG BytesInMultiByteString,
01383   _In_reads_bytes_(BytesInUnicodeString) PCWCH UnicodeString,
01384   _In_ ULONG BytesInUnicodeString);
01385 
01386 _IRQL_requires_max_(PASSIVE_LEVEL)
01387 NTSYSAPI
01388 NTSTATUS
01389 NTAPI
01390 RtlOemToUnicodeN(
01391   _Out_writes_bytes_to_(MaxBytesInUnicodeString, *BytesInUnicodeString) PWSTR UnicodeString,
01392   _In_ ULONG MaxBytesInUnicodeString,
01393   _Out_opt_ PULONG BytesInUnicodeString,
01394   _In_reads_bytes_(BytesInOemString) PCCH OemString,
01395   _In_ ULONG BytesInOemString);
01396 
01397 _IRQL_requires_max_(PASSIVE_LEVEL)
01398 NTSYSAPI
01399 NTSTATUS
01400 NTAPI
01401 RtlUnicodeToOemN(
01402   _Out_writes_bytes_to_(MaxBytesInOemString, *BytesInOemString) PCHAR OemString,
01403   _In_ ULONG MaxBytesInOemString,
01404   _Out_opt_ PULONG BytesInOemString,
01405   _In_reads_bytes_(BytesInUnicodeString) PCWCH UnicodeString,
01406   _In_ ULONG BytesInUnicodeString);
01407 
01408 _IRQL_requires_max_(PASSIVE_LEVEL)
01409 NTSYSAPI
01410 NTSTATUS
01411 NTAPI
01412 RtlUpcaseUnicodeToOemN(
01413   _Out_writes_bytes_to_(MaxBytesInOemString, *BytesInOemString) PCHAR OemString,
01414   _In_ ULONG MaxBytesInOemString,
01415   _Out_opt_ PULONG BytesInOemString,
01416   _In_reads_bytes_(BytesInUnicodeString) PCWCH UnicodeString,
01417   _In_ ULONG BytesInUnicodeString);
01418 
01419 #if (NTDDI_VERSION >= NTDDI_VISTASP1)
01420 _IRQL_requires_max_(PASSIVE_LEVEL)
01421 NTSYSAPI
01422 NTSTATUS
01423 NTAPI
01424 RtlGenerate8dot3Name(
01425   _In_ PCUNICODE_STRING Name,
01426   _In_ BOOLEAN AllowExtendedCharacters,
01427   _Inout_ PGENERATE_NAME_CONTEXT Context,
01428   _Inout_ PUNICODE_STRING Name8dot3);
01429 #else
01430 _IRQL_requires_max_(PASSIVE_LEVEL)
01431 NTSYSAPI
01432 VOID
01433 NTAPI
01434 RtlGenerate8dot3Name(
01435   _In_ PCUNICODE_STRING Name,
01436   _In_ BOOLEAN AllowExtendedCharacters,
01437   _Inout_ PGENERATE_NAME_CONTEXT Context,
01438   _Inout_ PUNICODE_STRING Name8dot3);
01439 #endif
01440 
01441 _IRQL_requires_max_(PASSIVE_LEVEL)
01442 _Must_inspect_result_
01443 NTSYSAPI
01444 BOOLEAN
01445 NTAPI
01446 RtlIsNameLegalDOS8Dot3(
01447   _In_ PCUNICODE_STRING Name,
01448   _Inout_opt_ POEM_STRING OemName,
01449   _Out_opt_ PBOOLEAN NameContainsSpaces);
01450 
01451 _IRQL_requires_max_(PASSIVE_LEVEL)
01452 _Must_inspect_result_
01453 NTSYSAPI
01454 BOOLEAN
01455 NTAPI
01456 RtlIsValidOemCharacter(
01457   _Inout_ PWCHAR Char);
01458 
01459 _IRQL_requires_max_(PASSIVE_LEVEL)
01460 NTSYSAPI
01461 VOID
01462 NTAPI
01463 PfxInitialize(
01464   _Out_ PPREFIX_TABLE PrefixTable);
01465 
01466 _IRQL_requires_max_(PASSIVE_LEVEL)
01467 NTSYSAPI
01468 BOOLEAN
01469 NTAPI
01470 PfxInsertPrefix(
01471   _In_ PPREFIX_TABLE PrefixTable,
01472   _In_ __drv_aliasesMem PSTRING Prefix,
01473   _Out_ PPREFIX_TABLE_ENTRY PrefixTableEntry);
01474 
01475 _IRQL_requires_max_(PASSIVE_LEVEL)
01476 NTSYSAPI
01477 VOID
01478 NTAPI
01479 PfxRemovePrefix(
01480   _In_ PPREFIX_TABLE PrefixTable,
01481   _In_ PPREFIX_TABLE_ENTRY PrefixTableEntry);
01482 
01483 _IRQL_requires_max_(PASSIVE_LEVEL)
01484 _Must_inspect_result_
01485 NTSYSAPI
01486 PPREFIX_TABLE_ENTRY
01487 NTAPI
01488 PfxFindPrefix(
01489   _In_ PPREFIX_TABLE PrefixTable,
01490   _In_ PSTRING FullName);
01491 
01492 _IRQL_requires_max_(PASSIVE_LEVEL)
01493 NTSYSAPI
01494 VOID
01495 NTAPI
01496 RtlInitializeUnicodePrefix(
01497   _Out_ PUNICODE_PREFIX_TABLE PrefixTable);
01498 
01499 _IRQL_requires_max_(PASSIVE_LEVEL)
01500 NTSYSAPI
01501 BOOLEAN
01502 NTAPI
01503 RtlInsertUnicodePrefix(
01504   _In_ PUNICODE_PREFIX_TABLE PrefixTable,
01505   _In_ __drv_aliasesMem PUNICODE_STRING Prefix,
01506   _Out_ PUNICODE_PREFIX_TABLE_ENTRY PrefixTableEntry);
01507 
01508 _IRQL_requires_max_(PASSIVE_LEVEL)
01509 NTSYSAPI
01510 VOID
01511 NTAPI
01512 RtlRemoveUnicodePrefix(
01513   _In_ PUNICODE_PREFIX_TABLE PrefixTable,
01514   _In_ PUNICODE_PREFIX_TABLE_ENTRY PrefixTableEntry);
01515 
01516 _IRQL_requires_max_(PASSIVE_LEVEL)
01517 _Must_inspect_result_
01518 NTSYSAPI
01519 PUNICODE_PREFIX_TABLE_ENTRY
01520 NTAPI
01521 RtlFindUnicodePrefix(
01522   _In_ PUNICODE_PREFIX_TABLE PrefixTable,
01523   _In_ PUNICODE_STRING FullName,
01524   _In_ ULONG CaseInsensitiveIndex);
01525 
01526 _IRQL_requires_max_(PASSIVE_LEVEL)
01527 _Must_inspect_result_
01528 NTSYSAPI
01529 PUNICODE_PREFIX_TABLE_ENTRY
01530 NTAPI
01531 RtlNextUnicodePrefix(
01532   _In_ PUNICODE_PREFIX_TABLE PrefixTable,
01533   _In_ BOOLEAN Restart);
01534 
01535 _Must_inspect_result_
01536 NTSYSAPI
01537 SIZE_T
01538 NTAPI
01539 RtlCompareMemoryUlong(
01540   _In_reads_bytes_(Length) PVOID Source,
01541   _In_ SIZE_T Length,
01542   _In_ ULONG Pattern);
01543 
01544 _Success_(return != 0)
01545 NTSYSAPI
01546 BOOLEAN
01547 NTAPI
01548 RtlTimeToSecondsSince1980(
01549   _In_ PLARGE_INTEGER Time,
01550   _Out_ PULONG ElapsedSeconds);
01551 
01552 NTSYSAPI
01553 VOID
01554 NTAPI
01555 RtlSecondsSince1980ToTime(
01556   _In_ ULONG ElapsedSeconds,
01557   _Out_ PLARGE_INTEGER Time);
01558 
01559 _Success_(return != 0)
01560 NTSYSAPI
01561 BOOLEAN
01562 NTAPI
01563 RtlTimeToSecondsSince1970(
01564   _In_ PLARGE_INTEGER Time,
01565   _Out_ PULONG ElapsedSeconds);
01566 
01567 NTSYSAPI
01568 VOID
01569 NTAPI
01570 RtlSecondsSince1970ToTime(
01571   _In_ ULONG ElapsedSeconds,
01572   _Out_ PLARGE_INTEGER Time);
01573 
01574 _IRQL_requires_max_(APC_LEVEL)
01575 _Must_inspect_result_
01576 NTSYSAPI
01577 BOOLEAN
01578 NTAPI
01579 RtlValidSid(
01580   _In_ PSID Sid);
01581 
01582 _Must_inspect_result_
01583 NTSYSAPI
01584 BOOLEAN
01585 NTAPI
01586 RtlEqualSid(
01587   _In_ PSID Sid1,
01588   _In_ PSID Sid2);
01589 
01590 _IRQL_requires_max_(APC_LEVEL)
01591 _Must_inspect_result_
01592 NTSYSAPI
01593 BOOLEAN
01594 NTAPI
01595 RtlEqualPrefixSid(
01596   _In_ PSID Sid1,
01597   _In_ PSID Sid2);
01598 
01599 _IRQL_requires_max_(APC_LEVEL)
01600 NTSYSAPI
01601 ULONG
01602 NTAPI
01603 RtlLengthRequiredSid(
01604   _In_ ULONG SubAuthorityCount);
01605 
01606 NTSYSAPI
01607 PVOID
01608 NTAPI
01609 RtlFreeSid(
01610   _In_ _Post_invalid_ PSID Sid);
01611 
01612 _Must_inspect_result_
01613 NTSYSAPI
01614 NTSTATUS
01615 NTAPI
01616 RtlAllocateAndInitializeSid(
01617   _In_ PSID_IDENTIFIER_AUTHORITY IdentifierAuthority,
01618   _In_ UCHAR SubAuthorityCount,
01619   _In_ ULONG SubAuthority0,
01620   _In_ ULONG SubAuthority1,
01621   _In_ ULONG SubAuthority2,
01622   _In_ ULONG SubAuthority3,
01623   _In_ ULONG SubAuthority4,
01624   _In_ ULONG SubAuthority5,
01625   _In_ ULONG SubAuthority6,
01626   _In_ ULONG SubAuthority7,
01627   _Outptr_ PSID *Sid);
01628 
01629 _IRQL_requires_max_(APC_LEVEL)
01630 NTSYSAPI
01631 NTSTATUS
01632 NTAPI
01633 RtlInitializeSid(
01634   _Out_ PSID Sid,
01635   _In_ PSID_IDENTIFIER_AUTHORITY IdentifierAuthority,
01636   _In_ UCHAR SubAuthorityCount);
01637 
01638 NTSYSAPI
01639 PULONG
01640 NTAPI
01641 RtlSubAuthoritySid(
01642   _In_ PSID Sid,
01643   _In_ ULONG SubAuthority);
01644 
01645 _Post_satisfies_(return >= 8 && return <= SECURITY_MAX_SID_SIZE)
01646 NTSYSAPI
01647 ULONG
01648 NTAPI
01649 RtlLengthSid(
01650   _In_ PSID Sid);
01651 
01652 _IRQL_requires_max_(APC_LEVEL)
01653 NTSYSAPI
01654 NTSTATUS
01655 NTAPI
01656 RtlCopySid(
01657   _In_ ULONG Length,
01658   _Out_writes_bytes_(Length) PSID Destination,
01659   _In_ PSID Source);
01660 
01661 _IRQL_requires_max_(APC_LEVEL)
01662 NTSYSAPI
01663 NTSTATUS
01664 NTAPI
01665 RtlConvertSidToUnicodeString(
01666   _Inout_ PUNICODE_STRING UnicodeString,
01667   _In_ PSID Sid,
01668   _In_ BOOLEAN AllocateDestinationString);
01669 
01670 _IRQL_requires_max_(APC_LEVEL)
01671 NTSYSAPI
01672 VOID
01673 NTAPI
01674 RtlCopyLuid(
01675   _Out_ PLUID DestinationLuid,
01676   _In_ PLUID SourceLuid);
01677 
01678 _IRQL_requires_max_(APC_LEVEL)
01679 NTSYSAPI
01680 NTSTATUS
01681 NTAPI
01682 RtlCreateAcl(
01683   _Out_writes_bytes_(AclLength) PACL Acl,
01684   _In_ ULONG AclLength,
01685   _In_ ULONG AclRevision);
01686 
01687 _IRQL_requires_max_(APC_LEVEL)
01688 NTSYSAPI
01689 NTSTATUS
01690 NTAPI
01691 RtlAddAce(
01692   _Inout_ PACL Acl,
01693   _In_ ULONG AceRevision,
01694   _In_ ULONG StartingAceIndex,
01695   _In_reads_bytes_(AceListLength) PVOID AceList,
01696   _In_ ULONG AceListLength);
01697 
01698 _IRQL_requires_max_(APC_LEVEL)
01699 NTSYSAPI
01700 NTSTATUS
01701 NTAPI
01702 RtlDeleteAce(
01703   _Inout_ PACL Acl,
01704   _In_ ULONG AceIndex);
01705 
01706 NTSYSAPI
01707 NTSTATUS
01708 NTAPI
01709 RtlGetAce(
01710   _In_ PACL Acl,
01711   _In_ ULONG AceIndex,
01712   _Outptr_ PVOID *Ace);
01713 
01714 _IRQL_requires_max_(APC_LEVEL)
01715 NTSYSAPI
01716 NTSTATUS
01717 NTAPI
01718 RtlAddAccessAllowedAce(
01719   _Inout_ PACL Acl,
01720   _In_ ULONG AceRevision,
01721   _In_ ACCESS_MASK AccessMask,
01722   _In_ PSID Sid);
01723 
01724 _IRQL_requires_max_(APC_LEVEL)
01725 NTSYSAPI
01726 NTSTATUS
01727 NTAPI
01728 RtlAddAccessAllowedAceEx(
01729   _Inout_ PACL Acl,
01730   _In_ ULONG AceRevision,
01731   _In_ ULONG AceFlags,
01732   _In_ ACCESS_MASK AccessMask,
01733   _In_ PSID Sid);
01734 
01735 _IRQL_requires_max_(APC_LEVEL)
01736 NTSYSAPI
01737 NTSTATUS
01738 NTAPI
01739 RtlCreateSecurityDescriptorRelative(
01740   _Out_ PISECURITY_DESCRIPTOR_RELATIVE SecurityDescriptor,
01741   _In_ ULONG Revision);
01742 
01743 NTSYSAPI
01744 NTSTATUS
01745 NTAPI
01746 RtlGetDaclSecurityDescriptor(
01747   _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
01748   _Out_ PBOOLEAN DaclPresent,
01749   _Out_ PACL *Dacl,
01750   _Out_ PBOOLEAN DaclDefaulted);
01751 
01752 _IRQL_requires_max_(APC_LEVEL)
01753 NTSYSAPI
01754 NTSTATUS
01755 NTAPI
01756 RtlSetOwnerSecurityDescriptor(
01757   _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
01758   _In_opt_ PSID Owner,
01759   _In_opt_ BOOLEAN OwnerDefaulted);
01760 
01761 _IRQL_requires_max_(APC_LEVEL)
01762 NTSYSAPI
01763 NTSTATUS
01764 NTAPI
01765 RtlGetOwnerSecurityDescriptor(
01766   _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
01767   _Out_ PSID *Owner,
01768   _Out_ PBOOLEAN OwnerDefaulted);
01769 
01770 _IRQL_requires_max_(APC_LEVEL)
01771 _When_(Status < 0, _Out_range_(>, 0))
01772 _When_(Status >= 0, _Out_range_(==, 0))
01773 NTSYSAPI
01774 ULONG
01775 NTAPI
01776 RtlNtStatusToDosError(
01777   _In_ NTSTATUS Status);
01778 
01779 _IRQL_requires_max_(PASSIVE_LEVEL)
01780 NTSYSAPI
01781 NTSTATUS
01782 NTAPI
01783 RtlCustomCPToUnicodeN(
01784   _In_ PCPTABLEINFO CustomCP,
01785   _Out_writes_bytes_to_(MaxBytesInUnicodeString, *BytesInUnicodeString) PWCH UnicodeString,
01786   _In_ ULONG MaxBytesInUnicodeString,
01787   _Out_opt_ PULONG BytesInUnicodeString,
01788   _In_reads_bytes_(BytesInCustomCPString) PCH CustomCPString,
01789   _In_ ULONG BytesInCustomCPString);
01790 
01791 _IRQL_requires_max_(PASSIVE_LEVEL)
01792 NTSYSAPI
01793 NTSTATUS
01794 NTAPI
01795 RtlUnicodeToCustomCPN(
01796   _In_ PCPTABLEINFO CustomCP,
01797   _Out_writes_bytes_to_(MaxBytesInCustomCPString, *BytesInCustomCPString) PCH CustomCPString,
01798   _In_ ULONG MaxBytesInCustomCPString,
01799   _Out_opt_ PULONG BytesInCustomCPString,
01800   _In_reads_bytes_(BytesInUnicodeString) PWCH UnicodeString,
01801   _In_ ULONG BytesInUnicodeString);
01802 
01803 _IRQL_requires_max_(PASSIVE_LEVEL)
01804 NTSYSAPI
01805 NTSTATUS
01806 NTAPI
01807 RtlUpcaseUnicodeToCustomCPN(
01808   _In_ PCPTABLEINFO CustomCP,
01809   _Out_writes_bytes_to_(MaxBytesInCustomCPString, *BytesInCustomCPString) PCH CustomCPString,
01810   _In_ ULONG MaxBytesInCustomCPString,
01811   _Out_opt_ PULONG BytesInCustomCPString,
01812   _In_reads_bytes_(BytesInUnicodeString) PWCH UnicodeString,
01813   _In_ ULONG BytesInUnicodeString);
01814 
01815 _IRQL_requires_max_(PASSIVE_LEVEL)
01816 NTSYSAPI
01817 VOID
01818 NTAPI
01819 RtlInitCodePageTable(
01820   _In_ PUSHORT TableBase,
01821   _Inout_ PCPTABLEINFO CodePageTable);
01822 
01823 $endif (_NTIFS_)
01824 
01825 #endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */
01826 
01827 $if (_WDMDDK_)
01828 
01829 #if (NTDDI_VERSION >= NTDDI_WIN2KSP3)
01830 NTSYSAPI
01831 VOID
01832 FASTCALL
01833 RtlPrefetchMemoryNonTemporal(
01834   _In_ PVOID Source,
01835   _In_ SIZE_T Length);
01836 #endif
01837 
01838 $endif (_WDMDDK_)
01839 
01840 #if (NTDDI_VERSION >= NTDDI_WINXP)
01841 
01842 $if (_WDMDDK_)
01843 
01844 NTSYSAPI
01845 VOID
01846 NTAPI
01847 RtlClearBit(
01848   _In_ PRTL_BITMAP BitMapHeader,
01849   _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber);
01850 
01851 _IRQL_requires_max_(PASSIVE_LEVEL)
01852 NTSYSAPI
01853 WCHAR
01854 NTAPI
01855 RtlDowncaseUnicodeChar(
01856   _In_ WCHAR SourceCharacter);
01857 
01858 NTSYSAPI
01859 VOID
01860 NTAPI
01861 RtlSetBit(
01862   _In_ PRTL_BITMAP BitMapHeader,
01863   _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber);
01864 
01865 _Must_inspect_result_
01866 NTSYSAPI
01867 BOOLEAN
01868 NTAPI
01869 RtlTestBit(
01870   _In_ PRTL_BITMAP BitMapHeader,
01871   _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitNumber);
01872 
01873 _IRQL_requires_max_(PASSIVE_LEVEL)
01874 NTSYSAPI
01875 NTSTATUS
01876 NTAPI
01877 RtlHashUnicodeString(
01878   _In_ CONST UNICODE_STRING *String,
01879   _In_ BOOLEAN CaseInSensitive,
01880   _In_ ULONG HashAlgorithm,
01881   _Out_ PULONG HashValue);
01882 
01883 $endif (_WDMDDK_)
01884 
01885 $if (_NTDDK_)
01886 
01887 NTSYSAPI
01888 VOID
01889 NTAPI
01890 RtlInitializeGenericTableAvl(
01891   _Out_ PRTL_AVL_TABLE Table,
01892   _In_ PRTL_AVL_COMPARE_ROUTINE CompareRoutine,
01893   _In_opt_ PRTL_AVL_ALLOCATE_ROUTINE AllocateRoutine,
01894   _In_opt_ PRTL_AVL_FREE_ROUTINE FreeRoutine,
01895   _In_opt_ PVOID TableContext);
01896 
01897 NTSYSAPI
01898 PVOID
01899 NTAPI
01900 RtlInsertElementGenericTableAvl(
01901   _In_ PRTL_AVL_TABLE Table,
01902   _In_reads_bytes_(BufferSize) PVOID Buffer,
01903   _In_ CLONG BufferSize,
01904   _Out_opt_ PBOOLEAN NewElement);
01905 
01906 NTSYSAPI
01907 PVOID
01908 NTAPI
01909 RtlInsertElementGenericTableFullAvl(
01910   _In_ PRTL_AVL_TABLE Table,
01911   _In_reads_bytes_(BufferSize) PVOID Buffer,
01912   _In_ CLONG BufferSize,
01913   _Out_opt_ PBOOLEAN NewElement,
01914   _In_ PVOID NodeOrParent,
01915   _In_ TABLE_SEARCH_RESULT SearchResult);
01916 
01917 NTSYSAPI
01918 BOOLEAN
01919 NTAPI
01920 RtlDeleteElementGenericTableAvl(
01921   _In_ PRTL_AVL_TABLE Table,
01922   _In_ PVOID Buffer);
01923 
01924 _Must_inspect_result_
01925 NTSYSAPI
01926 PVOID
01927 NTAPI
01928 RtlLookupElementGenericTableAvl(
01929   _In_ PRTL_AVL_TABLE Table,
01930   _In_ PVOID Buffer);
01931 
01932 NTSYSAPI
01933 PVOID
01934 NTAPI
01935 RtlLookupElementGenericTableFullAvl(
01936   _In_ PRTL_AVL_TABLE Table,
01937   _In_ PVOID Buffer,
01938   _Out_ PVOID *NodeOrParent,
01939   _Out_ TABLE_SEARCH_RESULT *SearchResult);
01940 
01941 _Must_inspect_result_
01942 NTSYSAPI
01943 PVOID
01944 NTAPI
01945 RtlEnumerateGenericTableAvl(
01946   _In_ PRTL_AVL_TABLE Table,
01947   _In_ BOOLEAN Restart);
01948 
01949 _Must_inspect_result_
01950 NTSYSAPI
01951 PVOID
01952 NTAPI
01953 RtlEnumerateGenericTableWithoutSplayingAvl(
01954   _In_ PRTL_AVL_TABLE Table,
01955   _Inout_ PVOID *RestartKey);
01956 
01957 _Must_inspect_result_
01958 NTSYSAPI
01959 PVOID
01960 NTAPI
01961 RtlLookupFirstMatchingElementGenericTableAvl(
01962   _In_ PRTL_AVL_TABLE Table,
01963   _In_ PVOID Buffer,
01964   _Out_ PVOID *RestartKey);
01965 
01966 _Must_inspect_result_
01967 NTSYSAPI
01968 PVOID
01969 NTAPI
01970 RtlEnumerateGenericTableLikeADirectory(
01971   _In_ PRTL_AVL_TABLE Table,
01972   _In_opt_ PRTL_AVL_MATCH_FUNCTION MatchFunction,
01973   _In_opt_ PVOID MatchData,
01974   _In_ ULONG NextFlag,
01975   _Inout_ PVOID *RestartKey,
01976   _Inout_ PULONG DeleteCount,
01977   _In_ PVOID Buffer);
01978 
01979 _Must_inspect_result_
01980 NTSYSAPI
01981 PVOID
01982 NTAPI
01983 RtlGetElementGenericTableAvl(
01984   _In_ PRTL_AVL_TABLE Table,
01985   _In_ ULONG I);
01986 
01987 NTSYSAPI
01988 ULONG
01989 NTAPI
01990 RtlNumberGenericTableElementsAvl(
01991   _In_ PRTL_AVL_TABLE Table);
01992 
01993 _Must_inspect_result_
01994 NTSYSAPI
01995 BOOLEAN
01996 NTAPI
01997 RtlIsGenericTableEmptyAvl(
01998   _In_ PRTL_AVL_TABLE Table);
01999 
02000 $endif (_NTDDK_)
02001 $if (_NTIFS_)
02002 
02003 _Must_inspect_result_
02004 NTSYSAPI
02005 PVOID
02006 NTAPI
02007 RtlCreateHeap(
02008   _In_ ULONG Flags,
02009   _In_opt_ PVOID HeapBase,
02010   _In_opt_ SIZE_T ReserveSize,
02011   _In_opt_ SIZE_T CommitSize,
02012   _In_opt_ PVOID Lock,
02013   _In_opt_ PRTL_HEAP_PARAMETERS Parameters);
02014 
02015 NTSYSAPI
02016 PVOID
02017 NTAPI
02018 RtlDestroyHeap(
02019   _In_ _Post_invalid_ PVOID HeapHandle);
02020 
02021 NTSYSAPI
02022 USHORT
02023 NTAPI
02024 RtlCaptureStackBackTrace(
02025   _In_ ULONG FramesToSkip,
02026   _In_ ULONG FramesToCapture,
02027   _Out_writes_to_(FramesToCapture, return) PVOID *BackTrace,
02028   _Out_opt_ PULONG BackTraceHash);
02029 
02030 _Ret_range_(<, MAXLONG)
02031 NTSYSAPI
02032 ULONG
02033 NTAPI
02034 RtlRandomEx(
02035   _Inout_ PULONG Seed);
02036 
02037 _IRQL_requires_max_(DISPATCH_LEVEL)
02038 NTSYSAPI
02039 NTSTATUS
02040 NTAPI
02041 RtlInitUnicodeStringEx(
02042   _Out_ PUNICODE_STRING DestinationString,
02043   _In_opt_z_ __drv_aliasesMem PCWSTR SourceString);
02044 
02045 _Must_inspect_result_
02046 NTSYSAPI
02047 NTSTATUS
02048 NTAPI
02049 RtlValidateUnicodeString(
02050   _In_ ULONG Flags,
02051   _In_ PCUNICODE_STRING String);
02052 
02053 _IRQL_requires_max_(PASSIVE_LEVEL)
02054 _Must_inspect_result_
02055 NTSYSAPI
02056 NTSTATUS
02057 NTAPI
02058 RtlDuplicateUnicodeString(
02059   _In_ ULONG Flags,
02060   _In_ PCUNICODE_STRING SourceString,
02061   _Out_ _At_(DestinationString->Buffer, __drv_allocatesMem(Mem)) PUNICODE_STRING DestinationString);
02062 
02063 NTSYSAPI
02064 NTSTATUS
02065 NTAPI
02066 RtlGetCompressionWorkSpaceSize(
02067   _In_ USHORT CompressionFormatAndEngine,
02068   _Out_ PULONG CompressBufferWorkSpaceSize,
02069   _Out_ PULONG CompressFragmentWorkSpaceSize);
02070 
02071 NTSYSAPI
02072 NTSTATUS
02073 NTAPI
02074 RtlCompressBuffer(
02075   _In_ USHORT CompressionFormatAndEngine,
02076   _In_reads_bytes_(UncompressedBufferSize) PUCHAR UncompressedBuffer,
02077   _In_ ULONG UncompressedBufferSize,
02078   _Out_writes_bytes_to_(CompressedBufferSize, *FinalCompressedSize) PUCHAR CompressedBuffer,
02079   _In_ ULONG CompressedBufferSize,
02080   _In_ ULONG UncompressedChunkSize,
02081   _Out_ PULONG FinalCompressedSize,
02082   _In_ PVOID WorkSpace);
02083 
02084 _IRQL_requires_max_(APC_LEVEL)
02085 NTSYSAPI
02086 NTSTATUS
02087 NTAPI
02088 RtlDecompressBuffer(
02089   _In_ USHORT CompressionFormat,
02090   _Out_writes_bytes_to_(UncompressedBufferSize, *FinalUncompressedSize) PUCHAR UncompressedBuffer,
02091   _In_ ULONG UncompressedBufferSize,
02092   _In_reads_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer,
02093   _In_ ULONG CompressedBufferSize,
02094   _Out_ PULONG FinalUncompressedSize);
02095 
02096 _IRQL_requires_max_(APC_LEVEL)
02097 NTSYSAPI
02098 NTSTATUS
02099 NTAPI
02100 RtlDecompressFragment(
02101   _In_ USHORT CompressionFormat,
02102   _Out_writes_bytes_to_(UncompressedFragmentSize, *FinalUncompressedSize) PUCHAR UncompressedFragment,
02103   _In_ ULONG UncompressedFragmentSize,
02104   _In_reads_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer,
02105   _In_ ULONG CompressedBufferSize,
02106   _In_range_(<, CompressedBufferSize) ULONG FragmentOffset,
02107   _Out_ PULONG FinalUncompressedSize,
02108   _In_ PVOID WorkSpace);
02109 
02110 _IRQL_requires_max_(APC_LEVEL)
02111 NTSYSAPI
02112 NTSTATUS
02113 NTAPI
02114 RtlDescribeChunk(
02115   _In_ USHORT CompressionFormat,
02116   _Inout_ PUCHAR *CompressedBuffer,
02117   _In_ PUCHAR EndOfCompressedBufferPlus1,
02118   _Out_ PUCHAR *ChunkBuffer,
02119   _Out_ PULONG ChunkSize);
02120 
02121 _IRQL_requires_max_(APC_LEVEL)
02122 NTSYSAPI
02123 NTSTATUS
02124 NTAPI
02125 RtlReserveChunk(
02126   _In_ USHORT CompressionFormat,
02127   _Inout_ PUCHAR *CompressedBuffer,
02128   _In_ PUCHAR EndOfCompressedBufferPlus1,
02129   _Out_ PUCHAR *ChunkBuffer,
02130   _In_ ULONG ChunkSize);
02131 
02132 _IRQL_requires_max_(APC_LEVEL)
02133 NTSYSAPI
02134 NTSTATUS
02135 NTAPI
02136 RtlDecompressChunks(
02137   _Out_writes_bytes_(UncompressedBufferSize) PUCHAR UncompressedBuffer,
02138   _In_ ULONG UncompressedBufferSize,
02139   _In_reads_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer,
02140   _In_ ULONG CompressedBufferSize,
02141   _In_reads_bytes_(CompressedTailSize) PUCHAR CompressedTail,
02142   _In_ ULONG CompressedTailSize,
02143   _In_ PCOMPRESSED_DATA_INFO CompressedDataInfo);
02144 
02145 _IRQL_requires_max_(APC_LEVEL)
02146 NTSYSAPI
02147 NTSTATUS
02148 NTAPI
02149 RtlCompressChunks(
02150   _In_reads_bytes_(UncompressedBufferSize) PUCHAR UncompressedBuffer,
02151   _In_ ULONG UncompressedBufferSize,
02152   _Out_writes_bytes_(CompressedBufferSize) PUCHAR CompressedBuffer,
02153   _In_range_(>=, (UncompressedBufferSize - (UncompressedBufferSize / 16))) ULONG CompressedBufferSize,
02154   _Inout_updates_bytes_(CompressedDataInfoLength) PCOMPRESSED_DATA_INFO CompressedDataInfo,
02155   _In_range_(>, sizeof(COMPRESSED_DATA_INFO)) ULONG CompressedDataInfoLength,
02156   _In_ PVOID WorkSpace);
02157 
02158 _IRQL_requires_max_(APC_LEVEL)
02159 NTSYSAPI
02160 PSID_IDENTIFIER_AUTHORITY
02161 NTAPI
02162 RtlIdentifierAuthoritySid(
02163   _In_ PSID Sid);
02164 
02165 NTSYSAPI
02166 PUCHAR
02167 NTAPI
02168 RtlSubAuthorityCountSid(
02169   _In_ PSID Sid);
02170 
02171 _When_(Status < 0, _Out_range_(>, 0))
02172 _When_(Status >= 0, _Out_range_(==, 0))
02173 NTSYSAPI
02174 ULONG
02175 NTAPI
02176 RtlNtStatusToDosErrorNoTeb(
02177   _In_ NTSTATUS Status);
02178 
02179 _IRQL_requires_max_(PASSIVE_LEVEL)
02180 NTSYSAPI
02181 NTSTATUS
02182 NTAPI
02183 RtlCreateSystemVolumeInformationFolder(
02184   _In_ PCUNICODE_STRING VolumeRootPath);
02185 
02186 #if defined(_M_AMD64)
02187 
02188 FORCEINLINE
02189 VOID
02190 RtlFillMemoryUlong(
02191   _Out_writes_bytes_all_(Length) PVOID Destination,
02192   _In_ SIZE_T Length,
02193   _In_ ULONG Pattern)
02194 {
02195   PULONG Address = (PULONG)Destination;
02196   if ((Length /= 4) != 0) {
02197     if (((ULONG64)Address & 4) != 0) {
02198       *Address = Pattern;
02199       if ((Length -= 1) == 0) {
02200         return;
02201       }
02202       Address += 1;
02203     }
02204     __stosq((PULONG64)(Address), Pattern | ((ULONG64)Pattern << 32), Length / 2);
02205     if ((Length & 1) != 0) Address[Length - 1] = Pattern;
02206   }
02207   return;
02208 }
02209 
02210 #define RtlFillMemoryUlonglong(Destination, Length, Pattern)                \
02211     __stosq((PULONG64)(Destination), Pattern, (Length) / 8)
02212 
02213 #else
02214 
02215 NTSYSAPI
02216 VOID
02217 NTAPI
02218 RtlFillMemoryUlong(
02219   OUT PVOID Destination,
02220   IN SIZE_T Length,
02221   IN ULONG Pattern);
02222 
02223 NTSYSAPI
02224 VOID
02225 NTAPI
02226 RtlFillMemoryUlonglong(
02227   _Out_writes_bytes_all_(Length) PVOID Destination,
02228   _In_ SIZE_T Length,
02229   _In_ ULONGLONG Pattern);
02230 
02231 #endif /* defined(_M_AMD64) */
02232 $endif (_NTIFS_)
02233 
02234 #endif /* (NTDDI_VERSION >= NTDDI_WINXP) */
02235 
02236 $if (_NTIFS_)
02237 #if (NTDDI_VERSION >= NTDDI_WS03)
02238 _IRQL_requires_max_(DISPATCH_LEVEL)
02239 NTSYSAPI
02240 NTSTATUS
02241 NTAPI
02242 RtlInitAnsiStringEx(
02243   _Out_ PANSI_STRING DestinationString,
02244   _In_opt_z_ __drv_aliasesMem PCSZ SourceString);
02245 #endif
02246 
02247 #if (NTDDI_VERSION >= NTDDI_WS03SP1)
02248 
02249 _IRQL_requires_max_(APC_LEVEL)
02250 NTSYSAPI
02251 NTSTATUS
02252 NTAPI
02253 RtlGetSaclSecurityDescriptor(
02254   _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
02255   _Out_ PBOOLEAN SaclPresent,
02256   _Out_ PACL *Sacl,
02257   _Out_ PBOOLEAN SaclDefaulted);
02258 
02259 _IRQL_requires_max_(APC_LEVEL)
02260 NTSYSAPI
02261 NTSTATUS
02262 NTAPI
02263 RtlSetGroupSecurityDescriptor(
02264   _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
02265   _In_opt_ PSID Group,
02266   _In_opt_ BOOLEAN GroupDefaulted);
02267 
02268 _IRQL_requires_max_(APC_LEVEL)
02269 NTSYSAPI
02270 NTSTATUS
02271 NTAPI
02272 RtlGetGroupSecurityDescriptor(
02273   _In_ PSECURITY_DESCRIPTOR SecurityDescriptor,
02274   _Out_ PSID *Group,
02275   _Out_ PBOOLEAN GroupDefaulted);
02276 
02277 _IRQL_requires_max_(APC_LEVEL)
02278 NTSYSAPI
02279 NTSTATUS
02280 NTAPI
02281 RtlAbsoluteToSelfRelativeSD(
02282   _In_ PSECURITY_DESCRIPTOR AbsoluteSecurityDescriptor,
02283   _Out_writes_bytes_to_opt_(*BufferLength, *BufferLength) PSECURITY_DESCRIPTOR SelfRelativeSecurityDescriptor,
02284   _Inout_ PULONG BufferLength);
02285 
02286 _IRQL_requires_max_(APC_LEVEL)
02287 NTSYSAPI
02288 NTSTATUS
02289 NTAPI
02290 RtlSelfRelativeToAbsoluteSD(
02291   _In_ PSECURITY_DESCRIPTOR SelfRelativeSecurityDescriptor,
02292   _Out_writes_bytes_to_opt_(*AbsoluteSecurityDescriptorSize, *AbsoluteSecurityDescriptorSize) PSECURITY_DESCRIPTOR AbsoluteSecurityDescriptor,
02293   _Inout_ PULONG AbsoluteSecurityDescriptorSize,
02294   _Out_writes_bytes_to_opt_(*DaclSize, *DaclSize) PACL Dacl,
02295   _Inout_ PULONG DaclSize,
02296   _Out_writes_bytes_to_opt_(*SaclSize, *SaclSize) PACL Sacl,
02297   _Inout_ PULONG SaclSize,
02298   _Out_writes_bytes_to_opt_(*OwnerSize, *OwnerSize) PSID Owner,
02299   _Inout_ PULONG OwnerSize,
02300   _Out_writes_bytes_to_opt_(*PrimaryGroupSize, *PrimaryGroupSize) PSID PrimaryGroup,
02301   _Inout_ PULONG PrimaryGroupSize);
02302 
02303 #endif /* (NTDDI_VERSION >= NTDDI_WS03SP1) */
02304 $endif (_NTIFS_)
02305 
02306 #if (NTDDI_VERSION >= NTDDI_VISTA)
02307 
02308 $if (_WDMDDK_)
02309 NTSYSAPI
02310 ULONG
02311 NTAPI
02312 RtlNumberOfSetBitsUlongPtr(
02313   _In_ ULONG_PTR Target);
02314 
02315 NTSYSAPI
02316 ULONGLONG
02317 NTAPI
02318 RtlIoDecodeMemIoResource(
02319   _In_ struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
02320   _Out_opt_ PULONGLONG Alignment,
02321   _Out_opt_ PULONGLONG MinimumAddress,
02322   _Out_opt_ PULONGLONG MaximumAddress);
02323 
02324 NTSYSAPI
02325 NTSTATUS
02326 NTAPI
02327 RtlIoEncodeMemIoResource(
02328   _In_ struct _IO_RESOURCE_DESCRIPTOR *Descriptor,
02329   _In_ UCHAR Type,
02330   _In_ ULONGLONG Length,
02331   _In_ ULONGLONG Alignment,
02332   _In_ ULONGLONG MinimumAddress,
02333   _In_ ULONGLONG MaximumAddress);
02334 
02335 NTSYSAPI
02336 ULONGLONG
02337 NTAPI
02338 RtlCmDecodeMemIoResource(
02339   _In_ struct _CM_PARTIAL_RESOURCE_DESCRIPTOR *Descriptor,
02340   _Out_opt_ PULONGLONG Start);
02341 
02342 NTSYSAPI
02343 NTSTATUS
02344 NTAPI
02345 RtlFindClosestEncodableLength(
02346   _In_ ULONGLONG SourceLength,
02347   _Out_ PULONGLONG TargetLength);
02348 
02349 NTSYSAPI
02350 NTSTATUS
02351 NTAPI
02352 RtlCmEncodeMemIoResource(
02353   _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor,
02354   _In_ UCHAR Type,
02355   _In_ ULONGLONG Length,
02356   _In_ ULONGLONG Start);
02357 
02358 $endif (_WDMDDK_)
02359 $if (_NTDDK_)
02360 
02361 _IRQL_requires_max_(APC_LEVEL)
02362 NTSYSAPI
02363 VOID
02364 NTAPI
02365 RtlRunOnceInitialize(
02366   _Out_ PRTL_RUN_ONCE RunOnce);
02367 
02368 _IRQL_requires_max_(APC_LEVEL)
02369 _Maybe_raises_SEH_exception_
02370 NTSYSAPI
02371 NTSTATUS
02372 NTAPI
02373 RtlRunOnceExecuteOnce(
02374   _Inout_ PRTL_RUN_ONCE RunOnce,
02375   _In_ __inner_callback PRTL_RUN_ONCE_INIT_FN InitFn,
02376   _Inout_opt_ PVOID Parameter,
02377   _Outptr_opt_result_maybenull_ PVOID *Context);
02378 
02379 _IRQL_requires_max_(APC_LEVEL)
02380 _Must_inspect_result_
02381 NTSYSAPI
02382 NTSTATUS
02383 NTAPI
02384 RtlRunOnceBeginInitialize(
02385   _Inout_ PRTL_RUN_ONCE RunOnce,
02386   _In_ ULONG Flags,
02387   _Outptr_opt_result_maybenull_ PVOID *Context);
02388 
02389 _IRQL_requires_max_(APC_LEVEL)
02390 NTSYSAPI
02391 NTSTATUS
02392 NTAPI
02393 RtlRunOnceComplete(
02394   _Inout_ PRTL_RUN_ONCE RunOnce,
02395   _In_ ULONG Flags,
02396   _In_opt_ PVOID Context);
02397 
02398 NTSYSAPI
02399 BOOLEAN
02400 NTAPI
02401 RtlGetProductInfo(
02402   _In_ ULONG OSMajorVersion,
02403   _In_ ULONG OSMinorVersion,
02404   _In_ ULONG SpMajorVersion,
02405   _In_ ULONG SpMinorVersion,
02406   _Out_ PULONG ReturnedProductType);
02407 
02408 $endif (_NTDDK_)
02409 $if (_NTIFS_)
02410 NTSYSAPI
02411 NTSTATUS
02412 NTAPI
02413 RtlNormalizeString(
02414   _In_ ULONG NormForm,
02415   _In_ PCWSTR SourceString,
02416   _In_ LONG SourceStringLength,
02417   _Out_writes_to_(*DestinationStringLength, *DestinationStringLength) PWSTR DestinationString,
02418   _Inout_ PLONG DestinationStringLength);
02419 
02420 NTSYSAPI
02421 NTSTATUS
02422 NTAPI
02423 RtlIsNormalizedString(
02424   _In_ ULONG NormForm,
02425   _In_ PCWSTR SourceString,
02426   _In_ LONG SourceStringLength,
02427   _Out_ PBOOLEAN Normalized);
02428 
02429 NTSYSAPI
02430 NTSTATUS
02431 NTAPI
02432 RtlIdnToAscii(
02433   _In_ ULONG Flags,
02434   _In_ PCWSTR SourceString,
02435   _In_ LONG SourceStringLength,
02436   _Out_writes_to_(*DestinationStringLength, *DestinationStringLength) PWSTR DestinationString,
02437   _Inout_ PLONG DestinationStringLength);
02438 
02439 NTSYSAPI
02440 NTSTATUS
02441 NTAPI
02442 RtlIdnToUnicode(
02443   IN ULONG Flags,
02444   IN PCWSTR SourceString,
02445   IN LONG SourceStringLength,
02446   OUT PWSTR DestinationString,
02447   IN OUT PLONG DestinationStringLength);
02448 
02449 NTSYSAPI
02450 NTSTATUS
02451 NTAPI
02452 RtlIdnToNameprepUnicode(
02453   _In_ ULONG Flags,
02454   _In_ PCWSTR SourceString,
02455   _In_ LONG SourceStringLength,
02456   _Out_writes_to_(*DestinationStringLength, *DestinationStringLength) PWSTR DestinationString,
02457   _Inout_ PLONG DestinationStringLength);
02458 
02459 NTSYSAPI
02460 NTSTATUS
02461 NTAPI
02462 RtlCreateServiceSid(
02463   _In_ PUNICODE_STRING ServiceName,
02464   _Out_writes_bytes_opt_(*ServiceSidLength) PSID ServiceSid,
02465   _Inout_ PULONG ServiceSidLength);
02466 
02467 NTSYSAPI
02468 LONG
02469 NTAPI
02470 RtlCompareAltitudes(
02471   _In_ PCUNICODE_STRING Altitude1,
02472   _In_ PCUNICODE_STRING Altitude2);
02473 
02474 $endif (_NTIFS_)
02475 
02476 #endif /* (NTDDI_VERSION >= NTDDI_VISTA) */
02477 
02478 #if (NTDDI_VERSION >= NTDDI_WIN7)
02479 
02480 $if (_WDMDDK_)
02481 _IRQL_requires_max_(PASSIVE_LEVEL)
02482 _Must_inspect_result_
02483 NTSYSAPI
02484 NTSTATUS
02485 NTAPI
02486 RtlUnicodeToUTF8N(
02487   _Out_writes_bytes_to_(UTF8StringMaxByteCount, *UTF8StringActualByteCount)
02488     PCHAR UTF8StringDestination,
02489   _In_ ULONG UTF8StringMaxByteCount,
02490   _Out_ PULONG UTF8StringActualByteCount,
02491   _In_reads_bytes_(UnicodeStringByteCount) PCWCH UnicodeStringSource,
02492   _In_ ULONG UnicodeStringByteCount);
02493 
02494 _IRQL_requires_max_(PASSIVE_LEVEL)
02495 _Must_inspect_result_
02496 NTSYSAPI
02497 NTSTATUS
02498 NTAPI
02499 RtlUTF8ToUnicodeN(
02500   _Out_writes_bytes_to_(UnicodeStringMaxByteCount, *UnicodeStringActualByteCount)
02501     PWSTR UnicodeStringDestination,
02502   _In_ ULONG UnicodeStringMaxByteCount,
02503   _Out_ PULONG UnicodeStringActualByteCount,
02504   _In_reads_bytes_(UTF8StringByteCount) PCCH UTF8StringSource,
02505   _In_ ULONG UTF8StringByteCount);
02506 
02507 NTSYSAPI
02508 ULONG64
02509 NTAPI
02510 RtlGetEnabledExtendedFeatures(
02511   IN ULONG64 FeatureMask);
02512 
02513 $endif (_WDMDDK_)
02514 $if (_NTDDK_)
02515 
02516 _Must_inspect_result_
02517 NTSYSAPI
02518 BOOLEAN
02519 NTAPI
02520 RtlCreateHashTable(
02521   _Inout_ _When_(NULL == *HashTable, __drv_allocatesMem(Mem))
02522     PRTL_DYNAMIC_HASH_TABLE *HashTable,
02523   _In_ ULONG Shift,
02524   _In_ _Reserved_ ULONG Flags);
02525 
02526 NTSYSAPI
02527 VOID
02528 NTAPI
02529 RtlDeleteHashTable(
02530   _In_ _When_((HashTable->Flags & RTL_HASH_ALLOCATED_HEADER), __drv_freesMem(Mem) _Post_invalid_)
02531     PRTL_DYNAMIC_HASH_TABLE HashTable);
02532 
02533 NTSYSAPI
02534 BOOLEAN
02535 NTAPI
02536 RtlInsertEntryHashTable(
02537   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
02538   _In_ __drv_aliasesMem PRTL_DYNAMIC_HASH_TABLE_ENTRY Entry,
02539   _In_ ULONG_PTR Signature,
02540   _Inout_opt_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context);
02541 
02542 NTSYSAPI
02543 BOOLEAN
02544 NTAPI
02545 RtlRemoveEntryHashTable(
02546   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
02547   _In_ PRTL_DYNAMIC_HASH_TABLE_ENTRY Entry,
02548   _Inout_opt_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context);
02549 
02550 _Must_inspect_result_
02551 NTSYSAPI
02552 PRTL_DYNAMIC_HASH_TABLE_ENTRY
02553 NTAPI
02554 RtlLookupEntryHashTable(
02555   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
02556   _In_ ULONG_PTR Signature,
02557   _Out_opt_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context);
02558 
02559 _Must_inspect_result_
02560 NTSYSAPI
02561 PRTL_DYNAMIC_HASH_TABLE_ENTRY
02562 NTAPI
02563 RtlGetNextEntryHashTable(
02564   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
02565   _In_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context);
02566 
02567 NTSYSAPI
02568 BOOLEAN
02569 NTAPI
02570 RtlInitEnumerationHashTable(
02571   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
02572   _Out_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
02573 
02574 _Must_inspect_result_
02575 NTSYSAPI
02576 PRTL_DYNAMIC_HASH_TABLE_ENTRY
02577 NTAPI
02578 RtlEnumerateEntryHashTable(
02579   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
02580   _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
02581 
02582 NTSYSAPI
02583 VOID
02584 NTAPI
02585 RtlEndEnumerationHashTable(
02586   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
02587   _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
02588 
02589 NTSYSAPI
02590 BOOLEAN
02591 NTAPI
02592 RtlInitWeakEnumerationHashTable(
02593   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
02594   _Out_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
02595 
02596 _Must_inspect_result_
02597 NTSYSAPI
02598 PRTL_DYNAMIC_HASH_TABLE_ENTRY
02599 NTAPI
02600 RtlWeaklyEnumerateEntryHashTable(
02601   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
02602   _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
02603 
02604 NTSYSAPI
02605 VOID
02606 NTAPI
02607 RtlEndWeakEnumerationHashTable(
02608   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable,
02609   _Inout_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator);
02610 
02611 NTSYSAPI
02612 BOOLEAN
02613 NTAPI
02614 RtlExpandHashTable(
02615   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable);
02616 
02617 NTSYSAPI
02618 BOOLEAN
02619 NTAPI
02620 RtlContractHashTable(
02621   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable);
02622 
02623 $endif (_NTDDK_)
02624 $if (_NTIFS_)
02625 _IRQL_requires_max_(PASSIVE_LEVEL)
02626 _Must_inspect_result_
02627 NTSYSAPI
02628 NTSTATUS
02629 NTAPI
02630 RtlUnicodeToUTF8N(
02631   _Out_writes_bytes_to_(UTF8StringMaxByteCount, *UTF8StringActualByteCount) PCHAR UTF8StringDestination,
02632   _In_ ULONG UTF8StringMaxByteCount,
02633   _Out_ PULONG UTF8StringActualByteCount,
02634   _In_reads_bytes_(UnicodeStringByteCount) PCWCH UnicodeStringSource,
02635   _In_ ULONG UnicodeStringByteCount);
02636 
02637 _IRQL_requires_max_(PASSIVE_LEVEL)
02638 _Must_inspect_result_
02639 NTSYSAPI
02640 NTSTATUS
02641 NTAPI
02642 RtlUTF8ToUnicodeN(
02643   _Out_writes_bytes_to_(UnicodeStringMaxByteCount, *UnicodeStringActualByteCount) PWSTR UnicodeStringDestination,
02644   _In_ ULONG UnicodeStringMaxByteCount,
02645   _Out_ PULONG UnicodeStringActualByteCount,
02646   _In_reads_bytes_(UTF8StringByteCount) PCCH UTF8StringSource,
02647   _In_ ULONG UTF8StringByteCount);
02648 
02649 _IRQL_requires_max_(APC_LEVEL)
02650 NTSYSAPI
02651 NTSTATUS
02652 NTAPI
02653 RtlReplaceSidInSd(
02654   _Inout_ PSECURITY_DESCRIPTOR SecurityDescriptor,
02655   _In_ PSID OldSid,
02656   _In_ PSID NewSid,
02657   _Out_ ULONG *NumChanges);
02658 
02659 NTSYSAPI
02660 NTSTATUS
02661 NTAPI
02662 RtlCreateVirtualAccountSid(
02663   _In_ PCUNICODE_STRING Name,
02664   _In_ ULONG BaseSubAuthority,
02665   _Out_writes_bytes_(*SidLength) PSID Sid,
02666   _Inout_ PULONG SidLength);
02667 $endif (_NTIFS_)
02668 
02669 #endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
02670 
02671 $if (_WDMDDK_)
02672 
02673 #if !defined(MIDL_PASS)
02674 /* inline funftions */
02675 //DECLSPEC_DEPRECATED_DDK_WINXP
02676 static __inline
02677 LARGE_INTEGER
02678 NTAPI_INLINE
02679 RtlConvertLongToLargeInteger(
02680   _In_ LONG SignedInteger)
02681 {
02682   LARGE_INTEGER ret;
02683   ret.QuadPart = SignedInteger;
02684   return ret;
02685 }
02686 
02687 //DECLSPEC_DEPRECATED_DDK_WINXP
02688 static __inline
02689 LARGE_INTEGER
02690 NTAPI_INLINE
02691 RtlConvertUlongToLargeInteger(
02692   _In_ ULONG UnsignedInteger)
02693 {
02694   LARGE_INTEGER ret;
02695   ret.QuadPart = UnsignedInteger;
02696   return ret;
02697 }
02698 
02699 //DECLSPEC_DEPRECATED_DDK_WINXP
02700 static __inline
02701 LARGE_INTEGER
02702 NTAPI_INLINE
02703 RtlLargeIntegerShiftLeft(
02704   _In_ LARGE_INTEGER LargeInteger,
02705   _In_ CCHAR ShiftCount)
02706 {
02707   LARGE_INTEGER Result;
02708 
02709   Result.QuadPart = LargeInteger.QuadPart << ShiftCount;
02710   return Result;
02711 }
02712 
02713 //DECLSPEC_DEPRECATED_DDK_WINXP
02714 static __inline
02715 LARGE_INTEGER
02716 NTAPI_INLINE
02717 RtlLargeIntegerShiftRight(
02718   _In_ LARGE_INTEGER LargeInteger,
02719   _In_ CCHAR ShiftCount)
02720 {
02721   LARGE_INTEGER Result;
02722 
02723   Result.QuadPart = (ULONG64)LargeInteger.QuadPart >> ShiftCount;
02724   return Result;
02725 }
02726 
02727 //DECLSPEC_DEPRECATED_DDK
02728 static __inline
02729 ULONG
02730 NTAPI_INLINE
02731 RtlEnlargedUnsignedDivide(
02732   _In_ ULARGE_INTEGER Dividend,
02733   _In_ ULONG Divisor,
02734   _Out_opt_ PULONG Remainder)
02735 {
02736   if (Remainder)
02737     *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
02738   return (ULONG)(Dividend.QuadPart / Divisor);
02739 }
02740 
02741 //DECLSPEC_DEPRECATED_DDK
02742 static __inline
02743 LARGE_INTEGER
02744 NTAPI_INLINE
02745 RtlLargeIntegerNegate(
02746   _In_ LARGE_INTEGER Subtrahend)
02747 {
02748   LARGE_INTEGER Difference;
02749 
02750   Difference.QuadPart = -Subtrahend.QuadPart;
02751   return Difference;
02752 }
02753 
02754 //DECLSPEC_DEPRECATED_DDK
02755 static __inline
02756 LARGE_INTEGER
02757 NTAPI_INLINE
02758 RtlLargeIntegerSubtract(
02759   _In_ LARGE_INTEGER Minuend,
02760   _In_ LARGE_INTEGER Subtrahend)
02761 {
02762   LARGE_INTEGER Difference;
02763 
02764   Difference.QuadPart = Minuend.QuadPart - Subtrahend.QuadPart;
02765   return Difference;
02766 }
02767 
02768 //DECLSPEC_DEPRECATED_DDK
02769 static __inline
02770 LARGE_INTEGER
02771 NTAPI_INLINE
02772 RtlEnlargedUnsignedMultiply(
02773   _In_ ULONG Multiplicand,
02774   _In_ ULONG Multiplier)
02775 {
02776   LARGE_INTEGER ret;
02777   ret.QuadPart = (ULONGLONG)Multiplicand * (ULONGLONG)Multiplier;
02778   return ret;
02779 }
02780 
02781 //DECLSPEC_DEPRECATED_DDK
02782 static __inline
02783 LARGE_INTEGER
02784 NTAPI_INLINE
02785 RtlEnlargedIntegerMultiply(
02786   _In_ LONG Multiplicand,
02787   _In_ LONG Multiplier)
02788 {
02789   LARGE_INTEGER ret;
02790   ret.QuadPart = (LONGLONG)Multiplicand * (ULONGLONG)Multiplier;
02791   return ret;
02792 }
02793 
02794 _At_(AnsiString->Buffer, _Post_equal_to_(Buffer))
02795 _At_(AnsiString->Length, _Post_equal_to_(0))
02796 _At_(AnsiString->MaximumLength, _Post_equal_to_(BufferSize))
02797 FORCEINLINE
02798 VOID
02799 RtlInitEmptyAnsiString(
02800   _Out_ PANSI_STRING AnsiString,
02801   _Pre_maybenull_ _Pre_readable_size_(BufferSize) __drv_aliasesMem PCHAR Buffer,
02802   _In_ USHORT BufferSize)
02803 {
02804   AnsiString->Length = 0;
02805   AnsiString->MaximumLength = BufferSize;
02806   AnsiString->Buffer = Buffer;
02807 }
02808 
02809 _At_(UnicodeString->Buffer, _Post_equal_to_(Buffer))
02810 _At_(UnicodeString->Length, _Post_equal_to_(0))
02811 _At_(UnicodeString->MaximumLength, _Post_equal_to_(BufferSize))
02812 FORCEINLINE
02813 VOID
02814 RtlInitEmptyUnicodeString(
02815     _Out_ PUNICODE_STRING UnicodeString,
02816     _Writable_bytes_(BufferSize)
02817     _When_(BufferSize != 0, _Notnull_)
02818     __drv_aliasesMem PWSTR Buffer,
02819     _In_ USHORT BufferSize)
02820 {
02821     UnicodeString->Length = 0;
02822     UnicodeString->MaximumLength = BufferSize;
02823     UnicodeString->Buffer = Buffer;
02824 }
02825 $endif (_WDMDDK_)
02826 
02827 #if defined(_AMD64_) || defined(_IA64_)
02828 
02829 $if (_WDMDDK_)
02830 
02831 static __inline
02832 LARGE_INTEGER
02833 NTAPI_INLINE
02834 RtlExtendedIntegerMultiply(
02835   _In_ LARGE_INTEGER Multiplicand,
02836   _In_ LONG Multiplier)
02837 {
02838   LARGE_INTEGER ret;
02839   ret.QuadPart = Multiplicand.QuadPart * Multiplier;
02840   return ret;
02841 }
02842 
02843 static __inline
02844 LARGE_INTEGER
02845 NTAPI_INLINE
02846 RtlExtendedLargeIntegerDivide(
02847   _In_ LARGE_INTEGER Dividend,
02848   _In_ ULONG Divisor,
02849   _Out_opt_ PULONG Remainder)
02850 {
02851   LARGE_INTEGER ret;
02852   ret.QuadPart = (ULONG64)Dividend.QuadPart / Divisor;
02853   if (Remainder)
02854     *Remainder = (ULONG)(Dividend.QuadPart % Divisor);
02855   return ret;
02856 }
02857 
02858 $endif (_WDMDDK_)
02859 
02860 $if (_NTDDK_)
02861 
02862 //DECLSPEC_DEPRECATED_DDK_WINXP
02863 FORCEINLINE
02864 LARGE_INTEGER
02865 NTAPI_INLINE
02866 RtlLargeIntegerDivide(
02867   _In_ LARGE_INTEGER Dividend,
02868   _In_ LARGE_INTEGER Divisor,
02869   _Out_opt_ PLARGE_INTEGER Remainder)
02870 {
02871   LARGE_INTEGER ret;
02872   ret.QuadPart = Dividend.QuadPart / Divisor.QuadPart;
02873   if (Remainder)
02874     Remainder->QuadPart = Dividend.QuadPart % Divisor.QuadPart;
02875   return ret;
02876 }
02877 
02878 #else
02879 
02880 #if (NTDDI_VERSION >= NTDDI_WIN2K)
02881 NTSYSAPI
02882 LARGE_INTEGER
02883 NTAPI
02884 RtlLargeIntegerDivide(
02885   _In_ LARGE_INTEGER Dividend,
02886   _In_ LARGE_INTEGER Divisor,
02887   _Out_opt_ PLARGE_INTEGER Remainder);
02888 #endif
02889 
02890 $endif (_NTDDK_)
02891 
02892 #endif /* defined(_AMD64_) || defined(_IA64_) */
02893 
02894 $if (_WDMDDK_)
02895 
02896 #if defined(_AMD64_)
02897 
02898 #define MultiplyHigh __mulh
02899 #define UnsignedMultiplyHigh __umulh
02900 
02901 //DECLSPEC_DEPRECATED_DDK
02902 static __inline
02903 LARGE_INTEGER
02904 NTAPI_INLINE
02905 RtlExtendedMagicDivide(
02906   _In_ LARGE_INTEGER Dividend,
02907   _In_ LARGE_INTEGER MagicDivisor,
02908   _In_ CCHAR ShiftCount)
02909 {
02910   LARGE_INTEGER ret;
02911   ULONG64 ret64;
02912   BOOLEAN Pos;
02913   Pos = (Dividend.QuadPart >= 0);
02914   ret64 = UnsignedMultiplyHigh(Pos ? Dividend.QuadPart : -Dividend.QuadPart,
02915                                MagicDivisor.QuadPart);
02916   ret64 >>= ShiftCount;
02917   ret.QuadPart = Pos ? ret64 : -(LONG64)ret64;
02918   return ret;
02919 }
02920 #endif
02921 
02922 //DECLSPEC_DEPRECATED_DDK
02923 static __inline
02924 LARGE_INTEGER
02925 NTAPI_INLINE
02926 RtlLargeIntegerAdd(
02927   _In_ LARGE_INTEGER Addend1,
02928   _In_ LARGE_INTEGER Addend2)
02929 {
02930   LARGE_INTEGER ret;
02931   ret.QuadPart = Addend1.QuadPart + Addend2.QuadPart;
02932   return ret;
02933 }
02934 
02935 /* VOID
02936  * RtlLargeIntegerAnd(
02937  *     IN OUT LARGE_INTEGER Result,
02938  *     IN LARGE_INTEGER Source,
02939  *     IN LARGE_INTEGER Mask);
02940  */
02941 #define RtlLargeIntegerAnd(Result, Source, Mask) \
02942     Result.QuadPart = Source.QuadPart & Mask.QuadPart
02943 
02944 //DECLSPEC_DEPRECATED_DDK
02945 static __inline
02946 LARGE_INTEGER
02947 NTAPI_INLINE
02948 RtlLargeIntegerArithmeticShift(
02949   _In_ LARGE_INTEGER LargeInteger,
02950   _In_ CCHAR ShiftCount)
02951 {
02952   LARGE_INTEGER ret;
02953   ret.QuadPart = LargeInteger.QuadPart >> ShiftCount;
02954   return ret;
02955 }
02956 
02957 /* BOOLEAN
02958  * RtlLargeIntegerEqualTo(
02959  *     IN LARGE_INTEGER  Operand1,
02960  *     IN LARGE_INTEGER  Operand2);
02961  */
02962 #define RtlLargeIntegerEqualTo(X,Y) \
02963     (!(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)))
02964 
02965 FORCEINLINE
02966 PVOID
02967 RtlSecureZeroMemory(
02968   _Out_writes_bytes_all_(Size) PVOID Pointer,
02969   _In_ SIZE_T Size)
02970 {
02971   volatile char* vptr = (volatile char*)Pointer;
02972 #if defined(_M_AMD64)
02973   __stosb((PUCHAR)vptr, 0, Size);
02974 #else
02975   char * endptr = (char *)vptr + Size;
02976   while (vptr < endptr) {
02977     *vptr = 0; vptr++;
02978   }
02979 #endif
02980    return Pointer;
02981 }
02982 
02983 #if defined(_M_AMD64)
02984 _Must_inspect_result_
02985 FORCEINLINE
02986 BOOLEAN
02987 RtlCheckBit(
02988   _In_ PRTL_BITMAP BitMapHeader,
02989   _In_range_(<, BitMapHeader->SizeOfBitMap) ULONG BitPosition)
02990 {
02991   return BitTest64((LONG64 CONST*)BitMapHeader->Buffer, (LONG64)BitPosition);
02992 }
02993 #else
02994 #define RtlCheckBit(BMH,BP) (((((PLONG)(BMH)->Buffer)[(BP)/32]) >> ((BP)%32)) & 0x1)
02995 #endif /* defined(_M_AMD64) */
02996 
02997 #define RtlLargeIntegerGreaterThan(X,Y) (                              \
02998     (((X).HighPart == (Y).HighPart) && ((X).LowPart > (Y).LowPart)) || \
02999     ((X).HighPart > (Y).HighPart)                                      \
03000 )
03001 
03002 #define RtlLargeIntegerGreaterThanOrEqualTo(X,Y) (                      \
03003     (((X).HighPart == (Y).HighPart) && ((X).LowPart >= (Y).LowPart)) || \
03004     ((X).HighPart > (Y).HighPart)                                       \
03005 )
03006 
03007 #define RtlLargeIntegerNotEqualTo(X,Y) (                          \
03008     (((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)) \
03009 )
03010 
03011 #define RtlLargeIntegerLessThan(X,Y) (                                 \
03012     (((X).HighPart == (Y).HighPart) && ((X).LowPart < (Y).LowPart)) || \
03013     ((X).HighPart < (Y).HighPart)                                      \
03014 )
03015 
03016 #define RtlLargeIntegerLessThanOrEqualTo(X,Y) (                         \
03017     (((X).HighPart == (Y).HighPart) && ((X).LowPart <= (Y).LowPart)) || \
03018     ((X).HighPart < (Y).HighPart)                                       \
03019 )
03020 
03021 #define RtlLargeIntegerGreaterThanZero(X) (       \
03022     (((X).HighPart == 0) && ((X).LowPart > 0)) || \
03023     ((X).HighPart > 0 )                           \
03024 )
03025 
03026 #define RtlLargeIntegerGreaterOrEqualToZero(X) ( (X).HighPart >= 0 )
03027 
03028 #define RtlLargeIntegerEqualToZero(X) ( !((X).LowPart | (X).HighPart) )
03029 
03030 #define RtlLargeIntegerNotEqualToZero(X) ( ((X).LowPart | (X).HighPart) )
03031 
03032 #define RtlLargeIntegerLessThanZero(X) ( ((X).HighPart < 0) )
03033 
03034 #define RtlLargeIntegerLessOrEqualToZero(X) ( ((X).HighPart < 0) || !((X).LowPart | (X).HighPart) )
03035 
03036 #endif /* !defined(MIDL_PASS) */
03037 
03038 /* Byte Swap Functions */
03039 #if (defined(_M_IX86) && (_MSC_FULL_VER > 13009037 || defined(__GNUC__))) || \
03040     ((defined(_M_AMD64) || defined(_M_IA64)) \
03041         && (_MSC_FULL_VER > 13009175 || defined(__GNUC__)))
03042 
03043 #define RtlUshortByteSwap(_x) _byteswap_ushort((USHORT)(_x))
03044 #define RtlUlongByteSwap(_x) _byteswap_ulong((_x))
03045 #define RtlUlonglongByteSwap(_x) _byteswap_uint64((_x))
03046 
03047 #endif
03048 
03049 #if DBG
03050 
03051 #define ASSERT(exp) \
03052   (VOID)((!(exp)) ? \
03053     RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, NULL ), FALSE : TRUE)
03054 
03055 #define ASSERTMSG(msg, exp) \
03056   (VOID)((!(exp)) ? \
03057     RtlAssert( (PVOID)#exp, (PVOID)__FILE__, __LINE__, (PCHAR)msg ), FALSE : TRUE)
03058 
03059 #define RTL_SOFT_ASSERT(exp) \
03060   (VOID)((!(exp)) ? \
03061     DbgPrint("%s(%d): Soft assertion failed\n   Expression: %s\n", __FILE__, __LINE__, #exp), FALSE : TRUE)
03062 
03063 #define RTL_SOFT_ASSERTMSG(msg, exp) \
03064   (VOID)((!(exp)) ? \
03065     DbgPrint("%s(%d): Soft assertion failed\n   Expression: %s\n   Message: %s\n", __FILE__, __LINE__, #exp, (msg)), FALSE : TRUE)
03066 
03067 #define RTL_VERIFY(exp) ASSERT(exp)
03068 #define RTL_VERIFYMSG(msg, exp) ASSERTMSG(msg, exp)
03069 
03070 #define RTL_SOFT_VERIFY(exp) RTL_SOFT_ASSERT(exp)
03071 #define RTL_SOFT_VERIFYMSG(msg, exp) RTL_SOFT_ASSERTMSG(msg, exp)
03072 
03073 #if defined(_MSC_VER)
03074 
03075 #define NT_ASSERT(exp) \
03076    ((!(exp)) ? \
03077       (__annotation(L"Debug", L"AssertFail", L#exp), \
03078        DbgRaiseAssertionFailure(), FALSE) : TRUE)
03079 
03080 #define NT_ASSERTMSG(msg, exp) \
03081    ((!(exp)) ? \
03082       (__annotation(L"Debug", L"AssertFail", L##msg), \
03083       DbgRaiseAssertionFailure(), FALSE) : TRUE)
03084 
03085 #define NT_ASSERTMSGW(msg, exp) \
03086     ((!(exp)) ? \
03087         (__annotation(L"Debug", L"AssertFail", msg), \
03088          DbgRaiseAssertionFailure(), FALSE) : TRUE)
03089 
03090 #define NT_VERIFY     NT_ASSERT
03091 #define NT_VERIFYMSG  NT_ASSERTMSG
03092 #define NT_VERIFYMSGW NT_ASSERTMSGW
03093 
03094 #else
03095 
03096 /* GCC doesn't support __annotation (nor PDB) */
03097 #define NT_ASSERT(exp) \
03098    (VOID)((!(exp)) ? (DbgRaiseAssertionFailure(), FALSE) : TRUE)
03099 
03100 #define NT_ASSERTMSG NT_ASSERT
03101 #define NT_ASSERTMSGW NT_ASSERT
03102 
03103 #endif
03104 
03105 #else /* !DBG */
03106 
03107 #define ASSERT(exp) ((VOID) 0)
03108 #define ASSERTMSG(msg, exp) ((VOID) 0)
03109 
03110 #define RTL_SOFT_ASSERT(exp) ((VOID) 0)
03111 #define RTL_SOFT_ASSERTMSG(msg, exp) ((VOID) 0)
03112 
03113 #define RTL_VERIFY(exp) ((exp) ? TRUE : FALSE)
03114 #define RTL_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)
03115 
03116 #define RTL_SOFT_VERIFY(exp) ((exp) ? TRUE : FALSE)
03117 #define RTL_SOFT_VERIFYMSG(msg, exp) ((exp) ? TRUE : FALSE)
03118 
03119 #define NT_ASSERT(exp)          ((VOID)0)
03120 #define NT_ASSERTMSG(msg, exp)  ((VOID)0)
03121 #define NT_ASSERTMSGW(msg, exp) ((VOID)0)
03122 
03123 #define NT_VERIFY(_exp)           ((_exp) ? TRUE : FALSE)
03124 #define NT_VERIFYMSG(_msg, _exp ) ((_exp) ? TRUE : FALSE)
03125 #define NT_VERIFYMSGW(_msg, _exp) ((_exp) ? TRUE : FALSE)
03126 
03127 #endif /* DBG */
03128 
03129 #define InitializeListHead32(ListHead) (\
03130     (ListHead)->Flink = (ListHead)->Blink = PtrToUlong((ListHead)))
03131 
03132 #if !defined(_WINBASE_)
03133 
03134 #if defined(_WIN64) && (defined(_NTDRIVER_) || defined(_NTDDK_) || defined(_NTIFS_) || defined(_NTHAL_) || defined(_NTOSP_))
03135 
03136 NTKERNELAPI
03137 VOID
03138 InitializeSListHead(
03139   _Out_ PSLIST_HEADER SListHead);
03140 
03141 #else
03142 
03143 FORCEINLINE
03144 VOID
03145 InitializeSListHead(
03146   _Out_ PSLIST_HEADER SListHead)
03147 {
03148 #if defined(_IA64_)
03149   ULONG64 FeatureBits;
03150 #endif
03151 
03152 #if defined(_WIN64)
03153   if (((ULONG_PTR)SListHead & 0xf) != 0) {
03154     RtlRaiseStatus(STATUS_DATATYPE_MISALIGNMENT);
03155   }
03156 #endif
03157   RtlZeroMemory(SListHead, sizeof(SLIST_HEADER));
03158 #if defined(_IA64_)
03159   FeatureBits = __getReg(CV_IA64_CPUID4);
03160   if ((FeatureBits & KF_16BYTE_INSTR) != 0) {
03161     SListHead->Header16.HeaderType = 1;
03162     SListHead->Header16.Init = 1;
03163   }
03164 #endif
03165 }
03166 
03167 #endif
03168 
03169 #if defined(_WIN64)
03170 
03171 #define InterlockedPopEntrySList(Head) \
03172     ExpInterlockedPopEntrySList(Head)
03173 
03174 #define InterlockedPushEntrySList(Head, Entry) \
03175     ExpInterlockedPushEntrySList(Head, Entry)
03176 
03177 #define InterlockedFlushSList(Head) \
03178     ExpInterlockedFlushSList(Head)
03179 
03180 #define QueryDepthSList(Head) \
03181     ExQueryDepthSList(Head)
03182 
03183 #else /* !defined(_WIN64) */
03184 
03185 NTKERNELAPI
03186 PSLIST_ENTRY
03187 FASTCALL
03188 InterlockedPopEntrySList(
03189   _Inout_ PSLIST_HEADER ListHead);
03190 
03191 NTKERNELAPI
03192 PSLIST_ENTRY
03193 FASTCALL
03194 InterlockedPushEntrySList(
03195   _Inout_ PSLIST_HEADER ListHead,
03196   _Inout_ __drv_aliasesMem PSLIST_ENTRY ListEntry);
03197 
03198 #define InterlockedFlushSList(ListHead) \
03199     ExInterlockedFlushSList(ListHead)
03200 
03201 #define QueryDepthSList(Head) \
03202     ExQueryDepthSList(Head)
03203 
03204 #endif /* !defined(_WIN64) */
03205 
03206 #endif /* !defined(_WINBASE_) */
03207 
03208 #define RTL_CONTEXT_EX_OFFSET(ContextEx, Chunk) ((ContextEx)->Chunk.Offset)
03209 #define RTL_CONTEXT_EX_LENGTH(ContextEx, Chunk) ((ContextEx)->Chunk.Length)
03210 #define RTL_CONTEXT_EX_CHUNK(Base, Layout, Chunk)       \
03211     ((PVOID)((PCHAR)(Base) + RTL_CONTEXT_EX_OFFSET(Layout, Chunk)))
03212 #define RTL_CONTEXT_OFFSET(Context, Chunk)              \
03213     RTL_CONTEXT_EX_OFFSET((PCONTEXT_EX)(Context + 1), Chunk)
03214 #define RTL_CONTEXT_LENGTH(Context, Chunk)              \
03215     RTL_CONTEXT_EX_LENGTH((PCONTEXT_EX)(Context + 1), Chunk)
03216 #define RTL_CONTEXT_CHUNK(Context, Chunk)               \
03217     RTL_CONTEXT_EX_CHUNK((PCONTEXT_EX)(Context + 1),    \
03218                          (PCONTEXT_EX)(Context + 1),    \
03219                          Chunk)
03220 
03221 BOOLEAN
03222 RTLVERLIB_DDI(RtlIsNtDdiVersionAvailable)(
03223   _In_ ULONG Version);
03224 
03225 BOOLEAN
03226 RTLVERLIB_DDI(RtlIsServicePackVersionInstalled)(
03227   _In_ ULONG Version);
03228 
03229 #ifndef RtlIsNtDdiVersionAvailable
03230 #define RtlIsNtDdiVersionAvailable WdmlibRtlIsNtDdiVersionAvailable
03231 #endif
03232 
03233 #ifndef RtlIsServicePackVersionInstalled
03234 #define RtlIsServicePackVersionInstalled WdmlibRtlIsServicePackVersionInstalled
03235 #endif
03236 
03237 #define RtlInterlockedSetBits(Flags, Flag) \
03238     InterlockedOr((PLONG)(Flags), Flag)
03239 
03240 #define RtlInterlockedAndBits(Flags, Flag) \
03241     InterlockedAnd((PLONG)(Flags), Flag)
03242 
03243 #define RtlInterlockedClearBits(Flags, Flag) \
03244     RtlInterlockedAndBits(Flags, ~(Flag))
03245 
03246 #define RtlInterlockedXorBits(Flags, Flag) \
03247     InterlockedXor(Flags, Flag)
03248 
03249 #define RtlInterlockedSetBitsDiscardReturn(Flags, Flag) \
03250     (VOID) RtlInterlockedSetBits(Flags, Flag)
03251 
03252 #define RtlInterlockedAndBitsDiscardReturn(Flags, Flag) \
03253     (VOID) RtlInterlockedAndBits(Flags, Flag)
03254 
03255 #define RtlInterlockedClearBitsDiscardReturn(Flags, Flag) \
03256     RtlInterlockedAndBitsDiscardReturn(Flags, ~(Flag))
03257 
03258 $endif (_WDMDDK_)
03259 
03260 $if (_NTDDK_)
03261 
03262 #ifdef RTL_USE_AVL_TABLES
03263 
03264 #define RtlInitializeGenericTable               RtlInitializeGenericTableAvl
03265 #define RtlInsertElementGenericTable            RtlInsertElementGenericTableAvl
03266 #define RtlInsertElementGenericTableFull        RtlInsertElementGenericTableFullAvl
03267 #define RtlDeleteElementGenericTable            RtlDeleteElementGenericTableAvl
03268 #define RtlLookupElementGenericTable            RtlLookupElementGenericTableAvl
03269 #define RtlLookupElementGenericTableFull        RtlLookupElementGenericTableFullAvl
03270 #define RtlEnumerateGenericTable                RtlEnumerateGenericTableAvl
03271 #define RtlEnumerateGenericTableWithoutSplaying RtlEnumerateGenericTableWithoutSplayingAvl
03272 #define RtlGetElementGenericTable               RtlGetElementGenericTableAvl
03273 #define RtlNumberGenericTableElements           RtlNumberGenericTableElementsAvl
03274 #define RtlIsGenericTableEmpty                  RtlIsGenericTableEmptyAvl
03275 
03276 #endif /* RTL_USE_AVL_TABLES */
03277 
03278 #define RtlInitializeSplayLinks(Links) {    \
03279   PRTL_SPLAY_LINKS _SplayLinks;            \
03280   _SplayLinks = (PRTL_SPLAY_LINKS)(Links); \
03281   _SplayLinks->Parent = _SplayLinks;   \
03282   _SplayLinks->LeftChild = NULL;       \
03283   _SplayLinks->RightChild = NULL;      \
03284 }
03285 
03286 #define RtlIsLeftChild(Links) \
03287     (RtlLeftChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))
03288 
03289 #define RtlIsRightChild(Links) \
03290     (RtlRightChild(RtlParent(Links)) == (PRTL_SPLAY_LINKS)(Links))
03291 
03292 #define RtlRightChild(Links) \
03293     ((PRTL_SPLAY_LINKS)(Links))->RightChild
03294 
03295 #define RtlIsRoot(Links) \
03296     (RtlParent(Links) == (PRTL_SPLAY_LINKS)(Links))
03297 
03298 #define RtlLeftChild(Links) \
03299     ((PRTL_SPLAY_LINKS)(Links))->LeftChild
03300 
03301 #define RtlParent(Links) \
03302     ((PRTL_SPLAY_LINKS)(Links))->Parent
03303 
03304 #define RtlInsertAsLeftChild(ParentLinks,ChildLinks)    \
03305     {                                                   \
03306         PRTL_SPLAY_LINKS _SplayParent;                  \
03307         PRTL_SPLAY_LINKS _SplayChild;                   \
03308         _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
03309         _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks);   \
03310         _SplayParent->LeftChild = _SplayChild;          \
03311         _SplayChild->Parent = _SplayParent;             \
03312     }
03313 
03314 #define RtlInsertAsRightChild(ParentLinks,ChildLinks)   \
03315     {                                                   \
03316         PRTL_SPLAY_LINKS _SplayParent;                  \
03317         PRTL_SPLAY_LINKS _SplayChild;                   \
03318         _SplayParent = (PRTL_SPLAY_LINKS)(ParentLinks); \
03319         _SplayChild = (PRTL_SPLAY_LINKS)(ChildLinks);   \
03320         _SplayParent->RightChild = _SplayChild;         \
03321         _SplayChild->Parent = _SplayParent;             \
03322     }
03323 
03324 #if !defined(MIDL_PASS)
03325 
03326 FORCEINLINE
03327 LUID
03328 NTAPI_INLINE
03329 RtlConvertLongToLuid(
03330   _In_ LONG Val)
03331 {
03332   LUID Luid;
03333   LARGE_INTEGER Temp;
03334 
03335   Temp.QuadPart = Val;
03336   Luid.LowPart = Temp.u.LowPart;
03337   Luid.HighPart = Temp.u.HighPart;
03338   return Luid;
03339 }
03340 
03341 FORCEINLINE
03342 LUID
03343 NTAPI_INLINE
03344 RtlConvertUlongToLuid(
03345   _In_ ULONG Val)
03346 {
03347   LUID Luid;
03348 
03349   Luid.LowPart = Val;
03350   Luid.HighPart = 0;
03351   return Luid;
03352 }
03353 
03354 #endif /* !defined(MIDL_PASS) */
03355 
03356 #if (defined(_M_AMD64) || defined(_M_IA64)) && !defined(_REALLY_GET_CALLERS_CALLER_)
03357 #define RtlGetCallersAddress(CallersAddress, CallersCaller) \
03358     *CallersAddress = (PVOID)_ReturnAddress(); \
03359     *CallersCaller = NULL;
03360 #else
03361 #if (NTDDI_VERSION >= NTDDI_WIN2K)
03362 NTSYSAPI
03363 VOID
03364 NTAPI
03365 RtlGetCallersAddress(
03366   _Out_ PVOID *CallersAddress,
03367   _Out_ PVOID *CallersCaller);
03368 #endif
03369 #endif
03370 
03371 #if !defined(MIDL_PASS) && !defined(SORTPP_PASS)
03372 
03373 #if (NTDDI_VERSION >= NTDDI_WIN7)
03374 
03375 FORCEINLINE
03376 VOID
03377 NTAPI
03378 RtlInitHashTableContext(
03379   _Inout_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context)
03380 {
03381   Context->ChainHead = NULL;
03382   Context->PrevLinkage = NULL;
03383 }
03384 
03385 FORCEINLINE
03386 VOID
03387 NTAPI
03388 RtlInitHashTableContextFromEnumerator(
03389   _Inout_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context,
03390   _In_ PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR Enumerator)
03391 {
03392   Context->ChainHead = Enumerator->ChainHead;
03393   Context->PrevLinkage = Enumerator->HashEntry.Linkage.Blink;
03394 }
03395 
03396 FORCEINLINE
03397 VOID
03398 NTAPI
03399 RtlReleaseHashTableContext(
03400   _Inout_ PRTL_DYNAMIC_HASH_TABLE_CONTEXT Context)
03401 {
03402   UNREFERENCED_PARAMETER(Context);
03403   return;
03404 }
03405 
03406 FORCEINLINE
03407 ULONG
03408 NTAPI
03409 RtlTotalBucketsHashTable(
03410   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable)
03411 {
03412   return HashTable->TableSize;
03413 }
03414 
03415 FORCEINLINE
03416 ULONG
03417 NTAPI
03418 RtlNonEmptyBucketsHashTable(
03419   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable)
03420 {
03421   return HashTable->NonEmptyBuckets;
03422 }
03423 
03424 FORCEINLINE
03425 ULONG
03426 NTAPI
03427 RtlEmptyBucketsHashTable(
03428   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable)
03429 {
03430   return HashTable->TableSize - HashTable->NonEmptyBuckets;
03431 }
03432 
03433 FORCEINLINE
03434 ULONG
03435 NTAPI
03436 RtlTotalEntriesHashTable(
03437   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable)
03438 {
03439   return HashTable->NumEntries;
03440 }
03441 
03442 FORCEINLINE
03443 ULONG
03444 NTAPI
03445 RtlActiveEnumeratorsHashTable(
03446   _In_ PRTL_DYNAMIC_HASH_TABLE HashTable)
03447 {
03448   return HashTable->NumEnumerators;
03449 }
03450 
03451 #endif /* (NTDDI_VERSION >= NTDDI_WIN7) */
03452 
03453 #endif /* !defined(MIDL_PASS) && !defined(SORTPP_PASS) */
03454 
03455 $endif (_NTDDK_)
03456 $if (_NTIFS_)
03457 
03458 #define RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE 1
03459 #define RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING 2
03460 
03461 #define RtlUnicodeStringToOemSize(STRING) (NLS_MB_OEM_CODE_PAGE_TAG ?                                \
03462                                            RtlxUnicodeStringToOemSize(STRING) :                      \
03463                                            ((STRING)->Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR) \
03464 )
03465 
03466 #define RtlOemStringToUnicodeSize(STRING) (                 \
03467     NLS_MB_OEM_CODE_PAGE_TAG ?                              \
03468     RtlxOemStringToUnicodeSize(STRING) :                    \
03469     ((STRING)->Length + sizeof(ANSI_NULL)) * sizeof(WCHAR)  \
03470 )
03471 
03472 #define RtlOemStringToCountedUnicodeSize(STRING) (                    \
03473     (ULONG)(RtlOemStringToUnicodeSize(STRING) - sizeof(UNICODE_NULL)) \
03474 )
03475 
03476 #define RtlOffsetToPointer(B,O) ((PCHAR)(((PCHAR)(B)) + ((ULONG_PTR)(O))))
03477 #define RtlPointerToOffset(B,P) ((ULONG)(((PCHAR)(P)) - ((PCHAR)(B))))
03478 $endif (_NTIFS_)
Generated on Mon May 28 2012 04:30:51 for ReactOS by doxygen 1.7.6.1
ReactOS is a registered trademark or a trademark of ReactOS Foundation in the United States and other countries.