include/ddk/ntstrsafe.h

   1 /**
   2  * This file has no copyright assigned and is placed in the Public Domain.
   3  * This file is part of the w64 mingw-runtime package.
   4  * No warranty is given; refer to the file DISCLAIMER.PD within this package.
   5  */
   6 #ifndef _NTSTRSAFE_H_INCLUDED_
   7 #define _NTSTRSAFE_H_INCLUDED_
   8
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include <stdarg.h>
  12
  13 #ifdef _MSC_VER
  14 #pragma warning(push)
  15 #pragma warning(disable:28719) /* disable banned api usage warning */
  16 #endif /* _MSC_VER */
  17
  18 #ifndef C_ASSERT
  19 #ifdef _MSC_VER
  20 # define C_ASSERT(e) typedef char __C_ASSERT__[(e)?1:-1]
  21 #else
  22 # define C_ASSERT(e) extern void __C_ASSERT__(int [(e)?1:-1])
  23 #endif
  24 #endif /* C_ASSERT */
  25
  26 #ifdef __cplusplus
  27 #define _STRSAFE_EXTERN_C extern "C"
  28 #else
  29 #define _STRSAFE_EXTERN_C extern
  30 #endif
  31
  32 #define NTSTRSAFEAPI static __inline NTSTATUS NTAPI
  33 #define NTSTRSAFE_INLINE_API static __inline NTSTATUS NTAPI
  34
  35 #ifndef NTSTRSAFE_MAX_CCH
  36 #define NTSTRSAFE_MAX_CCH 2147483647
  37 #endif
  38
  39 #ifndef _STRSAFE_H_INCLUDED_
  40 #define STRSAFE_IGNORE_NULLS 0x00000100
  41 #define STRSAFE_FILL_BEHIND_NULL 0x00000200
  42 #define STRSAFE_FILL_ON_FAILURE 0x00000400
  43 #define STRSAFE_NULL_ON_FAILURE 0x00000800
  44 #define STRSAFE_NO_TRUNCATION 0x00001000
  45 #define STRSAFE_IGNORE_NULL_UNICODE_STRINGS 0x00010000
  46 #define STRSAFE_UNICODE_STRING_DEST_NULL_TERMINATED 0x00020000
  47
  48 #define STRSAFE_VALID_FLAGS (0x000000FF | STRSAFE_IGNORE_NULLS | STRSAFE_FILL_BEHIND_NULL | STRSAFE_FILL_ON_FAILURE | STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION)
  49 #define STRSAFE_UNICODE_STRING_VALID_FLAGS (STRSAFE_VALID_FLAGS | STRSAFE_IGNORE_NULL_UNICODE_STRINGS | STRSAFE_UNICODE_STRING_DEST_NULL_TERMINATED)
  50
  51 #define STRSAFE_FILL_BYTE(x) ((STRSAFE_DWORD)(((x) & 0x000000FF) | STRSAFE_FILL_BEHIND_NULL))
  52 #define STRSAFE_FAILURE_BYTE(x) ((STRSAFE_DWORD)(((x) & 0x000000FF) | STRSAFE_FILL_ON_FAILURE))
  53
  54 #define STRSAFE_GET_FILL_PATTERN(dwFlags) ((int)((dwFlags) & 0x000000FF))
  55 #endif
  56
  57 typedef char *STRSAFE_LPSTR;
  58 typedef const char *STRSAFE_LPCSTR;
  59 typedef wchar_t *STRSAFE_LPWSTR;
  60 typedef const wchar_t *STRSAFE_LPCWSTR;
  61
  62 typedef ULONG STRSAFE_DWORD;
  63
  64 NTSTRSAFEAPI RtlStringCopyWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc);
  65 NTSTRSAFEAPI RtlStringCopyWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc);
  66 NTSTRSAFEAPI RtlStringCopyExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
  67 NTSTRSAFEAPI RtlStringCopyExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
  68 NTSTRSAFEAPI RtlStringCopyNWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy);
  69 NTSTRSAFEAPI RtlStringCopyNWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy);
  70 NTSTRSAFEAPI RtlStringCopyNExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
  71 NTSTRSAFEAPI RtlStringCopyNExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
  72 NTSTRSAFEAPI RtlStringCatWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc);
  73 NTSTRSAFEAPI RtlStringCatWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc);
  74 NTSTRSAFEAPI RtlStringCatExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
  75 NTSTRSAFEAPI RtlStringCatExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
  76 NTSTRSAFEAPI RtlStringCatNWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend);
  77 NTSTRSAFEAPI RtlStringCatNWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend);
  78 NTSTRSAFEAPI RtlStringCatNExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
  79 NTSTRSAFEAPI RtlStringCatNExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
  80 NTSTRSAFEAPI RtlStringVPrintfWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,va_list argList);
  81 NTSTRSAFEAPI RtlStringVPrintfWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,va_list argList);
  82 NTSTRSAFEAPI RtlStringVPrintfExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList);
  83 NTSTRSAFEAPI RtlStringVPrintfExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList);
  84 NTSTRSAFEAPI RtlStringLengthWorkerA(STRSAFE_LPCSTR psz,size_t cchMax,size_t *pcchLength);
  85 NTSTRSAFEAPI RtlStringLengthWorkerW(STRSAFE_LPCWSTR psz,size_t cchMax,size_t *pcchLength);
  86
  87 NTSTRSAFEAPI RtlStringCchCopyA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc);
  88 NTSTRSAFEAPI RtlStringCchCopyW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc);
  89
  90
  91 NTSTRSAFEAPI RtlStringCchCopyA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc)
  92 {
  93     return (cchDest > NTSTRSAFE_MAX_CCH ? STATUS_INVALID_PARAMETER : RtlStringCopyWorkerA(pszDest,cchDest,pszSrc));
  94 }
  95
  96 NTSTRSAFEAPI RtlStringCchCopyW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc)
  97 {
  98     if (cchDest > NTSTRSAFE_MAX_CCH)
  99         return STATUS_INVALID_PARAMETER;
 100     return RtlStringCopyWorkerW(pszDest,cchDest,pszSrc);
 101 }
 102
 103
 104 NTSTRSAFEAPI RtlStringCbCopyA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc);
 105 NTSTRSAFEAPI RtlStringCbCopyW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc);
 106
 107
 108 NTSTRSAFEAPI RtlStringCbCopyA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc)
 109 {
 110     if (cbDest > NTSTRSAFE_MAX_CCH)
 111         return STATUS_INVALID_PARAMETER;
 112     return RtlStringCopyWorkerA(pszDest,cbDest,pszSrc);
 113 }
 114
 115 NTSTRSAFEAPI RtlStringCbCopyW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc)
 116 {
 117     size_t cchDest = cbDest / sizeof(wchar_t);
 118     if (cchDest > NTSTRSAFE_MAX_CCH)
 119         return STATUS_INVALID_PARAMETER;
 120     return RtlStringCopyWorkerW(pszDest,cchDest,pszSrc);
 121 }
 122
 123
 124 NTSTRSAFEAPI RtlStringCchCopyExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 125 NTSTRSAFEAPI RtlStringCchCopyExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 126
 127
 128 NTSTRSAFEAPI RtlStringCchCopyExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
 129 {
 130     if (cchDest > NTSTRSAFE_MAX_CCH)
 131         return STATUS_INVALID_PARAMETER;
 132     return RtlStringCopyExWorkerA(pszDest,cchDest,cchDest,pszSrc,ppszDestEnd,pcchRemaining,dwFlags);
 133 }
 134
 135 NTSTRSAFEAPI RtlStringCchCopyExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
 136 {
 137     size_t cbDest;
 138     if (cchDest > NTSTRSAFE_MAX_CCH)
 139         return STATUS_INVALID_PARAMETER;
 140     cbDest = cchDest * sizeof(wchar_t);
 141     return RtlStringCopyExWorkerW(pszDest,cchDest,cbDest,pszSrc,ppszDestEnd,pcchRemaining,dwFlags);
 142 }
 143
 144
 145 NTSTRSAFEAPI RtlStringCbCopyExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 146 NTSTRSAFEAPI RtlStringCbCopyExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 147
 148
 149 NTSTRSAFEAPI RtlStringCbCopyExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
 150 {
 151     NTSTATUS Status;
 152     size_t cchRemaining = 0;
 153     if (cbDest > NTSTRSAFE_MAX_CCH)
 154         return STATUS_INVALID_PARAMETER;
 155     Status = RtlStringCopyExWorkerA(pszDest,cbDest,cbDest,pszSrc,ppszDestEnd,&cchRemaining,dwFlags);
 156     if (NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW)
 157     {
 158         if (pcbRemaining)
 159             *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
 160     }
 161     return Status;
 162 }
 163
 164 NTSTRSAFEAPI RtlStringCbCopyExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
 165 {
 166     NTSTATUS Status;
 167     size_t cchDest = cbDest / sizeof(wchar_t);
 168     size_t cchRemaining = 0;
 169
 170     if (cchDest > NTSTRSAFE_MAX_CCH)
 171         return STATUS_INVALID_PARAMETER;
 172     Status = RtlStringCopyExWorkerW(pszDest,cchDest,cbDest,pszSrc,ppszDestEnd,&cchRemaining,dwFlags);
 173     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
 174     {
 175         if (pcbRemaining)
 176             *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
 177     }
 178     return Status;
 179 }
 180
 181
 182 NTSTRSAFEAPI RtlStringCchCopyNA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy);
 183 NTSTRSAFEAPI RtlStringCchCopyNW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy);
 184
 185
 186 NTSTRSAFEAPI RtlStringCchCopyNA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy)
 187 {
 188     if (cchDest > NTSTRSAFE_MAX_CCH || cchToCopy > NTSTRSAFE_MAX_CCH)
 189         return STATUS_INVALID_PARAMETER;
 190     return RtlStringCopyNWorkerA(pszDest,cchDest,pszSrc,cchToCopy);
 191 }
 192
 193 NTSTRSAFEAPI RtlStringCchCopyNW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy)
 194 {
 195     if (cchDest > NTSTRSAFE_MAX_CCH || cchToCopy > NTSTRSAFE_MAX_CCH)
 196         return STATUS_INVALID_PARAMETER;
 197     return RtlStringCopyNWorkerW(pszDest,cchDest,pszSrc,cchToCopy);
 198 }
 199
 200
 201 NTSTRSAFEAPI RtlStringCbCopyNA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToCopy);
 202 NTSTRSAFEAPI RtlStringCbCopyNW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToCopy);
 203
 204
 205 NTSTRSAFEAPI RtlStringCbCopyNA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToCopy)
 206 {
 207     if (cbDest > NTSTRSAFE_MAX_CCH || cbToCopy > NTSTRSAFE_MAX_CCH)
 208         return STATUS_INVALID_PARAMETER;
 209     return RtlStringCopyNWorkerA(pszDest,cbDest,pszSrc,cbToCopy);
 210 }
 211
 212 NTSTRSAFEAPI RtlStringCbCopyNW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToCopy)
 213 {
 214     size_t cchDest  = cbDest / sizeof(wchar_t);
 215     size_t cchToCopy = cbToCopy / sizeof(wchar_t);
 216     if (cchDest > NTSTRSAFE_MAX_CCH || cchToCopy > NTSTRSAFE_MAX_CCH)
 217         return STATUS_INVALID_PARAMETER;
 218     return RtlStringCopyNWorkerW(pszDest,cchDest,pszSrc,cchToCopy);
 219 }
 220
 221
 222 NTSTRSAFEAPI RtlStringCchCopyNExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 223 NTSTRSAFEAPI RtlStringCchCopyNExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 224
 225
 226 NTSTRSAFEAPI RtlStringCchCopyNExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
 227 {
 228     if (cchDest > NTSTRSAFE_MAX_CCH)
 229         return STATUS_INVALID_PARAMETER;
 230     return RtlStringCopyNExWorkerA(pszDest,cchDest,cchDest,pszSrc,cchToCopy,ppszDestEnd,pcchRemaining,dwFlags);
 231 }
 232
 233 NTSTRSAFEAPI RtlStringCchCopyNExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
 234 {
 235     if (cchDest > NTSTRSAFE_MAX_CCH)
 236         return STATUS_INVALID_PARAMETER;
 237     return RtlStringCopyNExWorkerW(pszDest,cchDest,cchDest * sizeof(wchar_t),pszSrc,cchToCopy,ppszDestEnd,pcchRemaining,dwFlags);
 238 }
 239
 240
 241 NTSTRSAFEAPI RtlStringCbCopyNExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 242 NTSTRSAFEAPI RtlStringCbCopyNExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 243
 244
 245 NTSTRSAFEAPI RtlStringCbCopyNExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
 246 {
 247     NTSTATUS Status;
 248     size_t cchRemaining = 0;
 249     if (cbDest > NTSTRSAFE_MAX_CCH)
 250         Status = STATUS_INVALID_PARAMETER;
 251     else
 252         Status = RtlStringCopyNExWorkerA(pszDest,cbDest,cbDest,pszSrc,cbToCopy,ppszDestEnd,&cchRemaining,dwFlags);
 253     if ((NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW) && pcbRemaining)
 254         *pcbRemaining = cchRemaining;
 255     return Status;
 256 }
 257
 258 NTSTRSAFEAPI RtlStringCbCopyNExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
 259 {
 260     NTSTATUS Status;
 261     size_t cchDest;
 262     size_t cchToCopy;
 263     size_t cchRemaining = 0;
 264     cchDest = cbDest / sizeof(wchar_t);
 265     cchToCopy = cbToCopy / sizeof(wchar_t);
 266     if (cchDest > NTSTRSAFE_MAX_CCH)
 267         Status = STATUS_INVALID_PARAMETER;
 268     else
 269         Status = RtlStringCopyNExWorkerW(pszDest,cchDest,cbDest,pszSrc,cchToCopy,ppszDestEnd,&cchRemaining,dwFlags);
 270     if ((NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW) && pcbRemaining)
 271         *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
 272     return Status;
 273 }
 274
 275
 276 NTSTRSAFEAPI RtlStringCchCatA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc);
 277 NTSTRSAFEAPI RtlStringCchCatW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc);
 278
 279
 280 NTSTRSAFEAPI RtlStringCchCatA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc)
 281 {
 282     if (cchDest > NTSTRSAFE_MAX_CCH)
 283         return STATUS_INVALID_PARAMETER;
 284     return RtlStringCatWorkerA(pszDest,cchDest,pszSrc);
 285 }
 286
 287 NTSTRSAFEAPI RtlStringCchCatW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc)
 288 {
 289     if (cchDest > NTSTRSAFE_MAX_CCH)
 290         return STATUS_INVALID_PARAMETER;
 291     return RtlStringCatWorkerW(pszDest,cchDest,pszSrc);
 292 }
 293
 294
 295 NTSTRSAFEAPI RtlStringCbCatA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc);
 296 NTSTRSAFEAPI RtlStringCbCatW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc);
 297
 298
 299 NTSTRSAFEAPI RtlStringCbCatA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc)
 300 {
 301     if (cbDest > NTSTRSAFE_MAX_CCH)
 302         return STATUS_INVALID_PARAMETER;
 303     return RtlStringCatWorkerA(pszDest,cbDest,pszSrc);
 304 }
 305
 306 NTSTRSAFEAPI RtlStringCbCatW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc)
 307 {
 308     size_t cchDest = cbDest / sizeof(wchar_t);
 309     if (cchDest > NTSTRSAFE_MAX_CCH)
 310         return STATUS_INVALID_PARAMETER;
 311     return RtlStringCatWorkerW(pszDest,cchDest,pszSrc);
 312 }
 313
 314
 315 NTSTRSAFEAPI RtlStringCchCatExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 316 NTSTRSAFEAPI RtlStringCchCatExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 317
 318
 319 NTSTRSAFEAPI RtlStringCchCatExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
 320 {
 321     if (cchDest > NTSTRSAFE_MAX_CCH)
 322         return STATUS_INVALID_PARAMETER;
 323     return RtlStringCatExWorkerA(pszDest,cchDest,cchDest,pszSrc,ppszDestEnd,pcchRemaining,dwFlags);
 324 }
 325
 326 NTSTRSAFEAPI RtlStringCchCatExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
 327 {
 328     size_t cbDest = cchDest*sizeof(wchar_t);
 329     if (cchDest > NTSTRSAFE_MAX_CCH)
 330         return STATUS_INVALID_PARAMETER;
 331     return RtlStringCatExWorkerW(pszDest,cchDest,cbDest,pszSrc,ppszDestEnd,pcchRemaining,dwFlags);
 332 }
 333
 334
 335 NTSTRSAFEAPI RtlStringCbCatExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 336 NTSTRSAFEAPI RtlStringCbCatExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 337
 338
 339 NTSTRSAFEAPI RtlStringCbCatExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
 340 {
 341     NTSTATUS Status;
 342     size_t cchRemaining = 0;
 343     if (cbDest > NTSTRSAFE_MAX_CCH)
 344         Status = STATUS_INVALID_PARAMETER;
 345     else
 346         Status = RtlStringCatExWorkerA(pszDest,cbDest,cbDest,pszSrc,ppszDestEnd,&cchRemaining,dwFlags);
 347     if ((NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW) && pcbRemaining)
 348         *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
 349     return Status;
 350 }
 351
 352 NTSTRSAFEAPI RtlStringCbCatExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
 353 {
 354     NTSTATUS Status;
 355     size_t cchDest = cbDest / sizeof(wchar_t);
 356     size_t cchRemaining = 0;
 357
 358     if (cchDest > NTSTRSAFE_MAX_CCH)
 359         Status = STATUS_INVALID_PARAMETER;
 360     else
 361         Status = RtlStringCatExWorkerW(pszDest,cchDest,cbDest,pszSrc,ppszDestEnd,&cchRemaining,dwFlags);
 362     if ((NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW) && pcbRemaining)
 363         *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
 364     return Status;
 365 }
 366
 367
 368 NTSTRSAFEAPI RtlStringCchCatNA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend);
 369 NTSTRSAFEAPI RtlStringCchCatNW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend);
 370
 371
 372 NTSTRSAFEAPI RtlStringCchCatNA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend)
 373 {
 374     if (cchDest > NTSTRSAFE_MAX_CCH)
 375         return STATUS_INVALID_PARAMETER;
 376     return RtlStringCatNWorkerA(pszDest,cchDest,pszSrc,cchToAppend);
 377 }
 378
 379 NTSTRSAFEAPI RtlStringCchCatNW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend)
 380 {
 381     if (cchDest > NTSTRSAFE_MAX_CCH)
 382         return STATUS_INVALID_PARAMETER;
 383     return RtlStringCatNWorkerW(pszDest,cchDest,pszSrc,cchToAppend);
 384 }
 385
 386
 387 NTSTRSAFEAPI RtlStringCbCatNA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToAppend);
 388 NTSTRSAFEAPI RtlStringCbCatNW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToAppend);
 389
 390
 391 NTSTRSAFEAPI RtlStringCbCatNA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToAppend)
 392 {
 393     if (cbDest > NTSTRSAFE_MAX_CCH)
 394         return STATUS_INVALID_PARAMETER;
 395     return RtlStringCatNWorkerA(pszDest,cbDest,pszSrc,cbToAppend);
 396 }
 397
 398 NTSTRSAFEAPI RtlStringCbCatNW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToAppend)
 399 {
 400     size_t cchDest = cbDest / sizeof(wchar_t);
 401     size_t cchToAppend = cbToAppend / sizeof(wchar_t);
 402
 403     if (cchDest > NTSTRSAFE_MAX_CCH)
 404         return STATUS_INVALID_PARAMETER;
 405     return RtlStringCatNWorkerW(pszDest,cchDest,pszSrc,cchToAppend);
 406 }
 407
 408
 409 NTSTRSAFEAPI RtlStringCchCatNExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 410 NTSTRSAFEAPI RtlStringCchCatNExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
 411
 412
 413 NTSTRSAFEAPI RtlStringCchCatNExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
 414 {
 415     if (cchDest > NTSTRSAFE_MAX_CCH)
 416         return STATUS_INVALID_PARAMETER;
 417     return RtlStringCatNExWorkerA(pszDest,cchDest,cchDest,pszSrc,cchToAppend,ppszDestEnd,pcchRemaining,dwFlags);
 418 }
 419
 420 NTSTRSAFEAPI RtlStringCchCatNExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
 421 {
 422     if (cchDest > NTSTRSAFE_MAX_CCH)
 423         return STATUS_INVALID_PARAMETER;
 424     return RtlStringCatNExWorkerW(pszDest,cchDest,(cchDest*sizeof(wchar_t)),pszSrc,cchToAppend,ppszDestEnd,pcchRemaining,dwFlags);
 425 }
 426
 427
 428 NTSTRSAFEAPI RtlStringCbCatNExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 429 NTSTRSAFEAPI RtlStringCbCatNExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
 430
 431
 432 NTSTRSAFEAPI RtlStringCbCatNExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
 433 {
 434     NTSTATUS Status;
 435     size_t cchRemaining = 0;
 436     if (cbDest > NTSTRSAFE_MAX_CCH)
 437         Status = STATUS_INVALID_PARAMETER;
 438     else
 439         Status = RtlStringCatNExWorkerA(pszDest,cbDest,cbDest,pszSrc,cbToAppend,ppszDestEnd,&cchRemaining,dwFlags);
 440     if ((NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW) && pcbRemaining)
 441         *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
 442     return Status;
 443 }
 444
 445 NTSTRSAFEAPI RtlStringCbCatNExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
 446 {
 447     NTSTATUS Status;
 448     size_t cchDest = cbDest / sizeof(wchar_t);
 449     size_t cchToAppend = cbToAppend / sizeof(wchar_t);
 450     size_t cchRemaining = 0;
 451     if (cchDest > NTSTRSAFE_MAX_CCH)
 452         Status = STATUS_INVALID_PARAMETER;
 453     else
 454         Status = RtlStringCatNExWorkerW(pszDest,cchDest,cbDest,pszSrc,cchToAppend,ppszDestEnd,&cchRemaining,dwFlags);
 455     if ((NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW) && pcbRemaining)
 456         *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
 457     return Status;
 458 }
 459
 460
 461 NTSTRSAFEAPI RtlStringCchVPrintfA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,va_list argList);
 462 NTSTRSAFEAPI RtlStringCchVPrintfW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,va_list argList);
 463
 464
 465 NTSTRSAFEAPI RtlStringCchVPrintfA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,va_list argList)
 466 {
 467     if (cchDest > NTSTRSAFE_MAX_CCH)
 468         return STATUS_INVALID_PARAMETER;
 469     return RtlStringVPrintfWorkerA(pszDest,cchDest,pszFormat,argList);
 470 }
 471
 472 NTSTRSAFEAPI RtlStringCchVPrintfW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,va_list argList)
 473 {
 474     if (cchDest > NTSTRSAFE_MAX_CCH)
 475         return STATUS_INVALID_PARAMETER;
 476     return RtlStringVPrintfWorkerW(pszDest,cchDest,pszFormat,argList);
 477 }
 478
 479
 480 NTSTRSAFEAPI RtlStringCbVPrintfA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszFormat,va_list argList);
 481 NTSTRSAFEAPI RtlStringCbVPrintfW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszFormat,va_list argList);
 482
 483
 484 NTSTRSAFEAPI RtlStringCbVPrintfA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszFormat,va_list argList)
 485 {
 486     if (cbDest > NTSTRSAFE_MAX_CCH)
 487         return STATUS_INVALID_PARAMETER;
 488     return RtlStringVPrintfWorkerA(pszDest,cbDest,pszFormat,argList);
 489 }
 490
 491 NTSTRSAFEAPI RtlStringCbVPrintfW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszFormat,va_list argList)
 492 {
 493     size_t cchDest = cbDest / sizeof(wchar_t);
 494     if (cchDest > NTSTRSAFE_MAX_CCH)
 495         return STATUS_INVALID_PARAMETER;
 496     return RtlStringVPrintfWorkerW(pszDest,cchDest,pszFormat,argList);
 497 }
 498
 499
 500 NTSTRSAFEAPI RtlStringCchPrintfA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,...);
 501 NTSTRSAFEAPI RtlStringCchPrintfW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,...);
 502
 503
 504 NTSTRSAFEAPI RtlStringCchPrintfA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,...)
 505 {
 506     NTSTATUS Status;
 507     va_list argList;
 508     if (cchDest > NTSTRSAFE_MAX_CCH)
 509         return STATUS_INVALID_PARAMETER;
 510     va_start(argList,pszFormat);
 511     Status = RtlStringVPrintfWorkerA(pszDest,cchDest,pszFormat,argList);
 512     va_end(argList);
 513     return Status;
 514 }
 515
 516 NTSTRSAFEAPI RtlStringCchPrintfW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,...)
 517 {
 518     NTSTATUS Status;
 519     va_list argList;
 520     if (cchDest > NTSTRSAFE_MAX_CCH)
 521         return STATUS_INVALID_PARAMETER;
 522     va_start(argList,pszFormat);
 523     Status = RtlStringVPrintfWorkerW(pszDest,cchDest,pszFormat,argList);
 524     va_end(argList);
 525     return Status;
 526 }
 527
 528
 529 NTSTRSAFEAPI RtlStringCbPrintfA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszFormat,...);
 530 NTSTRSAFEAPI RtlStringCbPrintfW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszFormat,...);
 531
 532
 533 NTSTRSAFEAPI RtlStringCbPrintfA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszFormat,...)
 534 {
 535     NTSTATUS Status;
 536     va_list argList;
 537     if (cbDest > NTSTRSAFE_MAX_CCH)
 538         return STATUS_INVALID_PARAMETER;
 539     va_start(argList,pszFormat);
 540     Status = RtlStringVPrintfWorkerA(pszDest,cbDest,pszFormat,argList);
 541     va_end(argList);
 542     return Status;
 543 }
 544
 545 NTSTRSAFEAPI RtlStringCbPrintfW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszFormat,...)
 546 {
 547     NTSTATUS Status;
 548     va_list argList;
 549     size_t cchDest = cbDest / sizeof(wchar_t);
 550     if (cchDest > NTSTRSAFE_MAX_CCH)
 551         return STATUS_INVALID_PARAMETER;
 552     va_start(argList,pszFormat);
 553     Status = RtlStringVPrintfWorkerW(pszDest,cchDest,pszFormat,argList);
 554     va_end(argList);
 555     return Status;
 556 }
 557
 558
 559 NTSTRSAFEAPI RtlStringCchPrintfExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,...);
 560 NTSTRSAFEAPI RtlStringCchPrintfExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,...);
 561
 562
 563 NTSTRSAFEAPI RtlStringCchPrintfExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,...)
 564 {
 565     NTSTATUS Status;
 566     va_list argList;
 567     if (cchDest > NTSTRSAFE_MAX_CCH)
 568         return STATUS_INVALID_PARAMETER;
 569     va_start(argList,pszFormat);
 570     Status = RtlStringVPrintfExWorkerA(pszDest,cchDest,cchDest,ppszDestEnd,pcchRemaining,dwFlags,pszFormat,argList);
 571     va_end(argList);
 572     return Status;
 573 }
 574
 575 NTSTRSAFEAPI RtlStringCchPrintfExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,...)
 576 {
 577     NTSTATUS Status;
 578     size_t cbDest = cchDest * sizeof(wchar_t);
 579     va_list argList;
 580     if (cchDest > NTSTRSAFE_MAX_CCH)
 581         return STATUS_INVALID_PARAMETER;
 582     va_start(argList,pszFormat);
 583     Status = RtlStringVPrintfExWorkerW(pszDest,cchDest,cbDest,ppszDestEnd,pcchRemaining,dwFlags,pszFormat,argList);
 584     va_end(argList);
 585     return Status;
 586 }
 587
 588
 589 NTSTRSAFEAPI RtlStringCbPrintfExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,...);
 590 NTSTRSAFEAPI RtlStringCbPrintfExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,...);
 591
 592
 593 NTSTRSAFEAPI RtlStringCbPrintfExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,...)
 594 {
 595     NTSTATUS Status;
 596     size_t cchDest;
 597     size_t cchRemaining = 0;
 598     cchDest = cbDest / sizeof(char);
 599     if (cchDest > NTSTRSAFE_MAX_CCH)
 600         Status = STATUS_INVALID_PARAMETER;
 601     else
 602     {
 603         va_list argList;
 604         va_start(argList,pszFormat);
 605         Status = RtlStringVPrintfExWorkerA(pszDest,cchDest,cbDest,ppszDestEnd,&cchRemaining,dwFlags,pszFormat,argList);
 606         va_end(argList);
 607     }
 608     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
 609     {
 610         if (pcbRemaining)
 611         {
 612             *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
 613         }
 614     }
 615     return Status;
 616 }
 617
 618 NTSTRSAFEAPI RtlStringCbPrintfExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,...)
 619 {
 620     NTSTATUS Status;
 621     size_t cchDest;
 622     size_t cchRemaining = 0;
 623     cchDest = cbDest / sizeof(wchar_t);
 624     if (cchDest > NTSTRSAFE_MAX_CCH)
 625         Status = STATUS_INVALID_PARAMETER;
 626     else
 627     {
 628         va_list argList;
 629         va_start(argList,pszFormat);
 630         Status = RtlStringVPrintfExWorkerW(pszDest,cchDest,cbDest,ppszDestEnd,&cchRemaining,dwFlags,pszFormat,argList);
 631         va_end(argList);
 632     }
 633     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
 634     {
 635         if (pcbRemaining)
 636         {
 637             *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
 638         }
 639     }
 640     return Status;
 641 }
 642
 643
 644 NTSTRSAFEAPI RtlStringCchVPrintfExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList);
 645 NTSTRSAFEAPI RtlStringCchVPrintfExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList);
 646
 647
 648 NTSTRSAFEAPI RtlStringCchVPrintfExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList)
 649 {
 650     NTSTATUS Status;
 651     if (cchDest > NTSTRSAFE_MAX_CCH)
 652         Status = STATUS_INVALID_PARAMETER;
 653     else
 654     {
 655         size_t cbDest;
 656         cbDest = cchDest*sizeof(char);
 657         Status = RtlStringVPrintfExWorkerA(pszDest,cchDest,cbDest,ppszDestEnd,pcchRemaining,dwFlags,pszFormat,argList);
 658     }
 659     return Status;
 660 }
 661
 662 NTSTRSAFEAPI RtlStringCchVPrintfExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList)
 663 {
 664     NTSTATUS Status;
 665     if (cchDest > NTSTRSAFE_MAX_CCH)
 666         Status = STATUS_INVALID_PARAMETER;
 667     else
 668     {
 669         size_t cbDest;
 670         cbDest = cchDest*sizeof(wchar_t);
 671         Status = RtlStringVPrintfExWorkerW(pszDest,cchDest,cbDest,ppszDestEnd,pcchRemaining,dwFlags,pszFormat,argList);
 672     }
 673     return Status;
 674 }
 675
 676
 677 NTSTRSAFEAPI RtlStringCbVPrintfExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList);
 678 NTSTRSAFEAPI RtlStringCbVPrintfExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList);
 679
 680
 681 NTSTRSAFEAPI RtlStringCbVPrintfExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList)
 682 {
 683     NTSTATUS Status;
 684     size_t cchDest;
 685     size_t cchRemaining = 0;
 686     cchDest = cbDest / sizeof(char);
 687     if (cchDest > NTSTRSAFE_MAX_CCH)
 688         Status = STATUS_INVALID_PARAMETER;
 689     else
 690         Status = RtlStringVPrintfExWorkerA(pszDest,cchDest,cbDest,ppszDestEnd,&cchRemaining,dwFlags,pszFormat,argList);
 691     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
 692     {
 693         if (pcbRemaining)
 694         {
 695             *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
 696         }
 697     }
 698     return Status;
 699 }
 700
 701 NTSTRSAFEAPI RtlStringCbVPrintfExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList)
 702 {
 703     NTSTATUS Status;
 704     size_t cchDest;
 705     size_t cchRemaining = 0;
 706     cchDest = cbDest / sizeof(wchar_t);
 707     if (cchDest > NTSTRSAFE_MAX_CCH)
 708         Status = STATUS_INVALID_PARAMETER;
 709     else
 710         Status = RtlStringVPrintfExWorkerW(pszDest,cchDest,cbDest,ppszDestEnd,&cchRemaining,dwFlags,pszFormat,argList);
 711     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
 712     {
 713         if (pcbRemaining)
 714         {
 715             *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
 716         }
 717     }
 718     return Status;
 719 }
 720
 721
 722 NTSTRSAFEAPI RtlStringCchLengthA(STRSAFE_LPCSTR psz,size_t cchMax,size_t *pcchLength);
 723 NTSTRSAFEAPI RtlStringCchLengthW(STRSAFE_LPCWSTR psz,size_t cchMax,size_t *pcchLength);
 724
 725
 726 NTSTRSAFEAPI RtlStringCchLengthA(STRSAFE_LPCSTR psz,size_t cchMax,size_t *pcchLength)
 727 {
 728     NTSTATUS Status;
 729     if (!psz || (cchMax > NTSTRSAFE_MAX_CCH))
 730         Status = STATUS_INVALID_PARAMETER;
 731     else
 732         Status = RtlStringLengthWorkerA(psz,cchMax,pcchLength);
 733     if (!NT_SUCCESS(Status) && pcchLength)
 734     {
 735         *pcchLength = 0;
 736     }
 737     return Status;
 738 }
 739
 740 NTSTRSAFEAPI RtlStringCchLengthW(STRSAFE_LPCWSTR psz,size_t cchMax,size_t *pcchLength)
 741 {
 742     NTSTATUS Status;
 743     if (!psz || (cchMax > NTSTRSAFE_MAX_CCH))
 744         Status = STATUS_INVALID_PARAMETER;
 745     else
 746         Status = RtlStringLengthWorkerW(psz,cchMax,pcchLength);
 747     if (!NT_SUCCESS(Status) && pcchLength)
 748     {
 749         *pcchLength = 0;
 750     }
 751     return Status;
 752 }
 753
 754
 755 NTSTRSAFEAPI RtlStringCbLengthA(STRSAFE_LPCSTR psz,size_t cbMax,size_t *pcbLength);
 756 NTSTRSAFEAPI RtlStringCbLengthW(STRSAFE_LPCWSTR psz,size_t cbMax,size_t *pcbLength);
 757
 758
 759 NTSTRSAFEAPI RtlStringCbLengthA(STRSAFE_LPCSTR psz,size_t cbMax,size_t *pcbLength)
 760 {
 761     NTSTATUS Status;
 762     size_t cchMax;
 763     size_t cchLength = 0;
 764     cchMax = cbMax / sizeof(char);
 765     if (!psz || (cchMax > NTSTRSAFE_MAX_CCH))
 766         Status = STATUS_INVALID_PARAMETER;
 767     else
 768         Status = RtlStringLengthWorkerA(psz,cchMax,&cchLength);
 769     if (pcbLength)
 770     {
 771         if (NT_SUCCESS(Status))
 772         {
 773             *pcbLength = cchLength*sizeof(char);
 774         }
 775         else
 776         {
 777             *pcbLength = 0;
 778         }
 779     }
 780     return Status;
 781 }
 782
 783 NTSTRSAFEAPI RtlStringCbLengthW(STRSAFE_LPCWSTR psz,size_t cbMax,size_t *pcbLength)
 784 {
 785     NTSTATUS Status;
 786     size_t cchMax;
 787     size_t cchLength = 0;
 788     cchMax = cbMax / sizeof(wchar_t);
 789     if (!psz || (cchMax > NTSTRSAFE_MAX_CCH))
 790         Status = STATUS_INVALID_PARAMETER;
 791     else
 792         Status = RtlStringLengthWorkerW(psz,cchMax,&cchLength);
 793     if (pcbLength)
 794     {
 795         if (NT_SUCCESS(Status))
 796         {
 797             *pcbLength = cchLength*sizeof(wchar_t);
 798         }
 799         else
 800         {
 801             *pcbLength = 0;
 802         }
 803     }
 804     return Status;
 805 }
 806
 807 NTSTRSAFEAPI RtlStringCopyWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc)
 808 {
 809     NTSTATUS Status = STATUS_SUCCESS;
 810     if (cchDest==0)
 811         Status = STATUS_INVALID_PARAMETER;
 812     else
 813     {
 814         while(cchDest && (*pszSrc!='\0'))
 815         {
 816             *pszDest++ = *pszSrc++;
 817             cchDest--;
 818         }
 819         if (cchDest==0)
 820         {
 821             pszDest--;
 822             Status = STATUS_BUFFER_OVERFLOW;
 823         }
 824         *pszDest= '\0';
 825     }
 826     return Status;
 827 }
 828
 829 NTSTRSAFEAPI RtlStringCopyWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc)
 830 {
 831     NTSTATUS Status = STATUS_SUCCESS;
 832     if (cchDest==0)
 833         Status = STATUS_INVALID_PARAMETER;
 834     else
 835     {
 836         while(cchDest && (*pszSrc!=L'\0'))
 837         {
 838             *pszDest++ = *pszSrc++;
 839             cchDest--;
 840         }
 841         if (cchDest==0)
 842         {
 843             pszDest--;
 844             Status = STATUS_BUFFER_OVERFLOW;
 845         }
 846         *pszDest= L'\0';
 847     }
 848     return Status;
 849 }
 850
 851 NTSTRSAFEAPI RtlStringCopyExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
 852 {
 853     NTSTATUS Status = STATUS_SUCCESS;
 854     STRSAFE_LPSTR pszDestEnd = pszDest;
 855     size_t cchRemaining = 0;
 856     if (dwFlags & (~STRSAFE_VALID_FLAGS))
 857         Status = STATUS_INVALID_PARAMETER;
 858     else
 859     {
 860         if (dwFlags & STRSAFE_IGNORE_NULLS)
 861         {
 862             if (!pszDest)
 863             {
 864                 if ((cchDest!=0) || (cbDest!=0))
 865                     Status = STATUS_INVALID_PARAMETER;
 866             }
 867             if (!pszSrc)
 868                 pszSrc = "";
 869         }
 870         if (NT_SUCCESS(Status))
 871         {
 872             if (cchDest==0)
 873             {
 874                 pszDestEnd = pszDest;
 875                 cchRemaining = 0;
 876                 if (*pszSrc!='\0')
 877                 {
 878                     if (!pszDest)
 879                         Status = STATUS_INVALID_PARAMETER;
 880                     else
 881                         Status = STATUS_BUFFER_OVERFLOW;
 882                 }
 883             }
 884             else
 885             {
 886                 pszDestEnd = pszDest;
 887                 cchRemaining = cchDest;
 888                 while(cchRemaining && (*pszSrc!='\0'))
 889                 {
 890                     *pszDestEnd++ = *pszSrc++;
 891                     cchRemaining--;
 892                 }
 893                 if (cchRemaining > 0)
 894                 {
 895                     if (dwFlags & STRSAFE_FILL_BEHIND_NULL)
 896                     {
 897                         memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(char)) + (cbDest % sizeof(char)));
 898                     }
 899                 }
 900                 else
 901                 {
 902                     pszDestEnd--;
 903                     cchRemaining++;
 904                     Status = STATUS_BUFFER_OVERFLOW;
 905                 }
 906                 *pszDestEnd = '\0';
 907             }
 908         }
 909     }
 910     if (!NT_SUCCESS(Status))
 911     {
 912         if (pszDest)
 913         {
 914             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
 915             {
 916                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
 917                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
 918                 {
 919                     pszDestEnd = pszDest;
 920                     cchRemaining = cchDest;
 921                 }
 922                 else
 923                     if (cchDest > 0)
 924                     {
 925                         pszDestEnd = pszDest + cchDest - 1;
 926                         cchRemaining = 1;
 927                         *pszDestEnd = '\0';
 928                     }
 929             }
 930             if (dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION))
 931             {
 932                 if (cchDest > 0)
 933                 {
 934                     pszDestEnd = pszDest;
 935                     cchRemaining = cchDest;
 936                     *pszDestEnd = '\0';
 937                 }
 938             }
 939         }
 940     }
 941     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
 942     {
 943         if (ppszDestEnd)
 944             *ppszDestEnd = pszDestEnd;
 945         if (pcchRemaining)
 946             *pcchRemaining = cchRemaining;
 947     }
 948     return Status;
 949 }
 950
 951 NTSTRSAFEAPI RtlStringCopyExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
 952 {
 953     NTSTATUS Status = STATUS_SUCCESS;
 954     STRSAFE_LPWSTR pszDestEnd = pszDest;
 955     size_t cchRemaining = 0;
 956     if (dwFlags & (~STRSAFE_VALID_FLAGS))
 957         Status = STATUS_INVALID_PARAMETER;
 958     else
 959     {
 960         if (dwFlags & STRSAFE_IGNORE_NULLS)
 961         {
 962             if (!pszDest)
 963             {
 964                 if ((cchDest!=0) || (cbDest!=0))
 965                     Status = STATUS_INVALID_PARAMETER;
 966             }
 967             if (!pszSrc)
 968                 pszSrc = L"";
 969         }
 970         if (NT_SUCCESS(Status))
 971         {
 972             if (cchDest==0)
 973             {
 974                 pszDestEnd = pszDest;
 975                 cchRemaining = 0;
 976                 if (*pszSrc!=L'\0')
 977                 {
 978                     if (!pszDest)
 979                         Status = STATUS_INVALID_PARAMETER;
 980                     else
 981                         Status = STATUS_BUFFER_OVERFLOW;
 982                 }
 983             }
 984             else
 985             {
 986                 pszDestEnd = pszDest;
 987                 cchRemaining = cchDest;
 988                 while(cchRemaining && (*pszSrc!=L'\0'))
 989                 {
 990                     *pszDestEnd++ = *pszSrc++;
 991                     cchRemaining--;
 992                 }
 993                 if (cchRemaining > 0)
 994                 {
 995                     if (dwFlags & STRSAFE_FILL_BEHIND_NULL)
 996                     {
 997                         memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t)));
 998                     }
 999                 }
1000                 else
1001                 {
1002                     pszDestEnd--;
1003                     cchRemaining++;
1004                     Status = STATUS_BUFFER_OVERFLOW;
1005                 }
1006                 *pszDestEnd = L'\0';
1007             }
1008         }
1009     }
1010     if (!NT_SUCCESS(Status))
1011     {
1012         if (pszDest)
1013         {
1014             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
1015             {
1016                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1017                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
1018                 {
1019                     pszDestEnd = pszDest;
1020                     cchRemaining = cchDest;
1021                 }
1022                 else
1023                     if (cchDest > 0)
1024                     {
1025                         pszDestEnd = pszDest + cchDest - 1;
1026                         cchRemaining = 1;
1027                         *pszDestEnd = L'\0';
1028                     }
1029             }
1030             if (dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION))
1031             {
1032                 if (cchDest > 0)
1033                 {
1034                     pszDestEnd = pszDest;
1035                     cchRemaining = cchDest;
1036                     *pszDestEnd = L'\0';
1037                 }
1038             }
1039         }
1040     }
1041     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
1042     {
1043         if (ppszDestEnd)
1044             *ppszDestEnd = pszDestEnd;
1045         if (pcchRemaining)
1046             *pcchRemaining = cchRemaining;
1047     }
1048     return Status;
1049 }
1050
1051 NTSTRSAFEAPI RtlStringCopyNWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchSrc)
1052 {
1053     NTSTATUS Status = STATUS_SUCCESS;
1054     if (cchDest==0)
1055         Status = STATUS_INVALID_PARAMETER;
1056     else
1057     {
1058         while(cchDest && cchSrc && (*pszSrc!='\0'))
1059         {
1060             *pszDest++ = *pszSrc++;
1061             cchDest--;
1062             cchSrc--;
1063         }
1064         if (cchDest==0)
1065         {
1066             pszDest--;
1067             Status = STATUS_BUFFER_OVERFLOW;
1068         }
1069         *pszDest= '\0';
1070     }
1071     return Status;
1072 }
1073
1074 NTSTRSAFEAPI RtlStringCopyNWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy)
1075 {
1076     NTSTATUS Status = STATUS_SUCCESS;
1077     if (cchDest==0)
1078         Status = STATUS_INVALID_PARAMETER;
1079     else
1080     {
1081         while(cchDest && cchToCopy && (*pszSrc!=L'\0'))
1082         {
1083             *pszDest++ = *pszSrc++;
1084             cchDest--;
1085             cchToCopy--;
1086         }
1087         if (cchDest==0)
1088         {
1089             pszDest--;
1090             Status = STATUS_BUFFER_OVERFLOW;
1091         }
1092         *pszDest= L'\0';
1093     }
1094     return Status;
1095 }
1096
1097 NTSTRSAFEAPI RtlStringCopyNExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
1098 {
1099     NTSTATUS Status = STATUS_SUCCESS;
1100     STRSAFE_LPSTR pszDestEnd = pszDest;
1101     size_t cchRemaining = 0;
1102     if (dwFlags & (~STRSAFE_VALID_FLAGS))
1103         Status = STATUS_INVALID_PARAMETER;
1104     else
1105         if (cchToCopy > NTSTRSAFE_MAX_CCH)
1106             Status = STATUS_INVALID_PARAMETER;
1107         else
1108         {
1109             if (dwFlags & STRSAFE_IGNORE_NULLS)
1110             {
1111                 if (!pszDest)
1112                 {
1113                     if ((cchDest!=0) || (cbDest!=0))
1114                         Status = STATUS_INVALID_PARAMETER;
1115                 }
1116                 if (!pszSrc)
1117                     pszSrc = "";
1118             }
1119             if (NT_SUCCESS(Status))
1120             {
1121                 if (cchDest==0)
1122                 {
1123                     pszDestEnd = pszDest;
1124                     cchRemaining = 0;
1125                     if ((cchToCopy!=0) && (*pszSrc!='\0'))
1126                     {
1127                         if (!pszDest)
1128                             Status = STATUS_INVALID_PARAMETER;
1129                         else
1130                             Status = STATUS_BUFFER_OVERFLOW;
1131                     }
1132                 }
1133                 else
1134                 {
1135                     pszDestEnd = pszDest;
1136                     cchRemaining = cchDest;
1137                     while(cchRemaining && cchToCopy && (*pszSrc!='\0'))
1138                     {
1139                         *pszDestEnd++ = *pszSrc++;
1140                         cchRemaining--;
1141                         cchToCopy--;
1142                     }
1143                     if (cchRemaining > 0)
1144                     {
1145                         if (dwFlags & STRSAFE_FILL_BEHIND_NULL)
1146                         {
1147                             memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(char)) + (cbDest % sizeof(char)));
1148                         }
1149                     }
1150                     else
1151                     {
1152                         pszDestEnd--;
1153                         cchRemaining++;
1154                         Status = STATUS_BUFFER_OVERFLOW;
1155                     }
1156                     *pszDestEnd = '\0';
1157                 }
1158             }
1159         }
1160     if (!NT_SUCCESS(Status))
1161     {
1162         if (pszDest)
1163         {
1164             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
1165             {
1166                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1167                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
1168                 {
1169                     pszDestEnd = pszDest;
1170                     cchRemaining = cchDest;
1171                 }
1172                 else
1173                     if (cchDest > 0)
1174                     {
1175                         pszDestEnd = pszDest + cchDest - 1;
1176                         cchRemaining = 1;
1177                         *pszDestEnd = '\0';
1178                     }
1179             }
1180             if (dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION))
1181             {
1182                 if (cchDest > 0)
1183                 {
1184                     pszDestEnd = pszDest;
1185                     cchRemaining = cchDest;
1186                     *pszDestEnd = '\0';
1187                 }
1188             }
1189         }
1190     }
1191     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
1192     {
1193         if (ppszDestEnd)
1194             *ppszDestEnd = pszDestEnd;
1195         if (pcchRemaining)
1196             *pcchRemaining = cchRemaining;
1197     }
1198     return Status;
1199 }
1200
1201 NTSTRSAFEAPI RtlStringCopyNExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
1202 {
1203     NTSTATUS Status = STATUS_SUCCESS;
1204     STRSAFE_LPWSTR pszDestEnd = pszDest;
1205     size_t cchRemaining = 0;
1206     if (dwFlags & (~STRSAFE_VALID_FLAGS))
1207         Status = STATUS_INVALID_PARAMETER;
1208     else
1209         if (cchToCopy > NTSTRSAFE_MAX_CCH)
1210             Status = STATUS_INVALID_PARAMETER;
1211         else
1212         {
1213             if (dwFlags & STRSAFE_IGNORE_NULLS)
1214             {
1215                 if (!pszDest)
1216                 {
1217                     if ((cchDest!=0) || (cbDest!=0))
1218                         Status = STATUS_INVALID_PARAMETER;
1219                 }
1220                 if (!pszSrc)
1221                     pszSrc = L"";
1222             }
1223             if (NT_SUCCESS(Status))
1224             {
1225                 if (cchDest==0)
1226                 {
1227                     pszDestEnd = pszDest;
1228                     cchRemaining = 0;
1229                     if ((cchToCopy!=0) && (*pszSrc!=L'\0'))
1230                     {
1231                         if (!pszDest)
1232                             Status = STATUS_INVALID_PARAMETER;
1233                         else
1234                             Status = STATUS_BUFFER_OVERFLOW;
1235                     }
1236                 }
1237                 else
1238                 {
1239                     pszDestEnd = pszDest;
1240                     cchRemaining = cchDest;
1241                     while(cchRemaining && cchToCopy && (*pszSrc!=L'\0'))
1242                     {
1243                         *pszDestEnd++ = *pszSrc++;
1244                         cchRemaining--;
1245                         cchToCopy--;
1246                     }
1247                     if (cchRemaining > 0)
1248                     {
1249                         if (dwFlags & STRSAFE_FILL_BEHIND_NULL)
1250                         {
1251                             memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t)));
1252                         }
1253                     }
1254                     else
1255                     {
1256                         pszDestEnd--;
1257                         cchRemaining++;
1258                         Status = STATUS_BUFFER_OVERFLOW;
1259                     }
1260                     *pszDestEnd = L'\0';
1261                 }
1262             }
1263         }
1264     if (!NT_SUCCESS(Status))
1265     {
1266         if (pszDest)
1267         {
1268             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
1269             {
1270                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1271                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
1272                 {
1273                     pszDestEnd = pszDest;
1274                     cchRemaining = cchDest;
1275                 }
1276                 else
1277                     if (cchDest > 0)
1278                     {
1279                         pszDestEnd = pszDest + cchDest - 1;
1280                         cchRemaining = 1;
1281                         *pszDestEnd = L'\0';
1282                     }
1283             }
1284             if (dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION))
1285             {
1286                 if (cchDest > 0)
1287                 {
1288                     pszDestEnd = pszDest;
1289                     cchRemaining = cchDest;
1290                     *pszDestEnd = L'\0';
1291                 }
1292             }
1293         }
1294     }
1295     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
1296     {
1297         if (ppszDestEnd)
1298             *ppszDestEnd = pszDestEnd;
1299         if (pcchRemaining)
1300             *pcchRemaining = cchRemaining;
1301     }
1302     return Status;
1303 }
1304
1305 NTSTRSAFEAPI RtlStringCatWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc)
1306 {
1307     NTSTATUS Status;
1308     size_t cchDestLength;
1309     Status = RtlStringLengthWorkerA(pszDest,cchDest,&cchDestLength);
1310     if (NT_SUCCESS(Status))
1311         Status = RtlStringCopyWorkerA(pszDest + cchDestLength,cchDest - cchDestLength,pszSrc);
1312     return Status;
1313 }
1314
1315 NTSTRSAFEAPI RtlStringCatWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc)
1316 {
1317     NTSTATUS Status;
1318     size_t cchDestLength;
1319     Status = RtlStringLengthWorkerW(pszDest,cchDest,&cchDestLength);
1320     if (NT_SUCCESS(Status))
1321         Status = RtlStringCopyWorkerW(pszDest + cchDestLength,cchDest - cchDestLength,pszSrc);
1322     return Status;
1323 }
1324
1325 NTSTRSAFEAPI RtlStringCatExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
1326 {
1327     NTSTATUS Status = STATUS_SUCCESS;
1328     STRSAFE_LPSTR pszDestEnd = pszDest;
1329     size_t cchRemaining = 0;
1330     if (dwFlags & (~STRSAFE_VALID_FLAGS))
1331         Status = STATUS_INVALID_PARAMETER;
1332     else
1333     {
1334         size_t cchDestLength;
1335         if (dwFlags & STRSAFE_IGNORE_NULLS)
1336         {
1337             if (!pszDest)
1338             {
1339                 if ((cchDest==0) && (cbDest==0))
1340                     cchDestLength = 0;
1341                 else
1342                     Status = STATUS_INVALID_PARAMETER;
1343             }
1344             else
1345             {
1346                 Status = RtlStringLengthWorkerA(pszDest,cchDest,&cchDestLength);
1347                 if (NT_SUCCESS(Status))
1348                 {
1349                     pszDestEnd = pszDest + cchDestLength;
1350                     cchRemaining = cchDest - cchDestLength;
1351                 }
1352             }
1353             if (!pszSrc)
1354                 pszSrc = "";
1355         }
1356         else
1357         {
1358             Status = RtlStringLengthWorkerA(pszDest,cchDest,&cchDestLength);
1359             if (NT_SUCCESS(Status))
1360             {
1361                 pszDestEnd = pszDest + cchDestLength;
1362                 cchRemaining = cchDest - cchDestLength;
1363             }
1364         }
1365         if (NT_SUCCESS(Status))
1366         {
1367             if (cchDest==0)
1368             {
1369                 if (*pszSrc!='\0')
1370                 {
1371                     if (!pszDest)
1372                         Status = STATUS_INVALID_PARAMETER;
1373                     else
1374                         Status = STATUS_BUFFER_OVERFLOW;
1375                 }
1376             }
1377             else
1378                 Status = RtlStringCopyExWorkerA(pszDestEnd,cchRemaining,(cchRemaining*sizeof(char)) + (cbDest % sizeof(char)),pszSrc,&pszDestEnd,&cchRemaining,dwFlags & (~(STRSAFE_FILL_ON_FAILURE | STRSAFE_NULL_ON_FAILURE)));
1379         }
1380     }
1381     if (!NT_SUCCESS(Status))
1382     {
1383         if (pszDest)
1384         {
1385             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
1386             {
1387                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1388                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
1389                 {
1390                     pszDestEnd = pszDest;
1391                     cchRemaining = cchDest;
1392                 }
1393                 else
1394                     if (cchDest > 0)
1395                     {
1396                         pszDestEnd = pszDest + cchDest - 1;
1397                         cchRemaining = 1;
1398                         *pszDestEnd = '\0';
1399                     }
1400             }
1401             if (dwFlags & STRSAFE_NULL_ON_FAILURE)
1402             {
1403                 if (cchDest > 0)
1404                 {
1405                     pszDestEnd = pszDest;
1406                     cchRemaining = cchDest;
1407                     *pszDestEnd = '\0';
1408                 }
1409             }
1410         }
1411     }
1412     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
1413     {
1414         if (ppszDestEnd)
1415             *ppszDestEnd = pszDestEnd;
1416         if (pcchRemaining)
1417             *pcchRemaining = cchRemaining;
1418     }
1419     return Status;
1420 }
1421
1422 NTSTRSAFEAPI RtlStringCatExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
1423 {
1424     NTSTATUS Status = STATUS_SUCCESS;
1425     STRSAFE_LPWSTR pszDestEnd = pszDest;
1426     size_t cchRemaining = 0;
1427     if (dwFlags & (~STRSAFE_VALID_FLAGS))
1428         Status = STATUS_INVALID_PARAMETER;
1429     else
1430     {
1431         size_t cchDestLength;
1432         if (dwFlags & STRSAFE_IGNORE_NULLS)
1433         {
1434             if (!pszDest)
1435             {
1436                 if ((cchDest==0) && (cbDest==0))
1437                     cchDestLength = 0;
1438                 else
1439                     Status = STATUS_INVALID_PARAMETER;
1440             }
1441             else
1442             {
1443                 Status = RtlStringLengthWorkerW(pszDest,cchDest,&cchDestLength);
1444                 if (NT_SUCCESS(Status))
1445                 {
1446                     pszDestEnd = pszDest + cchDestLength;
1447                     cchRemaining = cchDest - cchDestLength;
1448                 }
1449             }
1450             if (!pszSrc)
1451                 pszSrc = L"";
1452         }
1453         else
1454         {
1455             Status = RtlStringLengthWorkerW(pszDest,cchDest,&cchDestLength);
1456             if (NT_SUCCESS(Status))
1457             {
1458                 pszDestEnd = pszDest + cchDestLength;
1459                 cchRemaining = cchDest - cchDestLength;
1460             }
1461         }
1462         if (NT_SUCCESS(Status))
1463         {
1464             if (cchDest==0)
1465             {
1466                 if (*pszSrc!=L'\0')
1467                 {
1468                     if (!pszDest)
1469                         Status = STATUS_INVALID_PARAMETER;
1470                     else
1471                         Status = STATUS_BUFFER_OVERFLOW;
1472                 }
1473             }
1474             else
1475                 Status = RtlStringCopyExWorkerW(pszDestEnd,cchRemaining,(cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t)),pszSrc,&pszDestEnd,&cchRemaining,dwFlags & (~(STRSAFE_FILL_ON_FAILURE | STRSAFE_NULL_ON_FAILURE)));
1476         }
1477     }
1478     if (!NT_SUCCESS(Status))
1479     {
1480         if (pszDest)
1481         {
1482             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
1483             {
1484                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1485                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
1486                 {
1487                     pszDestEnd = pszDest;
1488                     cchRemaining = cchDest;
1489                 }
1490                 else
1491                     if (cchDest > 0)
1492                     {
1493                         pszDestEnd = pszDest + cchDest - 1;
1494                         cchRemaining = 1;
1495                         *pszDestEnd = L'\0';
1496                     }
1497             }
1498             if (dwFlags & STRSAFE_NULL_ON_FAILURE)
1499             {
1500                 if (cchDest > 0)
1501                 {
1502                     pszDestEnd = pszDest;
1503                     cchRemaining = cchDest;
1504                     *pszDestEnd = L'\0';
1505                 }
1506             }
1507         }
1508     }
1509     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
1510     {
1511         if (ppszDestEnd)
1512             *ppszDestEnd = pszDestEnd;
1513         if (pcchRemaining)
1514             *pcchRemaining = cchRemaining;
1515     }
1516     return Status;
1517 }
1518
1519 NTSTRSAFEAPI RtlStringCatNWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend)
1520 {
1521     NTSTATUS Status;
1522     size_t cchDestLength;
1523     Status = RtlStringLengthWorkerA(pszDest,cchDest,&cchDestLength);
1524     if (NT_SUCCESS(Status))
1525         Status = RtlStringCopyNWorkerA(pszDest + cchDestLength,cchDest - cchDestLength,pszSrc,cchToAppend);
1526     return Status;
1527 }
1528
1529 NTSTRSAFEAPI RtlStringCatNWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend)
1530 {
1531     NTSTATUS Status;
1532     size_t cchDestLength;
1533     Status = RtlStringLengthWorkerW(pszDest,cchDest,&cchDestLength);
1534     if (NT_SUCCESS(Status))
1535         Status = RtlStringCopyNWorkerW(pszDest + cchDestLength,cchDest - cchDestLength,pszSrc,cchToAppend);
1536     return Status;
1537 }
1538
1539 NTSTRSAFEAPI RtlStringCatNExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
1540 {
1541     NTSTATUS Status = STATUS_SUCCESS;
1542     STRSAFE_LPSTR pszDestEnd = pszDest;
1543     size_t cchRemaining = 0;
1544     size_t cchDestLength = 0;
1545     if (dwFlags & (~STRSAFE_VALID_FLAGS))
1546         Status = STATUS_INVALID_PARAMETER;
1547     else
1548         if (cchToAppend > NTSTRSAFE_MAX_CCH)
1549             Status = STATUS_INVALID_PARAMETER;
1550         else
1551         {
1552             if (dwFlags & STRSAFE_IGNORE_NULLS)
1553             {
1554                 if (!pszDest)
1555                 {
1556                     if ((cchDest==0) && (cbDest==0))
1557                         cchDestLength = 0;
1558                     else
1559                         Status = STATUS_INVALID_PARAMETER;
1560                 }
1561                 else
1562                 {
1563                     Status = RtlStringLengthWorkerA(pszDest,cchDest,&cchDestLength);
1564                     if (NT_SUCCESS(Status))
1565                     {
1566                         pszDestEnd = pszDest + cchDestLength;
1567                         cchRemaining = cchDest - cchDestLength;
1568                     }
1569                 }
1570                 if (!pszSrc)
1571                     pszSrc = "";
1572             }
1573             else
1574             {
1575                 Status = RtlStringLengthWorkerA(pszDest,cchDest,&cchDestLength);
1576                 if (NT_SUCCESS(Status))
1577                 {
1578                     pszDestEnd = pszDest + cchDestLength;
1579                     cchRemaining = cchDest - cchDestLength;
1580                 }
1581             }
1582             if (NT_SUCCESS(Status))
1583             {
1584                 if (cchDest==0)
1585                 {
1586                     if ((cchToAppend!=0) && (*pszSrc!='\0'))
1587                     {
1588                         if (!pszDest)
1589                             Status = STATUS_INVALID_PARAMETER;
1590                         else
1591                             Status = STATUS_BUFFER_OVERFLOW;
1592                     }
1593                 }
1594                 else
1595                     Status = RtlStringCopyNExWorkerA(pszDestEnd,cchRemaining,(cchRemaining*sizeof(char)) + (cbDest % sizeof(char)),pszSrc,cchToAppend,&pszDestEnd,&cchRemaining,dwFlags & (~(STRSAFE_FILL_ON_FAILURE | STRSAFE_NULL_ON_FAILURE)));
1596             }
1597         }
1598     if (!NT_SUCCESS(Status))
1599     {
1600         if (pszDest)
1601         {
1602             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
1603             {
1604                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1605                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
1606                 {
1607                     pszDestEnd = pszDest;
1608                     cchRemaining = cchDest;
1609                 }
1610                 else
1611                     if (cchDest > 0)
1612                     {
1613                         pszDestEnd = pszDest + cchDest - 1;
1614                         cchRemaining = 1;
1615                         *pszDestEnd = '\0';
1616                     }
1617             }
1618             if (dwFlags & (STRSAFE_NULL_ON_FAILURE))
1619             {
1620                 if (cchDest > 0)
1621                 {
1622                     pszDestEnd = pszDest;
1623                     cchRemaining = cchDest;
1624                     *pszDestEnd = '\0';
1625                 }
1626             }
1627         }
1628     }
1629     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
1630     {
1631         if (ppszDestEnd)
1632             *ppszDestEnd = pszDestEnd;
1633         if (pcchRemaining)
1634             *pcchRemaining = cchRemaining;
1635     }
1636     return Status;
1637 }
1638
1639 NTSTRSAFEAPI RtlStringCatNExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
1640 {
1641     NTSTATUS Status = STATUS_SUCCESS;
1642     STRSAFE_LPWSTR pszDestEnd = pszDest;
1643     size_t cchRemaining = 0;
1644     size_t cchDestLength = 0;
1645     if (dwFlags & (~STRSAFE_VALID_FLAGS))
1646         Status = STATUS_INVALID_PARAMETER;
1647     else
1648         if (cchToAppend > NTSTRSAFE_MAX_CCH)
1649             Status = STATUS_INVALID_PARAMETER;
1650         else
1651         {
1652             if (dwFlags & STRSAFE_IGNORE_NULLS)
1653             {
1654                 if (!pszDest)
1655                 {
1656                     if ((cchDest==0) && (cbDest==0))
1657                         cchDestLength = 0;
1658                     else
1659                         Status = STATUS_INVALID_PARAMETER;
1660                 }
1661                 else
1662                 {
1663                     Status = RtlStringLengthWorkerW(pszDest,cchDest,&cchDestLength);
1664                     if (NT_SUCCESS(Status))
1665                     {
1666                         pszDestEnd = pszDest + cchDestLength;
1667                         cchRemaining = cchDest - cchDestLength;
1668                     }
1669                 }
1670                 if (!pszSrc)
1671                     pszSrc = L"";
1672             }
1673             else
1674             {
1675                 Status = RtlStringLengthWorkerW(pszDest,cchDest,&cchDestLength);
1676                 if (NT_SUCCESS(Status))
1677                 {
1678                     pszDestEnd = pszDest + cchDestLength;
1679                     cchRemaining = cchDest - cchDestLength;
1680                 }
1681             }
1682             if (NT_SUCCESS(Status))
1683             {
1684                 if (cchDest==0)
1685                 {
1686                     if ((cchToAppend!=0) && (*pszSrc!=L'\0'))
1687                     {
1688                         if (!pszDest)
1689                             Status = STATUS_INVALID_PARAMETER;
1690                         else
1691                             Status = STATUS_BUFFER_OVERFLOW;
1692                     }
1693                 }
1694                 else
1695                     Status = RtlStringCopyNExWorkerW(pszDestEnd,cchRemaining,(cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t)),pszSrc,cchToAppend,&pszDestEnd,&cchRemaining,dwFlags & (~(STRSAFE_FILL_ON_FAILURE | STRSAFE_NULL_ON_FAILURE)));
1696             }
1697         }
1698     if (!NT_SUCCESS(Status))
1699     {
1700         if (pszDest)
1701         {
1702             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
1703             {
1704                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1705                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
1706                 {
1707                     pszDestEnd = pszDest;
1708                     cchRemaining = cchDest;
1709                 }
1710                 else
1711                     if (cchDest > 0)
1712                     {
1713                         pszDestEnd = pszDest + cchDest - 1;
1714                         cchRemaining = 1;
1715                         *pszDestEnd = L'\0';
1716                     }
1717             }
1718             if (dwFlags & (STRSAFE_NULL_ON_FAILURE))
1719             {
1720                 if (cchDest > 0)
1721                 {
1722                     pszDestEnd = pszDest;
1723                     cchRemaining = cchDest;
1724                     *pszDestEnd = L'\0';
1725                 }
1726             }
1727         }
1728     }
1729     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
1730     {
1731         if (ppszDestEnd)
1732             *ppszDestEnd = pszDestEnd;
1733         if (pcchRemaining)
1734             *pcchRemaining = cchRemaining;
1735     }
1736     return Status;
1737 }
1738
1739 NTSTRSAFEAPI RtlStringVPrintfWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,va_list argList)
1740 {
1741     NTSTATUS Status = STATUS_SUCCESS;
1742     if (cchDest==0)
1743         Status = STATUS_INVALID_PARAMETER;
1744     else
1745     {
1746         int iRet;
1747         size_t cchMax;
1748         cchMax = cchDest - 1;
1749         iRet = _vsnprintf(pszDest,cchMax,pszFormat,argList);
1750         if ((iRet < 0) || (((size_t)iRet) > cchMax))
1751         {
1752             pszDest += cchMax;
1753             *pszDest = '\0';
1754             Status = STATUS_BUFFER_OVERFLOW;
1755         }
1756         else
1757             if (((size_t)iRet)==cchMax)
1758             {
1759                 pszDest += cchMax;
1760                 *pszDest = '\0';
1761             }
1762     }
1763     return Status;
1764 }
1765
1766 NTSTRSAFEAPI RtlStringVPrintfWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,va_list argList)
1767 {
1768     NTSTATUS Status = STATUS_SUCCESS;
1769     if (cchDest==0)
1770         Status = STATUS_INVALID_PARAMETER;
1771     else
1772     {
1773         int iRet;
1774         size_t cchMax;
1775         cchMax = cchDest - 1;
1776         iRet = _vsnwprintf(pszDest,cchMax,pszFormat,argList);
1777         if ((iRet < 0) || (((size_t)iRet) > cchMax))
1778         {
1779             pszDest += cchMax;
1780             *pszDest = L'\0';
1781             Status = STATUS_BUFFER_OVERFLOW;
1782         }
1783         else
1784             if (((size_t)iRet)==cchMax)
1785             {
1786                 pszDest += cchMax;
1787                 *pszDest = L'\0';
1788             }
1789     }
1790     return Status;
1791 }
1792
1793 NTSTRSAFEAPI RtlStringVPrintfExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList)
1794 {
1795     NTSTATUS Status = STATUS_SUCCESS;
1796     STRSAFE_LPSTR pszDestEnd = pszDest;
1797     size_t cchRemaining = 0;
1798     if (dwFlags & (~STRSAFE_VALID_FLAGS))
1799         Status = STATUS_INVALID_PARAMETER;
1800     else
1801     {
1802         if (dwFlags & STRSAFE_IGNORE_NULLS)
1803         {
1804             if (!pszDest)
1805             {
1806                 if ((cchDest!=0) || (cbDest!=0))
1807                     Status = STATUS_INVALID_PARAMETER;
1808             }
1809             if (!pszFormat)
1810                 pszFormat = "";
1811         }
1812         if (NT_SUCCESS(Status))
1813         {
1814             if (cchDest==0)
1815             {
1816                 pszDestEnd = pszDest;
1817                 cchRemaining = 0;
1818                 if (*pszFormat!='\0')
1819                 {
1820                     if (!pszDest)
1821                         Status = STATUS_INVALID_PARAMETER;
1822                     else
1823                         Status = STATUS_BUFFER_OVERFLOW;
1824                 }
1825             }
1826             else
1827             {
1828                 int iRet;
1829                 size_t cchMax;
1830                 cchMax = cchDest - 1;
1831                 iRet = _vsnprintf(pszDest,cchMax,pszFormat,argList);
1832                 if ((iRet < 0) || (((size_t)iRet) > cchMax))
1833                 {
1834                     pszDestEnd = pszDest + cchMax;
1835                     cchRemaining = 1;
1836                     *pszDestEnd = '\0';
1837                     Status = STATUS_BUFFER_OVERFLOW;
1838                 }
1839                 else
1840                     if (((size_t)iRet)==cchMax)
1841                     {
1842                         pszDestEnd = pszDest + cchMax;
1843                         cchRemaining = 1;
1844                         *pszDestEnd = '\0';
1845                     }
1846                     else
1847                         if (((size_t)iRet) < cchMax)
1848                         {
1849                             pszDestEnd = pszDest + iRet;
1850                             cchRemaining = cchDest - iRet;
1851                             if (dwFlags & STRSAFE_FILL_BEHIND_NULL)
1852                             {
1853                                 memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(char)) + (cbDest % sizeof(char)));
1854                             }
1855                         }
1856             }
1857         }
1858     }
1859     if (!NT_SUCCESS(Status))
1860     {
1861         if (pszDest)
1862         {
1863             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
1864             {
1865                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1866                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
1867                 {
1868                     pszDestEnd = pszDest;
1869                     cchRemaining = cchDest;
1870                 }
1871                 else
1872                     if (cchDest > 0)
1873                     {
1874                         pszDestEnd = pszDest + cchDest - 1;
1875                         cchRemaining = 1;
1876                         *pszDestEnd = '\0';
1877                     }
1878             }
1879             if (dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION))
1880             {
1881                 if (cchDest > 0)
1882                 {
1883                     pszDestEnd = pszDest;
1884                     cchRemaining = cchDest;
1885                     *pszDestEnd = '\0';
1886                 }
1887             }
1888         }
1889     }
1890     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
1891     {
1892         if (ppszDestEnd)
1893             *ppszDestEnd = pszDestEnd;
1894         if (pcchRemaining)
1895             *pcchRemaining = cchRemaining;
1896     }
1897     return Status;
1898 }
1899
1900 NTSTRSAFEAPI RtlStringVPrintfExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList)
1901 {
1902     NTSTATUS Status = STATUS_SUCCESS;
1903     STRSAFE_LPWSTR pszDestEnd = pszDest;
1904     size_t cchRemaining = 0;
1905     if (dwFlags & (~STRSAFE_VALID_FLAGS))
1906         Status = STATUS_INVALID_PARAMETER;
1907     else
1908     {
1909         if (dwFlags & STRSAFE_IGNORE_NULLS)
1910         {
1911             if (!pszDest)
1912             {
1913                 if ((cchDest!=0) || (cbDest!=0))
1914                     Status = STATUS_INVALID_PARAMETER;
1915             }
1916             if (!pszFormat)
1917                 pszFormat = L"";
1918         }
1919         if (NT_SUCCESS(Status))
1920         {
1921             if (cchDest==0)
1922             {
1923                 pszDestEnd = pszDest;
1924                 cchRemaining = 0;
1925                 if (*pszFormat!=L'\0')
1926                 {
1927                     if (!pszDest)
1928                         Status = STATUS_INVALID_PARAMETER;
1929                     else
1930                         Status = STATUS_BUFFER_OVERFLOW;
1931                 }
1932             }
1933             else
1934             {
1935                 int iRet;
1936                 size_t cchMax;
1937                 cchMax = cchDest - 1;
1938                 iRet = _vsnwprintf(pszDest,cchMax,pszFormat,argList);
1939                 if ((iRet < 0) || (((size_t)iRet) > cchMax))
1940                 {
1941                     pszDestEnd = pszDest + cchMax;
1942                     cchRemaining = 1;
1943                     *pszDestEnd = L'\0';
1944                     Status = STATUS_BUFFER_OVERFLOW;
1945                 }
1946                 else
1947                     if (((size_t)iRet)==cchMax)
1948                     {
1949                         pszDestEnd = pszDest + cchMax;
1950                         cchRemaining = 1;
1951                         *pszDestEnd = L'\0';
1952                     }
1953                     else
1954                         if (((size_t)iRet) < cchMax)
1955                         {
1956                             pszDestEnd = pszDest + iRet;
1957                             cchRemaining = cchDest - iRet;
1958                             if (dwFlags & STRSAFE_FILL_BEHIND_NULL)
1959                             {
1960                                 memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t)));
1961                             }
1962                         }
1963             }
1964         }
1965     }
1966     if (!NT_SUCCESS(Status))
1967     {
1968         if (pszDest)
1969         {
1970             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
1971             {
1972                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
1973                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
1974                 {
1975                     pszDestEnd = pszDest;
1976                     cchRemaining = cchDest;
1977                 }
1978                 else
1979                     if (cchDest > 0)
1980                     {
1981                         pszDestEnd = pszDest + cchDest - 1;
1982                         cchRemaining = 1;
1983                         *pszDestEnd = L'\0';
1984                     }
1985             }
1986             if (dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION))
1987             {
1988                 if (cchDest > 0)
1989                 {
1990                     pszDestEnd = pszDest;
1991                     cchRemaining = cchDest;
1992                     *pszDestEnd = L'\0';
1993                 }
1994             }
1995         }
1996     }
1997     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
1998     {
1999         if (ppszDestEnd)
2000             *ppszDestEnd = pszDestEnd;
2001         if (pcchRemaining)
2002             *pcchRemaining = cchRemaining;
2003     }
2004     return Status;
2005 }
2006
2007 NTSTRSAFEAPI RtlStringLengthWorkerA(STRSAFE_LPCSTR psz,size_t cchMax,size_t *pcchLength)
2008 {
2009     NTSTATUS Status = STATUS_SUCCESS;
2010     size_t cchMaxPrev = cchMax;
2011     while(cchMax && (*psz!='\0'))
2012     {
2013         psz++;
2014         cchMax--;
2015     }
2016     if (cchMax==0)
2017         Status = STATUS_INVALID_PARAMETER;
2018     if (pcchLength)
2019     {
2020         if (NT_SUCCESS(Status))
2021             *pcchLength = cchMaxPrev - cchMax;
2022         else
2023             *pcchLength = 0;
2024     }
2025     return Status;
2026 }
2027
2028 NTSTRSAFEAPI RtlStringLengthWorkerW(STRSAFE_LPCWSTR psz,size_t cchMax,size_t *pcchLength)
2029 {
2030     NTSTATUS Status = STATUS_SUCCESS;
2031     size_t cchMaxPrev = cchMax;
2032     while(cchMax && (*psz!=L'\0'))
2033     {
2034         psz++;
2035         cchMax--;
2036     }
2037     if (cchMax==0)
2038         Status = STATUS_INVALID_PARAMETER;
2039     if (pcchLength)
2040     {
2041         if (NT_SUCCESS(Status))
2042             *pcchLength = cchMaxPrev - cchMax;
2043         else
2044             *pcchLength = 0;
2045     }
2046     return Status;
2047 }
2048
2049
2050
2051 #define RtlStringCopyWorkerA RtlStringCopyWorkerA_instead_use_StringCchCopyA_or_StringCchCopyExA;
2052 #define RtlStringCopyWorkerW RtlStringCopyWorkerW_instead_use_StringCchCopyW_or_StringCchCopyExW;
2053 #define RtlStringCopyExWorkerA RtlStringCopyExWorkerA_instead_use_StringCchCopyA_or_StringCchCopyExA;
2054 #define RtlStringCopyExWorkerW RtlStringCopyExWorkerW_instead_use_StringCchCopyW_or_StringCchCopyExW;
2055 #define RtlStringCatWorkerA RtlStringCatWorkerA_instead_use_StringCchCatA_or_StringCchCatExA;
2056 #define RtlStringCatWorkerW RtlStringCatWorkerW_instead_use_StringCchCatW_or_StringCchCatExW;
2057 #define RtlStringCatExWorkerA RtlStringCatExWorkerA_instead_use_StringCchCatA_or_StringCchCatExA;
2058 #define RtlStringCatExWorkerW RtlStringCatExWorkerW_instead_use_StringCchCatW_or_StringCchCatExW;
2059 #define RtlStringCatNWorkerA RtlStringCatNWorkerA_instead_use_StringCchCatNA_or_StrincCbCatNA;
2060 #define RtlStringCatNWorkerW RtlStringCatNWorkerW_instead_use_StringCchCatNW_or_StringCbCatNW;
2061 #define RtlStringCatNExWorkerA RtlStringCatNExWorkerA_instead_use_StringCchCatNExA_or_StringCbCatNExA;
2062 #define RtlStringCatNExWorkerW RtlStringCatNExWorkerW_instead_use_StringCchCatNExW_or_StringCbCatNExW;
2063 #define RtlStringVPrintfWorkerA RtlStringVPrintfWorkerA_instead_use_StringCchVPrintfA_or_StringCchVPrintfExA;
2064 #define RtlStringVPrintfWorkerW RtlStringVPrintfWorkerW_instead_use_StringCchVPrintfW_or_StringCchVPrintfExW;
2065 #define RtlStringVPrintfExWorkerA RtlStringVPrintfExWorkerA_instead_use_StringCchVPrintfA_or_StringCchVPrintfExA;
2066 #define RtlStringVPrintfExWorkerW RtlStringVPrintfExWorkerW_instead_use_StringCchVPrintfW_or_StringCchVPrintfExW;
2067 #define RtlStringLengthWorkerA RtlStringLengthWorkerA_instead_use_StringCchLengthA_or_StringCbLengthA;
2068 #define RtlStringLengthWorkerW RtlStringLengthWorkerW_instead_use_StringCchLengthW_or_StringCbLengthW;
2069
2070 #ifdef _MSC_VER
2071 #pragma warning(pop)
2072 #endif /* _MSC_VER */
2073
2074 #endif /* _NTSTRSAFE_H_INCLUDED_ */