ReactOS Development > Doxygen

include
ddk
00001 
00006 #ifndef _NTSTRSAFE_H_INCLUDED_
00007 #define _NTSTRSAFE_H_INCLUDED_
00008 
00009 #include <stdio.h>
00010 #include <string.h>
00011 #include <stdarg.h>
00012 
00013 #ifdef _MSC_VER
00014 #pragma warning(push)
00015 #pragma warning(disable:28719) /* disable banned api usage warning */
00016 #endif /* _MSC_VER */
00017 
00018 #ifndef C_ASSERT
00019 #ifdef _MSC_VER
00020 # define C_ASSERT(e) typedef char __C_ASSERT__[(e)?1:-1]
00021 #else
00022 # define C_ASSERT(e) extern void __C_ASSERT__(int [(e)?1:-1])
00023 #endif
00024 #endif /* C_ASSERT */
00025 
00026 #ifdef __cplusplus
00027 #define _STRSAFE_EXTERN_C extern "C"
00028 #else
00029 #define _STRSAFE_EXTERN_C extern
00030 #endif
00031 
00032 #define NTSTRSAFEAPI static __inline NTSTATUS NTAPI
00033 #define NTSTRSAFE_INLINE_API static __inline NTSTATUS NTAPI
00034 
00035 #ifndef NTSTRSAFE_MAX_CCH
00036 #define NTSTRSAFE_MAX_CCH 2147483647
00037 #endif
00038 
00039 #ifndef _STRSAFE_H_INCLUDED_
00040 #define STRSAFE_IGNORE_NULLS 0x00000100
00041 #define STRSAFE_FILL_BEHIND_NULL 0x00000200
00042 #define STRSAFE_FILL_ON_FAILURE 0x00000400
00043 #define STRSAFE_NULL_ON_FAILURE 0x00000800
00044 #define STRSAFE_NO_TRUNCATION 0x00001000
00045 #define STRSAFE_IGNORE_NULL_UNICODE_STRINGS 0x00010000
00046 #define STRSAFE_UNICODE_STRING_DEST_NULL_TERMINATED 0x00020000
00047 
00048 #define STRSAFE_VALID_FLAGS (0x000000FF | STRSAFE_IGNORE_NULLS | STRSAFE_FILL_BEHIND_NULL | STRSAFE_FILL_ON_FAILURE | STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION)
00049 #define STRSAFE_UNICODE_STRING_VALID_FLAGS (STRSAFE_VALID_FLAGS | STRSAFE_IGNORE_NULL_UNICODE_STRINGS | STRSAFE_UNICODE_STRING_DEST_NULL_TERMINATED)
00050 
00051 #define STRSAFE_FILL_BYTE(x) ((STRSAFE_DWORD)(((x) & 0x000000FF) | STRSAFE_FILL_BEHIND_NULL))
00052 #define STRSAFE_FAILURE_BYTE(x) ((STRSAFE_DWORD)(((x) & 0x000000FF) | STRSAFE_FILL_ON_FAILURE))
00053 
00054 #define STRSAFE_GET_FILL_PATTERN(dwFlags) ((int)((dwFlags) & 0x000000FF))
00055 #endif
00056 
00057 typedef char *STRSAFE_LPSTR;
00058 typedef const char *STRSAFE_LPCSTR;
00059 typedef wchar_t *STRSAFE_LPWSTR;
00060 typedef const wchar_t *STRSAFE_LPCWSTR;
00061 
00062 typedef ULONG STRSAFE_DWORD;
00063 
00064 NTSTRSAFEAPI RtlStringCopyWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc);
00065 NTSTRSAFEAPI RtlStringCopyWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc);
00066 NTSTRSAFEAPI RtlStringCopyExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
00067 NTSTRSAFEAPI RtlStringCopyExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
00068 NTSTRSAFEAPI RtlStringCopyNWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy);
00069 NTSTRSAFEAPI RtlStringCopyNWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy);
00070 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);
00071 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);
00072 NTSTRSAFEAPI RtlStringCatWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc);
00073 NTSTRSAFEAPI RtlStringCatWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc);
00074 NTSTRSAFEAPI RtlStringCatExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
00075 NTSTRSAFEAPI RtlStringCatExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
00076 NTSTRSAFEAPI RtlStringCatNWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend);
00077 NTSTRSAFEAPI RtlStringCatNWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend);
00078 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);
00079 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);
00080 NTSTRSAFEAPI RtlStringVPrintfWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,va_list argList);
00081 NTSTRSAFEAPI RtlStringVPrintfWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,va_list argList);
00082 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);
00083 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);
00084 NTSTRSAFEAPI RtlStringLengthWorkerA(STRSAFE_LPCSTR psz,size_t cchMax,size_t *pcchLength);
00085 NTSTRSAFEAPI RtlStringLengthWorkerW(STRSAFE_LPCWSTR psz,size_t cchMax,size_t *pcchLength);
00086 
00087 NTSTRSAFEAPI RtlStringCchCopyA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc);
00088 NTSTRSAFEAPI RtlStringCchCopyW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc);
00089 
00090 
00091 NTSTRSAFEAPI RtlStringCchCopyA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc)
00092 {
00093     return (cchDest > NTSTRSAFE_MAX_CCH ? STATUS_INVALID_PARAMETER : RtlStringCopyWorkerA(pszDest,cchDest,pszSrc));
00094 }
00095 
00096 NTSTRSAFEAPI RtlStringCchCopyW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc)
00097 {
00098     if (cchDest > NTSTRSAFE_MAX_CCH)
00099         return STATUS_INVALID_PARAMETER;
00100     return RtlStringCopyWorkerW(pszDest,cchDest,pszSrc);
00101 }
00102 
00103 
00104 NTSTRSAFEAPI RtlStringCbCopyA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc);
00105 NTSTRSAFEAPI RtlStringCbCopyW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc);
00106 
00107 
00108 NTSTRSAFEAPI RtlStringCbCopyA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc)
00109 {
00110     if (cbDest > NTSTRSAFE_MAX_CCH)
00111         return STATUS_INVALID_PARAMETER;
00112     return RtlStringCopyWorkerA(pszDest,cbDest,pszSrc);
00113 }
00114 
00115 NTSTRSAFEAPI RtlStringCbCopyW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc)
00116 {
00117     size_t cchDest = cbDest / sizeof(wchar_t);
00118     if (cchDest > NTSTRSAFE_MAX_CCH)
00119         return STATUS_INVALID_PARAMETER;
00120     return RtlStringCopyWorkerW(pszDest,cchDest,pszSrc);
00121 }
00122 
00123 
00124 NTSTRSAFEAPI RtlStringCchCopyExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
00125 NTSTRSAFEAPI RtlStringCchCopyExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
00126 
00127 
00128 NTSTRSAFEAPI RtlStringCchCopyExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
00129 {
00130     if (cchDest > NTSTRSAFE_MAX_CCH)
00131         return STATUS_INVALID_PARAMETER;
00132     return RtlStringCopyExWorkerA(pszDest,cchDest,cchDest,pszSrc,ppszDestEnd,pcchRemaining,dwFlags);
00133 }
00134 
00135 NTSTRSAFEAPI RtlStringCchCopyExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
00136 {
00137     size_t cbDest;
00138     if (cchDest > NTSTRSAFE_MAX_CCH)
00139         return STATUS_INVALID_PARAMETER;
00140     cbDest = cchDest * sizeof(wchar_t);
00141     return RtlStringCopyExWorkerW(pszDest,cchDest,cbDest,pszSrc,ppszDestEnd,pcchRemaining,dwFlags);
00142 }
00143 
00144 
00145 NTSTRSAFEAPI RtlStringCbCopyExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
00146 NTSTRSAFEAPI RtlStringCbCopyExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
00147 
00148 
00149 NTSTRSAFEAPI RtlStringCbCopyExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
00150 {
00151     NTSTATUS Status;
00152     size_t cchRemaining = 0;
00153     if (cbDest > NTSTRSAFE_MAX_CCH)
00154         return STATUS_INVALID_PARAMETER;
00155     Status = RtlStringCopyExWorkerA(pszDest,cbDest,cbDest,pszSrc,ppszDestEnd,&cchRemaining,dwFlags);
00156     if (NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW)
00157     {
00158         if (pcbRemaining)
00159             *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
00160     }
00161     return Status;
00162 }
00163 
00164 NTSTRSAFEAPI RtlStringCbCopyExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
00165 {
00166     NTSTATUS Status;
00167     size_t cchDest = cbDest / sizeof(wchar_t);
00168     size_t cchRemaining = 0;
00169 
00170     if (cchDest > NTSTRSAFE_MAX_CCH)
00171         return STATUS_INVALID_PARAMETER;
00172     Status = RtlStringCopyExWorkerW(pszDest,cchDest,cbDest,pszSrc,ppszDestEnd,&cchRemaining,dwFlags);
00173     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
00174     {
00175         if (pcbRemaining)
00176             *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
00177     }
00178     return Status;
00179 }
00180 
00181 
00182 NTSTRSAFEAPI RtlStringCchCopyNA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy);
00183 NTSTRSAFEAPI RtlStringCchCopyNW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy);
00184 
00185 
00186 NTSTRSAFEAPI RtlStringCchCopyNA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy)
00187 {
00188     if (cchDest > NTSTRSAFE_MAX_CCH || cchToCopy > NTSTRSAFE_MAX_CCH)
00189         return STATUS_INVALID_PARAMETER;
00190     return RtlStringCopyNWorkerA(pszDest,cchDest,pszSrc,cchToCopy);
00191 }
00192 
00193 NTSTRSAFEAPI RtlStringCchCopyNW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy)
00194 {
00195     if (cchDest > NTSTRSAFE_MAX_CCH || cchToCopy > NTSTRSAFE_MAX_CCH)
00196         return STATUS_INVALID_PARAMETER;
00197     return RtlStringCopyNWorkerW(pszDest,cchDest,pszSrc,cchToCopy);
00198 }
00199 
00200 
00201 NTSTRSAFEAPI RtlStringCbCopyNA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToCopy);
00202 NTSTRSAFEAPI RtlStringCbCopyNW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToCopy);
00203 
00204 
00205 NTSTRSAFEAPI RtlStringCbCopyNA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToCopy)
00206 {
00207     if (cbDest > NTSTRSAFE_MAX_CCH || cbToCopy > NTSTRSAFE_MAX_CCH)
00208         return STATUS_INVALID_PARAMETER;
00209     return RtlStringCopyNWorkerA(pszDest,cbDest,pszSrc,cbToCopy);
00210 }
00211 
00212 NTSTRSAFEAPI RtlStringCbCopyNW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToCopy)
00213 {
00214     size_t cchDest  = cbDest / sizeof(wchar_t);
00215     size_t cchToCopy = cbToCopy / sizeof(wchar_t);
00216     if (cchDest > NTSTRSAFE_MAX_CCH || cchToCopy > NTSTRSAFE_MAX_CCH)
00217         return STATUS_INVALID_PARAMETER;
00218     return RtlStringCopyNWorkerW(pszDest,cchDest,pszSrc,cchToCopy);
00219 }
00220 
00221 
00222 NTSTRSAFEAPI RtlStringCchCopyNExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
00223 NTSTRSAFEAPI RtlStringCchCopyNExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
00224 
00225 
00226 NTSTRSAFEAPI RtlStringCchCopyNExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
00227 {
00228     if (cchDest > NTSTRSAFE_MAX_CCH)
00229         return STATUS_INVALID_PARAMETER;
00230     return RtlStringCopyNExWorkerA(pszDest,cchDest,cchDest,pszSrc,cchToCopy,ppszDestEnd,pcchRemaining,dwFlags);
00231 }
00232 
00233 NTSTRSAFEAPI RtlStringCchCopyNExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
00234 {
00235     if (cchDest > NTSTRSAFE_MAX_CCH)
00236         return STATUS_INVALID_PARAMETER;
00237     return RtlStringCopyNExWorkerW(pszDest,cchDest,cchDest * sizeof(wchar_t),pszSrc,cchToCopy,ppszDestEnd,pcchRemaining,dwFlags);
00238 }
00239 
00240 
00241 NTSTRSAFEAPI RtlStringCbCopyNExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
00242 NTSTRSAFEAPI RtlStringCbCopyNExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
00243 
00244 
00245 NTSTRSAFEAPI RtlStringCbCopyNExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToCopy,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
00246 {
00247     NTSTATUS Status;
00248     size_t cchRemaining = 0;
00249     if (cbDest > NTSTRSAFE_MAX_CCH)
00250         Status = STATUS_INVALID_PARAMETER;
00251     else
00252         Status = RtlStringCopyNExWorkerA(pszDest,cbDest,cbDest,pszSrc,cbToCopy,ppszDestEnd,&cchRemaining,dwFlags);
00253     if ((NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW) && pcbRemaining)
00254         *pcbRemaining = cchRemaining;
00255     return Status;
00256 }
00257 
00258 NTSTRSAFEAPI RtlStringCbCopyNExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToCopy,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
00259 {
00260     NTSTATUS Status;
00261     size_t cchDest;
00262     size_t cchToCopy;
00263     size_t cchRemaining = 0;
00264     cchDest = cbDest / sizeof(wchar_t);
00265     cchToCopy = cbToCopy / sizeof(wchar_t);
00266     if (cchDest > NTSTRSAFE_MAX_CCH)
00267         Status = STATUS_INVALID_PARAMETER;
00268     else
00269         Status = RtlStringCopyNExWorkerW(pszDest,cchDest,cbDest,pszSrc,cchToCopy,ppszDestEnd,&cchRemaining,dwFlags);
00270     if ((NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW) && pcbRemaining)
00271         *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
00272     return Status;
00273 }
00274 
00275 
00276 NTSTRSAFEAPI RtlStringCchCatA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc);
00277 NTSTRSAFEAPI RtlStringCchCatW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc);
00278 
00279 
00280 NTSTRSAFEAPI RtlStringCchCatA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc)
00281 {
00282     if (cchDest > NTSTRSAFE_MAX_CCH)
00283         return STATUS_INVALID_PARAMETER;
00284     return RtlStringCatWorkerA(pszDest,cchDest,pszSrc);
00285 }
00286 
00287 NTSTRSAFEAPI RtlStringCchCatW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc)
00288 {
00289     if (cchDest > NTSTRSAFE_MAX_CCH)
00290         return STATUS_INVALID_PARAMETER;
00291     return RtlStringCatWorkerW(pszDest,cchDest,pszSrc);
00292 }
00293 
00294 
00295 NTSTRSAFEAPI RtlStringCbCatA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc);
00296 NTSTRSAFEAPI RtlStringCbCatW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc);
00297 
00298 
00299 NTSTRSAFEAPI RtlStringCbCatA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc)
00300 {
00301     if (cbDest > NTSTRSAFE_MAX_CCH)
00302         return STATUS_INVALID_PARAMETER;
00303     return RtlStringCatWorkerA(pszDest,cbDest,pszSrc);
00304 }
00305 
00306 NTSTRSAFEAPI RtlStringCbCatW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc)
00307 {
00308     size_t cchDest = cbDest / sizeof(wchar_t);
00309     if (cchDest > NTSTRSAFE_MAX_CCH)
00310         return STATUS_INVALID_PARAMETER;
00311     return RtlStringCatWorkerW(pszDest,cchDest,pszSrc);
00312 }
00313 
00314 
00315 NTSTRSAFEAPI RtlStringCchCatExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
00316 NTSTRSAFEAPI RtlStringCchCatExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
00317 
00318 
00319 NTSTRSAFEAPI RtlStringCchCatExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
00320 {
00321     if (cchDest > NTSTRSAFE_MAX_CCH)
00322         return STATUS_INVALID_PARAMETER;
00323     return RtlStringCatExWorkerA(pszDest,cchDest,cchDest,pszSrc,ppszDestEnd,pcchRemaining,dwFlags);
00324 }
00325 
00326 NTSTRSAFEAPI RtlStringCchCatExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
00327 {
00328     size_t cbDest = cchDest*sizeof(wchar_t);
00329     if (cchDest > NTSTRSAFE_MAX_CCH)
00330         return STATUS_INVALID_PARAMETER;
00331     return RtlStringCatExWorkerW(pszDest,cchDest,cbDest,pszSrc,ppszDestEnd,pcchRemaining,dwFlags);
00332 }
00333 
00334 
00335 NTSTRSAFEAPI RtlStringCbCatExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
00336 NTSTRSAFEAPI RtlStringCbCatExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
00337 
00338 
00339 NTSTRSAFEAPI RtlStringCbCatExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
00340 {
00341     NTSTATUS Status;
00342     size_t cchRemaining = 0;
00343     if (cbDest > NTSTRSAFE_MAX_CCH)
00344         Status = STATUS_INVALID_PARAMETER;
00345     else
00346         Status = RtlStringCatExWorkerA(pszDest,cbDest,cbDest,pszSrc,ppszDestEnd,&cchRemaining,dwFlags);
00347     if ((NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW) && pcbRemaining)
00348         *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
00349     return Status;
00350 }
00351 
00352 NTSTRSAFEAPI RtlStringCbCatExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
00353 {
00354     NTSTATUS Status;
00355     size_t cchDest = cbDest / sizeof(wchar_t);
00356     size_t cchRemaining = 0;
00357 
00358     if (cchDest > NTSTRSAFE_MAX_CCH)
00359         Status = STATUS_INVALID_PARAMETER;
00360     else
00361         Status = RtlStringCatExWorkerW(pszDest,cchDest,cbDest,pszSrc,ppszDestEnd,&cchRemaining,dwFlags);
00362     if ((NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW) && pcbRemaining)
00363         *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
00364     return Status;
00365 }
00366 
00367 
00368 NTSTRSAFEAPI RtlStringCchCatNA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend);
00369 NTSTRSAFEAPI RtlStringCchCatNW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend);
00370 
00371 
00372 NTSTRSAFEAPI RtlStringCchCatNA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend)
00373 {
00374     if (cchDest > NTSTRSAFE_MAX_CCH)
00375         return STATUS_INVALID_PARAMETER;
00376     return RtlStringCatNWorkerA(pszDest,cchDest,pszSrc,cchToAppend);
00377 }
00378 
00379 NTSTRSAFEAPI RtlStringCchCatNW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend)
00380 {
00381     if (cchDest > NTSTRSAFE_MAX_CCH)
00382         return STATUS_INVALID_PARAMETER;
00383     return RtlStringCatNWorkerW(pszDest,cchDest,pszSrc,cchToAppend);
00384 }
00385 
00386 
00387 NTSTRSAFEAPI RtlStringCbCatNA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToAppend);
00388 NTSTRSAFEAPI RtlStringCbCatNW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToAppend);
00389 
00390 
00391 NTSTRSAFEAPI RtlStringCbCatNA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToAppend)
00392 {
00393     if (cbDest > NTSTRSAFE_MAX_CCH)
00394         return STATUS_INVALID_PARAMETER;
00395     return RtlStringCatNWorkerA(pszDest,cbDest,pszSrc,cbToAppend);
00396 }
00397 
00398 NTSTRSAFEAPI RtlStringCbCatNW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToAppend)
00399 {
00400     size_t cchDest = cbDest / sizeof(wchar_t);
00401     size_t cchToAppend = cbToAppend / sizeof(wchar_t);
00402 
00403     if (cchDest > NTSTRSAFE_MAX_CCH)
00404         return STATUS_INVALID_PARAMETER;
00405     return RtlStringCatNWorkerW(pszDest,cchDest,pszSrc,cchToAppend);
00406 }
00407 
00408 
00409 NTSTRSAFEAPI RtlStringCchCatNExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
00410 NTSTRSAFEAPI RtlStringCchCatNExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags);
00411 
00412 
00413 NTSTRSAFEAPI RtlStringCchCatNExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
00414 {
00415     if (cchDest > NTSTRSAFE_MAX_CCH)
00416         return STATUS_INVALID_PARAMETER;
00417     return RtlStringCatNExWorkerA(pszDest,cchDest,cchDest,pszSrc,cchToAppend,ppszDestEnd,pcchRemaining,dwFlags);
00418 }
00419 
00420 NTSTRSAFEAPI RtlStringCchCatNExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
00421 {
00422     if (cchDest > NTSTRSAFE_MAX_CCH)
00423         return STATUS_INVALID_PARAMETER;
00424     return RtlStringCatNExWorkerW(pszDest,cchDest,(cchDest*sizeof(wchar_t)),pszSrc,cchToAppend,ppszDestEnd,pcchRemaining,dwFlags);
00425 }
00426 
00427 
00428 NTSTRSAFEAPI RtlStringCbCatNExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
00429 NTSTRSAFEAPI RtlStringCbCatNExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags);
00430 
00431 
00432 NTSTRSAFEAPI RtlStringCbCatNExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,size_t cbToAppend,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
00433 {
00434     NTSTATUS Status;
00435     size_t cchRemaining = 0;
00436     if (cbDest > NTSTRSAFE_MAX_CCH)
00437         Status = STATUS_INVALID_PARAMETER;
00438     else
00439         Status = RtlStringCatNExWorkerA(pszDest,cbDest,cbDest,pszSrc,cbToAppend,ppszDestEnd,&cchRemaining,dwFlags);
00440     if ((NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW) && pcbRemaining)
00441         *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
00442     return Status;
00443 }
00444 
00445 NTSTRSAFEAPI RtlStringCbCatNExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,size_t cbToAppend,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags)
00446 {
00447     NTSTATUS Status;
00448     size_t cchDest = cbDest / sizeof(wchar_t);
00449     size_t cchToAppend = cbToAppend / sizeof(wchar_t);
00450     size_t cchRemaining = 0;
00451     if (cchDest > NTSTRSAFE_MAX_CCH)
00452         Status = STATUS_INVALID_PARAMETER;
00453     else
00454         Status = RtlStringCatNExWorkerW(pszDest,cchDest,cbDest,pszSrc,cchToAppend,ppszDestEnd,&cchRemaining,dwFlags);
00455     if ((NT_SUCCESS(Status) || Status == STATUS_BUFFER_OVERFLOW) && pcbRemaining)
00456         *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
00457     return Status;
00458 }
00459 
00460 
00461 NTSTRSAFEAPI RtlStringCchVPrintfA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,va_list argList);
00462 NTSTRSAFEAPI RtlStringCchVPrintfW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,va_list argList);
00463 
00464 
00465 NTSTRSAFEAPI RtlStringCchVPrintfA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,va_list argList)
00466 {
00467     if (cchDest > NTSTRSAFE_MAX_CCH)
00468         return STATUS_INVALID_PARAMETER;
00469     return RtlStringVPrintfWorkerA(pszDest,cchDest,pszFormat,argList);
00470 }
00471 
00472 NTSTRSAFEAPI RtlStringCchVPrintfW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,va_list argList)
00473 {
00474     if (cchDest > NTSTRSAFE_MAX_CCH)
00475         return STATUS_INVALID_PARAMETER;
00476     return RtlStringVPrintfWorkerW(pszDest,cchDest,pszFormat,argList);
00477 }
00478 
00479 
00480 NTSTRSAFEAPI RtlStringCbVPrintfA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszFormat,va_list argList);
00481 NTSTRSAFEAPI RtlStringCbVPrintfW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszFormat,va_list argList);
00482 
00483 
00484 NTSTRSAFEAPI RtlStringCbVPrintfA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszFormat,va_list argList)
00485 {
00486     if (cbDest > NTSTRSAFE_MAX_CCH)
00487         return STATUS_INVALID_PARAMETER;
00488     return RtlStringVPrintfWorkerA(pszDest,cbDest,pszFormat,argList);
00489 }
00490 
00491 NTSTRSAFEAPI RtlStringCbVPrintfW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszFormat,va_list argList)
00492 {
00493     size_t cchDest = cbDest / sizeof(wchar_t);
00494     if (cchDest > NTSTRSAFE_MAX_CCH)
00495         return STATUS_INVALID_PARAMETER;
00496     return RtlStringVPrintfWorkerW(pszDest,cchDest,pszFormat,argList);
00497 }
00498 
00499 
00500 NTSTRSAFEAPI RtlStringCchPrintfA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,...);
00501 NTSTRSAFEAPI RtlStringCchPrintfW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,...);
00502 
00503 
00504 NTSTRSAFEAPI RtlStringCchPrintfA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,...)
00505 {
00506     NTSTATUS Status;
00507     va_list argList;
00508     if (cchDest > NTSTRSAFE_MAX_CCH)
00509         return STATUS_INVALID_PARAMETER;
00510     va_start(argList,pszFormat);
00511     Status = RtlStringVPrintfWorkerA(pszDest,cchDest,pszFormat,argList);
00512     va_end(argList);
00513     return Status;
00514 }
00515 
00516 NTSTRSAFEAPI RtlStringCchPrintfW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,...)
00517 {
00518     NTSTATUS Status;
00519     va_list argList;
00520     if (cchDest > NTSTRSAFE_MAX_CCH)
00521         return STATUS_INVALID_PARAMETER;
00522     va_start(argList,pszFormat);
00523     Status = RtlStringVPrintfWorkerW(pszDest,cchDest,pszFormat,argList);
00524     va_end(argList);
00525     return Status;
00526 }
00527 
00528 
00529 NTSTRSAFEAPI RtlStringCbPrintfA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszFormat,...);
00530 NTSTRSAFEAPI RtlStringCbPrintfW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszFormat,...);
00531 
00532 
00533 NTSTRSAFEAPI RtlStringCbPrintfA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPCSTR pszFormat,...)
00534 {
00535     NTSTATUS Status;
00536     va_list argList;
00537     if (cbDest > NTSTRSAFE_MAX_CCH)
00538         return STATUS_INVALID_PARAMETER;
00539     va_start(argList,pszFormat);
00540     Status = RtlStringVPrintfWorkerA(pszDest,cbDest,pszFormat,argList);
00541     va_end(argList);
00542     return Status;
00543 }
00544 
00545 NTSTRSAFEAPI RtlStringCbPrintfW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPCWSTR pszFormat,...)
00546 {
00547     NTSTATUS Status;
00548     va_list argList;
00549     size_t cchDest = cbDest / sizeof(wchar_t);
00550     if (cchDest > NTSTRSAFE_MAX_CCH)
00551         return STATUS_INVALID_PARAMETER;
00552     va_start(argList,pszFormat);
00553     Status = RtlStringVPrintfWorkerW(pszDest,cchDest,pszFormat,argList);
00554     va_end(argList);
00555     return Status;
00556 }
00557 
00558 
00559 NTSTRSAFEAPI RtlStringCchPrintfExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,...);
00560 NTSTRSAFEAPI RtlStringCchPrintfExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,...);
00561 
00562 
00563 NTSTRSAFEAPI RtlStringCchPrintfExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,...)
00564 {
00565     NTSTATUS Status;
00566     va_list argList;
00567     if (cchDest > NTSTRSAFE_MAX_CCH)
00568         return STATUS_INVALID_PARAMETER;
00569     va_start(argList,pszFormat);
00570     Status = RtlStringVPrintfExWorkerA(pszDest,cchDest,cchDest,ppszDestEnd,pcchRemaining,dwFlags,pszFormat,argList);
00571     va_end(argList);
00572     return Status;
00573 }
00574 
00575 NTSTRSAFEAPI RtlStringCchPrintfExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,...)
00576 {
00577     NTSTATUS Status;
00578     size_t cbDest = cchDest * sizeof(wchar_t);
00579     va_list argList;
00580     if (cchDest > NTSTRSAFE_MAX_CCH)
00581         return STATUS_INVALID_PARAMETER;
00582     va_start(argList,pszFormat);
00583     Status = RtlStringVPrintfExWorkerW(pszDest,cchDest,cbDest,ppszDestEnd,pcchRemaining,dwFlags,pszFormat,argList);
00584     va_end(argList);
00585     return Status;
00586 }
00587 
00588 
00589 NTSTRSAFEAPI RtlStringCbPrintfExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,...);
00590 NTSTRSAFEAPI RtlStringCbPrintfExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,...);
00591 
00592 
00593 NTSTRSAFEAPI RtlStringCbPrintfExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,...)
00594 {
00595     NTSTATUS Status;
00596     size_t cchDest;
00597     size_t cchRemaining = 0;
00598     cchDest = cbDest / sizeof(char);
00599     if (cchDest > NTSTRSAFE_MAX_CCH)
00600         Status = STATUS_INVALID_PARAMETER;
00601     else
00602     {
00603         va_list argList;
00604         va_start(argList,pszFormat);
00605         Status = RtlStringVPrintfExWorkerA(pszDest,cchDest,cbDest,ppszDestEnd,&cchRemaining,dwFlags,pszFormat,argList);
00606         va_end(argList);
00607     }
00608     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
00609     {
00610         if (pcbRemaining)
00611         {
00612             *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
00613         }
00614     }
00615     return Status;
00616 }
00617 
00618 NTSTRSAFEAPI RtlStringCbPrintfExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,...)
00619 {
00620     NTSTATUS Status;
00621     size_t cchDest;
00622     size_t cchRemaining = 0;
00623     cchDest = cbDest / sizeof(wchar_t);
00624     if (cchDest > NTSTRSAFE_MAX_CCH)
00625         Status = STATUS_INVALID_PARAMETER;
00626     else
00627     {
00628         va_list argList;
00629         va_start(argList,pszFormat);
00630         Status = RtlStringVPrintfExWorkerW(pszDest,cchDest,cbDest,ppszDestEnd,&cchRemaining,dwFlags,pszFormat,argList);
00631         va_end(argList);
00632     }
00633     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
00634     {
00635         if (pcbRemaining)
00636         {
00637             *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
00638         }
00639     }
00640     return Status;
00641 }
00642 
00643 
00644 NTSTRSAFEAPI RtlStringCchVPrintfExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList);
00645 NTSTRSAFEAPI RtlStringCchVPrintfExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList);
00646 
00647 
00648 NTSTRSAFEAPI RtlStringCchVPrintfExA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList)
00649 {
00650     NTSTATUS Status;
00651     if (cchDest > NTSTRSAFE_MAX_CCH)
00652         Status = STATUS_INVALID_PARAMETER;
00653     else
00654     {
00655         size_t cbDest;
00656         cbDest = cchDest*sizeof(char);
00657         Status = RtlStringVPrintfExWorkerA(pszDest,cchDest,cbDest,ppszDestEnd,pcchRemaining,dwFlags,pszFormat,argList);
00658     }
00659     return Status;
00660 }
00661 
00662 NTSTRSAFEAPI RtlStringCchVPrintfExW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList)
00663 {
00664     NTSTATUS Status;
00665     if (cchDest > NTSTRSAFE_MAX_CCH)
00666         Status = STATUS_INVALID_PARAMETER;
00667     else
00668     {
00669         size_t cbDest;
00670         cbDest = cchDest*sizeof(wchar_t);
00671         Status = RtlStringVPrintfExWorkerW(pszDest,cchDest,cbDest,ppszDestEnd,pcchRemaining,dwFlags,pszFormat,argList);
00672     }
00673     return Status;
00674 }
00675 
00676 
00677 NTSTRSAFEAPI RtlStringCbVPrintfExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList);
00678 NTSTRSAFEAPI RtlStringCbVPrintfExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList);
00679 
00680 
00681 NTSTRSAFEAPI RtlStringCbVPrintfExA(STRSAFE_LPSTR pszDest,size_t cbDest,STRSAFE_LPSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCSTR pszFormat,va_list argList)
00682 {
00683     NTSTATUS Status;
00684     size_t cchDest;
00685     size_t cchRemaining = 0;
00686     cchDest = cbDest / sizeof(char);
00687     if (cchDest > NTSTRSAFE_MAX_CCH)
00688         Status = STATUS_INVALID_PARAMETER;
00689     else
00690         Status = RtlStringVPrintfExWorkerA(pszDest,cchDest,cbDest,ppszDestEnd,&cchRemaining,dwFlags,pszFormat,argList);
00691     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
00692     {
00693         if (pcbRemaining)
00694         {
00695             *pcbRemaining = (cchRemaining*sizeof(char)) + (cbDest % sizeof(char));
00696         }
00697     }
00698     return Status;
00699 }
00700 
00701 NTSTRSAFEAPI RtlStringCbVPrintfExW(STRSAFE_LPWSTR pszDest,size_t cbDest,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcbRemaining,STRSAFE_DWORD dwFlags,STRSAFE_LPCWSTR pszFormat,va_list argList)
00702 {
00703     NTSTATUS Status;
00704     size_t cchDest;
00705     size_t cchRemaining = 0;
00706     cchDest = cbDest / sizeof(wchar_t);
00707     if (cchDest > NTSTRSAFE_MAX_CCH)
00708         Status = STATUS_INVALID_PARAMETER;
00709     else
00710         Status = RtlStringVPrintfExWorkerW(pszDest,cchDest,cbDest,ppszDestEnd,&cchRemaining,dwFlags,pszFormat,argList);
00711     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
00712     {
00713         if (pcbRemaining)
00714         {
00715             *pcbRemaining = (cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t));
00716         }
00717     }
00718     return Status;
00719 }
00720 
00721 
00722 NTSTRSAFEAPI RtlStringCchLengthA(STRSAFE_LPCSTR psz,size_t cchMax,size_t *pcchLength);
00723 NTSTRSAFEAPI RtlStringCchLengthW(STRSAFE_LPCWSTR psz,size_t cchMax,size_t *pcchLength);
00724 
00725 
00726 NTSTRSAFEAPI RtlStringCchLengthA(STRSAFE_LPCSTR psz,size_t cchMax,size_t *pcchLength)
00727 {
00728     NTSTATUS Status;
00729     if (!psz || (cchMax > NTSTRSAFE_MAX_CCH))
00730         Status = STATUS_INVALID_PARAMETER;
00731     else
00732         Status = RtlStringLengthWorkerA(psz,cchMax,pcchLength);
00733     if (!NT_SUCCESS(Status) && pcchLength)
00734     {
00735         *pcchLength = 0;
00736     }
00737     return Status;
00738 }
00739 
00740 NTSTRSAFEAPI RtlStringCchLengthW(STRSAFE_LPCWSTR psz,size_t cchMax,size_t *pcchLength)
00741 {
00742     NTSTATUS Status;
00743     if (!psz || (cchMax > NTSTRSAFE_MAX_CCH))
00744         Status = STATUS_INVALID_PARAMETER;
00745     else
00746         Status = RtlStringLengthWorkerW(psz,cchMax,pcchLength);
00747     if (!NT_SUCCESS(Status) && pcchLength)
00748     {
00749         *pcchLength = 0;
00750     }
00751     return Status;
00752 }
00753 
00754 
00755 NTSTRSAFEAPI RtlStringCbLengthA(STRSAFE_LPCSTR psz,size_t cbMax,size_t *pcbLength);
00756 NTSTRSAFEAPI RtlStringCbLengthW(STRSAFE_LPCWSTR psz,size_t cbMax,size_t *pcbLength);
00757 
00758 
00759 NTSTRSAFEAPI RtlStringCbLengthA(STRSAFE_LPCSTR psz,size_t cbMax,size_t *pcbLength)
00760 {
00761     NTSTATUS Status;
00762     size_t cchMax;
00763     size_t cchLength = 0;
00764     cchMax = cbMax / sizeof(char);
00765     if (!psz || (cchMax > NTSTRSAFE_MAX_CCH))
00766         Status = STATUS_INVALID_PARAMETER;
00767     else
00768         Status = RtlStringLengthWorkerA(psz,cchMax,&cchLength);
00769     if (pcbLength)
00770     {
00771         if (NT_SUCCESS(Status))
00772         {
00773             *pcbLength = cchLength*sizeof(char);
00774         }
00775         else
00776         {
00777             *pcbLength = 0;
00778         }
00779     }
00780     return Status;
00781 }
00782 
00783 NTSTRSAFEAPI RtlStringCbLengthW(STRSAFE_LPCWSTR psz,size_t cbMax,size_t *pcbLength)
00784 {
00785     NTSTATUS Status;
00786     size_t cchMax;
00787     size_t cchLength = 0;
00788     cchMax = cbMax / sizeof(wchar_t);
00789     if (!psz || (cchMax > NTSTRSAFE_MAX_CCH))
00790         Status = STATUS_INVALID_PARAMETER;
00791     else
00792         Status = RtlStringLengthWorkerW(psz,cchMax,&cchLength);
00793     if (pcbLength)
00794     {
00795         if (NT_SUCCESS(Status))
00796         {
00797             *pcbLength = cchLength*sizeof(wchar_t);
00798         }
00799         else
00800         {
00801             *pcbLength = 0;
00802         }
00803     }
00804     return Status;
00805 }
00806 
00807 NTSTRSAFEAPI RtlStringCopyWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc)
00808 {
00809     NTSTATUS Status = STATUS_SUCCESS;
00810     if (cchDest==0)
00811         Status = STATUS_INVALID_PARAMETER;
00812     else
00813     {
00814         while(cchDest && (*pszSrc!='\0'))
00815         {
00816             *pszDest++ = *pszSrc++;
00817             cchDest--;
00818         }
00819         if (cchDest==0)
00820         {
00821             pszDest--;
00822             Status = STATUS_BUFFER_OVERFLOW;
00823         }
00824         *pszDest= '\0';
00825     }
00826     return Status;
00827 }
00828 
00829 NTSTRSAFEAPI RtlStringCopyWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc)
00830 {
00831     NTSTATUS Status = STATUS_SUCCESS;
00832     if (cchDest==0)
00833         Status = STATUS_INVALID_PARAMETER;
00834     else
00835     {
00836         while(cchDest && (*pszSrc!=L'\0'))
00837         {
00838             *pszDest++ = *pszSrc++;
00839             cchDest--;
00840         }
00841         if (cchDest==0)
00842         {
00843             pszDest--;
00844             Status = STATUS_BUFFER_OVERFLOW;
00845         }
00846         *pszDest= L'\0';
00847     }
00848     return Status;
00849 }
00850 
00851 NTSTRSAFEAPI RtlStringCopyExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
00852 {
00853     NTSTATUS Status = STATUS_SUCCESS;
00854     STRSAFE_LPSTR pszDestEnd = pszDest;
00855     size_t cchRemaining = 0;
00856     if (dwFlags & (~STRSAFE_VALID_FLAGS))
00857         Status = STATUS_INVALID_PARAMETER;
00858     else
00859     {
00860         if (dwFlags & STRSAFE_IGNORE_NULLS)
00861         {
00862             if (!pszDest)
00863             {
00864                 if ((cchDest!=0) || (cbDest!=0))
00865                     Status = STATUS_INVALID_PARAMETER;
00866             }
00867             if (!pszSrc)
00868                 pszSrc = "";
00869         }
00870         if (NT_SUCCESS(Status))
00871         {
00872             if (cchDest==0)
00873             {
00874                 pszDestEnd = pszDest;
00875                 cchRemaining = 0;
00876                 if (*pszSrc!='\0')
00877                 {
00878                     if (!pszDest)
00879                         Status = STATUS_INVALID_PARAMETER;
00880                     else
00881                         Status = STATUS_BUFFER_OVERFLOW;
00882                 }
00883             }
00884             else
00885             {
00886                 pszDestEnd = pszDest;
00887                 cchRemaining = cchDest;
00888                 while(cchRemaining && (*pszSrc!='\0'))
00889                 {
00890                     *pszDestEnd++ = *pszSrc++;
00891                     cchRemaining--;
00892                 }
00893                 if (cchRemaining > 0)
00894                 {
00895                     if (dwFlags & STRSAFE_FILL_BEHIND_NULL)
00896                     {
00897                         memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(char)) + (cbDest % sizeof(char)));
00898                     }
00899                 }
00900                 else
00901                 {
00902                     pszDestEnd--;
00903                     cchRemaining++;
00904                     Status = STATUS_BUFFER_OVERFLOW;
00905                 }
00906                 *pszDestEnd = '\0';
00907             }
00908         }
00909     }
00910     if (!NT_SUCCESS(Status))
00911     {
00912         if (pszDest)
00913         {
00914             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
00915             {
00916                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
00917                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
00918                 {
00919                     pszDestEnd = pszDest;
00920                     cchRemaining = cchDest;
00921                 }
00922                 else
00923                     if (cchDest > 0)
00924                     {
00925                         pszDestEnd = pszDest + cchDest - 1;
00926                         cchRemaining = 1;
00927                         *pszDestEnd = '\0';
00928                     }
00929             }
00930             if (dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION))
00931             {
00932                 if (cchDest > 0)
00933                 {
00934                     pszDestEnd = pszDest;
00935                     cchRemaining = cchDest;
00936                     *pszDestEnd = '\0';
00937                 }
00938             }
00939         }
00940     }
00941     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
00942     {
00943         if (ppszDestEnd)
00944             *ppszDestEnd = pszDestEnd;
00945         if (pcchRemaining)
00946             *pcchRemaining = cchRemaining;
00947     }
00948     return Status;
00949 }
00950 
00951 NTSTRSAFEAPI RtlStringCopyExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
00952 {
00953     NTSTATUS Status = STATUS_SUCCESS;
00954     STRSAFE_LPWSTR pszDestEnd = pszDest;
00955     size_t cchRemaining = 0;
00956     if (dwFlags & (~STRSAFE_VALID_FLAGS))
00957         Status = STATUS_INVALID_PARAMETER;
00958     else
00959     {
00960         if (dwFlags & STRSAFE_IGNORE_NULLS)
00961         {
00962             if (!pszDest)
00963             {
00964                 if ((cchDest!=0) || (cbDest!=0))
00965                     Status = STATUS_INVALID_PARAMETER;
00966             }
00967             if (!pszSrc)
00968                 pszSrc = L"";
00969         }
00970         if (NT_SUCCESS(Status))
00971         {
00972             if (cchDest==0)
00973             {
00974                 pszDestEnd = pszDest;
00975                 cchRemaining = 0;
00976                 if (*pszSrc!=L'\0')
00977                 {
00978                     if (!pszDest)
00979                         Status = STATUS_INVALID_PARAMETER;
00980                     else
00981                         Status = STATUS_BUFFER_OVERFLOW;
00982                 }
00983             }
00984             else
00985             {
00986                 pszDestEnd = pszDest;
00987                 cchRemaining = cchDest;
00988                 while(cchRemaining && (*pszSrc!=L'\0'))
00989                 {
00990                     *pszDestEnd++ = *pszSrc++;
00991                     cchRemaining--;
00992                 }
00993                 if (cchRemaining > 0)
00994                 {
00995                     if (dwFlags & STRSAFE_FILL_BEHIND_NULL)
00996                     {
00997                         memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t)));
00998                     }
00999                 }
01000                 else
01001                 {
01002                     pszDestEnd--;
01003                     cchRemaining++;
01004                     Status = STATUS_BUFFER_OVERFLOW;
01005                 }
01006                 *pszDestEnd = L'\0';
01007             }
01008         }
01009     }
01010     if (!NT_SUCCESS(Status))
01011     {
01012         if (pszDest)
01013         {
01014             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
01015             {
01016                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
01017                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
01018                 {
01019                     pszDestEnd = pszDest;
01020                     cchRemaining = cchDest;
01021                 }
01022                 else
01023                     if (cchDest > 0)
01024                     {
01025                         pszDestEnd = pszDest + cchDest - 1;
01026                         cchRemaining = 1;
01027                         *pszDestEnd = L'\0';
01028                     }
01029             }
01030             if (dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION))
01031             {
01032                 if (cchDest > 0)
01033                 {
01034                     pszDestEnd = pszDest;
01035                     cchRemaining = cchDest;
01036                     *pszDestEnd = L'\0';
01037                 }
01038             }
01039         }
01040     }
01041     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
01042     {
01043         if (ppszDestEnd)
01044             *ppszDestEnd = pszDestEnd;
01045         if (pcchRemaining)
01046             *pcchRemaining = cchRemaining;
01047     }
01048     return Status;
01049 }
01050 
01051 NTSTRSAFEAPI RtlStringCopyNWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchSrc)
01052 {
01053     NTSTATUS Status = STATUS_SUCCESS;
01054     if (cchDest==0)
01055         Status = STATUS_INVALID_PARAMETER;
01056     else
01057     {
01058         while(cchDest && cchSrc && (*pszSrc!='\0'))
01059         {
01060             *pszDest++ = *pszSrc++;
01061             cchDest--;
01062             cchSrc--;
01063         }
01064         if (cchDest==0)
01065         {
01066             pszDest--;
01067             Status = STATUS_BUFFER_OVERFLOW;
01068         }
01069         *pszDest= '\0';
01070     }
01071     return Status;
01072 }
01073 
01074 NTSTRSAFEAPI RtlStringCopyNWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToCopy)
01075 {
01076     NTSTATUS Status = STATUS_SUCCESS;
01077     if (cchDest==0)
01078         Status = STATUS_INVALID_PARAMETER;
01079     else
01080     {
01081         while(cchDest && cchToCopy && (*pszSrc!=L'\0'))
01082         {
01083             *pszDest++ = *pszSrc++;
01084             cchDest--;
01085             cchToCopy--;
01086         }
01087         if (cchDest==0)
01088         {
01089             pszDest--;
01090             Status = STATUS_BUFFER_OVERFLOW;
01091         }
01092         *pszDest= L'\0';
01093     }
01094     return Status;
01095 }
01096 
01097 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)
01098 {
01099     NTSTATUS Status = STATUS_SUCCESS;
01100     STRSAFE_LPSTR pszDestEnd = pszDest;
01101     size_t cchRemaining = 0;
01102     if (dwFlags & (~STRSAFE_VALID_FLAGS))
01103         Status = STATUS_INVALID_PARAMETER;
01104     else
01105         if (cchToCopy > NTSTRSAFE_MAX_CCH)
01106             Status = STATUS_INVALID_PARAMETER;
01107         else
01108         {
01109             if (dwFlags & STRSAFE_IGNORE_NULLS)
01110             {
01111                 if (!pszDest)
01112                 {
01113                     if ((cchDest!=0) || (cbDest!=0))
01114                         Status = STATUS_INVALID_PARAMETER;
01115                 }
01116                 if (!pszSrc)
01117                     pszSrc = "";
01118             }
01119             if (NT_SUCCESS(Status))
01120             {
01121                 if (cchDest==0)
01122                 {
01123                     pszDestEnd = pszDest;
01124                     cchRemaining = 0;
01125                     if ((cchToCopy!=0) && (*pszSrc!='\0'))
01126                     {
01127                         if (!pszDest)
01128                             Status = STATUS_INVALID_PARAMETER;
01129                         else
01130                             Status = STATUS_BUFFER_OVERFLOW;
01131                     }
01132                 }
01133                 else
01134                 {
01135                     pszDestEnd = pszDest;
01136                     cchRemaining = cchDest;
01137                     while(cchRemaining && cchToCopy && (*pszSrc!='\0'))
01138                     {
01139                         *pszDestEnd++ = *pszSrc++;
01140                         cchRemaining--;
01141                         cchToCopy--;
01142                     }
01143                     if (cchRemaining > 0)
01144                     {
01145                         if (dwFlags & STRSAFE_FILL_BEHIND_NULL)
01146                         {
01147                             memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(char)) + (cbDest % sizeof(char)));
01148                         }
01149                     }
01150                     else
01151                     {
01152                         pszDestEnd--;
01153                         cchRemaining++;
01154                         Status = STATUS_BUFFER_OVERFLOW;
01155                     }
01156                     *pszDestEnd = '\0';
01157                 }
01158             }
01159         }
01160     if (!NT_SUCCESS(Status))
01161     {
01162         if (pszDest)
01163         {
01164             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
01165             {
01166                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
01167                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
01168                 {
01169                     pszDestEnd = pszDest;
01170                     cchRemaining = cchDest;
01171                 }
01172                 else
01173                     if (cchDest > 0)
01174                     {
01175                         pszDestEnd = pszDest + cchDest - 1;
01176                         cchRemaining = 1;
01177                         *pszDestEnd = '\0';
01178                     }
01179             }
01180             if (dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION))
01181             {
01182                 if (cchDest > 0)
01183                 {
01184                     pszDestEnd = pszDest;
01185                     cchRemaining = cchDest;
01186                     *pszDestEnd = '\0';
01187                 }
01188             }
01189         }
01190     }
01191     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
01192     {
01193         if (ppszDestEnd)
01194             *ppszDestEnd = pszDestEnd;
01195         if (pcchRemaining)
01196             *pcchRemaining = cchRemaining;
01197     }
01198     return Status;
01199 }
01200 
01201 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)
01202 {
01203     NTSTATUS Status = STATUS_SUCCESS;
01204     STRSAFE_LPWSTR pszDestEnd = pszDest;
01205     size_t cchRemaining = 0;
01206     if (dwFlags & (~STRSAFE_VALID_FLAGS))
01207         Status = STATUS_INVALID_PARAMETER;
01208     else
01209         if (cchToCopy > NTSTRSAFE_MAX_CCH)
01210             Status = STATUS_INVALID_PARAMETER;
01211         else
01212         {
01213             if (dwFlags & STRSAFE_IGNORE_NULLS)
01214             {
01215                 if (!pszDest)
01216                 {
01217                     if ((cchDest!=0) || (cbDest!=0))
01218                         Status = STATUS_INVALID_PARAMETER;
01219                 }
01220                 if (!pszSrc)
01221                     pszSrc = L"";
01222             }
01223             if (NT_SUCCESS(Status))
01224             {
01225                 if (cchDest==0)
01226                 {
01227                     pszDestEnd = pszDest;
01228                     cchRemaining = 0;
01229                     if ((cchToCopy!=0) && (*pszSrc!=L'\0'))
01230                     {
01231                         if (!pszDest)
01232                             Status = STATUS_INVALID_PARAMETER;
01233                         else
01234                             Status = STATUS_BUFFER_OVERFLOW;
01235                     }
01236                 }
01237                 else
01238                 {
01239                     pszDestEnd = pszDest;
01240                     cchRemaining = cchDest;
01241                     while(cchRemaining && cchToCopy && (*pszSrc!=L'\0'))
01242                     {
01243                         *pszDestEnd++ = *pszSrc++;
01244                         cchRemaining--;
01245                         cchToCopy--;
01246                     }
01247                     if (cchRemaining > 0)
01248                     {
01249                         if (dwFlags & STRSAFE_FILL_BEHIND_NULL)
01250                         {
01251                             memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t)));
01252                         }
01253                     }
01254                     else
01255                     {
01256                         pszDestEnd--;
01257                         cchRemaining++;
01258                         Status = STATUS_BUFFER_OVERFLOW;
01259                     }
01260                     *pszDestEnd = L'\0';
01261                 }
01262             }
01263         }
01264     if (!NT_SUCCESS(Status))
01265     {
01266         if (pszDest)
01267         {
01268             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
01269             {
01270                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
01271                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
01272                 {
01273                     pszDestEnd = pszDest;
01274                     cchRemaining = cchDest;
01275                 }
01276                 else
01277                     if (cchDest > 0)
01278                     {
01279                         pszDestEnd = pszDest + cchDest - 1;
01280                         cchRemaining = 1;
01281                         *pszDestEnd = L'\0';
01282                     }
01283             }
01284             if (dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION))
01285             {
01286                 if (cchDest > 0)
01287                 {
01288                     pszDestEnd = pszDest;
01289                     cchRemaining = cchDest;
01290                     *pszDestEnd = L'\0';
01291                 }
01292             }
01293         }
01294     }
01295     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
01296     {
01297         if (ppszDestEnd)
01298             *ppszDestEnd = pszDestEnd;
01299         if (pcchRemaining)
01300             *pcchRemaining = cchRemaining;
01301     }
01302     return Status;
01303 }
01304 
01305 NTSTRSAFEAPI RtlStringCatWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc)
01306 {
01307     NTSTATUS Status;
01308     size_t cchDestLength;
01309     Status = RtlStringLengthWorkerA(pszDest,cchDest,&cchDestLength);
01310     if (NT_SUCCESS(Status))
01311         Status = RtlStringCopyWorkerA(pszDest + cchDestLength,cchDest - cchDestLength,pszSrc);
01312     return Status;
01313 }
01314 
01315 NTSTRSAFEAPI RtlStringCatWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc)
01316 {
01317     NTSTATUS Status;
01318     size_t cchDestLength;
01319     Status = RtlStringLengthWorkerW(pszDest,cchDest,&cchDestLength);
01320     if (NT_SUCCESS(Status))
01321         Status = RtlStringCopyWorkerW(pszDest + cchDestLength,cchDest - cchDestLength,pszSrc);
01322     return Status;
01323 }
01324 
01325 NTSTRSAFEAPI RtlStringCatExWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCSTR pszSrc,STRSAFE_LPSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
01326 {
01327     NTSTATUS Status = STATUS_SUCCESS;
01328     STRSAFE_LPSTR pszDestEnd = pszDest;
01329     size_t cchRemaining = 0;
01330     if (dwFlags & (~STRSAFE_VALID_FLAGS))
01331         Status = STATUS_INVALID_PARAMETER;
01332     else
01333     {
01334         size_t cchDestLength;
01335         if (dwFlags & STRSAFE_IGNORE_NULLS)
01336         {
01337             if (!pszDest)
01338             {
01339                 if ((cchDest==0) && (cbDest==0))
01340                     cchDestLength = 0;
01341                 else
01342                     Status = STATUS_INVALID_PARAMETER;
01343             }
01344             else
01345             {
01346                 Status = RtlStringLengthWorkerA(pszDest,cchDest,&cchDestLength);
01347                 if (NT_SUCCESS(Status))
01348                 {
01349                     pszDestEnd = pszDest + cchDestLength;
01350                     cchRemaining = cchDest - cchDestLength;
01351                 }
01352             }
01353             if (!pszSrc)
01354                 pszSrc = "";
01355         }
01356         else
01357         {
01358             Status = RtlStringLengthWorkerA(pszDest,cchDest,&cchDestLength);
01359             if (NT_SUCCESS(Status))
01360             {
01361                 pszDestEnd = pszDest + cchDestLength;
01362                 cchRemaining = cchDest - cchDestLength;
01363             }
01364         }
01365         if (NT_SUCCESS(Status))
01366         {
01367             if (cchDest==0)
01368             {
01369                 if (*pszSrc!='\0')
01370                 {
01371                     if (!pszDest)
01372                         Status = STATUS_INVALID_PARAMETER;
01373                     else
01374                         Status = STATUS_BUFFER_OVERFLOW;
01375                 }
01376             }
01377             else
01378                 Status = RtlStringCopyExWorkerA(pszDestEnd,cchRemaining,(cchRemaining*sizeof(char)) + (cbDest % sizeof(char)),pszSrc,&pszDestEnd,&cchRemaining,dwFlags & (~(STRSAFE_FILL_ON_FAILURE | STRSAFE_NULL_ON_FAILURE)));
01379         }
01380     }
01381     if (!NT_SUCCESS(Status))
01382     {
01383         if (pszDest)
01384         {
01385             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
01386             {
01387                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
01388                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
01389                 {
01390                     pszDestEnd = pszDest;
01391                     cchRemaining = cchDest;
01392                 }
01393                 else
01394                     if (cchDest > 0)
01395                     {
01396                         pszDestEnd = pszDest + cchDest - 1;
01397                         cchRemaining = 1;
01398                         *pszDestEnd = '\0';
01399                     }
01400             }
01401             if (dwFlags & STRSAFE_NULL_ON_FAILURE)
01402             {
01403                 if (cchDest > 0)
01404                 {
01405                     pszDestEnd = pszDest;
01406                     cchRemaining = cchDest;
01407                     *pszDestEnd = '\0';
01408                 }
01409             }
01410         }
01411     }
01412     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
01413     {
01414         if (ppszDestEnd)
01415             *ppszDestEnd = pszDestEnd;
01416         if (pcchRemaining)
01417             *pcchRemaining = cchRemaining;
01418     }
01419     return Status;
01420 }
01421 
01422 NTSTRSAFEAPI RtlStringCatExWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,size_t cbDest,STRSAFE_LPCWSTR pszSrc,STRSAFE_LPWSTR *ppszDestEnd,size_t *pcchRemaining,STRSAFE_DWORD dwFlags)
01423 {
01424     NTSTATUS Status = STATUS_SUCCESS;
01425     STRSAFE_LPWSTR pszDestEnd = pszDest;
01426     size_t cchRemaining = 0;
01427     if (dwFlags & (~STRSAFE_VALID_FLAGS))
01428         Status = STATUS_INVALID_PARAMETER;
01429     else
01430     {
01431         size_t cchDestLength;
01432         if (dwFlags & STRSAFE_IGNORE_NULLS)
01433         {
01434             if (!pszDest)
01435             {
01436                 if ((cchDest==0) && (cbDest==0))
01437                     cchDestLength = 0;
01438                 else
01439                     Status = STATUS_INVALID_PARAMETER;
01440             }
01441             else
01442             {
01443                 Status = RtlStringLengthWorkerW(pszDest,cchDest,&cchDestLength);
01444                 if (NT_SUCCESS(Status))
01445                 {
01446                     pszDestEnd = pszDest + cchDestLength;
01447                     cchRemaining = cchDest - cchDestLength;
01448                 }
01449             }
01450             if (!pszSrc)
01451                 pszSrc = L"";
01452         }
01453         else
01454         {
01455             Status = RtlStringLengthWorkerW(pszDest,cchDest,&cchDestLength);
01456             if (NT_SUCCESS(Status))
01457             {
01458                 pszDestEnd = pszDest + cchDestLength;
01459                 cchRemaining = cchDest - cchDestLength;
01460             }
01461         }
01462         if (NT_SUCCESS(Status))
01463         {
01464             if (cchDest==0)
01465             {
01466                 if (*pszSrc!=L'\0')
01467                 {
01468                     if (!pszDest)
01469                         Status = STATUS_INVALID_PARAMETER;
01470                     else
01471                         Status = STATUS_BUFFER_OVERFLOW;
01472                 }
01473             }
01474             else
01475                 Status = RtlStringCopyExWorkerW(pszDestEnd,cchRemaining,(cchRemaining*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t)),pszSrc,&pszDestEnd,&cchRemaining,dwFlags & (~(STRSAFE_FILL_ON_FAILURE | STRSAFE_NULL_ON_FAILURE)));
01476         }
01477     }
01478     if (!NT_SUCCESS(Status))
01479     {
01480         if (pszDest)
01481         {
01482             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
01483             {
01484                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
01485                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
01486                 {
01487                     pszDestEnd = pszDest;
01488                     cchRemaining = cchDest;
01489                 }
01490                 else
01491                     if (cchDest > 0)
01492                     {
01493                         pszDestEnd = pszDest + cchDest - 1;
01494                         cchRemaining = 1;
01495                         *pszDestEnd = L'\0';
01496                     }
01497             }
01498             if (dwFlags & STRSAFE_NULL_ON_FAILURE)
01499             {
01500                 if (cchDest > 0)
01501                 {
01502                     pszDestEnd = pszDest;
01503                     cchRemaining = cchDest;
01504                     *pszDestEnd = L'\0';
01505                 }
01506             }
01507         }
01508     }
01509     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
01510     {
01511         if (ppszDestEnd)
01512             *ppszDestEnd = pszDestEnd;
01513         if (pcchRemaining)
01514             *pcchRemaining = cchRemaining;
01515     }
01516     return Status;
01517 }
01518 
01519 NTSTRSAFEAPI RtlStringCatNWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszSrc,size_t cchToAppend)
01520 {
01521     NTSTATUS Status;
01522     size_t cchDestLength;
01523     Status = RtlStringLengthWorkerA(pszDest,cchDest,&cchDestLength);
01524     if (NT_SUCCESS(Status))
01525         Status = RtlStringCopyNWorkerA(pszDest + cchDestLength,cchDest - cchDestLength,pszSrc,cchToAppend);
01526     return Status;
01527 }
01528 
01529 NTSTRSAFEAPI RtlStringCatNWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszSrc,size_t cchToAppend)
01530 {
01531     NTSTATUS Status;
01532     size_t cchDestLength;
01533     Status = RtlStringLengthWorkerW(pszDest,cchDest,&cchDestLength);
01534     if (NT_SUCCESS(Status))
01535         Status = RtlStringCopyNWorkerW(pszDest + cchDestLength,cchDest - cchDestLength,pszSrc,cchToAppend);
01536     return Status;
01537 }
01538 
01539 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)
01540 {
01541     NTSTATUS Status = STATUS_SUCCESS;
01542     STRSAFE_LPSTR pszDestEnd = pszDest;
01543     size_t cchRemaining = 0;
01544     size_t cchDestLength = 0;
01545     if (dwFlags & (~STRSAFE_VALID_FLAGS))
01546         Status = STATUS_INVALID_PARAMETER;
01547     else
01548         if (cchToAppend > NTSTRSAFE_MAX_CCH)
01549             Status = STATUS_INVALID_PARAMETER;
01550         else
01551         {
01552             if (dwFlags & STRSAFE_IGNORE_NULLS)
01553             {
01554                 if (!pszDest)
01555                 {
01556                     if ((cchDest==0) && (cbDest==0))
01557                         cchDestLength = 0;
01558                     else
01559                         Status = STATUS_INVALID_PARAMETER;
01560                 }
01561                 else
01562                 {
01563                     Status = RtlStringLengthWorkerA(pszDest,cchDest,&cchDestLength);
01564                     if (NT_SUCCESS(Status))
01565                     {
01566                         pszDestEnd = pszDest + cchDestLength;
01567                         cchRemaining = cchDest - cchDestLength;
01568                     }
01569                 }
01570                 if (!pszSrc)
01571                     pszSrc = "";
01572             }
01573             else
01574             {
01575                 Status = RtlStringLengthWorkerA(pszDest,cchDest,&cchDestLength);
01576                 if (NT_SUCCESS(Status))
01577                 {
01578                     pszDestEnd = pszDest + cchDestLength;
01579                     cchRemaining = cchDest - cchDestLength;
01580                 }
01581             }
01582             if (NT_SUCCESS(Status))
01583             {
01584                 if (cchDest==0)
01585                 {
01586                     if ((cchToAppend!=0) && (*pszSrc!='\0'))
01587                     {
01588                         if (!pszDest)
01589                             Status = STATUS_INVALID_PARAMETER;
01590                         else
01591                             Status = STATUS_BUFFER_OVERFLOW;
01592                     }
01593                 }
01594                 else
01595                     Status = RtlStringCopyNExWorkerA(pszDestEnd,cchRemaining,(cchRemaining*sizeof(char)) + (cbDest % sizeof(char)),pszSrc,cchToAppend,&pszDestEnd,&cchRemaining,dwFlags & (~(STRSAFE_FILL_ON_FAILURE | STRSAFE_NULL_ON_FAILURE)));
01596             }
01597         }
01598     if (!NT_SUCCESS(Status))
01599     {
01600         if (pszDest)
01601         {
01602             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
01603             {
01604                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
01605                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
01606                 {
01607                     pszDestEnd = pszDest;
01608                     cchRemaining = cchDest;
01609                 }
01610                 else
01611                     if (cchDest > 0)
01612                     {
01613                         pszDestEnd = pszDest + cchDest - 1;
01614                         cchRemaining = 1;
01615                         *pszDestEnd = '\0';
01616                     }
01617             }
01618             if (dwFlags & (STRSAFE_NULL_ON_FAILURE))
01619             {
01620                 if (cchDest > 0)
01621                 {
01622                     pszDestEnd = pszDest;
01623                     cchRemaining = cchDest;
01624                     *pszDestEnd = '\0';
01625                 }
01626             }
01627         }
01628     }
01629     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
01630     {
01631         if (ppszDestEnd)
01632             *ppszDestEnd = pszDestEnd;
01633         if (pcchRemaining)
01634             *pcchRemaining = cchRemaining;
01635     }
01636     return Status;
01637 }
01638 
01639 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)
01640 {
01641     NTSTATUS Status = STATUS_SUCCESS;
01642     STRSAFE_LPWSTR pszDestEnd = pszDest;
01643     size_t cchRemaining = 0;
01644     size_t cchDestLength = 0;
01645     if (dwFlags & (~STRSAFE_VALID_FLAGS))
01646         Status = STATUS_INVALID_PARAMETER;
01647     else
01648         if (cchToAppend > NTSTRSAFE_MAX_CCH)
01649             Status = STATUS_INVALID_PARAMETER;
01650         else
01651         {
01652             if (dwFlags & STRSAFE_IGNORE_NULLS)
01653             {
01654                 if (!pszDest)
01655                 {
01656                     if ((cchDest==0) && (cbDest==0))
01657                         cchDestLength = 0;
01658                     else
01659                         Status = STATUS_INVALID_PARAMETER;
01660                 }
01661                 else
01662                 {
01663                     Status = RtlStringLengthWorkerW(pszDest,cchDest,&cchDestLength);
01664                     if (NT_SUCCESS(Status))
01665                     {
01666                         pszDestEnd = pszDest + cchDestLength;
01667                         cchRemaining = cchDest - cchDestLength;
01668                     }
01669                 }
01670                 if (!pszSrc)
01671                     pszSrc = L"";
01672             }
01673             else
01674             {
01675                 Status = RtlStringLengthWorkerW(pszDest,cchDest,&cchDestLength);
01676                 if (NT_SUCCESS(Status))
01677                 {
01678                     pszDestEnd = pszDest + cchDestLength;
01679                     cchRemaining = cchDest - cchDestLength;
01680                 }
01681             }
01682             if (NT_SUCCESS(Status))
01683             {
01684                 if (cchDest==0)
01685                 {
01686                     if ((cchToAppend!=0) && (*pszSrc!=L'\0'))
01687                     {
01688                         if (!pszDest)
01689                             Status = STATUS_INVALID_PARAMETER;
01690                         else
01691                             Status = STATUS_BUFFER_OVERFLOW;
01692                     }
01693                 }
01694                 else
01695                     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)));
01696             }
01697         }
01698     if (!NT_SUCCESS(Status))
01699     {
01700         if (pszDest)
01701         {
01702             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
01703             {
01704                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
01705                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
01706                 {
01707                     pszDestEnd = pszDest;
01708                     cchRemaining = cchDest;
01709                 }
01710                 else
01711                     if (cchDest > 0)
01712                     {
01713                         pszDestEnd = pszDest + cchDest - 1;
01714                         cchRemaining = 1;
01715                         *pszDestEnd = L'\0';
01716                     }
01717             }
01718             if (dwFlags & (STRSAFE_NULL_ON_FAILURE))
01719             {
01720                 if (cchDest > 0)
01721                 {
01722                     pszDestEnd = pszDest;
01723                     cchRemaining = cchDest;
01724                     *pszDestEnd = L'\0';
01725                 }
01726             }
01727         }
01728     }
01729     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
01730     {
01731         if (ppszDestEnd)
01732             *ppszDestEnd = pszDestEnd;
01733         if (pcchRemaining)
01734             *pcchRemaining = cchRemaining;
01735     }
01736     return Status;
01737 }
01738 
01739 NTSTRSAFEAPI RtlStringVPrintfWorkerA(STRSAFE_LPSTR pszDest,size_t cchDest,STRSAFE_LPCSTR pszFormat,va_list argList)
01740 {
01741     NTSTATUS Status = STATUS_SUCCESS;
01742     if (cchDest==0)
01743         Status = STATUS_INVALID_PARAMETER;
01744     else
01745     {
01746         int iRet;
01747         size_t cchMax;
01748         cchMax = cchDest - 1;
01749         iRet = _vsnprintf(pszDest,cchMax,pszFormat,argList);
01750         if ((iRet < 0) || (((size_t)iRet) > cchMax))
01751         {
01752             pszDest += cchMax;
01753             *pszDest = '\0';
01754             Status = STATUS_BUFFER_OVERFLOW;
01755         }
01756         else
01757             if (((size_t)iRet)==cchMax)
01758             {
01759                 pszDest += cchMax;
01760                 *pszDest = '\0';
01761             }
01762     }
01763     return Status;
01764 }
01765 
01766 NTSTRSAFEAPI RtlStringVPrintfWorkerW(STRSAFE_LPWSTR pszDest,size_t cchDest,STRSAFE_LPCWSTR pszFormat,va_list argList)
01767 {
01768     NTSTATUS Status = STATUS_SUCCESS;
01769     if (cchDest==0)
01770         Status = STATUS_INVALID_PARAMETER;
01771     else
01772     {
01773         int iRet;
01774         size_t cchMax;
01775         cchMax = cchDest - 1;
01776         iRet = _vsnwprintf(pszDest,cchMax,pszFormat,argList);
01777         if ((iRet < 0) || (((size_t)iRet) > cchMax))
01778         {
01779             pszDest += cchMax;
01780             *pszDest = L'\0';
01781             Status = STATUS_BUFFER_OVERFLOW;
01782         }
01783         else
01784             if (((size_t)iRet)==cchMax)
01785             {
01786                 pszDest += cchMax;
01787                 *pszDest = L'\0';
01788             }
01789     }
01790     return Status;
01791 }
01792 
01793 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)
01794 {
01795     NTSTATUS Status = STATUS_SUCCESS;
01796     STRSAFE_LPSTR pszDestEnd = pszDest;
01797     size_t cchRemaining = 0;
01798     if (dwFlags & (~STRSAFE_VALID_FLAGS))
01799         Status = STATUS_INVALID_PARAMETER;
01800     else
01801     {
01802         if (dwFlags & STRSAFE_IGNORE_NULLS)
01803         {
01804             if (!pszDest)
01805             {
01806                 if ((cchDest!=0) || (cbDest!=0))
01807                     Status = STATUS_INVALID_PARAMETER;
01808             }
01809             if (!pszFormat)
01810                 pszFormat = "";
01811         }
01812         if (NT_SUCCESS(Status))
01813         {
01814             if (cchDest==0)
01815             {
01816                 pszDestEnd = pszDest;
01817                 cchRemaining = 0;
01818                 if (*pszFormat!='\0')
01819                 {
01820                     if (!pszDest)
01821                         Status = STATUS_INVALID_PARAMETER;
01822                     else
01823                         Status = STATUS_BUFFER_OVERFLOW;
01824                 }
01825             }
01826             else
01827             {
01828                 int iRet;
01829                 size_t cchMax;
01830                 cchMax = cchDest - 1;
01831                 iRet = _vsnprintf(pszDest,cchMax,pszFormat,argList);
01832                 if ((iRet < 0) || (((size_t)iRet) > cchMax))
01833                 {
01834                     pszDestEnd = pszDest + cchMax;
01835                     cchRemaining = 1;
01836                     *pszDestEnd = '\0';
01837                     Status = STATUS_BUFFER_OVERFLOW;
01838                 }
01839                 else
01840                     if (((size_t)iRet)==cchMax)
01841                     {
01842                         pszDestEnd = pszDest + cchMax;
01843                         cchRemaining = 1;
01844                         *pszDestEnd = '\0';
01845                     }
01846                     else
01847                         if (((size_t)iRet) < cchMax)
01848                         {
01849                             pszDestEnd = pszDest + iRet;
01850                             cchRemaining = cchDest - iRet;
01851                             if (dwFlags & STRSAFE_FILL_BEHIND_NULL)
01852                             {
01853                                 memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(char)) + (cbDest % sizeof(char)));
01854                             }
01855                         }
01856             }
01857         }
01858     }
01859     if (!NT_SUCCESS(Status))
01860     {
01861         if (pszDest)
01862         {
01863             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
01864             {
01865                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
01866                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
01867                 {
01868                     pszDestEnd = pszDest;
01869                     cchRemaining = cchDest;
01870                 }
01871                 else
01872                     if (cchDest > 0)
01873                     {
01874                         pszDestEnd = pszDest + cchDest - 1;
01875                         cchRemaining = 1;
01876                         *pszDestEnd = '\0';
01877                     }
01878             }
01879             if (dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION))
01880             {
01881                 if (cchDest > 0)
01882                 {
01883                     pszDestEnd = pszDest;
01884                     cchRemaining = cchDest;
01885                     *pszDestEnd = '\0';
01886                 }
01887             }
01888         }
01889     }
01890     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
01891     {
01892         if (ppszDestEnd)
01893             *ppszDestEnd = pszDestEnd;
01894         if (pcchRemaining)
01895             *pcchRemaining = cchRemaining;
01896     }
01897     return Status;
01898 }
01899 
01900 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)
01901 {
01902     NTSTATUS Status = STATUS_SUCCESS;
01903     STRSAFE_LPWSTR pszDestEnd = pszDest;
01904     size_t cchRemaining = 0;
01905     if (dwFlags & (~STRSAFE_VALID_FLAGS))
01906         Status = STATUS_INVALID_PARAMETER;
01907     else
01908     {
01909         if (dwFlags & STRSAFE_IGNORE_NULLS)
01910         {
01911             if (!pszDest)
01912             {
01913                 if ((cchDest!=0) || (cbDest!=0))
01914                     Status = STATUS_INVALID_PARAMETER;
01915             }
01916             if (!pszFormat)
01917                 pszFormat = L"";
01918         }
01919         if (NT_SUCCESS(Status))
01920         {
01921             if (cchDest==0)
01922             {
01923                 pszDestEnd = pszDest;
01924                 cchRemaining = 0;
01925                 if (*pszFormat!=L'\0')
01926                 {
01927                     if (!pszDest)
01928                         Status = STATUS_INVALID_PARAMETER;
01929                     else
01930                         Status = STATUS_BUFFER_OVERFLOW;
01931                 }
01932             }
01933             else
01934             {
01935                 int iRet;
01936                 size_t cchMax;
01937                 cchMax = cchDest - 1;
01938                 iRet = _vsnwprintf(pszDest,cchMax,pszFormat,argList);
01939                 if ((iRet < 0) || (((size_t)iRet) > cchMax))
01940                 {
01941                     pszDestEnd = pszDest + cchMax;
01942                     cchRemaining = 1;
01943                     *pszDestEnd = L'\0';
01944                     Status = STATUS_BUFFER_OVERFLOW;
01945                 }
01946                 else
01947                     if (((size_t)iRet)==cchMax)
01948                     {
01949                         pszDestEnd = pszDest + cchMax;
01950                         cchRemaining = 1;
01951                         *pszDestEnd = L'\0';
01952                     }
01953                     else
01954                         if (((size_t)iRet) < cchMax)
01955                         {
01956                             pszDestEnd = pszDest + iRet;
01957                             cchRemaining = cchDest - iRet;
01958                             if (dwFlags & STRSAFE_FILL_BEHIND_NULL)
01959                             {
01960                                 memset(pszDestEnd + 1,STRSAFE_GET_FILL_PATTERN(dwFlags),((cchRemaining - 1)*sizeof(wchar_t)) + (cbDest % sizeof(wchar_t)));
01961                             }
01962                         }
01963             }
01964         }
01965     }
01966     if (!NT_SUCCESS(Status))
01967     {
01968         if (pszDest)
01969         {
01970             if (dwFlags & STRSAFE_FILL_ON_FAILURE)
01971             {
01972                 memset(pszDest,STRSAFE_GET_FILL_PATTERN(dwFlags),cbDest);
01973                 if (STRSAFE_GET_FILL_PATTERN(dwFlags)==0)
01974                 {
01975                     pszDestEnd = pszDest;
01976                     cchRemaining = cchDest;
01977                 }
01978                 else
01979                     if (cchDest > 0)
01980                     {
01981                         pszDestEnd = pszDest + cchDest - 1;
01982                         cchRemaining = 1;
01983                         *pszDestEnd = L'\0';
01984                     }
01985             }
01986             if (dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION))
01987             {
01988                 if (cchDest > 0)
01989                 {
01990                     pszDestEnd = pszDest;
01991                     cchRemaining = cchDest;
01992                     *pszDestEnd = L'\0';
01993                 }
01994             }
01995         }
01996     }
01997     if (NT_SUCCESS(Status) || (Status==STATUS_BUFFER_OVERFLOW))
01998     {
01999         if (ppszDestEnd)
02000             *ppszDestEnd = pszDestEnd;
02001         if (pcchRemaining)
02002             *pcchRemaining = cchRemaining;
02003     }
02004     return Status;
02005 }
02006 
02007 NTSTRSAFEAPI RtlStringLengthWorkerA(STRSAFE_LPCSTR psz,size_t cchMax,size_t *pcchLength)
02008 {
02009     NTSTATUS Status = STATUS_SUCCESS;
02010     size_t cchMaxPrev = cchMax;
02011     while(cchMax && (*psz!='\0'))
02012     {
02013         psz++;
02014         cchMax--;
02015     }
02016     if (cchMax==0)
02017         Status = STATUS_INVALID_PARAMETER;
02018     if (pcchLength)
02019     {
02020         if (NT_SUCCESS(Status))
02021             *pcchLength = cchMaxPrev - cchMax;
02022         else
02023             *pcchLength = 0;
02024     }
02025     return Status;
02026 }
02027 
02028 NTSTRSAFEAPI RtlStringLengthWorkerW(STRSAFE_LPCWSTR psz,size_t cchMax,size_t *pcchLength)
02029 {
02030     NTSTATUS Status = STATUS_SUCCESS;
02031     size_t cchMaxPrev = cchMax;
02032     while(cchMax && (*psz!=L'\0'))
02033     {
02034         psz++;
02035         cchMax--;
02036     }
02037     if (cchMax==0)
02038         Status = STATUS_INVALID_PARAMETER;
02039     if (pcchLength)
02040     {
02041         if (NT_SUCCESS(Status))
02042             *pcchLength = cchMaxPrev - cchMax;
02043         else
02044             *pcchLength = 0;
02045     }
02046     return Status;
02047 }
02048 
02049 
02050 
02051 #define RtlStringCopyWorkerA RtlStringCopyWorkerA_instead_use_StringCchCopyA_or_StringCchCopyExA;
02052 #define RtlStringCopyWorkerW RtlStringCopyWorkerW_instead_use_StringCchCopyW_or_StringCchCopyExW;
02053 #define RtlStringCopyExWorkerA RtlStringCopyExWorkerA_instead_use_StringCchCopyA_or_StringCchCopyExA;
02054 #define RtlStringCopyExWorkerW RtlStringCopyExWorkerW_instead_use_StringCchCopyW_or_StringCchCopyExW;
02055 #define RtlStringCatWorkerA RtlStringCatWorkerA_instead_use_StringCchCatA_or_StringCchCatExA;
02056 #define RtlStringCatWorkerW RtlStringCatWorkerW_instead_use_StringCchCatW_or_StringCchCatExW;
02057 #define RtlStringCatExWorkerA RtlStringCatExWorkerA_instead_use_StringCchCatA_or_StringCchCatExA;
02058 #define RtlStringCatExWorkerW RtlStringCatExWorkerW_instead_use_StringCchCatW_or_StringCchCatExW;
02059 #define RtlStringCatNWorkerA RtlStringCatNWorkerA_instead_use_StringCchCatNA_or_StrincCbCatNA;
02060 #define RtlStringCatNWorkerW RtlStringCatNWorkerW_instead_use_StringCchCatNW_or_StringCbCatNW;
02061 #define RtlStringCatNExWorkerA RtlStringCatNExWorkerA_instead_use_StringCchCatNExA_or_StringCbCatNExA;
02062 #define RtlStringCatNExWorkerW RtlStringCatNExWorkerW_instead_use_StringCchCatNExW_or_StringCbCatNExW;
02063 #define RtlStringVPrintfWorkerA RtlStringVPrintfWorkerA_instead_use_StringCchVPrintfA_or_StringCchVPrintfExA;
02064 #define RtlStringVPrintfWorkerW RtlStringVPrintfWorkerW_instead_use_StringCchVPrintfW_or_StringCchVPrintfExW;
02065 #define RtlStringVPrintfExWorkerA RtlStringVPrintfExWorkerA_instead_use_StringCchVPrintfA_or_StringCchVPrintfExA;
02066 #define RtlStringVPrintfExWorkerW RtlStringVPrintfExWorkerW_instead_use_StringCchVPrintfW_or_StringCchVPrintfExW;
02067 #define RtlStringLengthWorkerA RtlStringLengthWorkerA_instead_use_StringCchLengthA_or_StringCbLengthA;
02068 #define RtlStringLengthWorkerW RtlStringLengthWorkerW_instead_use_StringCchLengthW_or_StringCbLengthW;
02069 
02070 #ifdef _MSC_VER
02071 #pragma warning(pop)
02072 #endif /* _MSC_VER */
02073 
02074 #endif /* _NTSTRSAFE_H_INCLUDED_ */
Generated on Sat May 26 2012 04:28:55 for ReactOS by
1.7.6.1