git.oblomov.eu Git - wine/blob - dlls/ntdll/rtlstr.c

   1 /*
   2  * Rtl string functions
   3  *
   4  * Copyright (C) 1996-1998 Marcus Meissner
   5  * Copyright (C) 2000      Alexandre Julliard
   6  * Copyright (C) 2003      Thomas Mertes
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include <assert.h>
  26 #include <stdarg.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winreg.h"
  33 #include "winternl.h"
  34 #include "wine/unicode.h"
  35 #include "wine/debug.h"
  36 #include "ntdll_misc.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  39
  40 #define GUID_STRING_LENGTH    38
  41
  42 UINT NlsAnsiCodePage = 0;
  43 BYTE NlsMbCodePageTag = 0;
  44 BYTE NlsMbOemCodePageTag = 0;
  45
  46 static const union cptable *ansi_table;
  47 static const union cptable *oem_table;
  48 static const union cptable* unix_table; /* NULL if UTF8 */
  49
  50
  51 /**************************************************************************
  52  *      __wine_init_codepages   (NTDLL.@)
  53  *
  54  * Set the code page once kernel32 is loaded. Should be done differently.
  55  */
  56 void __wine_init_codepages( const union cptable *ansi, const union cptable *oem,
  57                             const union cptable *ucp)
  58 {
  59     ansi_table = ansi;
  60     oem_table = oem;
  61     unix_table = ucp;
  62     NlsAnsiCodePage = ansi->info.codepage;
  63 }
  64
  65 int ntdll_umbstowcs(DWORD flags, const char* src, int srclen, WCHAR* dst, int dstlen)
  66 {
  67     return (unix_table) ?
  68         wine_cp_mbstowcs( unix_table, flags, src, srclen, dst, dstlen ) :
  69         wine_utf8_mbstowcs( flags, src, srclen, dst, dstlen );
  70 }
  71
  72 int ntdll_wcstoumbs(DWORD flags, const WCHAR* src, int srclen, char* dst, int dstlen,
  73                     const char* defchar, int *used )
  74 {
  75     if (unix_table)
  76         return wine_cp_wcstombs( unix_table, flags, src, srclen, dst, dstlen, defchar, used );
  77     if (used) *used = 0;  /* all chars are valid for UTF-8 */
  78     return wine_utf8_wcstombs( src, srclen, dst, dstlen );
  79 }
  80
  81 /**************************************************************************
  82  *      RtlInitAnsiString   (NTDLL.@)
  83  *
  84  * Initializes a buffered ansi string.
  85  *
  86  * RETURNS
  87  *  Nothing.
  88  *
  89  * NOTES
  90  *  Assigns source to target->Buffer. The length of source is assigned to
  91  *  target->Length and target->MaximumLength. If source is NULL the length
  92  *  of source is assumed to be 0.
  93  */
  94 void WINAPI RtlInitAnsiString(
  95     PANSI_STRING target, /* [I/O] Buffered ansi string to be initialized */
  96     PCSZ source)         /* [I]   '\0' terminated string used to initialize target */
  97 {
  98     if ((target->Buffer = (PCHAR) source))
  99     {
 100         target->Length = strlen(source);
 101         target->MaximumLength = target->Length + 1;
 102     }
 103     else target->Length = target->MaximumLength = 0;
 104 }
 105
 106
 107 /**************************************************************************
 108  *      RtlInitString   (NTDLL.@)
 109  *
 110  * Initializes a buffered string.
 111  *
 112  * RETURNS
 113  *  Nothing.
 114  *
 115  * NOTES
 116  *  Assigns source to target->Buffer. The length of source is assigned to
 117  *  target->Length and target->MaximumLength. If source is NULL the length
 118  *  of source is assumed to be 0.
 119  */
 120 void WINAPI RtlInitString(
 121     PSTRING target, /* [I/O] Buffered string to be initialized */
 122     PCSZ source)    /* [I]   '\0' terminated string used to initialize target */
 123 {
 124     RtlInitAnsiString( target, source );
 125 }
 126
 127
 128 /**************************************************************************
 129  *      RtlFreeAnsiString   (NTDLL.@)
 130  */
 131 void WINAPI RtlFreeAnsiString( PSTRING str )
 132 {
 133     if (str->Buffer) RtlFreeHeap( GetProcessHeap(), 0, str->Buffer );
 134 }
 135
 136
 137 /**************************************************************************
 138  *      RtlFreeOemString   (NTDLL.@)
 139  */
 140 void WINAPI RtlFreeOemString( PSTRING str )
 141 {
 142     RtlFreeAnsiString( str );
 143 }
 144
 145
 146 /**************************************************************************
 147  *      RtlCopyString   (NTDLL.@)
 148  */
 149 void WINAPI RtlCopyString( STRING *dst, const STRING *src )
 150 {
 151     if (src)
 152     {
 153         unsigned int len = min( src->Length, dst->MaximumLength );
 154         memcpy( dst->Buffer, src->Buffer, len );
 155         dst->Length = len;
 156     }
 157     else dst->Length = 0;
 158 }
 159
 160
 161 /**************************************************************************
 162  *      RtlInitUnicodeString   (NTDLL.@)
 163  *
 164  * Initializes a buffered unicode string.
 165  *
 166  * RETURNS
 167  *  Nothing.
 168  *
 169  * NOTES
 170  *  Assigns source to target->Buffer. The length of source is assigned to
 171  *  target->Length and target->MaximumLength. If source is NULL the length
 172  *  of source is assumed to be 0.
 173  */
 174 void WINAPI RtlInitUnicodeString(
 175     PUNICODE_STRING target, /* [I/O] Buffered unicode string to be initialized */
 176     PCWSTR source)          /* [I]   '\0' terminated unicode string used to initialize target */
 177 {
 178     if ((target->Buffer = (PWSTR) source))
 179     {
 180         target->Length = strlenW(source) * sizeof(WCHAR);
 181         target->MaximumLength = target->Length + sizeof(WCHAR);
 182     }
 183     else target->Length = target->MaximumLength = 0;
 184 }
 185
 186
 187 /**************************************************************************
 188  *      RtlInitUnicodeStringEx   (NTDLL.@)
 189  *
 190  * Initializes a buffered unicode string.
 191  *
 192  * RETURNS
 193  *  Success: STATUS_SUCCESS. target is initialized.
 194  *  Failure: STATUS_NAME_TOO_LONG, if the source string is larger than 65532 bytes.
 195  *
 196  * NOTES
 197  *  Assigns source to target->Buffer. The length of source is assigned to
 198  *  target->Length and target->MaximumLength. If source is NULL the length
 199  *  of source is assumed to be 0.
 200  */
 201 NTSTATUS WINAPI RtlInitUnicodeStringEx(
 202     PUNICODE_STRING target, /* [I/O] Buffered unicode string to be initialized */
 203     PCWSTR source)          /* [I]   '\0' terminated unicode string used to initialize target */
 204 {
 205     if (source != NULL) {
 206         unsigned int len = strlenW(source) * sizeof(WCHAR);
 207
 208         if (len > 0xFFFC) {
 209             return STATUS_NAME_TOO_LONG;
 210         } else {
 211             target->Length = len;
 212             target->MaximumLength = len + sizeof(WCHAR);
 213             target->Buffer = (PWSTR) source;
 214         } /* if */
 215     } else {
 216         target->Length = 0;
 217         target->MaximumLength = 0;
 218         target->Buffer = NULL;
 219     } /* if */
 220     return STATUS_SUCCESS;
 221 }
 222
 223
 224 /**************************************************************************
 225  *      RtlCreateUnicodeString   (NTDLL.@)
 226  *
 227  * Creates a UNICODE_STRING from a null-terminated Unicode string.
 228  *
 229  * RETURNS
 230  *     Success: TRUE
 231  *     Failure: FALSE
 232  */
 233 BOOLEAN WINAPI RtlCreateUnicodeString( PUNICODE_STRING target, LPCWSTR src )
 234 {
 235     int len = (strlenW(src) + 1) * sizeof(WCHAR);
 236     if (!(target->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, len ))) return FALSE;
 237     memcpy( target->Buffer, src, len );
 238     target->MaximumLength = len;
 239     target->Length = len - sizeof(WCHAR);
 240     return TRUE;
 241 }
 242
 243
 244 /**************************************************************************
 245  *      RtlCreateUnicodeStringFromAsciiz   (NTDLL.@)
 246  *
 247  * Creates a UNICODE_STRING from a null-terminated Ascii string.
 248  *
 249  * RETURNS
 250  *     Success: TRUE
 251  *     Failure: FALSE
 252  */
 253 BOOLEAN WINAPI RtlCreateUnicodeStringFromAsciiz( PUNICODE_STRING target, LPCSTR src )
 254 {
 255     STRING ansi;
 256     RtlInitAnsiString( &ansi, src );
 257     return !RtlAnsiStringToUnicodeString( target, &ansi, TRUE );
 258 }
 259
 260
 261 /**************************************************************************
 262  *      RtlFreeUnicodeString   (NTDLL.@)
 263  *
 264  * Frees a UNICODE_STRING created with RtlCreateUnicodeString() or
 265  * RtlCreateUnicodeStringFromAsciiz().
 266  *
 267  * RETURNS
 268  *     nothing
 269  */
 270 void WINAPI RtlFreeUnicodeString( PUNICODE_STRING str )
 271 {
 272     if (str->Buffer) RtlFreeHeap( GetProcessHeap(), 0, str->Buffer );
 273 }
 274
 275
 276 /**************************************************************************
 277  *      RtlCopyUnicodeString   (NTDLL.@)
 278  *
 279  * Copies from one UNICODE_STRING to another.
 280  *
 281  * RETURNS
 282  *     nothing
 283  */
 284 void WINAPI RtlCopyUnicodeString( UNICODE_STRING *dst, const UNICODE_STRING *src )
 285 {
 286     if (src)
 287     {
 288         unsigned int len = min( src->Length, dst->MaximumLength );
 289         memcpy( dst->Buffer, src->Buffer, len );
 290         dst->Length = len;
 291         /* append terminating '\0' if enough space */
 292         if (len < dst->MaximumLength) dst->Buffer[len / sizeof(WCHAR)] = 0;
 293     }
 294     else dst->Length = 0;
 295 }
 296
 297
 298 /**************************************************************************
 299  *      RtlDuplicateUnicodeString   (NTDLL.@)
 300  *
 301  * Duplicates an unicode string.
 302  *
 303  * RETURNS
 304  *  Success: STATUS_SUCCESS. destination contains the duplicated unicode string.
 305  *  Failure: STATUS_INVALID_PARAMETER, if one of the parameters is illegal.
 306  *           STATUS_NO_MEMORY, if the allocation fails.
 307  *
 308  * NOTES
 309  *  For add_nul there are several possible values:
 310  *  0 = destination will not be '\0' terminated,
 311  *  1 = destination will be '\0' terminated,
 312  *  3 = like 1 but for an empty source string produce '\0' terminated empty
 313  *     Buffer instead of assigning NULL to the Buffer.
 314  *  Other add_nul values are invalid.
 315  */
 316 NTSTATUS WINAPI RtlDuplicateUnicodeString(
 317     int add_nul,                  /* [I] flag */
 318     const UNICODE_STRING *source, /* [I] Unicode string to be duplicated */
 319     UNICODE_STRING *destination)  /* [O] destination for the duplicated unicode string */
 320 {
 321     if (source == NULL || destination == NULL ||
 322         source->Length > source->MaximumLength ||
 323         (source->Length == 0 && source->MaximumLength > 0 && source->Buffer == NULL) ||
 324         add_nul == 2 || add_nul >= 4 || add_nul < 0) {
 325         return STATUS_INVALID_PARAMETER;
 326     } else {
 327         if (source->Length == 0 && add_nul != 3) {
 328             destination->Length = 0;
 329             destination->MaximumLength = 0;
 330             destination->Buffer = NULL;
 331         } else {
 332             unsigned int destination_max_len = source->Length;
 333
 334             if (add_nul) {
 335                 destination_max_len += sizeof(WCHAR);
 336             } /* if */
 337             destination->Buffer = RtlAllocateHeap(GetProcessHeap(), 0, destination_max_len);
 338             if (destination->Buffer == NULL) {
 339                 return STATUS_NO_MEMORY;
 340             } else {
 341                 memcpy(destination->Buffer, source->Buffer, source->Length);
 342                 destination->Length = source->Length;
 343                 destination->MaximumLength = source->Length;
 344                 /* append terminating '\0' if enough space */
 345                 if (add_nul) {
 346                     destination->MaximumLength = destination_max_len;
 347                     destination->Buffer[destination->Length / sizeof(WCHAR)] = 0;
 348                 } /* if */
 349             } /* if */
 350         } /* if */
 351     } /* if */
 352     return STATUS_SUCCESS;
 353 }
 354
 355
 356 /**************************************************************************
 357  *      RtlEraseUnicodeString   (NTDLL.@)
 358  *
 359  * Overwrites a UNICODE_STRING with zeros.
 360  *
 361  * RETURNS
 362  *     nothing
 363  */
 364 void WINAPI RtlEraseUnicodeString( UNICODE_STRING *str )
 365 {
 366     if (str->Buffer)
 367     {
 368         memset( str->Buffer, 0, str->MaximumLength );
 369         str->Length = 0;
 370     }
 371 }
 372
 373
 374 /*
 375     COMPARISON FUNCTIONS
 376 */
 377
 378
 379 /******************************************************************************
 380  *      RtlCompareString   (NTDLL.@)
 381  */
 382 LONG WINAPI RtlCompareString( const STRING *s1, const STRING *s2, BOOLEAN CaseInsensitive )
 383 {
 384     unsigned int len;
 385     LONG ret = 0;
 386     LPCSTR p1, p2;
 387
 388     len = min(s1->Length, s2->Length);
 389     p1 = s1->Buffer;
 390     p2 = s2->Buffer;
 391
 392     if (CaseInsensitive)
 393     {
 394         while (!ret && len--) ret = RtlUpperChar(*p1++) - RtlUpperChar(*p2++);
 395     }
 396     else
 397     {
 398         while (!ret && len--) ret = *p1++ - *p2++;
 399     }
 400     if (!ret) ret = s1->Length - s2->Length;
 401     return ret;
 402 }
 403
 404
 405 /******************************************************************************
 406  *      RtlCompareUnicodeString   (NTDLL.@)
 407  */
 408 LONG WINAPI RtlCompareUnicodeString( const UNICODE_STRING *s1, const UNICODE_STRING *s2,
 409                                      BOOLEAN CaseInsensitive )
 410 {
 411     unsigned int len;
 412     LONG ret = 0;
 413     LPCWSTR p1, p2;
 414
 415     len = min(s1->Length, s2->Length) / sizeof(WCHAR);
 416     p1 = s1->Buffer;
 417     p2 = s2->Buffer;
 418
 419     if (CaseInsensitive)
 420     {
 421         while (!ret && len--) ret = toupperW(*p1++) - toupperW(*p2++);
 422     }
 423     else
 424     {
 425         while (!ret && len--) ret = *p1++ - *p2++;
 426     }
 427     if (!ret) ret = s1->Length - s2->Length;
 428     return ret;
 429 }
 430
 431
 432 /**************************************************************************
 433  *      RtlEqualString   (NTDLL.@)
 434  *
 435  * Determine if two strings are equal.
 436  *
 437  * PARAMS
 438  *  s1              [I] Source string
 439  *  s2              [I] String to compare to s1
 440  *  CaseInsensitive [I] TRUE = Case insensitive, FALSE = Case sensitive
 441  *
 442  * RETURNS
 443  *  Non-zero if s1 is equal to s2, 0 otherwise.
 444  */
 445 BOOLEAN WINAPI RtlEqualString( const STRING *s1, const STRING *s2, BOOLEAN CaseInsensitive )
 446 {
 447     if (s1->Length != s2->Length) return FALSE;
 448     return !RtlCompareString( s1, s2, CaseInsensitive );
 449 }
 450
 451
 452 /**************************************************************************
 453  *      RtlEqualUnicodeString   (NTDLL.@)
 454  *
 455  * Unicode version of RtlEqualString.
 456  */
 457 BOOLEAN WINAPI RtlEqualUnicodeString( const UNICODE_STRING *s1, const UNICODE_STRING *s2,
 458                                       BOOLEAN CaseInsensitive )
 459 {
 460     if (s1->Length != s2->Length) return FALSE;
 461     return !RtlCompareUnicodeString( s1, s2, CaseInsensitive );
 462 }
 463
 464
 465 /**************************************************************************
 466  *      RtlPrefixString   (NTDLL.@)
 467  *
 468  * Determine if one string is a prefix of another.
 469  *
 470  * PARAMS
 471  *  s1          [I] Prefix to look for in s2
 472  *  s2          [I] String that may contain s1 as a prefix
 473  *  ignore_case [I] TRUE = Case insensitive, FALSE = Case sensitive
 474  *
 475  * RETURNS
 476  *  TRUE if s2 contains s1 as a prefix, FALSE otherwise.
 477  */
 478 BOOLEAN WINAPI RtlPrefixString( const STRING *s1, const STRING *s2, BOOLEAN ignore_case )
 479 {
 480     unsigned int i;
 481
 482     if (s1->Length > s2->Length) return FALSE;
 483     if (ignore_case)
 484     {
 485         for (i = 0; i < s1->Length; i++)
 486             if (RtlUpperChar(s1->Buffer[i]) != RtlUpperChar(s2->Buffer[i])) return FALSE;
 487     }
 488     else
 489     {
 490         for (i = 0; i < s1->Length; i++)
 491             if (s1->Buffer[i] != s2->Buffer[i]) return FALSE;
 492     }
 493     return TRUE;
 494 }
 495
 496
 497 /**************************************************************************
 498  *      RtlPrefixUnicodeString   (NTDLL.@)
 499  *
 500  * Unicode version of RtlPrefixString.
 501  */
 502 BOOLEAN WINAPI RtlPrefixUnicodeString( const UNICODE_STRING *s1,
 503                                        const UNICODE_STRING *s2,
 504                                        BOOLEAN ignore_case )
 505 {
 506     unsigned int i;
 507
 508     if (s1->Length > s2->Length) return FALSE;
 509     if (ignore_case)
 510     {
 511         for (i = 0; i < s1->Length / sizeof(WCHAR); i++)
 512             if (toupperW(s1->Buffer[i]) != toupperW(s2->Buffer[i])) return FALSE;
 513     }
 514     else
 515     {
 516         for (i = 0; i < s1->Length / sizeof(WCHAR); i++)
 517             if (s1->Buffer[i] != s2->Buffer[i]) return FALSE;
 518     }
 519     return TRUE;
 520 }
 521
 522
 523 /**************************************************************************
 524  *      RtlEqualComputerName   (NTDLL.@)
 525  *
 526  * Determine if two computer names are the same.
 527  *
 528  * PARAMS
 529  *  left  [I] First computer name
 530  *  right [I] Second computer name
 531  *
 532  * RETURNS
 533  *  0 if the names are equal, non-zero otherwise.
 534  *
 535  * NOTES
 536  *  The comparison is case insensitive.
 537  */
 538 NTSTATUS WINAPI RtlEqualComputerName(const UNICODE_STRING *left,
 539                                      const UNICODE_STRING *right)
 540 {
 541     NTSTATUS ret;
 542     STRING upLeft, upRight;
 543
 544     if (!(ret = RtlUpcaseUnicodeStringToOemString( &upLeft, left, TRUE )))
 545     {
 546        if (!(ret = RtlUpcaseUnicodeStringToOemString( &upRight, right, TRUE )))
 547        {
 548          ret = RtlEqualString( &upLeft, &upRight, FALSE );
 549          RtlFreeOemString( &upRight );
 550        }
 551        RtlFreeOemString( &upLeft );
 552     }
 553     return ret;
 554 }
 555
 556
 557 /**************************************************************************
 558  *      RtlEqualDomainName   (NTDLL.@)
 559  *
 560  * Determine if two domain names are the same.
 561  *
 562  * PARAMS
 563  *  left  [I] First domain name
 564  *  right [I] Second domain name
 565  *
 566  * RETURNS
 567  *  0 if the names are equal, non-zero otherwise.
 568  *
 569  * NOTES
 570  *  The comparison is case insensitive.
 571  */
 572 NTSTATUS WINAPI RtlEqualDomainName(const UNICODE_STRING *left,
 573                                    const UNICODE_STRING *right)
 574 {
 575     return RtlEqualComputerName(left, right);
 576 }
 577
 578
 579 /**************************************************************************
 580  *      RtlAnsiCharToUnicodeChar   (NTDLL.@)
 581  *
 582  * Converts the first ansi character to a unicode character.
 583  *
 584  * PARAMS
 585  *  ansi [I/O] Pointer to the ansi string.
 586  *
 587  * RETURNS
 588  *  Unicode representation of the first character in the ansi string.
 589  *
 590  * NOTES
 591  *  Upon successful completion, the char pointer ansi points to is
 592  *  incremented by the size of the character.
 593  */
 594 WCHAR WINAPI RtlAnsiCharToUnicodeChar(LPSTR *ansi)
 595 {
 596     WCHAR str;
 597     DWORD charSize = sizeof(CHAR);
 598
 599     if (is_dbcs_leadbyte(ansi_table, **ansi))
 600         charSize++;
 601
 602     RtlMultiByteToUnicodeN(&str, sizeof(WCHAR), NULL, *ansi, charSize);
 603     *ansi += charSize;
 604
 605     return str;
 606 }
 607
 608 /*
 609         COPY BETWEEN ANSI_STRING or UNICODE_STRING
 610         there is no parameter checking, it just crashes
 611 */
 612
 613
 614 /**************************************************************************
 615  *      RtlAnsiStringToUnicodeString   (NTDLL.@)
 616  *
 617  * Converts an ansi string to an unicode string.
 618  *
 619  * RETURNS
 620  *  Success: STATUS_SUCCESS. uni contains the converted string
 621  *  Failure: STATUS_BUFFER_OVERFLOW, if doalloc is FALSE and ansi is too small.
 622  *           STATUS_NO_MEMORY, if doalloc is TRUE and the allocation fails.
 623  *           STATUS_INVALID_PARAMETER_2, if the unicode string would be larger than 65535.
 624  *
 625  * NOTES
 626  *  This function always writes a terminating '\0'.
 627  */
 628 NTSTATUS WINAPI RtlAnsiStringToUnicodeString(
 629     PUNICODE_STRING uni, /* [I/O] Destination for the unicode string */
 630     PCANSI_STRING ansi,  /* [I]   Ansi string to be converted */
 631     BOOLEAN doalloc)     /* [I]   TRUE=Allocate new buffer for uni, FALSE=Use existing buffer */
 632 {
 633     DWORD total = RtlAnsiStringToUnicodeSize( ansi );
 634
 635     if (total > 0xffff) return STATUS_INVALID_PARAMETER_2;
 636     uni->Length = total - sizeof(WCHAR);
 637     if (doalloc)
 638     {
 639         uni->MaximumLength = total;
 640         if (!(uni->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, total )))
 641             return STATUS_NO_MEMORY;
 642     }
 643     else if (total > uni->MaximumLength) return STATUS_BUFFER_OVERFLOW;
 644
 645     RtlMultiByteToUnicodeN( uni->Buffer, uni->Length, NULL, ansi->Buffer, ansi->Length );
 646     uni->Buffer[uni->Length / sizeof(WCHAR)] = 0;
 647     return STATUS_SUCCESS;
 648 }
 649
 650
 651 /**************************************************************************
 652  *      RtlOemStringToUnicodeString   (NTDLL.@)
 653  *
 654  * Converts an oem string to an unicode string.
 655  *
 656  * RETURNS
 657  *  Success: STATUS_SUCCESS. uni contains the converted string
 658  *  Failure: STATUS_BUFFER_OVERFLOW, if doalloc is FALSE and oem is too small.
 659  *           STATUS_NO_MEMORY, if doalloc is TRUE and the allocation fails.
 660  *           STATUS_INVALID_PARAMETER_2, if the unicode string would be larger than 65535.
 661  *
 662  * NOTES
 663  *  This function always writes a terminating '\0'.
 664  */
 665 NTSTATUS WINAPI RtlOemStringToUnicodeString(
 666     UNICODE_STRING *uni, /* [I/O] Destination for the unicode string */
 667     const STRING *oem,   /* [I]   Oem string to be converted */
 668     BOOLEAN doalloc)     /* [I]   TRUE=Allocate new buffer for uni, FALSE=Use existing buffer */
 669 {
 670     DWORD total = RtlOemStringToUnicodeSize( oem );
 671
 672     if (total > 0xffff) return STATUS_INVALID_PARAMETER_2;
 673     uni->Length = total - sizeof(WCHAR);
 674     if (doalloc)
 675     {
 676         uni->MaximumLength = total;
 677         if (!(uni->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, total )))
 678             return STATUS_NO_MEMORY;
 679     }
 680     else if (total > uni->MaximumLength) return STATUS_BUFFER_OVERFLOW;
 681
 682     RtlOemToUnicodeN( uni->Buffer, uni->Length, NULL, oem->Buffer, oem->Length );
 683     uni->Buffer[uni->Length / sizeof(WCHAR)] = 0;
 684     return STATUS_SUCCESS;
 685 }
 686
 687
 688 /**************************************************************************
 689  *      RtlUnicodeStringToAnsiString   (NTDLL.@)
 690  *
 691  * Converts an unicode string to an ansi string.
 692  *
 693  * RETURNS
 694  *  Success: STATUS_SUCCESS. ansi contains the converted string
 695  *  Failure: STATUS_BUFFER_OVERFLOW, if doalloc is FALSE and ansi is too small.
 696  *           STATUS_NO_MEMORY, if doalloc is TRUE and the allocation fails.
 697  *
 698  * NOTES
 699  *  This function always writes a terminating '\0'.
 700  *  It performs a partial copy if ansi is too small.
 701  */
 702 NTSTATUS WINAPI RtlUnicodeStringToAnsiString(
 703     STRING *ansi,              /* [I/O] Destination for the ansi string */
 704     const UNICODE_STRING *uni, /* [I]   Unicode string to be converted */
 705     BOOLEAN doalloc)           /* [I]   TRUE=Allocate new buffer for ansi, FALSE=Use existing buffer */
 706 {
 707     NTSTATUS ret = STATUS_SUCCESS;
 708     DWORD len = RtlUnicodeStringToAnsiSize( uni );
 709
 710     ansi->Length = len - 1;
 711     if (doalloc)
 712     {
 713         ansi->MaximumLength = len;
 714         if (!(ansi->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, len )))
 715             return STATUS_NO_MEMORY;
 716     }
 717     else if (ansi->MaximumLength < len)
 718     {
 719         if (!ansi->MaximumLength) return STATUS_BUFFER_OVERFLOW;
 720         ansi->Length = ansi->MaximumLength - 1;
 721         ret = STATUS_BUFFER_OVERFLOW;
 722     }
 723
 724     RtlUnicodeToMultiByteN( ansi->Buffer, ansi->Length, NULL, uni->Buffer, uni->Length );
 725     ansi->Buffer[ansi->Length] = 0;
 726     return ret;
 727 }
 728
 729
 730 /**************************************************************************
 731  *      RtlUnicodeStringToOemString   (NTDLL.@)
 732  *
 733  * Converts a Rtl Unicode string to an OEM string.
 734  *
 735  * PARAMS
 736  *  oem     [O] Destination for OEM string
 737  *  uni     [I] Source Unicode string
 738  *  doalloc [I] TRUE=Allocate new buffer for oem,FALSE=Use existing buffer
 739  *
 740  * RETURNS
 741  *  Success: STATUS_SUCCESS. oem contains the converted string
 742  *  Failure: STATUS_BUFFER_OVERFLOW, if doalloc is FALSE and oem is too small.
 743  *           STATUS_NO_MEMORY, if doalloc is TRUE and allocation fails.
 744  *
 745  * NOTES
 746  *   If doalloc is TRUE, the length allocated is uni->Length + 1.
 747  *   This function always '\0' terminates the string returned.
 748  */
 749 NTSTATUS WINAPI RtlUnicodeStringToOemString( STRING *oem,
 750                                              const UNICODE_STRING *uni,
 751                                              BOOLEAN doalloc )
 752 {
 753     NTSTATUS ret = STATUS_SUCCESS;
 754     DWORD len = RtlUnicodeStringToOemSize( uni );
 755
 756     oem->Length = len - 1;
 757     if (doalloc)
 758     {
 759         oem->MaximumLength = len;
 760         if (!(oem->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, len )))
 761             return STATUS_NO_MEMORY;
 762     }
 763     else if (oem->MaximumLength < len)
 764     {
 765         if (!oem->MaximumLength) return STATUS_BUFFER_OVERFLOW;
 766         oem->Length = oem->MaximumLength - 1;
 767         ret = STATUS_BUFFER_OVERFLOW;
 768     }
 769
 770     RtlUnicodeToOemN( oem->Buffer, oem->Length, NULL, uni->Buffer, uni->Length );
 771     oem->Buffer[oem->Length] = 0;
 772     return ret;
 773 }
 774
 775
 776 /**************************************************************************
 777  *      RtlMultiByteToUnicodeN   (NTDLL.@)
 778  *
 779  * Converts a multi-byte string to a Unicode string.
 780  *
 781  * RETURNS
 782  *  NTSTATUS code
 783  *
 784  * NOTES
 785  *  Performs a partial copy if dst is too small.
 786  */
 787 NTSTATUS WINAPI RtlMultiByteToUnicodeN( LPWSTR dst, DWORD dstlen, LPDWORD reslen,
 788                                         LPCSTR src, DWORD srclen )
 789 {
 790
 791     int ret = wine_cp_mbstowcs( ansi_table, 0, src, srclen, dst, dstlen/sizeof(WCHAR) );
 792     if (reslen)
 793         *reslen = (ret >= 0) ? ret*sizeof(WCHAR) : dstlen; /* overflow -> we filled up to dstlen */
 794     return STATUS_SUCCESS;
 795 }
 796
 797
 798 /**************************************************************************
 799  *      RtlOemToUnicodeN   (NTDLL.@)
 800  *
 801  * Converts a multi-byte string in the OEM code page to a Unicode string.
 802  *
 803  * RETURNS
 804  *  NTSTATUS code
 805  */
 806 NTSTATUS WINAPI RtlOemToUnicodeN( LPWSTR dst, DWORD dstlen, LPDWORD reslen,
 807                                   LPCSTR src, DWORD srclen )
 808 {
 809     int ret = wine_cp_mbstowcs( oem_table, 0, src, srclen, dst, dstlen/sizeof(WCHAR) );
 810     if (reslen)
 811         *reslen = (ret >= 0) ? ret*sizeof(WCHAR) : dstlen; /* overflow -> we filled up to dstlen */
 812     return STATUS_SUCCESS;
 813 }
 814
 815
 816 /**************************************************************************
 817  *      RtlUnicodeToMultiByteN   (NTDLL.@)
 818  *
 819  * Converts a Unicode string to a multi-byte string in the ANSI code page.
 820  *
 821  * RETURNS
 822  *  NTSTATUS code
 823  */
 824 NTSTATUS WINAPI RtlUnicodeToMultiByteN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
 825                                         LPCWSTR src, DWORD srclen )
 826 {
 827     int ret = wine_cp_wcstombs( ansi_table, 0, src, srclen / sizeof(WCHAR),
 828                                 dst, dstlen, NULL, NULL );
 829     if (reslen)
 830         *reslen = (ret >= 0) ? ret : dstlen; /* overflow -> we filled up to dstlen */
 831     return STATUS_SUCCESS;
 832 }
 833
 834
 835 /**************************************************************************
 836  *      RtlUnicodeToOemN   (NTDLL.@)
 837  *
 838  * Converts a Unicode string to a multi-byte string in the OEM code page.
 839  *
 840  * RETURNS
 841  *  NTSTATUS code
 842  */
 843 NTSTATUS WINAPI RtlUnicodeToOemN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
 844                                   LPCWSTR src, DWORD srclen )
 845 {
 846     int ret = wine_cp_wcstombs( oem_table, 0, src, srclen / sizeof(WCHAR),
 847                                 dst, dstlen, NULL, NULL );
 848     if (reslen)
 849         *reslen = (ret >= 0) ? ret : dstlen; /* overflow -> we filled up to dstlen */
 850     return STATUS_SUCCESS;
 851 }
 852
 853
 854 /*
 855      CASE CONVERSIONS
 856 */
 857
 858
 859 /**************************************************************************
 860  *      RtlUpperChar   (NTDLL.@)
 861  *
 862  * Converts an Ascii character to uppercase.
 863  *
 864  * PARAMS
 865  *  ch [I] Character to convert
 866  *
 867  * RETURNS
 868  *  The uppercase character value.
 869  *
 870  * NOTES
 871  *  For the input characters from 'a' .. 'z' it returns 'A' .. 'Z'.
 872  *  All other input characters are returned unchanged. The locale and
 873  *  multibyte characters are not taken into account (as native DLL).
 874  */
 875 CHAR WINAPI RtlUpperChar( CHAR ch )
 876 {
 877     if (ch >= 'a' && ch <= 'z') {
 878         return ch - 'a' + 'A';
 879     } else {
 880         return ch;
 881     } /* if */
 882 }
 883
 884
 885 /**************************************************************************
 886  *      RtlUpperString   (NTDLL.@)
 887  *
 888  * Converts an Ascii string to uppercase.
 889  *
 890  * PARAMS
 891  *  dst [O] Destination for converted string
 892  *  src [I] Source string to convert
 893  *
 894  * RETURNS
 895  *  Nothing.
 896  *
 897  * NOTES
 898  *  For the src characters from 'a' .. 'z' it assigns 'A' .. 'Z' to dst.
 899  *  All other src characters are copied unchanged to dst. The locale and
 900  *  multibyte characters are not taken into account (as native DLL).
 901  *  The number of character copied is the minimum of src->Length and
 902  *  the dst->MaximumLength.
 903  */
 904 void WINAPI RtlUpperString( STRING *dst, const STRING *src )
 905 {
 906     unsigned int i, len = min(src->Length, dst->MaximumLength);
 907
 908     for (i = 0; i < len; i++) dst->Buffer[i] = RtlUpperChar(src->Buffer[i]);
 909     dst->Length = len;
 910 }
 911
 912
 913 /**************************************************************************
 914  *      RtlUpcaseUnicodeChar   (NTDLL.@)
 915  *
 916  * Converts an Unicode character to uppercase.
 917  *
 918  * PARAMS
 919  *  wch [I] Character to convert
 920  *
 921  * RETURNS
 922  *  The uppercase character value.
 923  */
 924 WCHAR WINAPI RtlUpcaseUnicodeChar( WCHAR wch )
 925 {
 926     return toupperW(wch);
 927 }
 928
 929
 930 /**************************************************************************
 931  *      RtlDowncaseUnicodeChar   (NTDLL.@)
 932  *
 933  * Converts an Unicode character to lowercase.
 934  *
 935  * PARAMS
 936  *  wch [I] Character to convert
 937  *
 938  * RETURNS
 939  *  The lowercase character value.
 940  */
 941 WCHAR WINAPI RtlDowncaseUnicodeChar(WCHAR wch)
 942 {
 943     return tolowerW(wch);
 944 }
 945
 946
 947 /**************************************************************************
 948  *      RtlUpcaseUnicodeString   (NTDLL.@)
 949  *
 950  * Converts an Unicode string to uppercase.
 951  *
 952  * PARAMS
 953  *  dest    [O] Destination for converted string
 954  *  src     [I] Source string to convert
 955  *  doalloc [I] TRUE=Allocate a buffer for dest if it doesn't have one
 956  *
 957  * RETURNS
 958  *  Success: STATUS_SUCCESS. dest contains the converted string.
 959  *  Failure: STATUS_NO_MEMORY, if doalloc is TRUE and memory allocation fails, or
 960  *           STATUS_BUFFER_OVERFLOW, if doalloc is FALSE and dest is too small.
 961  *
 962  * NOTES
 963  *  dest is never '\0' terminated because it may be equal to src, and src
 964  *  might not be '\0' terminated. dest->Length is only set upon success.
 965  */
 966 NTSTATUS WINAPI RtlUpcaseUnicodeString( UNICODE_STRING *dest,
 967                                         const UNICODE_STRING *src,
 968                                         BOOLEAN doalloc)
 969 {
 970     DWORD i, len = src->Length;
 971
 972     if (doalloc)
 973     {
 974         dest->MaximumLength = len;
 975         if (!(dest->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, len )))
 976             return STATUS_NO_MEMORY;
 977     }
 978     else if (len > dest->MaximumLength) return STATUS_BUFFER_OVERFLOW;
 979
 980     for (i = 0; i < len/sizeof(WCHAR); i++) dest->Buffer[i] = toupperW(src->Buffer[i]);
 981     dest->Length = len;
 982     return STATUS_SUCCESS;
 983 }
 984
 985
 986 /**************************************************************************
 987  *      RtlDowncaseUnicodeString   (NTDLL.@)
 988  *
 989  * Converts an Unicode string to lowercase.
 990  *
 991  * PARAMS
 992  *  dest    [O] Destination for converted string
 993  *  src     [I] Source string to convert
 994  *  doalloc [I] TRUE=Allocate a buffer for dest if it doesn't have one
 995  *
 996  * RETURNS
 997  *  Success: STATUS_SUCCESS. dest contains the converted string.
 998  *  Failure: STATUS_NO_MEMORY, if doalloc is TRUE and memory allocation fails, or
 999  *           STATUS_BUFFER_OVERFLOW, if doalloc is FALSE and dest is too small.
1000  *
1001  * NOTES
1002  *  dest is never '\0' terminated because it may be equal to src, and src
1003  *  might not be '\0' terminated. dest->Length is only set upon success.
1004  */
1005 NTSTATUS WINAPI RtlDowncaseUnicodeString(
1006     UNICODE_STRING *dest,
1007     const UNICODE_STRING *src,
1008     BOOLEAN doalloc)
1009 {
1010     DWORD i;
1011     DWORD len = src->Length;
1012
1013     if (doalloc) {
1014         dest->MaximumLength = len;
1015         if (!(dest->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, len ))) {
1016             return STATUS_NO_MEMORY;
1017         } /* if */
1018     } else if (len > dest->MaximumLength) {
1019         return STATUS_BUFFER_OVERFLOW;
1020     } /* if */
1021
1022     for (i = 0; i < len/sizeof(WCHAR); i++) {
1023         dest->Buffer[i] = tolowerW(src->Buffer[i]);
1024     } /* for */
1025     dest->Length = len;
1026     return STATUS_SUCCESS;
1027 }
1028
1029
1030 /**************************************************************************
1031  *      RtlUpcaseUnicodeStringToAnsiString   (NTDLL.@)
1032  *
1033  * Converts a Unicode string to the equivalent ANSI upper-case representation.
1034  *
1035  * RETURNS
1036  *  NTSTATUS code
1037  *
1038  * NOTES
1039  *  writes terminating 0
1040  */
1041 NTSTATUS WINAPI RtlUpcaseUnicodeStringToAnsiString( STRING *dst,
1042                                                     const UNICODE_STRING *src,
1043                                                     BOOLEAN doalloc )
1044 {
1045     NTSTATUS ret;
1046     UNICODE_STRING upcase;
1047
1048     if (!(ret = RtlUpcaseUnicodeString( &upcase, src, TRUE )))
1049     {
1050         ret = RtlUnicodeStringToAnsiString( dst, &upcase, doalloc );
1051         RtlFreeUnicodeString( &upcase );
1052     }
1053     return ret;
1054 }
1055
1056
1057 /**************************************************************************
1058  *      RtlUpcaseUnicodeStringToOemString   (NTDLL.@)
1059  *
1060  * Converts a UNICODE_STRING to the equivalent OEM upper-case representation
1061  * stored in STRING format.
1062  *
1063  * RETURNS
1064  *  NTSTATUS code
1065  *
1066  * NOTES
1067  *  writes terminating 0
1068  */
1069 NTSTATUS WINAPI RtlUpcaseUnicodeStringToOemString( STRING *dst,
1070                                                    const UNICODE_STRING *src,
1071                                                    BOOLEAN doalloc )
1072 {
1073     NTSTATUS ret;
1074     UNICODE_STRING upcase;
1075
1076     if (!(ret = RtlUpcaseUnicodeString( &upcase, src, TRUE )))
1077     {
1078         ret = RtlUnicodeStringToOemString( dst, &upcase, doalloc );
1079         RtlFreeUnicodeString( &upcase );
1080     }
1081     return ret;
1082 }
1083
1084
1085 /**************************************************************************
1086  *      RtlUpcaseUnicodeStringToCountedOemString   (NTDLL.@)
1087  *
1088  * Converts a UNICODE_STRING to the equivalent OEM upper-case representation
1089  * stored in STRING format.
1090  *
1091  * RETURNS
1092  *  NTSTATUS code
1093  *
1094  * NOTES
1095  *  Same as RtlUpcaseUnicodeStringToOemString but doesn't write terminating null
1096  */
1097 NTSTATUS WINAPI RtlUpcaseUnicodeStringToCountedOemString( STRING *oem,
1098                                                           const UNICODE_STRING *uni,
1099                                                           BOOLEAN doalloc )
1100 {
1101     NTSTATUS ret;
1102     UNICODE_STRING upcase;
1103     WCHAR tmp[32];
1104
1105     upcase.Buffer = tmp;
1106     upcase.MaximumLength = sizeof(tmp);
1107     ret = RtlUpcaseUnicodeString( &upcase, uni, FALSE );
1108     if (ret == STATUS_BUFFER_OVERFLOW) ret = RtlUpcaseUnicodeString( &upcase, uni, TRUE );
1109
1110     if (!ret)
1111     {
1112         DWORD len = RtlUnicodeStringToOemSize( &upcase ) - 1;
1113         oem->Length = len;
1114         if (doalloc)
1115         {
1116             oem->MaximumLength = len;
1117             if (!(oem->Buffer = RtlAllocateHeap( GetProcessHeap(), 0, len )))
1118             {
1119                 ret = STATUS_NO_MEMORY;
1120                 goto done;
1121             }
1122         }
1123         else if (oem->MaximumLength < len)
1124         {
1125             ret = STATUS_BUFFER_OVERFLOW;
1126             oem->Length = oem->MaximumLength;
1127             if (!oem->MaximumLength) goto done;
1128         }
1129         RtlUnicodeToOemN( oem->Buffer, oem->Length, NULL, upcase.Buffer, upcase.Length );
1130     done:
1131         if (upcase.Buffer != tmp) RtlFreeUnicodeString( &upcase );
1132     }
1133     return ret;
1134 }
1135
1136
1137 /**************************************************************************
1138  *      RtlUpcaseUnicodeToMultiByteN   (NTDLL.@)
1139  *
1140  * Converts a Unicode string to the equivalent ANSI upper-case representation.
1141  *
1142  * RETURNS
1143  *  NTSTATUS code
1144  */
1145 NTSTATUS WINAPI RtlUpcaseUnicodeToMultiByteN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
1146                                               LPCWSTR src, DWORD srclen )
1147 {
1148     NTSTATUS ret;
1149     LPWSTR upcase;
1150     DWORD i;
1151
1152     if (!(upcase = RtlAllocateHeap( GetProcessHeap(), 0, srclen ))) return STATUS_NO_MEMORY;
1153     for (i = 0; i < srclen/sizeof(WCHAR); i++) upcase[i] = toupperW(src[i]);
1154     ret = RtlUnicodeToMultiByteN( dst, dstlen, reslen, upcase, srclen );
1155     RtlFreeHeap( GetProcessHeap(), 0, upcase );
1156     return ret;
1157 }
1158
1159
1160 /**************************************************************************
1161  *      RtlUpcaseUnicodeToOemN   (NTDLL.@)
1162  *
1163  * Converts a Unicode string to the equivalent OEM upper-case representation.
1164  *
1165  * RETURNS
1166  *  NTSTATUS code
1167  */
1168 NTSTATUS WINAPI RtlUpcaseUnicodeToOemN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
1169                                         LPCWSTR src, DWORD srclen )
1170 {
1171     NTSTATUS ret;
1172     LPWSTR upcase;
1173     DWORD i;
1174
1175     if (!(upcase = RtlAllocateHeap( GetProcessHeap(), 0, srclen ))) return STATUS_NO_MEMORY;
1176     for (i = 0; i < srclen/sizeof(WCHAR); i++) upcase[i] = toupperW(src[i]);
1177     ret = RtlUnicodeToOemN( dst, dstlen, reslen, upcase, srclen );
1178     RtlFreeHeap( GetProcessHeap(), 0, upcase );
1179     return ret;
1180 }
1181
1182
1183 /*
1184         STRING SIZE
1185 */
1186
1187
1188 /**************************************************************************
1189  *      RtlOemStringToUnicodeSize   (NTDLL.@)
1190  *      RtlxOemStringToUnicodeSize  (NTDLL.@)
1191  *
1192  * Calculate the size in bytes necessary for the Unicode conversion of str,
1193  * including the terminating '\0'.
1194  *
1195  * PARAMS
1196  *  str [I] String to calculate the size of
1197  *
1198  * RETURNS
1199  *  The calculated size.
1200  */
1201 UINT WINAPI RtlOemStringToUnicodeSize( const STRING *str )
1202 {
1203     int ret = wine_cp_mbstowcs( oem_table, 0, str->Buffer, str->Length, NULL, 0 );
1204     return (ret + 1) * sizeof(WCHAR);
1205 }
1206
1207
1208 /**************************************************************************
1209  *      RtlAnsiStringToUnicodeSize   (NTDLL.@)
1210  *      RtlxAnsiStringToUnicodeSize  (NTDLL.@)
1211  *
1212  * Calculate the size in bytes necessary for the Unicode conversion of str,
1213  * including the terminating '\0'.
1214  *
1215  * PARAMS
1216  *  str [I] String to calculate the size of
1217  *
1218  * RETURNS
1219  *  The calculated size.
1220  */
1221 DWORD WINAPI RtlAnsiStringToUnicodeSize( const STRING *str )
1222 {
1223     DWORD ret;
1224     RtlMultiByteToUnicodeSize( &ret, str->Buffer, str->Length );
1225     return ret + sizeof(WCHAR);
1226 }
1227
1228
1229 /**************************************************************************
1230  *      RtlMultiByteToUnicodeSize   (NTDLL.@)
1231  *
1232  * Compute the size in bytes necessary for the Unicode conversion of str,
1233  * without the terminating '\0'.
1234  *
1235  * PARAMS
1236  *  size [O] Destination for size
1237  *  str  [I] String to calculate the size of
1238  *  len  [I] Length of str
1239  *
1240  * RETURNS
1241  *  STATUS_SUCCESS.
1242  */
1243 NTSTATUS WINAPI RtlMultiByteToUnicodeSize( DWORD *size, LPCSTR str, UINT len )
1244 {
1245     *size = wine_cp_mbstowcs( ansi_table, 0, str, len, NULL, 0 ) * sizeof(WCHAR);
1246     return STATUS_SUCCESS;
1247 }
1248
1249
1250 /**************************************************************************
1251  *      RtlUnicodeToMultiByteSize   (NTDLL.@)
1252  *
1253  * Calculate the size in bytes necessary for the multibyte conversion of str,
1254  * without the terminating '\0'.
1255  *
1256  * PARAMS
1257  *  size [O] Destination for size
1258  *  str  [I] String to calculate the size of
1259  *  len  [I] Length of str
1260  *
1261  * RETURNS
1262  *  STATUS_SUCCESS.
1263  */
1264 NTSTATUS WINAPI RtlUnicodeToMultiByteSize( PULONG size, LPCWSTR str, ULONG len )
1265 {
1266     *size = wine_cp_wcstombs( ansi_table, 0, str, len / sizeof(WCHAR), NULL, 0, NULL, NULL );
1267     return STATUS_SUCCESS;
1268 }
1269
1270
1271 /**************************************************************************
1272  *      RtlUnicodeStringToAnsiSize   (NTDLL.@)
1273  *      RtlxUnicodeStringToAnsiSize  (NTDLL.@)
1274  *
1275  * Calculate the size in bytes necessary for the Ansi conversion of str,
1276  * including the terminating '\0'.
1277  *
1278  * PARAMS
1279  *  str [I] String to calculate the size of
1280  *
1281  * RETURNS
1282  *  The calculated size.
1283  */
1284 DWORD WINAPI RtlUnicodeStringToAnsiSize( const UNICODE_STRING *str )
1285 {
1286     DWORD ret;
1287     RtlUnicodeToMultiByteSize( &ret, str->Buffer, str->Length );
1288     return ret + 1;
1289 }
1290
1291
1292 /**************************************************************************
1293  *      RtlUnicodeStringToOemSize   (NTDLL.@)
1294  *      RtlxUnicodeStringToOemSize  (NTDLL.@)
1295  *
1296  * Calculate the size in bytes necessary for the OEM conversion of str,
1297  * including the terminating '\0'.
1298  *
1299  * PARAMS
1300  *  str [I] String to calculate the size of
1301  *
1302  * RETURNS
1303  *  The calculated size.
1304  */
1305 DWORD WINAPI RtlUnicodeStringToOemSize( const UNICODE_STRING *str )
1306 {
1307     return wine_cp_wcstombs( oem_table, 0, str->Buffer, str->Length / sizeof(WCHAR),
1308                              NULL, 0, NULL, NULL ) + 1;
1309 }
1310
1311
1312 /**************************************************************************
1313  *      RtlAppendAsciizToString   (NTDLL.@)
1314  *
1315  * Concatenates a buffered character string and a '\0' terminated character
1316  * string
1317  *
1318  * RETURNS
1319  *  Success: STATUS_SUCCESS. src is appended to dest.
1320  *  Failure: STATUS_BUFFER_TOO_SMALL, if the buffer of dest is too small
1321  *                  to hold the concatenated string.
1322  *
1323  * NOTES
1324  *  if src is NULL dest is unchanged.
1325  *  dest is never '\0' terminated.
1326  */
1327 NTSTATUS WINAPI RtlAppendAsciizToString(
1328     STRING *dest, /* [I/O] Buffered character string to which src is concatenated */
1329     LPCSTR src)   /* [I]   '\0' terminated character string to be concatenated */
1330 {
1331     if (src != NULL) {
1332         unsigned int src_len = strlen(src);
1333         unsigned int dest_len  = src_len + dest->Length;
1334
1335         if (dest_len > dest->MaximumLength) return STATUS_BUFFER_TOO_SMALL;
1336         memcpy(dest->Buffer + dest->Length, src, src_len);
1337         dest->Length = dest_len;
1338     } /* if */
1339     return STATUS_SUCCESS;
1340 }
1341
1342
1343 /**************************************************************************
1344  *      RtlAppendStringToString   (NTDLL.@)
1345  *
1346  * Concatenates two buffered character strings
1347  *
1348  * RETURNS
1349  *  Success: STATUS_SUCCESS. src is appended to dest.
1350  *  Failure: STATUS_BUFFER_TOO_SMALL, if the buffer of dest is too small
1351  *                  to hold the concatenated string.
1352  *
1353  * NOTES
1354  *  if src->length is zero dest is unchanged.
1355  *  dest is never '\0' terminated.
1356  */
1357 NTSTATUS WINAPI RtlAppendStringToString(
1358     STRING *dest,       /* [I/O] Buffered character string to which src is concatenated */
1359     const STRING *src)  /* [I]   Buffered character string to be concatenated */
1360 {
1361     if (src->Length != 0) {
1362         unsigned int dest_len = src->Length + dest->Length;
1363
1364         if (dest_len > dest->MaximumLength) return STATUS_BUFFER_TOO_SMALL;
1365         memcpy(dest->Buffer + dest->Length, src->Buffer, src->Length);
1366         dest->Length = dest_len;
1367     } /* if */
1368     return STATUS_SUCCESS;
1369 }
1370
1371
1372 /**************************************************************************
1373  *      RtlAppendUnicodeToString   (NTDLL.@)
1374  *
1375  * Concatenates a buffered unicode string and a '\0' terminated unicode
1376  * string
1377  *
1378  * RETURNS
1379  *  Success: STATUS_SUCCESS. src is appended to dest.
1380  *  Failure: STATUS_BUFFER_TOO_SMALL, if the buffer of dest is too small
1381  *                  to hold the concatenated string.
1382  *
1383  * NOTES
1384  *  if src is NULL dest is unchanged.
1385  *  dest is '\0' terminated when the MaximumLength allows it.
1386  *  When dest fits exactly in MaximumLength characters the '\0' is omitted.
1387  *
1388  * DIFFERENCES
1389  *  Does not write in the src->Buffer beyond MaximumLength when
1390  *  MaximumLength is odd as the native function does.
1391  */
1392 NTSTATUS WINAPI RtlAppendUnicodeToString(
1393     UNICODE_STRING *dest, /* [I/O] Buffered unicode string to which src is concatenated */
1394     LPCWSTR src)          /* [I]   '\0' terminated unicode string to be concatenated */
1395 {
1396     if (src != NULL) {
1397         unsigned int src_len = strlenW(src) * sizeof(WCHAR);
1398         unsigned int dest_len  = src_len + dest->Length;
1399
1400         if (dest_len > dest->MaximumLength) return STATUS_BUFFER_TOO_SMALL;
1401         memcpy(dest->Buffer + dest->Length/sizeof(WCHAR), src, src_len);
1402         dest->Length = dest_len;
1403         /* append terminating '\0' if enough space */
1404         if (dest_len + sizeof(WCHAR) <= dest->MaximumLength) {
1405             dest->Buffer[dest_len / sizeof(WCHAR)] = 0;
1406         } /* if */
1407     } /* if */
1408     return STATUS_SUCCESS;
1409 }
1410
1411
1412 /**************************************************************************
1413  *      RtlAppendUnicodeStringToString   (NTDLL.@)
1414  *
1415  * Concatenates two buffered unicode strings
1416  *
1417  * RETURNS
1418  *  Success: STATUS_SUCCESS. src is appended to dest.
1419  *  Failure: STATUS_BUFFER_TOO_SMALL, if the buffer of dest is too small
1420  *                  to hold the concatenated string.
1421  *
1422  * NOTES
1423  *  if src->length is zero dest is unchanged.
1424  *  dest is '\0' terminated when the MaximumLength allows it.
1425  *  When dest fits exactly in MaximumLength characters the '\0' is omitted.
1426  *
1427  * DIFFERENCES
1428  *  Does not write in the src->Buffer beyond MaximumLength when
1429  *  MaximumLength is odd as the native function does.
1430  */
1431 NTSTATUS WINAPI RtlAppendUnicodeStringToString(
1432     UNICODE_STRING *dest,      /* [I/O] Buffered unicode string to which src is concatenated */
1433     const UNICODE_STRING *src) /* [I]   Buffered unicode string to be concatenated */
1434 {
1435     if (src->Length != 0) {
1436         unsigned int dest_len = src->Length + dest->Length;
1437
1438         if (dest_len > dest->MaximumLength) return STATUS_BUFFER_TOO_SMALL;
1439         memcpy(dest->Buffer + dest->Length/sizeof(WCHAR), src->Buffer, src->Length);
1440         dest->Length = dest_len;
1441         /* append terminating '\0' if enough space */
1442         if (dest_len + sizeof(WCHAR) <= dest->MaximumLength) {
1443             dest->Buffer[dest_len / sizeof(WCHAR)] = 0;
1444         } /* if */
1445     } /* if */
1446     return STATUS_SUCCESS;
1447 }
1448
1449
1450 /**************************************************************************
1451  *      RtlFindCharInUnicodeString   (NTDLL.@)
1452  *
1453  * Searches for one of several unicode characters in an unicode string.
1454  *
1455  * RETURNS
1456  *  Success: STATUS_SUCCESS. pos contains the position after the character found.
1457  *  Failure: STATUS_NOT_FOUND, if none of the search_chars are in main_str.
1458  */
1459 NTSTATUS WINAPI RtlFindCharInUnicodeString(
1460     int flags,                          /* [I] Flags */
1461     const UNICODE_STRING *main_str,     /* [I] Unicode string in which one or more characters are searched */
1462     const UNICODE_STRING *search_chars, /* [I] Unicode string which contains the characters to search for */
1463     USHORT *pos)                        /* [O] Position of the first character found + 2 */
1464 {
1465     int main_idx;
1466     unsigned int search_idx;
1467
1468     switch (flags) {
1469         case 0:
1470             for (main_idx = 0; main_idx < main_str->Length / sizeof(WCHAR); main_idx++) {
1471                 for (search_idx = 0; search_idx < search_chars->Length / sizeof(WCHAR); search_idx++) {
1472                     if (main_str->Buffer[main_idx] == search_chars->Buffer[search_idx]) {
1473                         *pos = (main_idx + 1) * sizeof(WCHAR);
1474                         return STATUS_SUCCESS;
1475                     }
1476                 }
1477             }
1478             *pos = 0;
1479             return STATUS_NOT_FOUND;
1480         case 1:
1481             for (main_idx = main_str->Length / sizeof(WCHAR) - 1; main_idx >= 0; main_idx--) {
1482                 for (search_idx = 0; search_idx < search_chars->Length / sizeof(WCHAR); search_idx++) {
1483                     if (main_str->Buffer[main_idx] == search_chars->Buffer[search_idx]) {
1484                         *pos = main_idx * sizeof(WCHAR);
1485                         return STATUS_SUCCESS;
1486                     }
1487                 }
1488             }
1489             *pos = 0;
1490             return STATUS_NOT_FOUND;
1491         case 2:
1492             for (main_idx = 0; main_idx < main_str->Length / sizeof(WCHAR); main_idx++) {
1493                 search_idx = 0;
1494                 while (search_idx < search_chars->Length / sizeof(WCHAR) &&
1495                          main_str->Buffer[main_idx] != search_chars->Buffer[search_idx]) {
1496                     search_idx++;
1497                 }
1498                 if (search_idx >= search_chars->Length / sizeof(WCHAR)) {
1499                     *pos = (main_idx + 1) * sizeof(WCHAR);
1500                     return STATUS_SUCCESS;
1501                 }
1502             }
1503             *pos = 0;
1504             return STATUS_NOT_FOUND;
1505         case 3:
1506             for (main_idx = main_str->Length / sizeof(WCHAR) - 1; main_idx >= 0; main_idx--) {
1507                 search_idx = 0;
1508                 while (search_idx < search_chars->Length / sizeof(WCHAR) &&
1509                          main_str->Buffer[main_idx] != search_chars->Buffer[search_idx]) {
1510                     search_idx++;
1511                 }
1512                 if (search_idx >= search_chars->Length / sizeof(WCHAR)) {
1513                     *pos = main_idx * sizeof(WCHAR);
1514                     return STATUS_SUCCESS;
1515                 }
1516             }
1517             *pos = 0;
1518             return STATUS_NOT_FOUND;
1519     } /* switch */
1520     return STATUS_NOT_FOUND;
1521 }
1522
1523
1524 /*
1525         MISC
1526 */
1527
1528 /**************************************************************************
1529  *      RtlIsTextUnicode (NTDLL.@)
1530  *
1531  * Attempt to guess whether a text buffer is Unicode.
1532  *
1533  * PARAMS
1534  *  buf [I] Text buffer to test
1535  *  len [I] Length of buf
1536  *  pf  [O] Destination for test results
1537  *
1538  * RETURNS
1539  *  TRUE if the buffer is likely Unicode, FALSE otherwise.
1540  *
1541  * FIXME
1542  *  Should implement more tests.
1543  */
1544 BOOLEAN WINAPI RtlIsTextUnicode( LPCVOID buf, INT len, INT *pf )
1545 {
1546     const WCHAR *s = buf;
1547     int i;
1548     unsigned int flags = ~0U, out_flags = 0;
1549
1550     if (len < sizeof(WCHAR))
1551     {
1552         /* FIXME: MSDN documents IS_TEXT_UNICODE_BUFFER_TOO_SMALL but there is no such thing... */
1553         if (pf) *pf = 0;
1554         return FALSE;
1555     }
1556     if (pf)
1557         flags = *pf;
1558     /*
1559      * Apply various tests to the text string. According to the
1560      * docs, each test "passed" sets the corresponding flag in
1561      * the output flags. But some of the tests are mutually
1562      * exclusive, so I don't see how you could pass all tests ...
1563      */
1564
1565     /* Check for an odd length ... pass if even. */
1566     if (len & 1) out_flags |= IS_TEXT_UNICODE_ODD_LENGTH;
1567
1568     len /= sizeof(WCHAR);
1569     /* Windows only checks the first 256 characters */
1570     if (len > 256) len = 256;
1571
1572     /* Check for the special byte order unicode marks. */
1573     if (*s == 0xFEFF) out_flags |= IS_TEXT_UNICODE_SIGNATURE;
1574     if (*s == 0xFFFE) out_flags |= IS_TEXT_UNICODE_REVERSE_SIGNATURE;
1575
1576     /* apply some statistical analysis */
1577     if (flags & IS_TEXT_UNICODE_STATISTICS)
1578     {
1579         int stats = 0;
1580         /* FIXME: checks only for ASCII characters in the unicode stream */
1581         for (i = 0; i < len; i++)
1582         {
1583             if (s[i] <= 255) stats++;
1584         }
1585         if (stats > len / 2)
1586             out_flags |= IS_TEXT_UNICODE_STATISTICS;
1587     }
1588
1589     /* Check for unicode NULL chars */
1590     if (flags & IS_TEXT_UNICODE_NULL_BYTES)
1591     {
1592         for (i = 0; i < len; i++)
1593         {
1594             if (!s[i])
1595             {
1596                 out_flags |= IS_TEXT_UNICODE_NULL_BYTES;
1597                 break;
1598             }
1599         }
1600     }
1601
1602     if (pf)
1603     {
1604         out_flags &= *pf;
1605         *pf = out_flags;
1606     }
1607     /* check for flags that indicate it's definitely not valid Unicode */
1608     if (out_flags & (IS_TEXT_UNICODE_REVERSE_MASK | IS_TEXT_UNICODE_NOT_UNICODE_MASK)) return FALSE;
1609     /* now check for invalid ASCII, and assume Unicode if so */
1610     if (out_flags & IS_TEXT_UNICODE_NOT_ASCII_MASK) return TRUE;
1611     /* now check for Unicode flags */
1612     if (out_flags & IS_TEXT_UNICODE_UNICODE_MASK) return TRUE;
1613     /* no flags set */
1614     return FALSE;
1615 }
1616
1617
1618 /**************************************************************************
1619  *      RtlCharToInteger   (NTDLL.@)
1620  *
1621  * Converts a character string into its integer equivalent.
1622  *
1623  * RETURNS
1624  *  Success: STATUS_SUCCESS. value contains the converted number
1625  *  Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
1626  *           STATUS_ACCESS_VIOLATION, if value is NULL.
1627  *
1628  * NOTES
1629  *  For base 0 it uses 10 as base and the string should be in the format
1630  *      "{whitespace} [+|-] [0[x|o|b]] {digits}".
1631  *  For other bases the string should be in the format
1632  *      "{whitespace} [+|-] {digits}".
1633  *  No check is made for value overflow, only the lower 32 bits are assigned.
1634  *  If str is NULL it crashes, as the native function does.
1635  *
1636  * DIFFERENCES
1637  *  This function does not read garbage behind '\0' as the native version does.
1638  */
1639 NTSTATUS WINAPI RtlCharToInteger(
1640     PCSZ str,      /* [I] '\0' terminated single-byte string containing a number */
1641     ULONG base,    /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
1642     ULONG *value)  /* [O] Destination for the converted value */
1643 {
1644     CHAR chCurrent;
1645     int digit;
1646     ULONG RunningTotal = 0;
1647     char bMinus = 0;
1648
1649     while (*str != '\0' && *str <= ' ') {
1650         str++;
1651     } /* while */
1652
1653     if (*str == '+') {
1654         str++;
1655     } else if (*str == '-') {
1656         bMinus = 1;
1657         str++;
1658     } /* if */
1659
1660     if (base == 0) {
1661         base = 10;
1662         if (str[0] == '0') {
1663             if (str[1] == 'b') {
1664                 str += 2;
1665                 base = 2;
1666             } else if (str[1] == 'o') {
1667                 str += 2;
1668                 base = 8;
1669             } else if (str[1] == 'x') {
1670                 str += 2;
1671                 base = 16;
1672             } /* if */
1673         } /* if */
1674     } else if (base != 2 && base != 8 && base != 10 && base != 16) {
1675         return STATUS_INVALID_PARAMETER;
1676     } /* if */
1677
1678     if (value == NULL) {
1679         return STATUS_ACCESS_VIOLATION;
1680     } /* if */
1681
1682     while (*str != '\0') {
1683         chCurrent = *str;
1684         if (chCurrent >= '0' && chCurrent <= '9') {
1685             digit = chCurrent - '0';
1686         } else if (chCurrent >= 'A' && chCurrent <= 'Z') {
1687             digit = chCurrent - 'A' + 10;
1688         } else if (chCurrent >= 'a' && chCurrent <= 'z') {
1689             digit = chCurrent - 'a' + 10;
1690         } else {
1691             digit = -1;
1692         } /* if */
1693         if (digit < 0 || digit >= base) {
1694             *value = bMinus ? -RunningTotal : RunningTotal;
1695             return STATUS_SUCCESS;
1696         } /* if */
1697
1698         RunningTotal = RunningTotal * base + digit;
1699         str++;
1700     } /* while */
1701
1702     *value = bMinus ? -RunningTotal : RunningTotal;
1703     return STATUS_SUCCESS;
1704 }
1705
1706
1707 /**************************************************************************
1708  *      RtlIntegerToChar   (NTDLL.@)
1709  *
1710  * Converts an unsigned integer to a character string.
1711  *
1712  * RETURNS
1713  *  Success: STATUS_SUCCESS. str contains the converted number
1714  *  Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
1715  *           STATUS_BUFFER_OVERFLOW, if str would be larger than length.
1716  *           STATUS_ACCESS_VIOLATION, if str is NULL.
1717  *
1718  * NOTES
1719  *  Instead of base 0 it uses 10 as base.
1720  *  Writes at most length characters to the string str.
1721  *  Str is '\0' terminated when length allows it.
1722  *  When str fits exactly in length characters the '\0' is omitted.
1723  */
1724 NTSTATUS WINAPI RtlIntegerToChar(
1725     ULONG value,   /* [I] Value to be converted */
1726     ULONG base,    /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
1727     ULONG length,  /* [I] Length of the str buffer in bytes */
1728     PCHAR str)     /* [O] Destination for the converted value */
1729 {
1730     CHAR buffer[33];
1731     PCHAR pos;
1732     CHAR digit;
1733     ULONG len;
1734
1735     if (base == 0) {
1736         base = 10;
1737     } else if (base != 2 && base != 8 && base != 10 && base != 16) {
1738         return STATUS_INVALID_PARAMETER;
1739     } /* if */
1740
1741     pos = &buffer[32];
1742     *pos = '\0';
1743
1744     do {
1745         pos--;
1746         digit = value % base;
1747         value = value / base;
1748         if (digit < 10) {
1749             *pos = '0' + digit;
1750         } else {
1751             *pos = 'A' + digit - 10;
1752         } /* if */
1753     } while (value != 0L);
1754
1755     len = &buffer[32] - pos;
1756     if (len > length) {
1757         return STATUS_BUFFER_OVERFLOW;
1758     } else if (str == NULL) {
1759         return STATUS_ACCESS_VIOLATION;
1760     } else if (len == length) {
1761         memcpy(str, pos, len);
1762     } else {
1763         memcpy(str, pos, len + 1);
1764     } /* if */
1765     return STATUS_SUCCESS;
1766 }
1767
1768
1769 /**************************************************************************
1770  *      RtlUnicodeStringToInteger (NTDLL.@)
1771  *
1772  * Converts an unicode string into its integer equivalent.
1773  *
1774  * RETURNS
1775  *  Success: STATUS_SUCCESS. value contains the converted number
1776  *  Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
1777  *           STATUS_ACCESS_VIOLATION, if value is NULL.
1778  *
1779  * NOTES
1780  *  For base 0 it uses 10 as base and the string should be in the format
1781  *      "{whitespace} [+|-] [0[x|o|b]] {digits}".
1782  *  For other bases the string should be in the format
1783  *      "{whitespace} [+|-] {digits}".
1784  *  No check is made for value overflow, only the lower 32 bits are assigned.
1785  *  If str is NULL it crashes, as the native function does.
1786  *
1787  * DIFFERENCES
1788  *  This function does not read garbage on string length 0 as the native
1789  *  version does.
1790  */
1791 NTSTATUS WINAPI RtlUnicodeStringToInteger(
1792     const UNICODE_STRING *str, /* [I] Unicode string to be converted */
1793     ULONG base,                /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
1794     ULONG *value)              /* [O] Destination for the converted value */
1795 {
1796     LPWSTR lpwstr = str->Buffer;
1797     USHORT CharsRemaining = str->Length / sizeof(WCHAR);
1798     WCHAR wchCurrent;
1799     int digit;
1800     ULONG RunningTotal = 0;
1801     char bMinus = 0;
1802
1803     while (CharsRemaining >= 1 && *lpwstr <= ' ') {
1804         lpwstr++;
1805         CharsRemaining--;
1806     } /* while */
1807
1808     if (CharsRemaining >= 1) {
1809         if (*lpwstr == '+') {
1810             lpwstr++;
1811             CharsRemaining--;
1812         } else if (*lpwstr == '-') {
1813             bMinus = 1;
1814             lpwstr++;
1815             CharsRemaining--;
1816         } /* if */
1817     } /* if */
1818
1819     if (base == 0) {
1820         base = 10;
1821         if (CharsRemaining >= 2 && lpwstr[0] == '0') {
1822             if (lpwstr[1] == 'b') {
1823                 lpwstr += 2;
1824                 CharsRemaining -= 2;
1825                 base = 2;
1826             } else if (lpwstr[1] == 'o') {
1827                 lpwstr += 2;
1828                 CharsRemaining -= 2;
1829                 base = 8;
1830             } else if (lpwstr[1] == 'x') {
1831                 lpwstr += 2;
1832                 CharsRemaining -= 2;
1833                 base = 16;
1834             } /* if */
1835         } /* if */
1836     } else if (base != 2 && base != 8 && base != 10 && base != 16) {
1837         return STATUS_INVALID_PARAMETER;
1838     } /* if */
1839
1840     if (value == NULL) {
1841         return STATUS_ACCESS_VIOLATION;
1842     } /* if */
1843
1844     while (CharsRemaining >= 1) {
1845         wchCurrent = *lpwstr;
1846         if (wchCurrent >= '0' && wchCurrent <= '9') {
1847             digit = wchCurrent - '0';
1848         } else if (wchCurrent >= 'A' && wchCurrent <= 'Z') {
1849             digit = wchCurrent - 'A' + 10;
1850         } else if (wchCurrent >= 'a' && wchCurrent <= 'z') {
1851             digit = wchCurrent - 'a' + 10;
1852         } else {
1853             digit = -1;
1854         } /* if */
1855         if (digit < 0 || digit >= base) {
1856             *value = bMinus ? -RunningTotal : RunningTotal;
1857             return STATUS_SUCCESS;
1858         } /* if */
1859
1860         RunningTotal = RunningTotal * base + digit;
1861         lpwstr++;
1862         CharsRemaining--;
1863     } /* while */
1864
1865     *value = bMinus ? -RunningTotal : RunningTotal;
1866     return STATUS_SUCCESS;
1867 }
1868
1869
1870 /**************************************************************************
1871  *      RtlIntegerToUnicodeString (NTDLL.@)
1872  *
1873  * Converts an unsigned integer to a '\0' terminated unicode string.
1874  *
1875  * RETURNS
1876  *  Success: STATUS_SUCCESS. str contains the converted number
1877  *  Failure: STATUS_INVALID_PARAMETER, if base is not 0, 2, 8, 10 or 16.
1878  *           STATUS_BUFFER_OVERFLOW, if str is too small to hold the string
1879  *                  (with the '\0' termination). In this case str->Length
1880  *                  is set to the length, the string would have (which can
1881  *                  be larger than the MaximumLength).
1882  *
1883  * NOTES
1884  *  Instead of base 0 it uses 10 as base.
1885  *  If str is NULL it crashes, as the native function does.
1886  *
1887  * DIFFERENCES
1888  *  Do not return STATUS_BUFFER_OVERFLOW when the string is long enough.
1889  *  The native function does this when the string would be longer than 16
1890  *  characters even when the string parameter is long enough.
1891  */
1892 NTSTATUS WINAPI RtlIntegerToUnicodeString(
1893     ULONG value,         /* [I] Value to be converted */
1894     ULONG base,          /* [I] Number base for conversion (allowed 0, 2, 8, 10 or 16) */
1895     UNICODE_STRING *str) /* [O] Destination for the converted value */
1896 {
1897     WCHAR buffer[33];
1898     PWCHAR pos;
1899     WCHAR digit;
1900
1901     if (base == 0) {
1902         base = 10;
1903     } else if (base != 2 && base != 8 && base != 10 && base != 16) {
1904         return STATUS_INVALID_PARAMETER;
1905     } /* if */
1906
1907     pos = &buffer[32];
1908     *pos = '\0';
1909
1910     do {
1911         pos--;
1912         digit = value % base;
1913         value = value / base;
1914         if (digit < 10) {
1915             *pos = '0' + digit;
1916         } else {
1917             *pos = 'A' + digit - 10;
1918         } /* if */
1919     } while (value != 0L);
1920
1921     str->Length = (&buffer[32] - pos) * sizeof(WCHAR);
1922     if (str->Length >= str->MaximumLength) {
1923         return STATUS_BUFFER_OVERFLOW;
1924     } else {
1925         memcpy(str->Buffer, pos, str->Length + sizeof(WCHAR));
1926     } /* if */
1927     return STATUS_SUCCESS;
1928 }
1929
1930
1931 /*************************************************************************
1932  * RtlGUIDFromString (NTDLL.@)
1933  *
1934  * Convert a string representation of a GUID into a GUID.
1935  *
1936  * PARAMS
1937  *  str  [I] String representation in the format "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}"
1938  *  guid [O] Destination for the converted GUID
1939  *
1940  * RETURNS
1941  *  Success: STATUS_SUCCESS. guid contains the converted value.
1942  *  Failure: STATUS_INVALID_PARAMETER, if str is not in the expected format.
1943  *
1944  * SEE ALSO
1945  *  See RtlStringFromGUID.
1946  */
1947 NTSTATUS WINAPI RtlGUIDFromString(const UNICODE_STRING *str, GUID* guid)
1948 {
1949   int i = 0;
1950   const WCHAR *lpszCLSID = str->Buffer;
1951   BYTE* lpOut = (BYTE*)guid;
1952
1953   TRACE("(%s,%p)\n", debugstr_us(str), guid);
1954
1955   /* Convert string: {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
1956    * to memory:       DWORD... WORD WORD BYTES............
1957    */
1958   while (i < 37)
1959   {
1960     switch (i)
1961     {
1962     case 0:
1963       if (*lpszCLSID != '{')
1964         return STATUS_INVALID_PARAMETER;
1965       break;
1966
1967     case 9: case 14: case 19: case 24:
1968       if (*lpszCLSID != '-')
1969         return STATUS_INVALID_PARAMETER;
1970       break;
1971
1972     case 37:
1973       if (*lpszCLSID != '}')
1974         return STATUS_INVALID_PARAMETER;
1975       break;
1976
1977     default:
1978       {
1979         WCHAR ch = *lpszCLSID, ch2 = lpszCLSID[1];
1980         unsigned char byte;
1981
1982         /* Read two hex digits as a byte value */
1983         if      (ch >= '0' && ch <= '9') ch = ch - '0';
1984         else if (ch >= 'a' && ch <= 'f') ch = ch - 'a' + 10;
1985         else if (ch >= 'A' && ch <= 'F') ch = ch - 'A' + 10;
1986         else return STATUS_INVALID_PARAMETER;
1987
1988         if      (ch2 >= '0' && ch2 <= '9') ch2 = ch2 - '0';
1989         else if (ch2 >= 'a' && ch2 <= 'f') ch2 = ch2 - 'a' + 10;
1990         else if (ch2 >= 'A' && ch2 <= 'F') ch2 = ch2 - 'A' + 10;
1991         else return STATUS_INVALID_PARAMETER;
1992
1993         byte = ch << 4 | ch2;
1994
1995         switch (i)
1996         {
1997 #ifndef WORDS_BIGENDIAN
1998         /* For Big Endian machines, we store the data such that the
1999          * dword/word members can be read as DWORDS and WORDS correctly. */
2000         /* Dword */
2001         case 1:  lpOut[3] = byte; break;
2002         case 3:  lpOut[2] = byte; break;
2003         case 5:  lpOut[1] = byte; break;
2004         case 7:  lpOut[0] = byte; lpOut += 4;  break;
2005         /* Word */
2006         case 10: case 15: lpOut[1] = byte; break;
2007         case 12: case 17: lpOut[0] = byte; lpOut += 2; break;
2008 #endif
2009         /* Byte */
2010         default: lpOut[0] = byte; lpOut++; break;
2011         }
2012         lpszCLSID++; /* Skip 2nd character of byte */
2013         i++;
2014       }
2015     }
2016     lpszCLSID++;
2017     i++;
2018   }
2019
2020   return STATUS_SUCCESS;
2021 }
2022
2023 /*************************************************************************
2024  * RtlStringFromGUID (NTDLL.@)
2025  *
2026  * Convert a GUID into a string representation of a GUID.
2027  *
2028  * PARAMS
2029  *  guid [I] GUID to convert
2030  *  str  [O] Destination for the converted string
2031  *
2032  * RETURNS
2033  *  Success: STATUS_SUCCESS. str contains the converted value.
2034  *  Failure: STATUS_NO_MEMORY, if memory for str cannot be allocated.
2035  *
2036  * SEE ALSO
2037  *  See RtlGUIDFromString.
2038  */
2039 NTSTATUS WINAPI RtlStringFromGUID(const GUID* guid, UNICODE_STRING *str)
2040 {
2041   static const WCHAR szFormat[] = { '{','%','0','8','l','X','-',
2042     '%','0','4','X','-',  '%','0','4','X','-','%','0','2','X','%','0','2','X',
2043     '-',   '%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X',
2044     '%','0','2','X','%','0','2','X','}','\0' };
2045
2046   TRACE("(%p,%p)\n", guid, str);
2047
2048   str->Length = GUID_STRING_LENGTH * sizeof(WCHAR);
2049   str->MaximumLength = str->Length + sizeof(WCHAR);
2050   str->Buffer = (WCHAR*)RtlAllocateHeap(GetProcessHeap(), 0, str->MaximumLength);
2051   if (!str->Buffer)
2052   {
2053     str->Length = str->MaximumLength = 0;
2054     return STATUS_NO_MEMORY;
2055   }
2056   sprintfW(str->Buffer, szFormat, guid->Data1, guid->Data2, guid->Data3,
2057           guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
2058           guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
2059
2060   return STATUS_SUCCESS;
2061 }