Sweden-Number/dlls/ntdll/rtlstr.c

616 lines
13 KiB
C
Raw Normal View History

/*
* Rtl string functions
*
* Copyright 1996-1998 Marcus Meissner
*/
1999-03-12 18:28:09 +01:00
#include "config.h"
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "wine/winestring.h"
#include "wine/unicode.h"
#include "heap.h"
#include "winnls.h"
#include "debugtools.h"
#include "ntdll_misc.h"
#include "ntddk.h"
DEFAULT_DEBUG_CHANNEL(ntdll);
/* STRING FUNCTIONS */
/**************************************************************************
* RtlInitString
*/
VOID WINAPI RtlInitString(PSTRING target,LPCSTR source)
{
TRACE("%p %p(%s)\n", target, source, debugstr_a(source));
target->Buffer = (LPSTR)source;
if (source)
{
target->Length = strlen(source);
target->MaximumLength = target->Length+1;
}
else
{
target->Length = target->MaximumLength = 0;
}
}
/* ANSI FUNCTIONS */
/**************************************************************************
* RtlInitAnsiString
*/
VOID WINAPI RtlInitAnsiString(
PANSI_STRING target,
LPCSTR source)
{
TRACE("%p %p(%s)\n", target, source, debugstr_a(source));
target->Buffer = (LPSTR)source;
if (source)
{
target->Length = strlen(source);
target->MaximumLength = target->Length+1;
}
else
{
target->Length = target->MaximumLength = 0;
}
}
/**************************************************************************
* RtlFreeAnsiString
*/
VOID WINAPI RtlFreeAnsiString(
PANSI_STRING AnsiString)
{
TRACE("%p\n", AnsiString);
dump_AnsiString(AnsiString, TRUE);
if( AnsiString->Buffer )
HeapFree( GetProcessHeap(),0,AnsiString->Buffer );
}
/* UNICODE FUNCTIONS */
/**************************************************************************
* RtlInitUnicodeString [NTDLL.403]
*/
VOID WINAPI RtlInitUnicodeString(
PUNICODE_STRING target,
LPCWSTR source)
{
TRACE("%p %p(%s)\n", target, source, debugstr_w(source));
target->Buffer = (LPWSTR)source;
if (source)
{
target->Length = strlenW(source)*2;
target->MaximumLength = target->Length + 2;
}
else
{
target->Length = target->MaximumLength = 0;
}
}
/**************************************************************************
* RtlFreeUnicodeString [NTDLL.377]
*/
VOID WINAPI RtlFreeUnicodeString(
PUNICODE_STRING UnicodeString)
{
TRACE("%p\n", UnicodeString);
dump_UnicodeString(UnicodeString, TRUE);
if (UnicodeString->Buffer)
HeapFree(GetProcessHeap(),0,UnicodeString->Buffer);
}
/*
COMPARE FUNCTIONS
*/
/**************************************************************************
* RtlEqualUnicodeString
*/
BOOLEAN WINAPI RtlEqualUnicodeString(
IN PUNICODE_STRING s1,
IN PUNICODE_STRING s2,
IN BOOLEAN CaseInsensitive)
{
BOOLEAN ret;
TRACE("(%p,%p,%x)\n",s1,s2,CaseInsensitive);
dump_UnicodeString(s1, TRUE);
dump_UnicodeString(s2, TRUE);
if(!s1 || !s2 || !s1->Buffer || !s2->Buffer) return FALSE;
if (s1->Length != s2->Length) return FALSE;
if (CaseInsensitive)
ret = !strncmpiW(s1->Buffer,s2->Buffer,s1->Length/sizeof(WCHAR));
else
ret = !strncmpW(s1->Buffer,s2->Buffer,s1->Length/sizeof(WCHAR));
return ret;
}
/******************************************************************************
* RtlCompareUnicodeString
*/
LONG WINAPI RtlCompareUnicodeString(
PUNICODE_STRING s1,
PUNICODE_STRING s2,
BOOLEAN CaseInsensitive)
{
LONG ret;
TRACE("(%p,%p,%x)\n",s1,s2,CaseInsensitive);
dump_UnicodeString(s1, TRUE);
dump_UnicodeString(s2, TRUE);
if(!s1 || !s2 || !s1->Buffer || !s2->Buffer) return FALSE;
if (s1->Length != s2->Length) return (s1->Length - s2->Length);
if (CaseInsensitive)
ret = strncmpiW(s1->Buffer,s2->Buffer,s1->Length/sizeof(WCHAR));
else
ret = strncmpW(s1->Buffer,s2->Buffer,s1->Length/sizeof(WCHAR));
return ret;
}
/*
COPY BETWEEN ANSI_STRING or UNICODE_STRING
there is no parameter checking, it just crashes
*/
/**************************************************************************
* RtlAnsiStringToUnicodeString
*
* NOTES:
* writes terminating 0
*/
NTSTATUS
WINAPI RtlAnsiStringToUnicodeString(
PUNICODE_STRING uni,
PANSI_STRING ansi,
BOOLEAN doalloc)
{
int len = ansi->Length * sizeof(WCHAR);
TRACE("%p %p %u\n",uni, ansi, doalloc);
dump_AnsiString(ansi, TRUE);
dump_UnicodeString(uni, FALSE);
if (len>0xfffe) return STATUS_INVALID_PARAMETER_2;
uni->Length = len;
if (doalloc)
{
2000-01-27 06:39:44 +01:00
uni->MaximumLength = len + sizeof(WCHAR);
uni->Buffer = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,uni->MaximumLength);
if (!uni->Buffer) return STATUS_NO_MEMORY;
}
else if (len+sizeof(WCHAR) > uni->MaximumLength)
{
return STATUS_BUFFER_OVERFLOW;
}
lstrcpynAtoW(uni->Buffer,ansi->Buffer,ansi->Length+1);
return STATUS_SUCCESS;
}
/**************************************************************************
* RtlUpcaseUnicodeString
*
* NOTES:
* destination string is never 0-terminated because dest can be equal to src
* and src might be not 0-terminated
* dest.Length only set when success
*/
DWORD WINAPI RtlUpcaseUnicodeString(
PUNICODE_STRING dest,
PUNICODE_STRING src,
BOOLEAN doalloc)
{
int i, len = src->Length;
TRACE("(%p,%p,%x)\n",dest, src, doalloc);
dump_UnicodeString(dest, FALSE);
dump_UnicodeString(src, TRUE);
if (doalloc)
{
dest->Buffer = (LPWSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
if (!dest->Buffer) return STATUS_NO_MEMORY;
dest->MaximumLength = len;
}
else if (len > dest->MaximumLength)
{
return STATUS_BUFFER_OVERFLOW;
}
for (i=0; i < len/sizeof(WCHAR); i++)
{
dest->Buffer[i] = toupperW(src->Buffer[i]);
}
dest->Length = len;
return STATUS_SUCCESS;
}
/**************************************************************************
* RtlOemStringToUnicodeString
*
* NOTES
* writes terminating 0
* buffer must be bigger than (ansi->Length+1)*2
* if astr.Length > 0x7ffe it returns STATUS_INVALID_PARAMETER_2
*
* FIXME
* OEM to unicode
*/
NTSTATUS
WINAPI RtlOemStringToUnicodeString(
PUNICODE_STRING uni,
PSTRING ansi,
BOOLEAN doalloc)
{
int len = ansi->Length * sizeof(WCHAR);
if (len > 0xfffe) return STATUS_INVALID_PARAMETER_2;
uni->Length = len;
if (doalloc)
{
uni->Buffer = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY, len + sizeof(WCHAR));
if (!uni->Buffer) return STATUS_NO_MEMORY;
uni->MaximumLength = len + sizeof(WCHAR);
}
else if (len+1 > uni->MaximumLength )
{
return STATUS_BUFFER_OVERFLOW;
}
lstrcpynAtoW(uni->Buffer,ansi->Buffer,ansi->Length+1);
return STATUS_SUCCESS;
}
/**************************************************************************
* RtlUnicodeStringToOemString
*
* NOTES
* allocates uni->Length+1
* writes terminating 0
*/
NTSTATUS
WINAPI RtlUnicodeStringToOemString(
PANSI_STRING oem,
PUNICODE_STRING uni,
BOOLEAN doalloc)
{
int len = uni->Length/sizeof(WCHAR);
TRACE("%p %s %i\n", oem, debugstr_us(uni), doalloc);
oem->Length = len;
if (doalloc)
{
oem->Buffer = (LPSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len+1);
if (! oem->Buffer) return STATUS_NO_MEMORY;
oem->MaximumLength = len + 1;
}
else if (oem->MaximumLength <= len)
{
return STATUS_BUFFER_OVERFLOW;
}
lstrcpynWtoA(oem->Buffer, uni->Buffer, len+1);
return STATUS_SUCCESS;
}
/**************************************************************************
* RtlUpcaseUnicodeStringToOemString
*
* NOTES
* writes terminating 0
*/
NTSTATUS
WINAPI RtlUpcaseUnicodeStringToOemString(
PANSI_STRING oem,
PUNICODE_STRING uni,
BOOLEAN doalloc)
{
int i, len = uni->Length/sizeof(WCHAR);
TRACE("%p %s %i\n", oem, debugstr_us(uni), doalloc);
oem->Length = len;
if (doalloc)
{
oem->Buffer = (LPSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len+1);
if (! oem->Buffer) return STATUS_NO_MEMORY;
oem->MaximumLength = len + 1;
}
else if (oem->MaximumLength <= len)
{
return STATUS_BUFFER_OVERFLOW;
}
for (i=0; i < len; i++)
{
oem->Buffer[i] = toupperW((char)(uni->Buffer[i]));
}
oem->Buffer[i] = 0;
return STATUS_SUCCESS;
}
/**************************************************************************
* RtlUnicodeStringToAnsiString
*
* NOTES
* writes terminating 0
* copys a part if the buffer is to small
*/
NTSTATUS
WINAPI RtlUnicodeStringToAnsiString(
PANSI_STRING ansi,
PUNICODE_STRING uni,
BOOLEAN doalloc)
{
int len = uni->Length/sizeof(WCHAR);
NTSTATUS ret = STATUS_SUCCESS;
TRACE("%p %s %i\n", ansi, debugstr_us(uni), doalloc);
ansi->Length = len;
if (doalloc)
{
ansi->Buffer = (LPSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len+1);
if (! ansi->Buffer) return STATUS_NO_MEMORY;
ansi->MaximumLength = len + 1;
}
else if (ansi->MaximumLength <= len)
{
ansi->Length = ansi->MaximumLength - 1;
ret = STATUS_BUFFER_OVERFLOW;
}
lstrcpynWtoA(ansi->Buffer, uni->Buffer, ansi->Length+1);
return ret;
}
/*
COPY BETWEEN ANSI/UNICODE_STRING AND MULTIBYTE STRINGS
*/
/**************************************************************************
* RtlMultiByteToUnicodeN
*
* NOTES
* dest can be equal to src
* if unistr is to small a part is copyed
*
* FIXME
* multibyte support
*/
NTSTATUS
WINAPI RtlMultiByteToUnicodeN(
LPWSTR unistr,
DWORD unilen,
LPDWORD reslen,
LPSTR oemstr,
DWORD oemlen)
{
UINT len;
int i;
TRACE("%p %lu, %p, %s, %lu\n", oemstr, oemlen, reslen, debugstr_w(unistr), unilen);
len = (unilen/sizeof(WCHAR) < oemlen) ? unilen/sizeof(WCHAR) : oemlen;
for (i = len-1; i>=0; i--)
unistr[i] = (WCHAR)oemstr[i];
if (reslen) *reslen = len * 2;
return 0;
}
/**************************************************************************
* RtlOemToUnicodeN
*/
NTSTATUS
WINAPI RtlOemToUnicodeN(
LPWSTR unistr,
DWORD unilen,
LPDWORD reslen,
LPSTR oemstr,
DWORD oemlen)
{
UINT len;
int i;
TRACE("%p %lu, %p, %s, %lu\n", oemstr, oemlen, reslen, debugstr_w(unistr), unilen);
len = (unilen/sizeof(WCHAR) < oemlen) ? unilen/sizeof(WCHAR) : oemlen;
for (i = len-1; i>=0; i--)
unistr[i] = (WCHAR)oemstr[i];
if (reslen) *reslen = len * 2;
return 0;
}
/**************************************************************************
* RtlUnicodeToOemN
*/
NTSTATUS
WINAPI RtlUnicodeToOemN(
LPSTR oemstr,
DWORD oemlen,
LPDWORD reslen,
LPWSTR unistr,
DWORD unilen)
{
UINT len;
int i;
TRACE("%p %lu, %p, %s, %lu\n", oemstr, oemlen, reslen, debugstr_w(unistr), unilen);
len = (oemlen < unilen/sizeof(WCHAR)) ? unilen/sizeof(WCHAR) : oemlen;
for (i = len-1; i>=0; i--)
oemstr[i] = (CHAR)unistr[i];
if (reslen) *reslen = len * 2;
return 0;
}
/**************************************************************************
* RtlUpcaseUnicodeToOemN
*/
NTSTATUS
WINAPI RtlUpcaseUnicodeToOemN(
LPSTR oemstr,
DWORD oemlen,
LPDWORD reslen,
LPWSTR unistr,
DWORD unilen)
{
UINT len;
int i;
TRACE("%p %lu, %p, %s, %lu\n", oemstr, oemlen, reslen, debugstr_w(unistr), unilen);
len = (oemlen < unilen/sizeof(WCHAR)) ? unilen/sizeof(WCHAR) : oemlen;
for (i = len-1; i>=0; i--)
oemstr[i] = toupper((CHAR)unistr[i]);
if (reslen) *reslen = len * 2;
return 0;
}
/**************************************************************************
* RtlUnicodeToMultiByteN
*/
NTSTATUS WINAPI RtlUnicodeToMultiByteN(
PCHAR MbString,
ULONG MbSize,
PULONG ResultSize,
PWCHAR UnicodeString,
ULONG UnicodeSize)
{
int Size = 0, i;
TRACE("(%p,%lu,%p,%p(%s),%lu)\n",
MbString, MbSize, ResultSize, UnicodeString, debugstr_w(UnicodeString), UnicodeSize);
Size = (UnicodeSize > (MbSize*sizeof(WCHAR))) ? MbSize: UnicodeSize/sizeof(WCHAR);
if (ResultSize != NULL) *ResultSize = Size;
for(i = 0; i < Size; i++)
{
*(MbString++) = *(UnicodeString++);
}
return STATUS_SUCCESS;
}
/*
STRING SIZE
Rtlx* supports multibyte
*/
/**************************************************************************
* RtlxOemStringToUnicodeSize
*/
UINT WINAPI RtlxOemStringToUnicodeSize(PSTRING str)
{
return str->Length*2+2;
}
/**************************************************************************
* RtlxAnsiStringToUnicodeSize
*/
UINT WINAPI RtlxAnsiStringToUnicodeSize(PANSI_STRING str)
{
return str->Length*2+2;
}
/**************************************************************************
* RtlxUnicodeStringToOemSize
*
*/
UINT WINAPI RtlxUnicodeStringToOemSize(PUNICODE_STRING str)
{
return str->Length+1;
}
/*
MISC
*/
/**************************************************************************
* RtlIsTextUnicode
*
* Apply various feeble heuristics to guess whether
* the text buffer contains Unicode.
* FIXME: should implement more tests.
*/
DWORD WINAPI RtlIsTextUnicode(
LPVOID buf,
DWORD len,
DWORD *pf)
{
LPWSTR s = buf;
DWORD flags = -1, out_flags = 0;
if (!len)
goto out;
if (pf)
flags = *pf;
/*
* Apply various tests to the text string. According to the
* docs, each test "passed" sets the corresponding flag in
* the output flags. But some of the tests are mutually
* exclusive, so I don't see how you could pass all tests ...
*/
/* Check for an odd length ... pass if even. */
if (!(len & 1))
out_flags |= IS_TEXT_UNICODE_ODD_LENGTH;
/* Check for the special unicode marker byte. */
if (*s == 0xFEFF)
out_flags |= IS_TEXT_UNICODE_SIGNATURE;
/*
* Check whether the string passed all of the tests.
*/
flags &= ITU_IMPLEMENTED_TESTS;
if ((out_flags & flags) != flags)
len = 0;
out:
if (pf)
*pf = out_flags;
return len;
}
/**************************************************************************
* RtlPrefixUnicodeString
*/
NTSTATUS WINAPI RtlPrefixUnicodeString(
PUNICODE_STRING a,
PUNICODE_STRING b,
DWORD x)
{
TRACE("(%s,%s,%lx)\n",debugstr_us(a),debugstr_us(b),x);
return STATUS_SUCCESS;
}