able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntos/rtl/string.c

832 lines
19 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1989 Microsoft Corporation
Module Name:
strings.c
Abstract:
This module defines functions for manipulating counted strings (STRING).
A counted string is a data structure containing three fields. The Buffer
field is a pointer to the string itself. The MaximumLength field contains
the maximum number of bytes that can be stored in the memory pointed to
by the Buffer field. The Length field contains the current length, in
bytes, of the string pointed to by the Buffer field. Users of counted
strings should not make any assumptions about the existence of a null
byte at the end of the string, unless the null byte is explicitly
included in the Length of the string.
Author:
Steve Wood (stevewo) 31-Mar-1989
Revision History:
22-Sep-1993 JulieB Fixed TO_UPPER macro for chars above 0x7f.
--*/
#include "string.h"
#include "nt.h"
#include "ntrtlp.h"
#if defined(ALLOC_PRAGMA) && defined(NTOS_KERNEL_RUNTIME)
//#pragma alloc_text(NONPAGE,RtlInitString)
//#pragma alloc_text(NONPAGE,RtlInitAnsiString)
//#pragma alloc_text(NONPAGE,RtlInitUnicodeString)
#pragma alloc_text(PAGE,RtlUpperChar)
#pragma alloc_text(PAGE,RtlCompareString)
#pragma alloc_text(PAGE,RtlPrefixString)
#pragma alloc_text(PAGE,RtlCreateUnicodeStringFromAsciiz)
#pragma alloc_text(PAGE,RtlUpperString)
#pragma alloc_text(PAGE,RtlAppendAsciizToString)
#pragma alloc_text(PAGE,RtlAppendStringToString)
#endif
//
// Global data used for translations.
//
extern PUSHORT NlsAnsiToUnicodeData; // Ansi CP to Unicode translation table
extern PCH NlsUnicodeToAnsiData; // Unicode to Ansi CP translation table
extern const PUSHORT NlsLeadByteInfo; // Lead byte info for ACP
extern PUSHORT NlsUnicodeToMbAnsiData; // Unicode to Multibyte Ansi CP translation table
extern BOOLEAN NlsMbCodePageTag; // TRUE -> Multibyte ACP, FALSE -> Singlebyte ACP
#if !defined(_M_IX86)
VOID
RtlInitString(
OUT PSTRING DestinationString,
IN PCSZ SourceString OPTIONAL
)
/*++
Routine Description:
The RtlInitString function initializes an NT counted string.
The DestinationString is initialized to point to the SourceString
and the Length and MaximumLength fields of DestinationString are
initialized to the length of the SourceString, which is zero if
SourceString is not specified.
Arguments:
DestinationString - Pointer to the counted string to initialize
SourceString - Optional pointer to a null terminated string that
the counted string is to point to.
Return Value:
None.
--*/
{
ULONG Length;
DestinationString->Buffer = (PCHAR)SourceString;
if (ARGUMENT_PRESENT( SourceString )) {
Length = strlen(SourceString);
DestinationString->Length = (USHORT)Length;
DestinationString->MaximumLength = (USHORT)(Length+1);
}
else {
DestinationString->Length = 0;
DestinationString->MaximumLength = 0;
}
}
VOID
RtlInitAnsiString(
OUT PANSI_STRING DestinationString,
IN PCSZ SourceString OPTIONAL
)
/*++
Routine Description:
The RtlInitAnsiString function initializes an NT counted string.
The DestinationString is initialized to point to the SourceString
and the Length and MaximumLength fields of DestinationString are
initialized to the length of the SourceString, which is zero if
SourceString is not specified.
Arguments:
DestinationString - Pointer to the counted string to initialize
SourceString - Optional pointer to a null terminated string that
the counted string is to point to.
Return Value:
None.
--*/
{
ULONG Length;
DestinationString->Buffer = (PCHAR)SourceString;
if (ARGUMENT_PRESENT( SourceString )) {
Length = strlen(SourceString);
DestinationString->Length = (USHORT)Length;
DestinationString->MaximumLength = (USHORT)(Length+1);
}
else {
DestinationString->Length = 0;
DestinationString->MaximumLength = 0;
}
}
VOID
RtlInitUnicodeString(
OUT PUNICODE_STRING DestinationString,
IN PCWSTR SourceString OPTIONAL
)
/*++
Routine Description:
The RtlInitUnicodeString function initializes an NT counted
unicode string. The DestinationString is initialized to point to
the SourceString and the Length and MaximumLength fields of
DestinationString are initialized to the length of the SourceString,
which is zero if SourceString is not specified.
Arguments:
DestinationString - Pointer to the counted string to initialize
SourceString - Optional pointer to a null terminated unicode string that
the counted string is to point to.
Return Value:
None.
--*/
{
ULONG Length;
DestinationString->Buffer = (PWSTR)SourceString;
if (ARGUMENT_PRESENT( SourceString )) {
Length = wcslen( SourceString ) * sizeof( WCHAR );
DestinationString->Length = (USHORT)Length;
DestinationString->MaximumLength = (USHORT)(Length + sizeof(UNICODE_NULL));
}
else {
DestinationString->MaximumLength = 0;
DestinationString->Length = 0;
}
}
#endif // !defined(_M_IX86)
NTSTATUS
RtlInitUnicodeStringEx(
OUT PUNICODE_STRING DestinationString,
IN PCWSTR SourceString OPTIONAL
)
{
if (SourceString != NULL) {
SIZE_T Length = wcslen(SourceString);
// We are actually limited to 32765 characters since we want to store a meaningful
// MaximumLength also.
if (Length > (UNICODE_STRING_MAX_CHARS - 1)) {
return STATUS_NAME_TOO_LONG;
}
Length *= sizeof(WCHAR);
DestinationString->Length = (USHORT) Length;
DestinationString->MaximumLength = (USHORT) (Length + sizeof(WCHAR));
DestinationString->Buffer = (PWSTR) SourceString;
} else {
DestinationString->Length = 0;
DestinationString->MaximumLength = 0;
DestinationString->Buffer = NULL;
}
return STATUS_SUCCESS;
}
VOID
RtlCopyString(
OUT PSTRING DestinationString,
IN const STRING *SourceString OPTIONAL
)
/*++
Routine Description:
The RtlCopyString function copies the SourceString to the
DestinationString. If SourceString is not specified, then
the Length field of DestinationString is set to zero. The
MaximumLength and Buffer fields of DestinationString are not
modified by this function.
The number of bytes copied from the SourceString is either the
Length of SourceString or the MaximumLength of DestinationString,
whichever is smaller.
Arguments:
DestinationString - Pointer to the destination string.
SourceString - Optional pointer to the source string.
Return Value:
None.
--*/
{
PSZ src, dst;
ULONG n;
if (ARGUMENT_PRESENT( SourceString )) {
dst = DestinationString->Buffer;
src = SourceString->Buffer;
n = SourceString->Length;
if ((USHORT)n > DestinationString->MaximumLength) {
n = DestinationString->MaximumLength;
}
DestinationString->Length = (USHORT)n;
while (n) {
*dst++ = *src++;
n--;
}
}
else {
DestinationString->Length = 0;
}
}
CHAR
RtlUpperChar (
register IN CHAR Character
)
/*++
Routine Description:
This routine returns a character uppercased
.
Arguments:
IN CHAR Character - Supplies the character to upper case
Return Value:
CHAR - Uppercased version of the charac
ter
--*/
{
RTL_PAGED_CODE();
//
// NOTE: This assumes an ANSI string and it does NOT upper case
// DOUBLE BYTE characters properly.
//
//
// Handle a - z separately.
//
if (Character <= 'z') {
if (Character >= 'a') {
return Character ^ 0x20;
}
else {
return Character;
}
}
else {
WCHAR wCh;
/*
* Handle extended characters.
*/
if (!NlsMbCodePageTag) {
//
// Single byte code page.
//
wCh = NlsAnsiToUnicodeData[(UCHAR)Character];
wCh = NLS_UPCASE(wCh);
return NlsUnicodeToAnsiData[(USHORT)wCh];
}
else {
//
// Multi byte code page. Do nothing to the character
// if it's a lead byte or if the translation of the
// upper case Unicode character is a DBCS character.
//
if (!NlsLeadByteInfo[Character]) {
wCh = NlsAnsiToUnicodeData[(UCHAR)Character];
wCh = NLS_UPCASE(wCh);
wCh = NlsUnicodeToMbAnsiData[(USHORT)wCh];
if (!HIBYTE(wCh)) {
return LOBYTE(wCh);
}
}
}
}
return Character;
}
LONG
RtlCompareString(
IN const STRING *String1,
IN const STRING *String2,
IN BOOLEAN CaseInSensitive
)
/*++
Routine Description:
The RtlCompareString function compares two counted strings. The return
value indicates if the strings are equal or String1 is less than String2
or String1 is greater than String2.
The CaseInSensitive parameter specifies if case is to be ignored when
doing the comparison.
Arguments:
String1 - Pointer to the first string.
String2 - Pointer to the second string.
CaseInsensitive - TRUE if case should be ignored when doing the
comparison.
Return Value:
Signed value that gives the results of the comparison:
Zero - String1 equals String2
< Zero - String1 less than String2
> Zero - String1 greater than String2
--*/
{
PUCHAR s1, s2, Limit;
LONG n1, n2;
UCHAR c1, c2;
RTL_PAGED_CODE();
s1 = String1->Buffer;
s2 = String2->Buffer;
n1 = String1->Length;
n2 = String2->Length;
Limit = s1 + (n1 <= n2 ? n1 : n2);
if (CaseInSensitive) {
while (s1 < Limit) {
c1 = *s1++;
c2 = *s2++;
if (c1 !=c2) {
c1 = RtlUpperChar(c1);
c2 = RtlUpperChar(c2);
if (c1 != c2) {
return (LONG)c1 - (LONG)c2;
}
}
}
} else {
while (s1 < Limit) {
c1 = *s1++;
c2 = *s2++;
if (c1 != c2) {
return (LONG)c1 - (LONG)c2;
}
}
}
return n1 - n2;
}
BOOLEAN
RtlEqualString(
IN const STRING *String1,
IN const STRING *String2,
IN BOOLEAN CaseInSensitive
)
/*++
Routine Description:
The RtlEqualString function compares two counted strings for equality.
The CaseInSensitive parameter specifies if case is to be ignored when
doing the comparison.
Arguments:
String1 - Pointer to the first string.
String2 - Pointer to the second string.
CaseInsensitive - TRUE if case should be ignored when doing the
comparison.
Return Value:
Boolean value that is TRUE if String1 equals String2 and FALSE otherwise.
--*/
{
PUCHAR s1, s2, Limit;
LONG n1, n2;
UCHAR c1, c2;
n1 = String1->Length;
n2 = String2->Length;
if (n1 == n2) {
s1 = String1->Buffer;
s2 = String2->Buffer;
Limit = s1 + n1;
if (CaseInSensitive) {
while (s1 < Limit) {
c1 = *s1++;
c2 = *s2++;
if (c1 != c2) {
c1 = RtlUpperChar(c1);
c2 = RtlUpperChar(c2);
if (c1 != c2) {
return FALSE;
}
}
}
return TRUE;
} else {
while (s1 < Limit) {
c1 = *s1++;
c2 = *s2++;
if (c1 != c2) {
return FALSE;
}
}
return TRUE;
}
} else {
return FALSE;
}
}
BOOLEAN
RtlPrefixString(
IN PSTRING String1,
IN PSTRING String2,
IN BOOLEAN CaseInSensitive
)
/*++
Routine Description:
The RtlPrefixString function determines if the String1 counted string
parameter is a prefix of the String2 counted string parameter.
The CaseInSensitive parameter specifies if case is to be ignored when
doing the comparison.
Arguments:
String1 - Pointer to the first string.
String2 - Pointer to the second string.
CaseInsensitive - TRUE if case should be ignored when doing the
comparison.
Return Value:
Boolean value that is TRUE if String1 equals a prefix of String2 and
FALSE otherwise.
--*/
{
PSZ s1, s2;
USHORT n;
UCHAR c1, c2;
RTL_PAGED_CODE();
s1 = String1->Buffer;
s2 = String2->Buffer;
n = String1->Length;
if (String2->Length < n) {
return( FALSE );
}
if (CaseInSensitive) {
while (n) {
c1 = *s1++;
c2 = *s2++;
if (c1 != c2 && RtlUpperChar(c1) != RtlUpperChar(c2)) {
return( FALSE );
}
n--;
}
}
else {
while (n) {
if (*s1++ != *s2++) {
return( FALSE );
}
n--;
}
}
return TRUE;
}
BOOLEAN
RtlCreateUnicodeStringFromAsciiz(
OUT PUNICODE_STRING DestinationString,
IN PCSZ SourceString
)
{
ANSI_STRING AnsiString;
NTSTATUS Status;
RTL_PAGED_CODE();
RtlInitAnsiString( &AnsiString, SourceString );
Status = RtlAnsiStringToUnicodeString( DestinationString, &AnsiString, TRUE );
if (NT_SUCCESS( Status )) {
return( TRUE );
}
else {
return( FALSE );
}
}
VOID
RtlUpperString(
IN PSTRING DestinationString,
IN const STRING *SourceString
)
/*++
Routine Description:
The RtlUpperString function copies the SourceString to the
DestinationString, converting it to upper case. The MaximumLength
and Buffer fields of DestinationString are not modified by this
function.
The number of bytes copied from the SourceString is either the
Length of SourceString or the MaximumLength of DestinationString,
whichever is smaller.
Arguments:
DestinationString - Pointer to the destination string.
SourceString - Pointer to the source string.
Return Value:
None.
--*/
{
PSZ src, dst;
ULONG n;
RTL_PAGED_CODE();
dst = DestinationString->Buffer;
src = SourceString->Buffer;
n = SourceString->Length;
if ((USHORT)n > DestinationString->MaximumLength) {
n = DestinationString->MaximumLength;
}
DestinationString->Length = (USHORT)n;
while (n) {
*dst++ = RtlUpperChar(*src++);
n--;
}
}
NTSTATUS
RtlAppendAsciizToString (
IN PSTRING Destination,
IN PCSZ Source OPTIONAL
)
/*++
Routine Description:
This routine appends the supplied ASCIIZ string to an existing PSTRING.
It will copy bytes from the Source PSZ to the destination PSTRING up to
the destinations PSTRING->MaximumLength field.
Arguments:
IN PSTRING Destination, - Supplies a pointer to the destination string
IN PSZ Source - Supplies the string to append to the destination
Return Value:
STATUS_SUCCESS - The source string was successfully appended to the
destination counted string.
STATUS_BUFFER_TOO_SMALL - The destination string length was not big
enough to allow the source string to be appended. The Destination
string length is not updated.
--*/
{
USHORT n;
RTL_PAGED_CODE();
if (ARGUMENT_PRESENT( Source )) {
n = (USHORT)strlen( Source );
if ((n + Destination->Length) > Destination->MaximumLength) {
return( STATUS_BUFFER_TOO_SMALL );
}
RtlMoveMemory( &Destination->Buffer[ Destination->Length ], Source, n );
Destination->Length += n;
}
return( STATUS_SUCCESS );
}
NTSTATUS
RtlAppendStringToString (
IN PSTRING Destination,
IN const STRING *Source
)
/*++
Routine Description:
This routine will concatinate two PSTRINGs together. It will copy
bytes from the source up to the MaximumLength of the destination.
Arguments:
IN PSTRING Destination, - Supplies the destination string
IN PSTRING Source - Supplies the source for the string copy
Return Value:
STATUS_SUCCESS - The source string was successfully appended to the
destination counted string.
STATUS_BUFFER_TOO_SMALL - The destination string length was not big
enough to allow the source string to be appended. The Destination
string length is not updated.
--*/
{
USHORT n = Source->Length;
RTL_PAGED_CODE();
if (n) {
if ((n + Destination->Length) > Destination->MaximumLength) {
return( STATUS_BUFFER_TOO_SMALL );
}
RtlMoveMemory( &Destination->Buffer[ Destination->Length ],
Source->Buffer,
n
);
Destination->Length += n;
}
return( STATUS_SUCCESS );
}
#if !defined(_X86_) && !defined(_AMD64_)
SIZE_T
NTAPI
RtlCompareMemoryUlong(
PVOID Source,
SIZE_T Length,
ULONG Pattern
)
/*++
Routine Description:
This function compares two blocks of memory and returns the number
of bytes that compared equal.
N.B. This routine requires that the source address is aligned on a
longword boundary and that the length is an even multiple of
longwords.
Arguments:
Source - Supplies a pointer to the block of memory to compare against.
Length - Supplies the Length, in bytes, of the memory to be
compared.
Pattern - Supplies a 32-bit pattern to compare against the block of
memory.
Return Value:
The number of bytes that compared equal is returned as the function
value. If all bytes compared equal, then the length of the orginal
block of memory is returned. Returns zero if either the Source
address is not longword aligned or the length is not a multiple of
longwords.
--*/
{
SIZE_T CountLongs;
PULONG p = (PULONG)Source;
PCHAR p1, p2;
if (((ULONG_PTR)p & (sizeof( ULONG )-1)) ||
(Length & (sizeof( ULONG )-1))
) {
return( 0 );
}
CountLongs = Length / sizeof( ULONG );
while (CountLongs--) {
if (*p++ != Pattern) {
p1 = (PCHAR)(p - 1);
p2 = (PCHAR)&Pattern;
Length = p1 - (PCHAR)Source;
while (*p1++ == *p2++) {
if (p1 > (PCHAR)p) {
break;
}
Length++;
}
}
}
return( Length );
}
#endif // !defined(_X86_) && !defined(_AMD64_)
Reference in a new issue Copy permalink