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