1 /* 2 * Copyright (c) Huawei Technologies Co., Ltd. 2014-2020. All rights reserved. 3 * Licensed under Mulan PSL v2. 4 * You can use this software according to the terms and conditions of the Mulan PSL v2. 5 * You may obtain a copy of Mulan PSL v2 at: 6 * http://license.coscl.org.cn/MulanPSL2 7 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, 8 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, 9 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. 10 * See the Mulan PSL v2 for more details. 11 * Description: Define internal used macro and data type. The marco of SECUREC_ON_64BITS 12 * will be determined in this header file, which is a switch for part 13 * of code. Some macro are used to supress warning by MS compiler. 14 * Author: lishunda 15 * Create: 2014-02-25 16 */ 17 18 #ifndef SECURECTYPE_H_A7BBB686_AADA_451B_B9F9_44DACDAE18A7 19 #define SECURECTYPE_H_A7BBB686_AADA_451B_B9F9_44DACDAE18A7 20 21 #ifndef SECUREC_USING_STD_SECURE_LIB 22 #if defined(_MSC_VER) && _MSC_VER >= 1400 23 #if defined(__STDC_WANT_SECURE_LIB__) && (!__STDC_WANT_SECURE_LIB__) 24 /* Security functions have been provided since vs2005, default use of system library functions */ 25 #define SECUREC_USING_STD_SECURE_LIB 0 26 #else 27 #define SECUREC_USING_STD_SECURE_LIB 1 28 #endif 29 #else 30 #define SECUREC_USING_STD_SECURE_LIB 0 31 #endif 32 #endif 33 34 /* Compatibility with older Secure C versions, shielding VC symbol redefinition warning */ 35 #if defined(_MSC_VER) && (_MSC_VER >= 1400) && (!SECUREC_USING_STD_SECURE_LIB) 36 #ifndef SECUREC_DISABLE_CRT_FUNC 37 #define SECUREC_DISABLE_CRT_FUNC 1 38 #endif 39 #ifndef SECUREC_DISABLE_CRT_IMP 40 #define SECUREC_DISABLE_CRT_IMP 1 41 #endif 42 #else /* MSC VER */ 43 #ifndef SECUREC_DISABLE_CRT_FUNC 44 #define SECUREC_DISABLE_CRT_FUNC 0 45 #endif 46 #ifndef SECUREC_DISABLE_CRT_IMP 47 #define SECUREC_DISABLE_CRT_IMP 0 48 #endif 49 #endif 50 51 #if SECUREC_DISABLE_CRT_FUNC 52 #ifdef __STDC_WANT_SECURE_LIB__ 53 #undef __STDC_WANT_SECURE_LIB__ 54 #endif 55 #define __STDC_WANT_SECURE_LIB__ 0 56 #endif 57 58 #if SECUREC_DISABLE_CRT_IMP 59 #ifdef _CRTIMP_ALTERNATIVE 60 #undef _CRTIMP_ALTERNATIVE 61 #endif 62 #define _CRTIMP_ALTERNATIVE /* Comment microsoft *_s function */ 63 #endif 64 65 /* Compile in kernel under macro control */ 66 #ifndef SECUREC_IN_KERNEL 67 #ifdef __KERNEL__ 68 #define SECUREC_IN_KERNEL 1 69 #else 70 #define SECUREC_IN_KERNEL 0 71 #endif 72 #endif 73 74 #if SECUREC_IN_KERNEL 75 #ifndef SECUREC_ENABLE_SCANF_FILE 76 #define SECUREC_ENABLE_SCANF_FILE 0 77 #endif 78 #ifndef SECUREC_ENABLE_WCHAR_FUNC 79 #define SECUREC_ENABLE_WCHAR_FUNC 0 80 #endif 81 #else /* SECUREC_IN_KERNEL */ 82 #ifndef SECUREC_ENABLE_SCANF_FILE 83 #define SECUREC_ENABLE_SCANF_FILE 1 84 #endif 85 #ifndef SECUREC_ENABLE_WCHAR_FUNC 86 #define SECUREC_ENABLE_WCHAR_FUNC 1 87 #endif 88 #endif 89 90 /* Default secure function declaration, default declarations for non-standard functions */ 91 #ifndef SECUREC_SNPRINTF_TRUNCATED 92 #define SECUREC_SNPRINTF_TRUNCATED 1 93 #endif 94 95 #if SECUREC_USING_STD_SECURE_LIB 96 #if defined(_MSC_VER) && _MSC_VER >= 1400 97 /* Declare secure functions that are not available in the VS compiler */ 98 #ifndef SECUREC_ENABLE_MEMSET 99 #define SECUREC_ENABLE_MEMSET 1 100 #endif 101 /* VS 2005 have vsnprintf_s function */ 102 #ifndef SECUREC_ENABLE_VSNPRINTF 103 #define SECUREC_ENABLE_VSNPRINTF 0 104 #endif 105 #ifndef SECUREC_ENABLE_SNPRINTF 106 /* VS 2005 have vsnprintf_s function Adapt the snprintf_s of the security function */ 107 #define snprintf_s _snprintf_s 108 #define SECUREC_ENABLE_SNPRINTF 0 109 #endif 110 /* Before VS 2010 do not have v functions */ 111 #if _MSC_VER <= 1600 || defined(SECUREC_FOR_V_SCANFS) 112 #ifndef SECUREC_ENABLE_VFSCANF 113 #define SECUREC_ENABLE_VFSCANF 1 114 #endif 115 #ifndef SECUREC_ENABLE_VSCANF 116 #define SECUREC_ENABLE_VSCANF 1 117 #endif 118 #ifndef SECUREC_ENABLE_VSSCANF 119 #define SECUREC_ENABLE_VSSCANF 1 120 #endif 121 #endif 122 123 #else /* MSC VER */ 124 #ifndef SECUREC_ENABLE_MEMSET 125 #define SECUREC_ENABLE_MEMSET 0 126 #endif 127 #ifndef SECUREC_ENABLE_SNPRINTF 128 #define SECUREC_ENABLE_SNPRINTF 0 129 #endif 130 #ifndef SECUREC_ENABLE_VSNPRINTF 131 #define SECUREC_ENABLE_VSNPRINTF 0 132 #endif 133 #endif 134 135 #ifndef SECUREC_ENABLE_MEMMOVE 136 #define SECUREC_ENABLE_MEMMOVE 0 137 #endif 138 #ifndef SECUREC_ENABLE_MEMCPY 139 #define SECUREC_ENABLE_MEMCPY 0 140 #endif 141 #ifndef SECUREC_ENABLE_STRCPY 142 #define SECUREC_ENABLE_STRCPY 0 143 #endif 144 #ifndef SECUREC_ENABLE_STRNCPY 145 #define SECUREC_ENABLE_STRNCPY 0 146 #endif 147 #ifndef SECUREC_ENABLE_STRCAT 148 #define SECUREC_ENABLE_STRCAT 0 149 #endif 150 #ifndef SECUREC_ENABLE_STRNCAT 151 #define SECUREC_ENABLE_STRNCAT 0 152 #endif 153 #ifndef SECUREC_ENABLE_SPRINTF 154 #define SECUREC_ENABLE_SPRINTF 0 155 #endif 156 #ifndef SECUREC_ENABLE_VSPRINTF 157 #define SECUREC_ENABLE_VSPRINTF 0 158 #endif 159 #ifndef SECUREC_ENABLE_SSCANF 160 #define SECUREC_ENABLE_SSCANF 0 161 #endif 162 #ifndef SECUREC_ENABLE_VSSCANF 163 #define SECUREC_ENABLE_VSSCANF 0 164 #endif 165 #ifndef SECUREC_ENABLE_SCANF 166 #define SECUREC_ENABLE_SCANF 0 167 #endif 168 #ifndef SECUREC_ENABLE_VSCANF 169 #define SECUREC_ENABLE_VSCANF 0 170 #endif 171 172 #ifndef SECUREC_ENABLE_FSCANF 173 #define SECUREC_ENABLE_FSCANF 0 174 #endif 175 #ifndef SECUREC_ENABLE_VFSCANF 176 #define SECUREC_ENABLE_VFSCANF 0 177 #endif 178 #ifndef SECUREC_ENABLE_STRTOK 179 #define SECUREC_ENABLE_STRTOK 0 180 #endif 181 #ifndef SECUREC_ENABLE_GETS 182 #define SECUREC_ENABLE_GETS 0 183 #endif 184 185 #else /* SECUREC USE STD SECURE LIB */ 186 187 #ifndef SECUREC_ENABLE_MEMSET 188 #define SECUREC_ENABLE_MEMSET 1 189 #endif 190 #ifndef SECUREC_ENABLE_MEMMOVE 191 #define SECUREC_ENABLE_MEMMOVE 1 192 #endif 193 #ifndef SECUREC_ENABLE_MEMCPY 194 #define SECUREC_ENABLE_MEMCPY 1 195 #endif 196 #ifndef SECUREC_ENABLE_STRCPY 197 #define SECUREC_ENABLE_STRCPY 1 198 #endif 199 #ifndef SECUREC_ENABLE_STRNCPY 200 #define SECUREC_ENABLE_STRNCPY 1 201 #endif 202 #ifndef SECUREC_ENABLE_STRCAT 203 #define SECUREC_ENABLE_STRCAT 1 204 #endif 205 #ifndef SECUREC_ENABLE_STRNCAT 206 #define SECUREC_ENABLE_STRNCAT 1 207 #endif 208 #ifndef SECUREC_ENABLE_SPRINTF 209 #define SECUREC_ENABLE_SPRINTF 1 210 #endif 211 #ifndef SECUREC_ENABLE_VSPRINTF 212 #define SECUREC_ENABLE_VSPRINTF 1 213 #endif 214 #ifndef SECUREC_ENABLE_SNPRINTF 215 #define SECUREC_ENABLE_SNPRINTF 1 216 #endif 217 #ifndef SECUREC_ENABLE_VSNPRINTF 218 #define SECUREC_ENABLE_VSNPRINTF 1 219 #endif 220 #ifndef SECUREC_ENABLE_SSCANF 221 #define SECUREC_ENABLE_SSCANF 1 222 #endif 223 #ifndef SECUREC_ENABLE_VSSCANF 224 #define SECUREC_ENABLE_VSSCANF 1 225 #endif 226 #ifndef SECUREC_ENABLE_SCANF 227 #if SECUREC_ENABLE_SCANF_FILE 228 #define SECUREC_ENABLE_SCANF 1 229 #else 230 #define SECUREC_ENABLE_SCANF 0 231 #endif 232 #endif 233 #ifndef SECUREC_ENABLE_VSCANF 234 #if SECUREC_ENABLE_SCANF_FILE 235 #define SECUREC_ENABLE_VSCANF 1 236 #else 237 #define SECUREC_ENABLE_VSCANF 0 238 #endif 239 #endif 240 241 #ifndef SECUREC_ENABLE_FSCANF 242 #if SECUREC_ENABLE_SCANF_FILE 243 #define SECUREC_ENABLE_FSCANF 1 244 #else 245 #define SECUREC_ENABLE_FSCANF 0 246 #endif 247 #endif 248 #ifndef SECUREC_ENABLE_VFSCANF 249 #if SECUREC_ENABLE_SCANF_FILE 250 #define SECUREC_ENABLE_VFSCANF 1 251 #else 252 #define SECUREC_ENABLE_VFSCANF 0 253 #endif 254 #endif 255 256 #ifndef SECUREC_ENABLE_STRTOK 257 #define SECUREC_ENABLE_STRTOK 1 258 #endif 259 #ifndef SECUREC_ENABLE_GETS 260 #define SECUREC_ENABLE_GETS 1 261 #endif 262 #endif /* SECUREC_USE_STD_SECURE_LIB */ 263 264 #if !SECUREC_ENABLE_SCANF_FILE 265 #if SECUREC_ENABLE_FSCANF 266 #undef SECUREC_ENABLE_FSCANF 267 #define SECUREC_ENABLE_FSCANF 0 268 #endif 269 #if SECUREC_ENABLE_VFSCANF 270 #undef SECUREC_ENABLE_VFSCANF 271 #define SECUREC_ENABLE_VFSCANF 0 272 #endif 273 #if SECUREC_ENABLE_SCANF 274 #undef SECUREC_ENABLE_SCANF 275 #define SECUREC_ENABLE_SCANF 0 276 #endif 277 #if SECUREC_ENABLE_FSCANF 278 #undef SECUREC_ENABLE_FSCANF 279 #define SECUREC_ENABLE_FSCANF 0 280 #endif 281 282 #endif 283 284 #if SECUREC_IN_KERNEL 285 #include <linux/kernel.h> 286 #include <linux/module.h> 287 #else 288 #ifndef SECUREC_HAVE_STDIO_H 289 #define SECUREC_HAVE_STDIO_H 1 290 #endif 291 #ifndef SECUREC_HAVE_STRING_H 292 #define SECUREC_HAVE_STRING_H 1 293 #endif 294 #ifndef SECUREC_HAVE_STDLIB_H 295 #define SECUREC_HAVE_STDLIB_H 1 296 #endif 297 #if SECUREC_HAVE_STDIO_H 298 #include <stdio.h> 299 #endif 300 #if SECUREC_HAVE_STRING_H 301 #include <string.h> 302 #endif 303 #if SECUREC_HAVE_STDLIB_H 304 #include <stdlib.h> 305 #endif 306 #endif 307 308 /* 309 * If you need high performance, enable the SECUREC_WITH_PERFORMANCE_ADDONS macro, default is enable. 310 * The macro is automatically closed on the windows platform and linux kernel 311 */ 312 #ifndef SECUREC_WITH_PERFORMANCE_ADDONS 313 #if SECUREC_IN_KERNEL 314 #define SECUREC_WITH_PERFORMANCE_ADDONS 0 315 #else 316 #define SECUREC_WITH_PERFORMANCE_ADDONS 1 317 #endif 318 #endif 319 320 /* If enable SECUREC_COMPATIBLE_WIN_FORMAT, the output format will be compatible to Windows. */ 321 #if (defined(_WIN32) || defined(_WIN64) || defined(_MSC_VER)) && !defined(SECUREC_COMPATIBLE_LINUX_FORMAT) 322 #ifndef SECUREC_COMPATIBLE_WIN_FORMAT 323 #define SECUREC_COMPATIBLE_WIN_FORMAT 324 #endif 325 #endif 326 327 #if defined(SECUREC_COMPATIBLE_WIN_FORMAT) 328 /* On windows platform, can't use optimized function for there is no __builtin_constant_p like function */ 329 /* If need optimized macro, can define this: define __builtin_constant_p(x) 0 */ 330 #ifdef SECUREC_WITH_PERFORMANCE_ADDONS 331 #undef SECUREC_WITH_PERFORMANCE_ADDONS 332 #define SECUREC_WITH_PERFORMANCE_ADDONS 0 333 #endif 334 #endif 335 336 #if defined(__VXWORKS__) || defined(__vxworks) || defined(__VXWORKS) || defined(_VXWORKS_PLATFORM_) || \ 337 defined(SECUREC_VXWORKS_VERSION_5_4) 338 #ifndef SECUREC_VXWORKS_PLATFORM 339 #define SECUREC_VXWORKS_PLATFORM 340 #endif 341 #endif 342 343 /* If enable SECUREC_COMPATIBLE_LINUX_FORMAT, the output format will be compatible to Linux. */ 344 #if !defined(SECUREC_COMPATIBLE_WIN_FORMAT) && !defined(SECUREC_VXWORKS_PLATFORM) 345 #ifndef SECUREC_COMPATIBLE_LINUX_FORMAT 346 #define SECUREC_COMPATIBLE_LINUX_FORMAT 347 #endif 348 #endif 349 350 #ifdef SECUREC_COMPATIBLE_LINUX_FORMAT 351 #ifndef SECUREC_HAVE_STDDEF_H 352 #define SECUREC_HAVE_STDDEF_H 1 353 #endif 354 /* Some system may no stddef.h */ 355 #if SECUREC_HAVE_STDDEF_H 356 #if !SECUREC_IN_KERNEL 357 #include <stddef.h> 358 #endif 359 #endif 360 #endif 361 362 /* 363 * Add the -DSECUREC_SUPPORT_FORMAT_WARNING=1 compiler option to supoort -Wformat=2. 364 * Default does not check the format is that the same data type in the actual code. 365 * In the product is different in the original data type definition of VxWorks and Linux. 366 */ 367 #ifndef SECUREC_SUPPORT_FORMAT_WARNING 368 #define SECUREC_SUPPORT_FORMAT_WARNING 0 369 #endif 370 371 #if SECUREC_SUPPORT_FORMAT_WARNING 372 #define SECUREC_ATTRIBUTE(x, y) __attribute__((format(printf, (x), (y)))) 373 #else 374 #define SECUREC_ATTRIBUTE(x, y) 375 #endif 376 377 /* 378 * Add the -DSECUREC_SUPPORT_BUILTIN_EXPECT=0 compiler option, if complier can not support __builtin_expect. 379 */ 380 #ifndef SECUREC_SUPPORT_BUILTIN_EXPECT 381 #define SECUREC_SUPPORT_BUILTIN_EXPECT 1 382 #endif 383 384 #if SECUREC_SUPPORT_BUILTIN_EXPECT && defined(__GNUC__) && ((__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 3))) 385 /* 386 * This is a built-in function that can be used without a declaration, if warning for declaration not found occurred, 387 * you can add -DSECUREC_NEED_BUILTIN_EXPECT_DECLARE to complier options 388 */ 389 #ifdef SECUREC_NEED_BUILTIN_EXPECT_DECLARE 390 long __builtin_expect(long exp, long c); 391 #endif 392 393 #define SECUREC_LIKELY(x) __builtin_expect(!!(x), 1) 394 #define SECUREC_UNLIKELY(x) __builtin_expect(!!(x), 0) 395 #else 396 #define SECUREC_LIKELY(x) (x) 397 #define SECUREC_UNLIKELY(x) (x) 398 #endif 399 400 /* Define the max length of the string */ 401 #ifndef SECUREC_STRING_MAX_LEN 402 #define SECUREC_STRING_MAX_LEN 0x7fffffffUL 403 #endif 404 #define SECUREC_WCHAR_STRING_MAX_LEN (SECUREC_STRING_MAX_LEN / sizeof(wchar_t)) 405 406 /* Add SECUREC_MEM_MAX_LEN for memcpy and memmove */ 407 #ifndef SECUREC_MEM_MAX_LEN 408 #define SECUREC_MEM_MAX_LEN 0x7fffffffUL 409 #endif 410 #define SECUREC_WCHAR_MEM_MAX_LEN (SECUREC_MEM_MAX_LEN / sizeof(wchar_t)) 411 412 #if SECUREC_STRING_MAX_LEN > 0x7fffffffUL 413 #error "max string is 2G" 414 #endif 415 416 #if (defined(__GNUC__) && defined(__SIZEOF_POINTER__)) 417 #if (__SIZEOF_POINTER__ != 4) && (__SIZEOF_POINTER__ != 8) 418 #error "unsupported system" 419 #endif 420 #endif 421 422 #if defined(_WIN64) || defined(WIN64) || defined(__LP64__) || defined(_LP64) 423 #define SECUREC_ON_64BITS 424 #endif 425 426 #if (!defined(SECUREC_ON_64BITS) && defined(__GNUC__) && defined(__SIZEOF_POINTER__)) 427 #if __SIZEOF_POINTER__ == 8 428 #define SECUREC_ON_64BITS 429 #endif 430 #endif 431 432 #if defined(__SVR4) || defined(__svr4__) 433 #define SECUREC_ON_SOLARIS 434 #endif 435 436 #if (defined(__hpux) || defined(_AIX) || defined(SECUREC_ON_SOLARIS)) 437 #define SECUREC_ON_UNIX 438 #endif 439 440 /* 441 * Codes should run under the macro SECUREC_COMPATIBLE_LINUX_FORMAT in unknow system on default, 442 * and strtold. 443 * The function strtold is referenced first at ISO9899:1999(C99), and some old compilers can 444 * not support these functions. Here provides a macro to open these functions: 445 * SECUREC_SUPPORT_STRTOLD -- If defined, strtold will be used 446 */ 447 #ifndef SECUREC_SUPPORT_STRTOLD 448 #define SECUREC_SUPPORT_STRTOLD 0 449 #if (defined(SECUREC_COMPATIBLE_LINUX_FORMAT)) 450 #if defined(__USE_ISOC99) || \ 451 (defined(_AIX) && defined(_ISOC99_SOURCE)) || \ 452 (defined(__hpux) && defined(__ia64)) || \ 453 (defined(SECUREC_ON_SOLARIS) && (!defined(_STRICT_STDC) && !defined(__XOPEN_OR_POSIX)) || \ 454 defined(_STDC_C99) || defined(__EXTENSIONS__)) 455 #undef SECUREC_SUPPORT_STRTOLD 456 #define SECUREC_SUPPORT_STRTOLD 1 457 #endif 458 #endif 459 #if ((defined(SECUREC_WRLINUX_BELOW4) || defined(_WRLINUX_BELOW4_))) 460 #undef SECUREC_SUPPORT_STRTOLD 461 #define SECUREC_SUPPORT_STRTOLD 0 462 #endif 463 #endif 464 465 #if SECUREC_WITH_PERFORMANCE_ADDONS 466 467 #ifndef SECUREC_TWO_MIN 468 #define SECUREC_TWO_MIN(a, b) ((a) < (b) ? (a) : (b)) 469 #endif 470 471 /* For strncpy_s performance optimization */ 472 #define SECUREC_STRNCPY_SM(dest, destMax, src, count) \ 473 (((void *)(dest) != NULL && (void *)(src) != NULL && (size_t)(destMax) > 0 && \ 474 (((unsigned long long)(destMax) & (unsigned long long)(-2)) < SECUREC_STRING_MAX_LEN) && \ 475 (SECUREC_TWO_MIN((size_t)(count), strlen(src)) + 1) <= (size_t)(destMax)) ? \ 476 (((size_t)(count) < strlen(src)) ? (memcpy((dest), (src), (count)), *((char *)(dest) + (count)) = '\0', EOK) : \ 477 (memcpy((dest), (src), strlen(src) + 1), EOK)) : (strncpy_error((dest), (destMax), (src), (count)))) 478 479 #define SECUREC_STRCPY_SM(dest, destMax, src) \ 480 (((void *)(dest) != NULL && (void *)(src) != NULL && (size_t)(destMax) > 0 && \ 481 (((unsigned long long)(destMax) & (unsigned long long)(-2)) < SECUREC_STRING_MAX_LEN) && \ 482 (strlen(src) + 1) <= (size_t)(destMax)) ? (memcpy((dest), (src), strlen(src) + 1), EOK) : \ 483 (strcpy_error((dest), (destMax), (src)))) 484 485 /* For strcat_s performance optimization */ 486 #if defined(__GNUC__) 487 #define SECUREC_STRCAT_SM(dest, destMax, src) ({ \ 488 int catRet_ = EOK; \ 489 if ((void *)(dest) != NULL && (void *)(src) != NULL && (size_t)(destMax) > 0 && \ 490 (((unsigned long long)(destMax) & (unsigned long long)(-2)) < SECUREC_STRING_MAX_LEN)) { \ 491 char *catTmpDst_ = (char *)(dest); \ 492 size_t catRestSize_ = (destMax); \ 493 while (catRestSize_ > 0 && *catTmpDst_ != '\0') { \ 494 ++catTmpDst_; \ 495 --catRestSize_; \ 496 } \ 497 if (catRestSize_ == 0) { \ 498 catRet_ = EINVAL; \ 499 } else if ((strlen(src) + 1) <= catRestSize_) { \ 500 memcpy(catTmpDst_, (src), strlen(src) + 1); \ 501 catRet_ = EOK; \ 502 } else { \ 503 catRet_ = ERANGE; \ 504 } \ 505 if (catRet_ != EOK) { \ 506 catRet_ = strcat_s((dest), (destMax), (src)); \ 507 } \ 508 } else { \ 509 catRet_ = strcat_s((dest), (destMax), (src)); \ 510 } \ 511 catRet_; \ 512 }) 513 #else 514 #define SECUREC_STRCAT_SM(dest, destMax, src) strcat_s((dest), (destMax), (src)) 515 #endif 516 517 /* For strncat_s performance optimization */ 518 #if defined(__GNUC__) 519 #define SECUREC_STRNCAT_SM(dest, destMax, src, count) ({ \ 520 int ncatRet_ = EOK; \ 521 if ((void *)(dest) != NULL && (void *)(src) != NULL && (size_t)(destMax) > 0 && \ 522 (((unsigned long long)(destMax) & (unsigned long long)(-2)) < SECUREC_STRING_MAX_LEN) && \ 523 (((unsigned long long)(count) & (unsigned long long)(-2)) < SECUREC_STRING_MAX_LEN)) { \ 524 char *ncatTmpDest_ = (char *)(dest); \ 525 size_t ncatRestSize_ = (size_t)(destMax); \ 526 while (ncatRestSize_ > 0 && *ncatTmpDest_ != '\0') { \ 527 ++ncatTmpDest_; \ 528 --ncatRestSize_; \ 529 } \ 530 if (ncatRestSize_ == 0) { \ 531 ncatRet_ = EINVAL; \ 532 } else if ((SECUREC_TWO_MIN((count), strlen(src)) + 1) <= ncatRestSize_) { \ 533 if ((size_t)(count) < strlen(src)) { \ 534 memcpy(ncatTmpDest_, (src), (count)); \ 535 *(ncatTmpDest_ + (count)) = '\0'; \ 536 } else { \ 537 memcpy(ncatTmpDest_, (src), strlen(src) + 1); \ 538 } \ 539 } else { \ 540 ncatRet_ = ERANGE; \ 541 } \ 542 if (ncatRet_ != EOK) { \ 543 ncatRet_ = strncat_s((dest), (destMax), (src), (count)); \ 544 } \ 545 } else { \ 546 ncatRet_ = strncat_s((dest), (destMax), (src), (count)); \ 547 } \ 548 ncatRet_; \ 549 }) 550 #else 551 #define SECUREC_STRNCAT_SM(dest, destMax, src, count) strncat_s((dest), (destMax), (src), (count)) 552 #endif 553 554 /* This macro do not check buffer overlap by default */ 555 #define SECUREC_MEMCPY_SM(dest, destMax, src, count) \ 556 (!(((size_t)(destMax) == 0) || \ 557 (((unsigned long long)(destMax) & (unsigned long long)(-2)) > SECUREC_MEM_MAX_LEN) || \ 558 ((size_t)(count) > (size_t)(destMax)) || ((void *)(dest)) == NULL || ((void *)(src) == NULL)) ? \ 559 (memcpy((dest), (src), (count)), EOK) : \ 560 (memcpy_s((dest), (destMax), (src), (count)))) 561 562 #define SECUREC_MEMSET_SM(dest, destMax, c, count) \ 563 (!((((unsigned long long)(destMax) & (unsigned long long)(-2)) > SECUREC_MEM_MAX_LEN) || \ 564 ((void *)(dest) == NULL) || ((size_t)(count) > (size_t)(destMax))) ? \ 565 (memset((dest), (c), (count)), EOK) : \ 566 (memset_s((dest), (destMax), (c), (count)))) 567 568 #endif 569 #endif 570 571