reactos/include/ddk/ntstrsafe.h

   1 /*
   2  * PROJECT:         ReactOS Kernel
   3  * LICENSE:         This file is in the public domain.
   4  * FILE:            include/ddk/ntstrsafe.h
   5  * PURPOSE:         Safe String Library for NT Code (Native/Kernel)
   6  * PROGRAMMERS:     Alex Ionescu (alex.ionescu@reactos.org)
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #ifndef _NTSTRSAFE_H_INCLUDED_
  12 #define _NTSTRSAFE_H_INCLUDED_
  13
  14 //
  15 // Dependencies
  16 //
  17 #include <stdio.h>
  18 #include <string.h>
  19 #include <stdarg.h>
  20
  21 //
  22 // Maximum limits: allow overriding the maximum
  23 //
  24 #ifndef NTSTRSAFE_MAX_CCH
  25 #define NTSTRSAFE_MAX_CCH       2147483647
  26 #endif
  27 #define NTSTRSAFE_MAX_LENGTH    (NTSTRSAFE_MAX_CCH - 1)
  28
  29 //
  30 // Typedefs
  31 //
  32 typedef unsigned long DWORD;
  33
  34 /* PRIVATE FUNCTIONS *********************************************************/
  35
  36 static __inline
  37 NTSTATUS
  38 NTAPI
  39 RtlStringLengthWorkerA(IN LPCSTR String,
  40                        IN SIZE_T MaxLength,
  41                        OUT PSIZE_T ReturnLength OPTIONAL)
  42 {
  43     NTSTATUS Status = STATUS_SUCCESS;
  44     SIZE_T LocalMax = MaxLength;
  45
  46     while (MaxLength && (*String != ANSI_NULL))
  47     {
  48         String++;
  49         MaxLength--;
  50     }
  51
  52     if (!MaxLength) Status = STATUS_INVALID_PARAMETER;
  53
  54     if (ReturnLength)
  55     {
  56         if (NT_SUCCESS(Status))
  57         {
  58             *ReturnLength = LocalMax - MaxLength;
  59         }
  60         else
  61         {
  62             *ReturnLength = 0;
  63         }
  64     }
  65
  66     return Status;
  67 }
  68
  69 static __inline
  70 NTSTATUS
  71 NTAPI
  72 RtlStringValidateDestA(IN LPSTR Destination,
  73                        IN SIZE_T Length,
  74                        OUT PSIZE_T ReturnLength OPTIONAL,
  75                        IN SIZE_T MaxLength)
  76 {
  77     NTSTATUS Status = STATUS_SUCCESS;
  78
  79     if (!(Length) || (Length > MaxLength)) Status = STATUS_INVALID_PARAMETER;
  80
  81     if (ReturnLength)
  82     {
  83         if (NT_SUCCESS(Status))
  84         {
  85             Status = RtlStringLengthWorkerA(Destination,
  86                                             Length,
  87                                             ReturnLength);
  88         }
  89         else
  90         {
  91             *ReturnLength = 0;
  92         }
  93     }
  94
  95     return Status;
  96 }
  97
  98 static __inline
  99 NTSTATUS
 100 NTAPI
 101 RtlStringExValidateDestA(IN OUT LPSTR *Destination,
 102                          IN OUT PSIZE_T DestinationLength,
 103                          OUT PSIZE_T ReturnLength OPTIONAL,
 104                          IN SIZE_T MaxLength,
 105                          IN DWORD Flags)
 106 {
 107     ASSERTMSG("We don't support Extended Flags yet!\n", Flags == 0);
 108     return RtlStringValidateDestA(*Destination,
 109                                   *DestinationLength,
 110                                   ReturnLength,
 111                                   MaxLength);
 112 }
 113
 114 static __inline
 115 NTSTATUS
 116 NTAPI
 117 RtlStringExValidateSrcA(IN OUT LPCSTR *Source OPTIONAL,
 118                         IN OUT PSIZE_T ReturnLength OPTIONAL,
 119                         IN SIZE_T MaxLength,
 120                         IN DWORD Flags)
 121 {
 122     NTSTATUS Status = STATUS_SUCCESS;
 123     ASSERTMSG("We don't support Extended Flags yet!\n", Flags == 0);
 124
 125     if ((ReturnLength) && (*ReturnLength >= MaxLength))
 126     {
 127         Status = STATUS_INVALID_PARAMETER;
 128     }
 129
 130     return Status;
 131 }
 132
 133 static __inline
 134 NTSTATUS
 135 NTAPI
 136 RtlStringVPrintfWorkerA(OUT LPSTR Destination,
 137                         IN SIZE_T Length,
 138                         OUT PSIZE_T NewLength OPTIONAL,
 139                         IN LPCSTR Format,
 140                         IN va_list argList)
 141 {
 142     NTSTATUS Status = STATUS_SUCCESS;
 143     LONG Return;
 144     SIZE_T MaxLength, LocalNewLength = 0;
 145
 146     MaxLength = Length - 1;
 147
 148     Return = _vsnprintf(Destination, MaxLength, Format, argList);
 149     if ((Return < 0) || ((SIZE_T)Return > MaxLength))
 150     {
 151         Destination += MaxLength;
 152         *Destination = ANSI_NULL;
 153
 154         LocalNewLength = MaxLength;
 155
 156         Status = STATUS_BUFFER_OVERFLOW;
 157     }
 158     else if ((SIZE_T)Return == MaxLength)
 159     {
 160         Destination += MaxLength;
 161         *Destination = ANSI_NULL;
 162
 163         LocalNewLength = MaxLength;
 164     }
 165     else
 166     {
 167         LocalNewLength = Return;
 168     }
 169
 170     if (NewLength) *NewLength = LocalNewLength;
 171     return Status;
 172 }
 173
 174 static __inline
 175 NTSTATUS
 176 NTAPI
 177 RtlStringCopyWorkerA(OUT LPSTR Destination,
 178                      IN SIZE_T Length,
 179                      OUT PSIZE_T NewLength OPTIONAL,
 180                      IN LPCSTR Source,
 181                      IN SIZE_T CopyLength)
 182 {
 183     NTSTATUS Status = STATUS_SUCCESS;
 184     SIZE_T LocalNewLength = 0;
 185
 186     while ((Length) && (CopyLength) && (*Source != ANSI_NULL))
 187     {
 188         *Destination++ = *Source++;
 189         Length--;
 190         CopyLength--;
 191
 192         LocalNewLength++;
 193     }
 194
 195     if (!Length)
 196     {
 197         Destination--;
 198         LocalNewLength--;
 199
 200         Status = STATUS_BUFFER_OVERFLOW;
 201     }
 202
 203     *Destination = ANSI_NULL;
 204
 205     if (NewLength) *NewLength = LocalNewLength;
 206     return Status;
 207 }
 208
 209 /* PUBLIC FUNCTIONS **********************************************************/
 210
 211 static __inline
 212 NTSTATUS
 213 NTAPI
 214 RtlStringCchCopyA(IN LPSTR Destination,
 215                   IN SIZE_T cchDest,
 216                   IN LPCSTR pszSrc)
 217 {
 218     ASSERTMSG("RtlStringCchCopyA is UNIMPLEMENTED!\n", FALSE);
 219     return STATUS_NOT_IMPLEMENTED;
 220 }
 221
 222 static __inline
 223 NTSTATUS
 224 RtlStringCbPrintfA(OUT LPSTR Destination,
 225                    IN SIZE_T Length,
 226                    IN LPCSTR Format,
 227                    ...)
 228 {
 229     NTSTATUS Status;
 230     SIZE_T CharLength = Length / sizeof(CHAR);
 231     va_list argList;
 232
 233     Status = RtlStringValidateDestA(Destination,
 234                                     CharLength,
 235                                     NULL,
 236                                     NTSTRSAFE_MAX_CCH);
 237     if (NT_SUCCESS(Status))
 238     {
 239         va_start(argList, Format);
 240         Status = RtlStringVPrintfWorkerA(Destination,
 241                                          CharLength,
 242                                          NULL,
 243                                          Format,
 244                                          argList);
 245         va_end(argList);
 246     }
 247
 248     return Status;
 249 }
 250
 251 static __inline
 252 NTSTATUS
 253 RtlStringCbPrintfExA(OUT LPSTR Destination,
 254                      IN SIZE_T Length,
 255                      OUT LPSTR *DestinationEnd OPTIONAL,
 256                      OUT PSIZE_T RemainingSize OPTIONAL,
 257                      IN DWORD Flags,
 258                      IN LPCSTR Format,
 259                      ...)
 260 {
 261     NTSTATUS Status;
 262     SIZE_T CharLength = Length / sizeof(CHAR), Remaining, LocalNewLength = 0;
 263     PCHAR LocalDestinationEnd;
 264     va_list argList;
 265     ASSERTMSG("We don't support Extended Flags yet!\n", Flags == 0);
 266
 267     Status = RtlStringExValidateDestA(&Destination,
 268                                       &CharLength,
 269                                       NULL,
 270                                       NTSTRSAFE_MAX_CCH,
 271                                       Flags);
 272     if (NT_SUCCESS(Status))
 273     {
 274         LocalDestinationEnd = Destination;
 275         Remaining = CharLength;
 276
 277         Status = RtlStringExValidateSrcA(&Format,
 278                                          NULL,
 279                                          NTSTRSAFE_MAX_CCH,
 280                                          Flags);
 281         if (NT_SUCCESS(Status))
 282         {
 283             if (!Length)
 284             {
 285                 if (*Format != ANSI_NULL)
 286                 {
 287                     if (!Destination)
 288                     {
 289                         Status = STATUS_INVALID_PARAMETER;
 290                     }
 291                     else
 292                     {
 293                         Status = STATUS_BUFFER_OVERFLOW;
 294                     }
 295                 }
 296             }
 297             else
 298             {
 299                 va_start(argList, Format);
 300                 Status = RtlStringVPrintfWorkerA(Destination,
 301                                                  CharLength,
 302                                                  &LocalNewLength,
 303                                                  Format,
 304                                                  argList);
 305                 va_end(argList);
 306
 307                 LocalDestinationEnd = Destination + LocalNewLength;
 308                 Remaining = CharLength - LocalNewLength;
 309             }
 310         }
 311         else
 312         {
 313             if (Length) *Destination = ANSI_NULL;
 314         }
 315
 316         if ((NT_SUCCESS(Status)) || (Status == STATUS_BUFFER_OVERFLOW))
 317         {
 318             if (DestinationEnd) *DestinationEnd = LocalDestinationEnd;
 319
 320             if (RemainingSize)
 321             {
 322                 *RemainingSize = (Remaining * sizeof(CHAR)) +
 323                                  (Length % sizeof(CHAR));
 324             }
 325         }
 326     }
 327
 328     return Status;
 329 }
 330
 331 static __inline
 332 NTSTATUS
 333 NTAPI
 334 RtlStringCbCopyExA(OUT LPSTR Destination,
 335                    IN SIZE_T Length,
 336                    IN LPCSTR Source,
 337                    OUT LPSTR *DestinationEnd OPTIONAL,
 338                    OUT PSIZE_T RemainingSize OPTIONAL,
 339                    IN DWORD Flags)
 340 {
 341     NTSTATUS Status;
 342     SIZE_T CharLength = Length / sizeof(CHAR), Copied = 0, Remaining;
 343     PCHAR LocalDestinationEnd;
 344     ASSERTMSG("We don't support Extended Flags yet!\n", Flags == 0);
 345
 346     Status = RtlStringExValidateDestA(&Destination,
 347                                       &Length,
 348                                       NULL,
 349                                       NTSTRSAFE_MAX_CCH,
 350                                       Flags);
 351     if (NT_SUCCESS(Status))
 352     {
 353         LocalDestinationEnd = Destination;
 354         Remaining = CharLength;
 355
 356         Status = RtlStringExValidateSrcA(&Source,
 357                                          NULL,
 358                                          NTSTRSAFE_MAX_CCH,
 359                                          Flags);
 360         if (NT_SUCCESS(Status))
 361         {
 362             if (!CharLength)
 363             {
 364                 if (*Source != ANSI_NULL)
 365                 {
 366                     if (!Destination)
 367                     {
 368                         Status = STATUS_INVALID_PARAMETER;
 369                     }
 370                     else
 371                     {
 372                         Status = STATUS_BUFFER_OVERFLOW;
 373                     }
 374                 }
 375             }
 376             else
 377             {
 378                 Status = RtlStringCopyWorkerA(Destination,
 379                                               CharLength,
 380                                               &Copied,
 381                                               Source,
 382                                               NTSTRSAFE_MAX_LENGTH);
 383
 384                 LocalDestinationEnd = Destination + Copied;
 385                 Remaining = CharLength - Copied;
 386             }
 387         }
 388         else
 389         {
 390             if (CharLength) *Destination = ANSI_NULL;
 391         }
 392
 393         if ((NT_SUCCESS(Status)) || (Status == STATUS_BUFFER_OVERFLOW))
 394         {
 395             if (DestinationEnd) *DestinationEnd = LocalDestinationEnd;
 396
 397             if (RemainingSize)
 398             {
 399                 *RemainingSize = (Remaining * sizeof(CHAR)) +
 400                                  (Length % sizeof(CHAR));
 401             }
 402         }
 403     }
 404
 405     return Status;
 406 }
 407
 408 static __inline
 409 NTSTATUS
 410 RtlStringCbPrintfW(
 411     LPWSTR pszDest,
 412     IN size_t cbDest,
 413     IN LPCWSTR pszFormat,
 414     ...)
 415 {
 416     ASSERTMSG("RtlStringCbPrintfW is UNIMPLEMENTED!\n", FALSE);
 417     return STATUS_NOT_IMPLEMENTED;
 418 }
 419
 420 static __inline
 421 NTSTATUS
 422 NTAPI
 423 RtlStringCbCatExA(IN OUT LPSTR Destination,
 424                   IN SIZE_T Length,
 425                   IN LPCSTR Source,
 426                   OUT LPSTR *DestinationEnd OPTIONAL,
 427                   OUT PSIZE_T RemainingSize OPTIONAL,
 428                   IN DWORD Flags)
 429 {
 430     NTSTATUS Status;
 431     SIZE_T CharLength = Length / sizeof(CHAR);
 432     SIZE_T DestinationLength, Remaining, Copied = 0;
 433     PCHAR LocalDestinationEnd;
 434     ASSERTMSG("We don't support Extended Flags yet!\n", Flags == 0);
 435
 436     Status = RtlStringExValidateDestA(&Destination,
 437                                       &CharLength,
 438                                       &DestinationLength,
 439                                       NTSTRSAFE_MAX_CCH,
 440                                       Flags);
 441     if (NT_SUCCESS(Status))
 442     {
 443         LocalDestinationEnd = Destination + DestinationLength;
 444         Remaining = CharLength - DestinationLength;
 445
 446         Status = RtlStringExValidateSrcA(&Source,
 447                                          NULL,
 448                                          NTSTRSAFE_MAX_CCH,
 449                                          Flags);
 450         if (NT_SUCCESS(Status))
 451         {
 452             if (Remaining <= 1)
 453             {
 454                 if (*Source != ANSI_NULL)
 455                 {
 456                     if (!Destination)
 457                     {
 458                         Status = STATUS_INVALID_PARAMETER;
 459                     }
 460                     else
 461                     {
 462                         Status = STATUS_BUFFER_OVERFLOW;
 463                     }
 464                 }
 465             }
 466             else
 467             {
 468                 Status = RtlStringCopyWorkerA(LocalDestinationEnd,
 469                                               Remaining,
 470                                               &Copied,
 471                                               Source,
 472                                               NTSTRSAFE_MAX_LENGTH);
 473
 474                 LocalDestinationEnd = LocalDestinationEnd + Copied;
 475                 Remaining = Remaining - Copied;
 476             }
 477         }
 478
 479         if ((NT_SUCCESS(Status)) || (Status == STATUS_BUFFER_OVERFLOW))
 480         {
 481             if (DestinationEnd) *DestinationEnd = LocalDestinationEnd;
 482
 483             if (RemainingSize)
 484             {
 485                 *RemainingSize = (Remaining * sizeof(CHAR)) +
 486                                  (Length % sizeof(CHAR));
 487             }
 488         }
 489     }
 490
 491     return Status;
 492 }
 493
 494 static __inline
 495 NTSTATUS
 496 NTAPI
 497 RtlStringCbCopyA(OUT LPSTR Destination,
 498                  IN SIZE_T Length,
 499                  IN LPCSTR Source)
 500 {
 501     NTSTATUS Status;
 502     SIZE_T CharLength = Length / sizeof(CHAR);
 503
 504     Status = RtlStringValidateDestA(Destination,
 505                                     CharLength,
 506                                     NULL,
 507                                     NTSTRSAFE_MAX_CCH);
 508     if (NT_SUCCESS(Status))
 509     {
 510         Status = RtlStringCopyWorkerA(Destination,
 511                                       CharLength,
 512                                       NULL,
 513                                       Source,
 514                                       NTSTRSAFE_MAX_LENGTH);
 515     }
 516
 517     return Status;
 518 }
 519
 520 #endif /* _NTSTRSAFE_H_INCLUDED_ */