lai/gk-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

GK SDK 源码库: XMIPCLinuxV100R005C00SPC030 (kernel/tools/open_source excluded)

Browse Source
This commit is contained in:
lai
2026-09-06 03:52:57 +08:00
commit b1928b41c0
21813 changed files with 4413081 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/bootloader/u-boot-2020.01/lotus/securec/Makefile
Executable
+39
View File
@@ -0,0 +1,39 @@
obj-y += securecutil.o
#obj-y += gets_s.o
#obj-y += vfwscanf_s.o
obj-y += secureprintoutput_w.o
#obj-y += fwscanf_s.o
#obj-y += scanf_s.o
#obj-y += vwscanf_s.o
obj-y += strncpy_s.o
obj-y += vsprintf_s.o
obj-y += secureinput_w.o
obj-y += wcscpy_s.o
#obj-y += vswscanf_s.o
obj-y += snprintf_s.o
#obj-y += wscanf_s.o
#obj-y += vfscanf_s.o
#obj-y += vsscanf_s.o
obj-y += memcpy_s.o
obj-y += secureinput_a.o
obj-y += memmove_s.o
obj-y += wcscat_s.o
obj-y += wmemcpy_s.o
#obj-y += sscanf_s.o
#obj-y += fscanf_s.o
#obj-y += vscanf_s.o
obj-y += strcat_s.o
obj-y += wcstok_s.o
obj-y += swprintf_s.o
obj-y += wcsncpy_s.o
obj-y += wmemmove_s.o
obj-y += secureprintoutput_a.o
obj-y += memset_s.o
obj-y += strtok_s.o
obj-y += wcsncat_s.o
obj-y += vswprintf_s.o
obj-y += sprintf_s.o
obj-y += strncat_s.o
obj-y += strcpy_s.o
#obj-y += swscanf_s.o
obj-y += vsnprintf_s.o
source/bootloader/u-boot-2020.01/lotus/securec/fscanf_s.c
Executable
+46
View File
@@ -0,0 +1,46 @@
/*
*
*/
/*
*/
#include "linux/lotus/securec.h"
/*
* <FUNCTION DESCRIPTION>
* The fscanf_s function is equivalent to fscanf except that the c, s,
* and [ conversion specifiers apply to a pair of arguments (unless assignment suppression is indicated by a*)
* The fscanf function reads data from the current position of stream into
* the locations given by argument (if any). Each argument must be a pointer
* to a variable of a type that corresponds to a type specifier in format.
* format controls the interpretation of the input fields and has the same
* form and function as the format argument for scanf.
*
* <INPUT PARAMETERS>
* stream Pointer to FILE structure.
* format Format control string, see Format Specifications.
* ... Optional arguments.
*
* <OUTPUT PARAMETERS>
* ... The convered value stored in user assigned address
*
* <RETURN VALUE>
* Each of these functions returns the number of fields successfully converted
* and assigned; the return value does not include fields that were read but
* not assigned. A return value of 0 indicates that no fields were assigned.
* return -1 if an error occurs.
*/
int fscanf_s(FILE *stream, const char *format, ...)
{
int ret; /* If initialization causes e838 */
va_list argList;
va_start(argList, format);
ret = vfscanf_s(stream, format, argList);
va_end(argList);
(void)argList; /* To clear e438 last value assigned not used , the compiler will optimize this code */
return ret;
}
source/bootloader/u-boot-2020.01/lotus/securec/fwscanf_s.c
Executable
+42
View File
@@ -0,0 +1,42 @@
/*
*
*/
#include "linux/lotus/securec.h"
/*
* <FUNCTION DESCRIPTION>
* The fwscanf_s function is the wide-character equivalent of the fscanf_s function
* The fwscanf_s function reads data from the current position of stream into
* the locations given by argument (if any). Each argument must be a pointer
* to a variable of a type that corresponds to a type specifier in format.
* format controls the interpretation of the input fields and has the same
* form and function as the format argument for scanf.
*
* <INPUT PARAMETERS>
* stream Pointer to FILE structure.
* format Format control string, see Format Specifications.
* ... Optional arguments.
*
* <OUTPUT PARAMETERS>
* ... The converted value stored in user assigned address
*
* <RETURN VALUE>
* Each of these functions returns the number of fields successfully converted
* and assigned; the return value does not include fields that were read but
* not assigned. A return value of 0 indicates that no fields were assigned.
* return -1 if an error occurs.
*/
int fwscanf_s(FILE *stream, const wchar_t *format, ...)
{
int ret; /* If initialization causes e838 */
va_list argList;
va_start(argList, format);
ret = vfwscanf_s(stream, format, argList);
va_end(argList);
(void)argList; /* To clear e438 last value assigned not used , the compiler will optimize this code */
return ret;
}
source/bootloader/u-boot-2020.01/lotus/securec/gets_s.c
Executable
+61
View File
@@ -0,0 +1,61 @@
/*
*
*/
#include "securecutil.h"
/*
* The parameter size is buffer size in byte
*/
SECUREC_INLINE void SecTrimCRLF(char *buffer, size_t size)
{
size_t len = strlen(buffer);
--len; /* Unsigned integer wrapping is accepted and is checked afterwards */
while (len < size && (buffer[len] == '\r' || buffer[len] == '\n')) {
buffer[len] = '\0';
--len; /* Unsigned integer wrapping is accepted and is checked next loop */
}
}
/*
* <FUNCTION DESCRIPTION>
* The gets_s function reads at most one less than the number of characters
* specified by destMax from the std input stream, into the array pointed to by buffer
* The line consists of all characters up to and including
* the first newline character ('\n'). gets_s then replaces the newline
* character with a null character ('\0') before returning the line.
* If the first character read is the end-of-file character, a null character
* is stored at the beginning of buffer and NULL is returned.
*
* <INPUT PARAMETERS>
* buffer Storage location for input string.
* destMax The size of the buffer.
*
* <OUTPUT PARAMETERS>
* buffer is updated
*
* <RETURN VALUE>
* buffer Successful operation
* NULL Improper parameter or read fail
*/
char *gets_s(char *buffer, size_t destMax)
{
#ifdef SECUREC_COMPATIBLE_WIN_FORMAT
size_t bufferSize = ((destMax == (size_t)(-1)) ? SECUREC_STRING_MAX_LEN : destMax);
#else
size_t bufferSize = destMax;
#endif
if (buffer == NULL || bufferSize == 0 || bufferSize > SECUREC_STRING_MAX_LEN) {
SECUREC_ERROR_INVALID_PARAMTER("gets_s");
return NULL;
}
if (fgets(buffer, (int)bufferSize, SECUREC_STREAM_STDIN) != NULL) {
SecTrimCRLF(buffer, bufferSize);
return buffer;
}
return NULL;
}
source/bootloader/u-boot-2020.01/lotus/securec/input.inl
Executable
+2209
View File
File diff suppressed because it is too large Load Diff
source/bootloader/u-boot-2020.01/lotus/securec/memcpy_s.c
Executable
+553
View File
@@ -0,0 +1,553 @@
/*
*
*/
/*
* [Standardize-exceptions] Use unsafe function: Portability
* [reason] Use unsafe function to implement security function to maintain platform compatibility.
* And sufficient input validation is performed before calling
*/
#include "securecutil.h"
#ifndef SECUREC_MEMCOPY_WITH_PERFORMANCE
#define SECUREC_MEMCOPY_WITH_PERFORMANCE 0
#endif
#if SECUREC_WITH_PERFORMANCE_ADDONS || SECUREC_MEMCOPY_WITH_PERFORMANCE
#ifndef SECUREC_MEMCOPY_THRESHOLD_SIZE
#define SECUREC_MEMCOPY_THRESHOLD_SIZE 64UL
#endif
#define SECUREC_SMALL_MEM_COPY(dest, src, count) do { \
if (SECUREC_ADDR_ALIGNED_8(dest) && SECUREC_ADDR_ALIGNED_8(src)) { \
/* Use struct assignment */ \
switch (count) { \
case 1: \
*(unsigned char *)(dest) = *(const unsigned char *)(src); \
break; \
case 2: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 2); \
break; \
case 3: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 3); \
break; \
case 4: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 4); \
break; \
case 5: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 5); \
break; \
case 6: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 6); \
break; \
case 7: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 7); \
break; \
case 8: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 8); \
break; \
case 9: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 9); \
break; \
case 10: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 10); \
break; \
case 11: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 11); \
break; \
case 12: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 12); \
break; \
case 13: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 13); \
break; \
case 14: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 14); \
break; \
case 15: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 15); \
break; \
case 16: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 16); \
break; \
case 17: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 17); \
break; \
case 18: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 18); \
break; \
case 19: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 19); \
break; \
case 20: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 20); \
break; \
case 21: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 21); \
break; \
case 22: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 22); \
break; \
case 23: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 23); \
break; \
case 24: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 24); \
break; \
case 25: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 25); \
break; \
case 26: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 26); \
break; \
case 27: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 27); \
break; \
case 28: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 28); \
break; \
case 29: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 29); \
break; \
case 30: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 30); \
break; \
case 31: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 31); \
break; \
case 32: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 32); \
break; \
case 33: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 33); \
break; \
case 34: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 34); \
break; \
case 35: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 35); \
break; \
case 36: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 36); \
break; \
case 37: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 37); \
break; \
case 38: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 38); \
break; \
case 39: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 39); \
break; \
case 40: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 40); \
break; \
case 41: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 41); \
break; \
case 42: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 42); \
break; \
case 43: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 43); \
break; \
case 44: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 44); \
break; \
case 45: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 45); \
break; \
case 46: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 46); \
break; \
case 47: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 47); \
break; \
case 48: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 48); \
break; \
case 49: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 49); \
break; \
case 50: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 50); \
break; \
case 51: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 51); \
break; \
case 52: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 52); \
break; \
case 53: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 53); \
break; \
case 54: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 54); \
break; \
case 55: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 55); \
break; \
case 56: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 56); \
break; \
case 57: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 57); \
break; \
case 58: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 58); \
break; \
case 59: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 59); \
break; \
case 60: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 60); \
break; \
case 61: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 61); \
break; \
case 62: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 62); \
break; \
case 63: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 63); \
break; \
case 64: \
SECUREC_COPY_VALUE_BY_STRUCT((dest), (src), 64); \
break; \
default: \
/* Do nothing */ \
break; \
} /* END switch */ \
} else { \
unsigned char *tmpDest_ = (unsigned char *)(dest); \
const unsigned char *tmpSrc_ = (const unsigned char *)(src); \
switch (count) { \
case 64: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 63: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 62: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 61: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 60: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 59: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 58: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 57: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 56: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 55: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 54: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 53: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 52: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 51: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 50: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 49: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 48: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 47: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 46: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 45: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 44: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 43: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 42: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 41: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 40: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 39: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 38: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 37: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 36: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 35: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 34: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 33: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 32: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 31: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 30: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 29: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 28: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 27: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 26: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 25: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 24: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 23: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 22: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 21: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 20: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 19: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 18: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 17: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 16: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 15: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 14: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 13: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 12: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 11: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 10: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 9: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 8: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 7: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 6: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 5: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 4: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 3: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 2: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 1: \
*(tmpDest_++) = *(tmpSrc_++); \
/* fall-through */ /* FALLTHRU */ \
default: \
/* Do nothing */ \
break; \
} \
} \
} SECUREC_WHILE_ZERO
/*
* Performance optimization
*/
#define SECUREC_MEMCPY_OPT(dest, src, count) do { \
if ((count) > SECUREC_MEMCOPY_THRESHOLD_SIZE) { \
SECUREC_MEMCPY_WARP_OPT((dest), (src), (count)); \
} else { \
SECUREC_SMALL_MEM_COPY((dest), (src), (count)); \
} \
} SECUREC_WHILE_ZERO
#endif
/*
* Handling errors
*/
SECUREC_INLINE errno_t SecMemcpyError(void *dest, size_t destMax, const void *src, size_t count)
{
if (destMax == 0 || destMax > SECUREC_MEM_MAX_LEN) {
SECUREC_ERROR_INVALID_RANGE("memcpy_s");
return ERANGE;
}
if (dest == NULL || src == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("memcpy_s");
if (dest != NULL) {
(void)memset(dest, 0, destMax);
return EINVAL_AND_RESET;
}
return EINVAL;
}
if (count > destMax) {
(void)memset(dest, 0, destMax);
SECUREC_ERROR_INVALID_RANGE("memcpy_s");
return ERANGE_AND_RESET;
}
if (SECUREC_MEMORY_IS_OVERLAP(dest, src, count)) {
(void)memset(dest, 0, destMax);
SECUREC_ERROR_BUFFER_OVERLAP("memcpy_s");
return EOVERLAP_AND_RESET;
}
/* Count is 0 or dest equal src also ret EOK */
return EOK;
}
#if defined(SECUREC_COMPATIBLE_WIN_FORMAT)
/*
* The fread API in windows will call memcpy_s and pass 0xffffffff to destMax.
* To avoid the failure of fread, we don't check desMax limit.
*/
#define SECUREC_MEMCPY_PARAM_OK(dest, destMax, src, count) (SECUREC_LIKELY((count) <= (destMax) && \
(dest) != NULL && (src) != NULL && \
(count) > 0 && SECUREC_MEMORY_NO_OVERLAP((dest), (src), (count))))
#else
#define SECUREC_MEMCPY_PARAM_OK(dest, destMax, src, count) (SECUREC_LIKELY((count) <= (destMax) && \
(dest) != NULL && (src) != NULL && (destMax) <= SECUREC_MEM_MAX_LEN && \
(count) > 0 && SECUREC_MEMORY_NO_OVERLAP((dest), (src), (count))))
#endif
/*
* <FUNCTION DESCRIPTION>
* The memcpy_s function copies n characters from the object pointed to by src into the object pointed to by dest
*
* <INPUT PARAMETERS>
* dest Destination buffer.
* destMax Size of the destination buffer.
* src Buffer to copy from.
* count Number of characters to copy
*
* <OUTPUT PARAMETERS>
* dest buffer is updated.
*
* <RETURN VALUE>
* EOK Success
* EINVAL dest is NULL and destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN
* EINVAL_AND_RESET dest != NULL and src is NULLL and destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN
* ERANGE destMax > SECUREC_MEM_MAX_LEN or destMax is 0
* ERANGE_AND_RESET count > destMax and destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN
* and dest != NULL and src != NULL
* EOVERLAP_AND_RESET dest buffer and source buffer are overlapped and
* count <= destMax destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN and dest != NULL
* and src != NULL and dest != src
*
* if an error occured, dest will be filled with 0.
* If the source and destination overlap, the behavior of memcpy_s is undefined.
* Use memmove_s to handle overlapping regions.
*/
errno_t memcpy_s(void *dest, size_t destMax, const void *src, size_t count)
{
if (SECUREC_MEMCPY_PARAM_OK(dest, destMax, src, count)) {
#if SECUREC_MEMCOPY_WITH_PERFORMANCE
SECUREC_MEMCPY_OPT(dest, src, count);
#else
SECUREC_MEMCPY_WARP_OPT(dest, src, count);
#endif
return EOK;
}
/* Meet some runtime violation, return error code */
return SecMemcpyError(dest, destMax, src, count);
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(memcpy_s);
#endif
#if SECUREC_WITH_PERFORMANCE_ADDONS
/*
* Performance optimization
*/
errno_t memcpy_sOptAsm(void *dest, size_t destMax, const void *src, size_t count)
{
if (SECUREC_MEMCPY_PARAM_OK(dest, destMax, src, count)) {
SECUREC_MEMCPY_OPT(dest, src, count);
return EOK;
}
/* Meet some runtime violation, return error code */
return SecMemcpyError(dest, destMax, src, count);
}
/* Trim judgement on "destMax <= SECUREC_MEM_MAX_LEN" */
errno_t memcpy_sOptTc(void *dest, size_t destMax, const void *src, size_t count)
{
if (SECUREC_LIKELY(count <= destMax && dest != NULL && src != NULL && \
count > 0 && SECUREC_MEMORY_NO_OVERLAP((dest), (src), (count)))) {
SECUREC_MEMCPY_OPT(dest, src, count);
return EOK;
}
/* Meet some runtime violation, return error code */
return SecMemcpyError(dest, destMax, src, count);
}
#endif
source/bootloader/u-boot-2020.01/lotus/securec/memmove_s.c
Executable
+113
View File
@@ -0,0 +1,113 @@
/*
*
*/
/*
* [Standardize-exceptions] Use unsafe function: Portability
* [reason] Use unsafe function to implement security function to maintain platform compatibility.
* And sufficient input validation is performed before calling
*/
#include "securecutil.h"
#ifdef SECUREC_NOT_CALL_LIBC_CORE_API
/*
* Implementing memory data movement
*/
SECUREC_INLINE void SecUtilMemmove(void *dst, const void *src, size_t count)
{
unsigned char *pDest = (unsigned char *)dst;
const unsigned char *pSrc = (const unsigned char *)src;
size_t maxCount = count;
if (dst <= src || pDest >= (pSrc + maxCount)) {
/*
* Non-Overlapping Buffers
* Copy from lower addresses to higher addresses
*/
while (maxCount > 0) {
--maxCount;
*pDest = *pSrc;
++pDest;
++pSrc;
}
} else {
/*
* Overlapping Buffers
* Copy from higher addresses to lower addresses
*/
pDest = pDest + maxCount - 1;
pSrc = pSrc + maxCount - 1;
while (maxCount > 0) {
--maxCount;
*pDest = *pSrc;
--pDest;
--pSrc;
}
}
}
#endif
/*
* <FUNCTION DESCRIPTION>
* The memmove_s function copies count bytes of characters from src to dest.
* This function can be assigned correctly when memory overlaps.
* <INPUT PARAMETERS>
* dest Destination object.
* destMax Size of the destination buffer.
* src Source object.
* count Number of characters to copy.
*
* <OUTPUT PARAMETERS>
* dest buffer is uptdated.
*
* <RETURN VALUE>
* EOK Success
* EINVAL dest is NULL and destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN
* EINVAL_AND_RESET dest != NULL and src is NULLL and destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN
* ERANGE destMax > SECUREC_MEM_MAX_LEN or destMax is 0
* ERANGE_AND_RESET count > destMax and dest != NULL and src != NULL and destMax != 0
* and destMax <= SECUREC_MEM_MAX_LEN
*
* If an error occured, dest will be filled with 0 when dest and destMax valid.
* If some regions of the source area and the destination overlap, memmove_s
* ensures that the original source bytes in the overlapping region are copied
* before being overwritten.
*/
errno_t memmove_s(void *dest, size_t destMax, const void *src, size_t count)
{
if (destMax == 0 || destMax > SECUREC_MEM_MAX_LEN) {
SECUREC_ERROR_INVALID_RANGE("memmove_s");
return ERANGE;
}
if (dest == NULL || src == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("memmove_s");
if (dest != NULL) {
(void)memset(dest, 0, destMax);
return EINVAL_AND_RESET;
}
return EINVAL;
}
if (count > destMax) {
(void)memset(dest, 0, destMax);
SECUREC_ERROR_INVALID_RANGE("memmove_s");
return ERANGE_AND_RESET;
}
if (dest == src) {
return EOK;
}
if (count > 0) {
#ifdef SECUREC_NOT_CALL_LIBC_CORE_API
SecUtilMemmove(dest, src, count);
#else
/* Use underlying memmove for performance consideration */
(void)memmove(dest, src, count);
#endif
}
return EOK;
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(memmove_s);
#endif
source/bootloader/u-boot-2020.01/lotus/securec/memset_s.c
Executable
+503
View File
@@ -0,0 +1,503 @@
/*
*
*/
/*
* [Standardize-exceptions] Use unsafe function: Portability
* [reason] Use unsafe function to implement security function to maintain platform compatibility.
* And sufficient input validation is performed before calling
*/
#include "securecutil.h"
#define SECUREC_MEMSET_PARAM_OK(dest, destMax, count) (SECUREC_LIKELY((destMax) <= SECUREC_MEM_MAX_LEN && \
(dest) != NULL && (count) <= (destMax)))
#if SECUREC_WITH_PERFORMANCE_ADDONS
/* Use union to clear strict-aliasing warning */
typedef union {
SecStrBuf32 buf32;
SecStrBuf31 buf31;
SecStrBuf30 buf30;
SecStrBuf29 buf29;
SecStrBuf28 buf28;
SecStrBuf27 buf27;
SecStrBuf26 buf26;
SecStrBuf25 buf25;
SecStrBuf24 buf24;
SecStrBuf23 buf23;
SecStrBuf22 buf22;
SecStrBuf21 buf21;
SecStrBuf20 buf20;
SecStrBuf19 buf19;
SecStrBuf18 buf18;
SecStrBuf17 buf17;
SecStrBuf16 buf16;
SecStrBuf15 buf15;
SecStrBuf14 buf14;
SecStrBuf13 buf13;
SecStrBuf12 buf12;
SecStrBuf11 buf11;
SecStrBuf10 buf10;
SecStrBuf9 buf9;
SecStrBuf8 buf8;
SecStrBuf7 buf7;
SecStrBuf6 buf6;
SecStrBuf5 buf5;
SecStrBuf4 buf4;
SecStrBuf3 buf3;
SecStrBuf2 buf2;
} SecStrBuf32Union;
/* C standard initializes the first member of the consortium. */
static const SecStrBuf32 g_allZero = {{
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'
}};
static const SecStrBuf32 g_allFF = {{
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
}};
/* Clear coversion warning strict aliasing" */
SECUREC_INLINE const SecStrBuf32Union *SecStrictAliasingCast(const SecStrBuf32 *buf)
{
return (const SecStrBuf32Union *)buf;
}
#ifndef SECUREC_MEMSET_THRESHOLD_SIZE
#define SECUREC_MEMSET_THRESHOLD_SIZE 32UL
#endif
#define SECUREC_UNALIGNED_SET(dest, c, count) do { \
unsigned char *pDest_ = (unsigned char *)(dest); \
switch (count) { \
case 32: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 31: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 30: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 29: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 28: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 27: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 26: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 25: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 24: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 23: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 22: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 21: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 20: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 19: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 18: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 17: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 16: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 15: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 14: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 13: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 12: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 11: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 10: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 9: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 8: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 7: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 6: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 5: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 4: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 3: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 2: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
case 1: \
*(pDest_++) = (unsigned char)(c); \
/* fall-through */ /* FALLTHRU */ \
default: \
/* Do nothing */ \
break; \
} \
} SECUREC_WHILE_ZERO
#define SECUREC_SET_VALUE_BY_STRUCT(dest, dataName, n) do { \
*(SecStrBuf##n *)(dest) = *(const SecStrBuf##n *)(&((SecStrictAliasingCast(&(dataName)))->buf##n)); \
} SECUREC_WHILE_ZERO
#define SECUREC_ALIGNED_SET_OPT_ZERO_FF(dest, c, count) do { \
switch (c) { \
case 0: \
switch (count) { \
case 1: \
*(unsigned char *)(dest) = (unsigned char)0; \
break; \
case 2: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 2); \
break; \
case 3: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 3); \
break; \
case 4: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 4); \
break; \
case 5: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 5); \
break; \
case 6: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 6); \
break; \
case 7: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 7); \
break; \
case 8: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 8); \
break; \
case 9: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 9); \
break; \
case 10: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 10); \
break; \
case 11: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 11); \
break; \
case 12: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 12); \
break; \
case 13: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 13); \
break; \
case 14: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 14); \
break; \
case 15: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 15); \
break; \
case 16: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 16); \
break; \
case 17: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 17); \
break; \
case 18: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 18); \
break; \
case 19: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 19); \
break; \
case 20: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 20); \
break; \
case 21: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 21); \
break; \
case 22: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 22); \
break; \
case 23: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 23); \
break; \
case 24: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 24); \
break; \
case 25: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 25); \
break; \
case 26: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 26); \
break; \
case 27: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 27); \
break; \
case 28: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 28); \
break; \
case 29: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 29); \
break; \
case 30: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 30); \
break; \
case 31: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 31); \
break; \
case 32: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allZero, 32); \
break; \
default: \
/* Do nothing */ \
break; \
} \
break; \
case 0xFF: \
switch (count) { \
case 1: \
*(unsigned char *)(dest) = (unsigned char)0xffU; \
break; \
case 2: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 2); \
break; \
case 3: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 3); \
break; \
case 4: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 4); \
break; \
case 5: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 5); \
break; \
case 6: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 6); \
break; \
case 7: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 7); \
break; \
case 8: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 8); \
break; \
case 9: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 9); \
break; \
case 10: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 10); \
break; \
case 11: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 11); \
break; \
case 12: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 12); \
break; \
case 13: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 13); \
break; \
case 14: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 14); \
break; \
case 15: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 15); \
break; \
case 16: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 16); \
break; \
case 17: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 17); \
break; \
case 18: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 18); \
break; \
case 19: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 19); \
break; \
case 20: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 20); \
break; \
case 21: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 21); \
break; \
case 22: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 22); \
break; \
case 23: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 23); \
break; \
case 24: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 24); \
break; \
case 25: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 25); \
break; \
case 26: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 26); \
break; \
case 27: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 27); \
break; \
case 28: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 28); \
break; \
case 29: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 29); \
break; \
case 30: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 30); \
break; \
case 31: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 31); \
break; \
case 32: \
SECUREC_SET_VALUE_BY_STRUCT((dest), g_allFF, 32); \
break; \
default: \
/* Do nothing */ \
break; \
} \
break; \
default: \
SECUREC_UNALIGNED_SET((dest), (c), (count)); \
break; \
} /* END switch */ \
} SECUREC_WHILE_ZERO
#define SECUREC_SMALL_MEM_SET(dest, c, count) do { \
if (SECUREC_ADDR_ALIGNED_8((dest))) { \
SECUREC_ALIGNED_SET_OPT_ZERO_FF((dest), (c), (count)); \
} else { \
SECUREC_UNALIGNED_SET((dest), (c), (count)); \
} \
} SECUREC_WHILE_ZERO
/*
* Performance optimization
*/
#define SECUREC_MEMSET_OPT(dest, c, count) do { \
if ((count) > SECUREC_MEMSET_THRESHOLD_SIZE) { \
SECUREC_MEMSET_WARP_OPT((dest), (c), (count)); \
} else { \
SECUREC_SMALL_MEM_SET((dest), (c), (count)); \
} \
} SECUREC_WHILE_ZERO
#endif
/*
* Handling errors
*/
SECUREC_INLINE errno_t SecMemsetError(void *dest, size_t destMax, int c, size_t count)
{
/* Check destMax is 0 compatible with _sp macro */
if (destMax == 0 || destMax > SECUREC_MEM_MAX_LEN) {
SECUREC_ERROR_INVALID_RANGE("memset_s");
return ERANGE;
}
if (dest == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("memset_s");
return EINVAL;
}
if (count > destMax) {
(void)memset(dest, c, destMax); /* Set entire buffer to value c */
SECUREC_ERROR_INVALID_RANGE("memset_s");
return ERANGE_AND_RESET;
}
return EOK;
}
/*
* <FUNCTION DESCRIPTION>
* The memset_s function copies the value of c (converted to an unsigned char)
* into each of the first count characters of the object pointed to by dest.
*
* <INPUT PARAMETERS>
* dest Pointer to destination.
* destMax The size of the buffer.
* c Character to set.
* count Number of characters.
*
* <OUTPUT PARAMETERS>
* dest buffer is uptdated.
*
* <RETURN VALUE>
* EOK Success
* EINVAL dest == NULL and destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN
* ERANGE destMax > SECUREC_MEM_MAX_LEN or (destMax is 0 and count > destMax)
* ERANGE_AND_RESET count > destMax and destMax != 0 and destMax <= SECUREC_MEM_MAX_LEN and dest != NULL
*
* if return ERANGE_AND_RESET then fill dest to c ,fill length is destMax
*/
errno_t memset_s(void *dest, size_t destMax, int c, size_t count)
{
if (SECUREC_MEMSET_PARAM_OK(dest, destMax, count)) {
SECUREC_MEMSET_WARP_OPT(dest, c, count);
return EOK;
}
/* Meet some runtime violation, return error code */
return SecMemsetError(dest, destMax, c, count);
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(memset_s);
#endif
#if SECUREC_WITH_PERFORMANCE_ADDONS
/*
* Performance optimization
*/
errno_t memset_sOptAsm(void *dest, size_t destMax, int c, size_t count)
{
if (SECUREC_MEMSET_PARAM_OK(dest, destMax, count)) {
SECUREC_MEMSET_OPT(dest, c, count);
return EOK;
}
/* Meet some runtime violation, return error code */
return SecMemsetError(dest, destMax, c, count);
}
/*
* Performance optimization, trim judgement on "destMax <= SECUREC_MEM_MAX_LEN"
*/
errno_t memset_sOptTc(void *dest, size_t destMax, int c, size_t count)
{
if (SECUREC_LIKELY(count <= destMax && dest != NULL)) {
SECUREC_MEMSET_OPT(dest, c, count);
return EOK;
}
/* Meet some runtime violation, return error code */
return SecMemsetError(dest, destMax, c, count);
}
#endif
source/bootloader/u-boot-2020.01/lotus/securec/output.inl
Executable
+1655
View File
File diff suppressed because it is too large Load Diff
source/bootloader/u-boot-2020.01/lotus/securec/scanf_s.c
Executable
+41
View File
@@ -0,0 +1,41 @@
/*
*
*/
#include "linux/lotus/securec.h"
/*
* <FUNCTION DESCRIPTION>
* The scanf_s function is equivalent to fscanf_s with the argument stdin interposed before the arguments to scanf_s
* The scanf_s function reads data from the standard input stream stdin and
* writes the data into the location that's given by argument. Each argument
* must be a pointer to a variable of a type that corresponds to a type specifier
* in format. If copying occurs between strings that overlap, the behavior is
* undefined.
*
* <INPUT PARAMETERS>
* format Format control string.
* ... Optional arguments.
*
* <OUTPUT PARAMETERS>
* ... The converted value stored in user assigned address
*
* <RETURN VALUE>
* Returns the number of fields successfully converted and assigned;
* the return value does not include fields that were read but not assigned.
* A return value of 0 indicates that no fields were assigned.
* return -1 if an error occurs.
*/
int scanf_s(const char *format, ...)
{
int ret; /* If initialization causes e838 */
va_list argList;
va_start(argList, format);
ret = vscanf_s(format, argList);
va_end(argList);
(void)argList; /* To clear e438 last value assigned not used , the compiler will optimize this code */
return ret;
}
source/bootloader/u-boot-2020.01/lotus/securec/secinput.h
Executable
+182
View File
@@ -0,0 +1,182 @@
/*
*
*/
#ifndef SEC_INPUT_H_E950DA2C_902F_4B15_BECD_948E99090D9C
#define SEC_INPUT_H_E950DA2C_902F_4B15_BECD_948E99090D9C
#include "securecutil.h"
#define SECUREC_SCANF_EINVAL (-1)
#define SECUREC_SCANF_ERROR_PARA (-2)
/* For internal stream flag */
#define SECUREC_MEM_STR_FLAG 0x01U
#define SECUREC_FILE_STREAM_FLAG 0x02U
#define SECUREC_PIPE_STREAM_FLAG 0x04U
#define SECUREC_LOAD_FILE_TO_MEM_FLAG 0x08U
#define SECUREC_UCS_BOM_HEADER_SIZE 2U
#define SECUREC_UCS_BOM_HEADER_BE_1ST 0xfeU
#define SECUREC_UCS_BOM_HEADER_BE_2ST 0xffU
#define SECUREC_UCS_BOM_HEADER_LE_1ST 0xffU
#define SECUREC_UCS_BOM_HEADER_LE_2ST 0xfeU
#define SECUREC_UTF8_BOM_HEADER_SIZE 3U
#define SECUREC_UTF8_BOM_HEADER_1ST 0xefU
#define SECUREC_UTF8_BOM_HEADER_2ND 0xbbU
#define SECUREC_UTF8_BOM_HEADER_3RD 0xbfU
#define SECUREC_UTF8_LEAD_1ST 0xe0U
#define SECUREC_UTF8_LEAD_2ND 0x80U
#define SECUREC_BEGIN_WITH_UCS_BOM(s, len) ((len) >= SECUREC_UCS_BOM_HEADER_SIZE && \
(((unsigned char)((s)[0]) == SECUREC_UCS_BOM_HEADER_LE_1ST && \
(unsigned char)((s)[1]) == SECUREC_UCS_BOM_HEADER_LE_2ST) || \
((unsigned char)((s)[0]) == SECUREC_UCS_BOM_HEADER_BE_1ST && \
(unsigned char)((s)[1]) == SECUREC_UCS_BOM_HEADER_BE_2ST)))
#define SECUREC_BEGIN_WITH_UTF8_BOM(s, len) ((len) >= SECUREC_UTF8_BOM_HEADER_SIZE && \
(unsigned char)((s)[0]) == SECUREC_UTF8_BOM_HEADER_1ST && \
(unsigned char)((s)[1]) == SECUREC_UTF8_BOM_HEADER_2ND && \
(unsigned char)((s)[2]) == SECUREC_UTF8_BOM_HEADER_3RD)
#ifdef SECUREC_FOR_WCHAR
#define SECUREC_BOM_HEADER_SIZE SECUREC_UCS_BOM_HEADER_SIZE
#define SECUREC_BEGIN_WITH_BOM(s, len) SECUREC_BEGIN_WITH_UCS_BOM((s), (len))
#else
#define SECUREC_BOM_HEADER_SIZE SECUREC_UTF8_BOM_HEADER_SIZE
#define SECUREC_BEGIN_WITH_BOM(s, len) SECUREC_BEGIN_WITH_UTF8_BOM((s), (len))
#endif
typedef struct {
unsigned int flag; /* Mark the properties of input stream */
char *base; /* The pointer to the header of buffered string */
const char *cur; /* The pointer to next read position */
size_t count; /* The size of buffered string in bytes */
#if SECUREC_ENABLE_SCANF_FILE
FILE *pf; /* The file pointer */
size_t fileRealRead;
long oriFilePos; /* The original position of file offset when fscanf is called */
#if !SECUREC_USE_STD_UNGETC
unsigned int lastChar; /* The char code of last input */
int fUnGet; /* The boolean flag of pushing a char back to read stream */
#endif
#endif
} SecFileStream;
#if SECUREC_ENABLE_SCANF_FILE && !SECUREC_USE_STD_UNGETC
#define SECUREC_FILE_STREAM_INIT_FILE(stream, fp) do { \
(stream)->pf = (fp); \
(stream)->fileRealRead = 0; \
(stream)->oriFilePos = 0; \
(stream)->lastChar = 0; \
(stream)->fUnGet = 0; \
} SECUREC_WHILE_ZERO
#elif SECUREC_ENABLE_SCANF_FILE && SECUREC_USE_STD_UNGETC
#define SECUREC_FILE_STREAM_INIT_FILE(stream, fp) do { \
(stream)->pf = (fp); \
(stream)->fileRealRead = 0; \
(stream)->oriFilePos = 0; \
} SECUREC_WHILE_ZERO
#else
/* Disable file */
#define SECUREC_FILE_STREAM_INIT_FILE(stream, fp)
#endif
/* This initialization for eliminating redundant initialization. */
#define SECUREC_FILE_STREAM_FROM_STRING(stream, buf, cnt) do { \
(stream)->flag = SECUREC_MEM_STR_FLAG; \
(stream)->base = NULL; \
(stream)->cur = (buf); \
(stream)->count = (cnt); \
SECUREC_FILE_STREAM_INIT_FILE((stream), NULL); \
} SECUREC_WHILE_ZERO
/* This initialization for eliminating redundant initialization. */
#define SECUREC_FILE_STREAM_FROM_FILE(stream, fp) do { \
(stream)->flag = SECUREC_FILE_STREAM_FLAG; \
(stream)->base = NULL; \
(stream)->cur = NULL; \
(stream)->count = 0; \
SECUREC_FILE_STREAM_INIT_FILE((stream), (fp)); \
} SECUREC_WHILE_ZERO
/* This initialization for eliminating redundant initialization. */
#define SECUREC_FILE_STREAM_FROM_STDIN(stream) do { \
(stream)->flag = SECUREC_PIPE_STREAM_FLAG; \
(stream)->base = NULL; \
(stream)->cur = NULL; \
(stream)->count = 0; \
SECUREC_FILE_STREAM_INIT_FILE((stream), SECUREC_STREAM_STDIN); \
} SECUREC_WHILE_ZERO
#ifdef __cplusplus
extern "C" {
#endif
int SecInputS(SecFileStream *stream, const char *cFormat, va_list argList);
void SecClearDestBuf(const char *buffer, const char *format, va_list argList);
#ifdef SECUREC_FOR_WCHAR
int SecInputSW(SecFileStream *stream, const wchar_t *cFormat, va_list argList);
void SecClearDestBufW(const wchar_t *buffer, const wchar_t *format, va_list argList);
#endif
/* 20150105 For software and hardware decoupling,such as UMG */
#ifdef SECUREC_SYSAPI4VXWORKS
#ifdef feof
#undef feof
#endif
extern int feof(FILE *stream);
#endif
#if 1//defined(SECUREC_SYSAPI4VXWORKS) || defined(SECUREC_CTYPE_MACRO_ADAPT)
#ifndef isspace
#define isspace(c) (((c) == ' ') || ((c) == '\t') || ((c) == '\r') || ((c) == '\n'))
#endif
#ifndef iswspace
#define iswspace(c) (((c) == L' ') || ((c) == L'\t') || ((c) == L'\r') || ((c) == L'\n'))
#endif
#ifndef isascii
#define isascii(c) (((unsigned char)(c)) <= 0x7f)
#endif
#ifndef isupper
#define isupper(c) ((c) >= 'A' && (c) <= 'Z')
#endif
#ifndef islower
#define islower(c) ((c) >= 'a' && (c) <= 'z')
#endif
#ifndef isalpha
#define isalpha(c) (isupper(c) || (islower(c)))
#endif
#ifndef isdigit
#define isdigit(c) ((c) >= '0' && (c) <= '9')
#endif
#ifndef isxupper
#define isxupper(c) ((c) >= 'A' && (c) <= 'F')
#endif
#ifndef isxlower
#define isxlower(c) ((c) >= 'a' && (c) <= 'f')
#endif
#ifndef isxdigit
#define isxdigit(c) (isdigit(c) || isxupper(c) || isxlower(c))
#endif
#endif
#ifdef __cplusplus
}
#endif
/* Reserved file operation macro interface, s is FILE *, i is fileno zero. */
#ifndef SECUREC_LOCK_FILE
#define SECUREC_LOCK_FILE(s)
#endif
#ifndef SECUREC_UNLOCK_FILE
#define SECUREC_UNLOCK_FILE(s)
#endif
#ifndef SECUREC_LOCK_STDIN
#define SECUREC_LOCK_STDIN(i, s)
#endif
#ifndef SECUREC_UNLOCK_STDIN
#define SECUREC_UNLOCK_STDIN(i, s)
#endif
#endif
source/bootloader/u-boot-2020.01/lotus/securec/securecutil.c
Executable
+67
View File
@@ -0,0 +1,67 @@
/*
*
*/
/* Avoid duplicate header files,not include securecutil.h */
#include "securecutil.h"
#if defined(ANDROID) && (SECUREC_HAVE_WCTOMB || SECUREC_HAVE_MBTOWC)
#include <wchar.h>
#if SECUREC_HAVE_WCTOMB
/*
* Convert wide characters to narrow multi-bytes
*/
int wctomb(char *s, wchar_t wc)
{
return wcrtomb(s, wc, NULL);
}
#endif
#if SECUREC_HAVE_MBTOWC
/*
* Converting narrow multi-byte characters to wide characters
*/
int mbtowc(wchar_t *pwc, const char *s, size_t n)
{
return mbrtowc(pwc, s, n, NULL);
}
#endif
#endif
/* The V100R001C01 version num is 0x5 (High 8 bits) */
#define SECUREC_C_VERSION 0x500U
#define SECUREC_SPC_VERSION 0xaU
#define SECUREC_VERSION_STR "Secure C V100R001C01SPC010B002"
/*
* Get version string and version number.
* The rules for version number are as follows:
* 1) SPC verNumber<->verStr like:
* 0x201<->C01
* 0x202<->C01SPC001 Redefine numbers after this version
* 0x502<->C01SPC002
* 0x503<->C01SPC003
* ...
* 0X50a<->SPC010
* 0X50b<->SPC011
* ...
* 0x700<->C02
* 0x701<->C01SPC001
* 0x702<->C02SPC002
* ...
* 2) CP verNumber<->verStr like:
* 0X601<->CP0001
* 0X602<->CP0002
* ...
*/
const char *GetHwSecureCVersion(unsigned short *verNumber)
{
if (verNumber != NULL) {
*verNumber = (unsigned short)(SECUREC_C_VERSION | SECUREC_SPC_VERSION);
}
return SECUREC_VERSION_STR;
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(GetHwSecureCVersion);
#endif
source/bootloader/u-boot-2020.01/lotus/securec/securecutil.h
Executable
+547
View File
@@ -0,0 +1,547 @@
/*
*
*/
#ifndef SECURECUTIL_H_46C86578_F8FF_4E49_8E64_9B175241761F
#define SECURECUTIL_H_46C86578_F8FF_4E49_8E64_9B175241761F
#include "linux/lotus/securec.h"
#if (defined(_MSC_VER)) && (_MSC_VER >= 1400)
/* Shield compilation alerts using discarded functions and Constant expression to maximize code compatibility */
#define SECUREC_MASK_MSVC_CRT_WARNING __pragma(warning(push)) \
__pragma(warning(disable : 4996 4127))
#define SECUREC_END_MASK_MSVC_CRT_WARNING __pragma(warning(pop))
#else
#define SECUREC_MASK_MSVC_CRT_WARNING
#define SECUREC_END_MASK_MSVC_CRT_WARNING
#endif
#define SECUREC_WHILE_ZERO SECUREC_MASK_MSVC_CRT_WARNING while (0) SECUREC_END_MASK_MSVC_CRT_WARNING
/* Automatically identify the platform that supports strnlen function, and use this function to improve performance */
#ifndef SECUREC_HAVE_STRNLEN
#if (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 700) || (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200809L)
#if SECUREC_IN_KERNEL
#define SECUREC_HAVE_STRNLEN 0
#else
#if defined(__GLIBC__) && __GLIBC__ >= 2 && defined(__GLIBC_MINOR__) && __GLIBC_MINOR__ >= 10
#define SECUREC_HAVE_STRNLEN 1
#else
#define SECUREC_HAVE_STRNLEN 0
#endif
#endif
#else
#define SECUREC_HAVE_STRNLEN 0
#endif
#endif
#if SECUREC_IN_KERNEL
/* In kernel disbale functions */
#ifndef SECUREC_ENABLE_SCANF_FILE
#define SECUREC_ENABLE_SCANF_FILE 0
#endif
#ifndef SECUREC_ENABLE_SCANF_FLOAT
#define SECUREC_ENABLE_SCANF_FLOAT 0
#endif
#ifndef SECUREC_ENABLE_SPRINTF_FLOAT
#define SECUREC_ENABLE_SPRINTF_FLOAT 0
#endif
#ifndef SECUREC_HAVE_MBTOWC
#define SECUREC_HAVE_MBTOWC 0
#endif
#ifndef SECUREC_HAVE_WCTOMB
#define SECUREC_HAVE_WCTOMB 0
#endif
#ifndef SECUREC_HAVE_WCHART
#define SECUREC_HAVE_WCHART 0
#endif
#else /* Not in kernel */
/* Systems that do not support file, can define this macro to 0. */
#ifndef SECUREC_ENABLE_SCANF_FILE
#define SECUREC_ENABLE_SCANF_FILE 1
#endif
#ifndef SECUREC_ENABLE_SCANF_FLOAT
#define SECUREC_ENABLE_SCANF_FLOAT 0
#endif
/* Systems that do not support float, can define this macro to 0. */
#ifndef SECUREC_ENABLE_SPRINTF_FLOAT
#define SECUREC_ENABLE_SPRINTF_FLOAT 1
#endif
#ifndef SECUREC_HAVE_MBTOWC
#define SECUREC_HAVE_MBTOWC 0
#endif
#ifndef SECUREC_HAVE_WCTOMB
#define SECUREC_HAVE_WCTOMB 0
#endif
#ifndef SECUREC_HAVE_WCHART
#define SECUREC_HAVE_WCHART 1
#endif
#endif
#ifndef SECUREC_USE_STD_UNGETC
#define SECUREC_USE_STD_UNGETC 1
#endif
#ifndef SECUREC_ENABLE_INLINE
#define SECUREC_ENABLE_INLINE 0
#endif
#ifndef SECUREC_INLINE
#if SECUREC_ENABLE_INLINE
#define SECUREC_INLINE static inline
#else
#define SECUREC_INLINE static
#endif
#endif
#ifndef SECUREC_WARP_OUTPUT
#if SECUREC_IN_KERNEL
#define SECUREC_WARP_OUTPUT 1
#else
#define SECUREC_WARP_OUTPUT 0
#endif
#endif
#ifndef SECUREC_STREAM_STDIN
#define SECUREC_STREAM_STDIN stdin
#endif
#define SECUREC_MUL_SIXTEEN(x) ((x) << 4U)
#define SECUREC_MUL_EIGHT(x) ((x) << 3U)
#define SECUREC_MUL_TEN(x) ((((x) << 2U) + (x)) << 1U)
/* Limited format input and output width, use signed integer */
#define SECUREC_MAX_WIDTH_LEN_DIV_TEN 21474836
#define SECUREC_MAX_WIDTH_LEN (SECUREC_MAX_WIDTH_LEN_DIV_TEN * 10)
/* Is the x multiplied by 10 greater than */
#define SECUREC_MUL_TEN_ADD_BEYOND_MAX(x) (((x) > SECUREC_MAX_WIDTH_LEN_DIV_TEN))
#define SECUREC_FLOAT_BUFSIZE (309 + 40) /* Max length of double value */
#define SECUREC_FLOAT_BUFSIZE_LB (4932 + 40) /* Max length of long double value */
#define SECUREC_FLOAT_DEFAULT_PRECISION 6
/* This macro does not handle pointer equality or integer overflow */
#define SECUREC_MEMORY_NO_OVERLAP(dest, src, count) \
(((src) < (dest) && ((const char *)(src) + (count)) <= (char *)(dest)) || \
((dest) < (src) && ((char *)(dest) + (count)) <= (const char *)(src)))
#define SECUREC_MEMORY_IS_OVERLAP(dest, src, count) \
(((src) < (dest) && ((const char *)(src) + (count)) > (char *)(dest)) || \
((dest) < (src) && ((char *)(dest) + (count)) > (const char *)(src)))
/*
* Check whether the strings overlap, len is the length of the string not include terminator
* Length is related to data type char or wchar , do not force conversion of types
*/
#define SECUREC_STRING_NO_OVERLAP(dest, src, len) \
(((src) < (dest) && ((src) + (len)) < (dest)) || \
((dest) < (src) && ((dest) + (len)) < (src)))
/*
* Check whether the strings overlap for strcpy wcscpy function, dest len and src Len are not include terminator
* Length is related to data type char or wchar , do not force conversion of types
*/
#define SECUREC_STRING_IS_OVERLAP(dest, src, len) \
(((src) < (dest) && ((src) + (len)) >= (dest)) || \
((dest) < (src) && ((dest) + (len)) >= (src)))
/*
* Check whether the strings overlap for strcat wcscat function, dest len and src Len are not include terminator
* Length is related to data type char or wchar , do not force conversion of types
*/
#define SECUREC_CAT_STRING_IS_OVERLAP(dest, destLen, src, srcLen) \
(((dest) < (src) && ((dest) + (destLen) + (srcLen)) >= (src)) || \
((src) < (dest) && ((src) + (srcLen)) >= (dest)))
#if SECUREC_HAVE_STRNLEN
#define SECUREC_CALC_STR_LEN(str, maxLen, outLen) do { \
*(outLen) = strnlen((str), (maxLen)); \
} SECUREC_WHILE_ZERO
#define SECUREC_CALC_STR_LEN_OPT(str, maxLen, outLen) do { \
if ((maxLen) > 8) { \
/* Optimization or len less then 8 */ \
if (*((str) + 0) == '\0') { \
*(outLen) = 0; \
} else if (*((str) + 1) == '\0') { \
*(outLen) = 1; \
} else if (*((str) + 2) == '\0') { \
*(outLen) = 2; \
} else if (*((str) + 3) == '\0') { \
*(outLen) = 3; \
} else if (*((str) + 4) == '\0') { \
*(outLen) = 4; \
} else if (*((str) + 5) == '\0') { \
*(outLen) = 5; \
} else if (*((str) + 6) == '\0') { \
*(outLen) = 6; \
} else if (*((str) + 7) == '\0') { \
*(outLen) = 7; \
} else if (*((str) + 8) == '\0') { \
/* Optimization with a length of 8 */ \
*(outLen) = 8; \
} else { \
/* The offset is 8 because the performance of 8 byte alignment is high */ \
*(outLen) = 8 + strnlen((str) + 8, (maxLen) - 8); \
} \
} else { \
SECUREC_CALC_STR_LEN((str), (maxLen), (outLen)); \
} \
} SECUREC_WHILE_ZERO
#else
#define SECUREC_CALC_STR_LEN(str, maxLen, outLen) do { \
const char *strEnd_ = (const char *)(str); \
size_t availableSize_ = (size_t)(maxLen); \
while (availableSize_ > 0 && *strEnd_ != '\0') { \
--availableSize_; \
++strEnd_; \
} \
*(outLen) = (size_t)(strEnd_ - (str)); \
} SECUREC_WHILE_ZERO
#define SECUREC_CALC_STR_LEN_OPT SECUREC_CALC_STR_LEN
#endif
#define SECUREC_CALC_WSTR_LEN(str, maxLen, outLen) do { \
const wchar_t *strEnd_ = (const wchar_t *)(str); \
size_t len_ = 0; \
while (len_ < (maxLen) && *strEnd_ != L'\0') { \
++len_; \
++strEnd_; \
} \
*(outLen) = len_; \
} SECUREC_WHILE_ZERO
/*
* Performance optimization, product may disable inline function.
* Using function pointer for MEMSET to prevent compiler optimization when cleaning up memory.
*/
#ifdef SECUREC_USE_ASM
#define SECUREC_MEMSET_FUNC_OPT memset_opt
#define SECUREC_MEMCPY_FUNC_OPT memcpy_opt
#else
#define SECUREC_MEMSET_FUNC_OPT memset
#define SECUREC_MEMCPY_FUNC_OPT memcpy
#endif
#define SECUREC_MEMCPY_WARP_OPT(dest, src, count) (void)SECUREC_MEMCPY_FUNC_OPT((dest), (src), (count))
#ifndef SECUREC_MEMSET_INDIRECT_USE
/* Can be turned off for scenarios that do not allow pointer calls */
#define SECUREC_MEMSET_INDIRECT_USE 1
#endif
#if SECUREC_MEMSET_INDIRECT_USE
#define SECUREC_MEMSET_WARP_OPT(dest, value, count) do { \
void *(* const volatile fn_)(void *s_, int c_, size_t n_) = SECUREC_MEMSET_FUNC_OPT; \
(void)(*fn_)((dest), (value), (count)); \
} SECUREC_WHILE_ZERO
#else
#define SECUREC_MEMSET_WARP_OPT(dest, value, count) (void)SECUREC_MEMSET_FUNC_OPT((dest), (value), (count))
#endif
#ifdef SECUREC_FORMAT_OUTPUT_INPUT
#if defined(SECUREC_COMPATIBLE_WIN_FORMAT) || defined(__ARMCC_VERSION)
typedef __int64 SecInt64;
typedef unsigned __int64 SecUnsignedInt64;
#if defined(__ARMCC_VERSION)
typedef unsigned int SecUnsignedInt32;
#else
typedef unsigned __int32 SecUnsignedInt32;
#endif
#else
typedef unsigned int SecUnsignedInt32;
typedef long long SecInt64;
typedef unsigned long long SecUnsignedInt64;
#endif
#ifdef SECUREC_FOR_WCHAR
#if 1//defined(SECUREC_VXWORKS_PLATFORM) && !defined(__WINT_TYPE__)
typedef wchar_t wint_t;
#endif
#ifndef WEOF
#define WEOF ((wchar_t)(-1))
#endif
#define SECUREC_CHAR(x) L ## x
typedef wchar_t SecChar;
typedef wchar_t SecUnsignedChar;
typedef wint_t SecInt;
typedef wint_t SecUnsignedInt;
#else /* no SECUREC_FOR_WCHAR */
#define SECUREC_CHAR(x) (x)
typedef char SecChar;
typedef unsigned char SecUnsignedChar;
typedef int SecInt;
typedef unsigned int SecUnsignedInt;
#endif
#endif
/*
* Determine whether the address is 8-byte aligned
* Some systems do not have uintptr_t type, so use NULL to clear tool alarm 507
*/
#define SECUREC_ADDR_ALIGNED_8(addr) ((((size_t)(addr)) & 7U) == 0) /* Use 7 to check aligned 8 */
/*
* If you define the memory allocation function, you need to define the function prototype.
* You can define this macro as a header file.
*/
#if defined(SECUREC_MALLOC_PROTOTYPE)
SECUREC_MALLOC_PROTOTYPE
#endif
#ifndef SECUREC_MALLOC
#define SECUREC_MALLOC(x) malloc((size_t)(x))
#endif
#ifndef SECUREC_FREE
#define SECUREC_FREE(x) free((void *)(x))
#endif
/* Improve performance with struct assignment, buf1 is not defined to avoid tool false positive */
#define SECUREC_COPY_VALUE_BY_STRUCT(dest, src, n) do { \
*(SecStrBuf##n *)(void *)(dest) = *(const SecStrBuf##n *)(const void *)(src); \
} SECUREC_WHILE_ZERO
typedef struct {
unsigned char buf[2]; /* Performance optimization code structure assignment length 2 bytes */
} SecStrBuf2;
typedef struct {
unsigned char buf[3]; /* Performance optimization code structure assignment length 3 bytes */
} SecStrBuf3;
typedef struct {
unsigned char buf[4]; /* Performance optimization code structure assignment length 4 bytes */
} SecStrBuf4;
typedef struct {
unsigned char buf[5]; /* Performance optimization code structure assignment length 5 bytes */
} SecStrBuf5;
typedef struct {
unsigned char buf[6]; /* Performance optimization code structure assignment length 6 bytes */
} SecStrBuf6;
typedef struct {
unsigned char buf[7]; /* Performance optimization code structure assignment length 7 bytes */
} SecStrBuf7;
typedef struct {
unsigned char buf[8]; /* Performance optimization code structure assignment length 8 bytes */
} SecStrBuf8;
typedef struct {
unsigned char buf[9]; /* Performance optimization code structure assignment length 9 bytes */
} SecStrBuf9;
typedef struct {
unsigned char buf[10]; /* Performance optimization code structure assignment length 10 bytes */
} SecStrBuf10;
typedef struct {
unsigned char buf[11]; /* Performance optimization code structure assignment length 11 bytes */
} SecStrBuf11;
typedef struct {
unsigned char buf[12]; /* Performance optimization code structure assignment length 12 bytes */
} SecStrBuf12;
typedef struct {
unsigned char buf[13]; /* Performance optimization code structure assignment length 13 bytes */
} SecStrBuf13;
typedef struct {
unsigned char buf[14]; /* Performance optimization code structure assignment length 14 bytes */
} SecStrBuf14;
typedef struct {
unsigned char buf[15]; /* Performance optimization code structure assignment length 15 bytes */
} SecStrBuf15;
typedef struct {
unsigned char buf[16]; /* Performance optimization code structure assignment length 16 bytes */
} SecStrBuf16;
typedef struct {
unsigned char buf[17]; /* Performance optimization code structure assignment length 17 bytes */
} SecStrBuf17;
typedef struct {
unsigned char buf[18]; /* Performance optimization code structure assignment length 18 bytes */
} SecStrBuf18;
typedef struct {
unsigned char buf[19]; /* Performance optimization code structure assignment length 19 bytes */
} SecStrBuf19;
typedef struct {
unsigned char buf[20]; /* Performance optimization code structure assignment length 20 bytes */
} SecStrBuf20;
typedef struct {
unsigned char buf[21]; /* Performance optimization code structure assignment length 21 bytes */
} SecStrBuf21;
typedef struct {
unsigned char buf[22]; /* Performance optimization code structure assignment length 22 bytes */
} SecStrBuf22;
typedef struct {
unsigned char buf[23]; /* Performance optimization code structure assignment length 23 bytes */
} SecStrBuf23;
typedef struct {
unsigned char buf[24]; /* Performance optimization code structure assignment length 24 bytes */
} SecStrBuf24;
typedef struct {
unsigned char buf[25]; /* Performance optimization code structure assignment length 25 bytes */
} SecStrBuf25;
typedef struct {
unsigned char buf[26]; /* Performance optimization code structure assignment length 26 bytes */
} SecStrBuf26;
typedef struct {
unsigned char buf[27]; /* Performance optimization code structure assignment length 27 bytes */
} SecStrBuf27;
typedef struct {
unsigned char buf[28]; /* Performance optimization code structure assignment length 28 bytes */
} SecStrBuf28;
typedef struct {
unsigned char buf[29]; /* Performance optimization code structure assignment length 29 bytes */
} SecStrBuf29;
typedef struct {
unsigned char buf[30]; /* Performance optimization code structure assignment length 30 bytes */
} SecStrBuf30;
typedef struct {
unsigned char buf[31]; /* Performance optimization code structure assignment length 31 bytes */
} SecStrBuf31;
typedef struct {
unsigned char buf[32]; /* Performance optimization code structure assignment length 32 bytes */
} SecStrBuf32;
typedef struct {
unsigned char buf[33]; /* Performance optimization code structure assignment length 33 bytes */
} SecStrBuf33;
typedef struct {
unsigned char buf[34]; /* Performance optimization code structure assignment length 34 bytes */
} SecStrBuf34;
typedef struct {
unsigned char buf[35]; /* Performance optimization code structure assignment length 35 bytes */
} SecStrBuf35;
typedef struct {
unsigned char buf[36]; /* Performance optimization code structure assignment length 36 bytes */
} SecStrBuf36;
typedef struct {
unsigned char buf[37]; /* Performance optimization code structure assignment length 37 bytes */
} SecStrBuf37;
typedef struct {
unsigned char buf[38]; /* Performance optimization code structure assignment length 38 bytes */
} SecStrBuf38;
typedef struct {
unsigned char buf[39]; /* Performance optimization code structure assignment length 39 bytes */
} SecStrBuf39;
typedef struct {
unsigned char buf[40]; /* Performance optimization code structure assignment length 40 bytes */
} SecStrBuf40;
typedef struct {
unsigned char buf[41]; /* Performance optimization code structure assignment length 41 bytes */
} SecStrBuf41;
typedef struct {
unsigned char buf[42]; /* Performance optimization code structure assignment length 42 bytes */
} SecStrBuf42;
typedef struct {
unsigned char buf[43]; /* Performance optimization code structure assignment length 43 bytes */
} SecStrBuf43;
typedef struct {
unsigned char buf[44]; /* Performance optimization code structure assignment length 44 bytes */
} SecStrBuf44;
typedef struct {
unsigned char buf[45]; /* Performance optimization code structure assignment length 45 bytes */
} SecStrBuf45;
typedef struct {
unsigned char buf[46]; /* Performance optimization code structure assignment length 46 bytes */
} SecStrBuf46;
typedef struct {
unsigned char buf[47]; /* Performance optimization code structure assignment length 47 bytes */
} SecStrBuf47;
typedef struct {
unsigned char buf[48]; /* Performance optimization code structure assignment length 48 bytes */
} SecStrBuf48;
typedef struct {
unsigned char buf[49]; /* Performance optimization code structure assignment length 49 bytes */
} SecStrBuf49;
typedef struct {
unsigned char buf[50]; /* Performance optimization code structure assignment length 50 bytes */
} SecStrBuf50;
typedef struct {
unsigned char buf[51]; /* Performance optimization code structure assignment length 51 bytes */
} SecStrBuf51;
typedef struct {
unsigned char buf[52]; /* Performance optimization code structure assignment length 52 bytes */
} SecStrBuf52;
typedef struct {
unsigned char buf[53]; /* Performance optimization code structure assignment length 53 bytes */
} SecStrBuf53;
typedef struct {
unsigned char buf[54]; /* Performance optimization code structure assignment length 54 bytes */
} SecStrBuf54;
typedef struct {
unsigned char buf[55]; /* Performance optimization code structure assignment length 55 bytes */
} SecStrBuf55;
typedef struct {
unsigned char buf[56]; /* Performance optimization code structure assignment length 56 bytes */
} SecStrBuf56;
typedef struct {
unsigned char buf[57]; /* Performance optimization code structure assignment length 57 bytes */
} SecStrBuf57;
typedef struct {
unsigned char buf[58]; /* Performance optimization code structure assignment length 58 bytes */
} SecStrBuf58;
typedef struct {
unsigned char buf[59]; /* Performance optimization code structure assignment length 59 bytes */
} SecStrBuf59;
typedef struct {
unsigned char buf[60]; /* Performance optimization code structure assignment length 60 bytes */
} SecStrBuf60;
typedef struct {
unsigned char buf[61]; /* Performance optimization code structure assignment length 61 bytes */
} SecStrBuf61;
typedef struct {
unsigned char buf[62]; /* Performance optimization code structure assignment length 62 bytes */
} SecStrBuf62;
typedef struct {
unsigned char buf[63]; /* Performance optimization code structure assignment length 63 bytes */
} SecStrBuf63;
typedef struct {
unsigned char buf[64]; /* Performance optimization code structure assignment length 64 bytes */
} SecStrBuf64;
/*
* User can change the error handler by modify the following definition,
* such as logging the detail error in file.
*/
#if defined(_DEBUG) || defined(DEBUG)
#if defined(SECUREC_ERROR_HANDLER_BY_ASSERT)
#define SECUREC_ERROR_INVALID_PARAMTER(msg) assert(msg "invalid argument" == NULL)
#define SECUREC_ERROR_INVALID_RANGE(msg) assert(msg "invalid dest buffer size" == NULL)
#define SECUREC_ERROR_BUFFER_OVERLAP(msg) assert(msg "buffer overlap" == NULL)
#elif defined(SECUREC_ERROR_HANDLER_BY_PRINTF)
#if SECUREC_IN_KERNEL
#define SECUREC_ERROR_INVALID_PARAMTER(msg) printk("%s invalid argument\n", msg)
#define SECUREC_ERROR_INVALID_RANGE(msg) printk("%s invalid dest buffer size\n", msg)
#define SECUREC_ERROR_BUFFER_OVERLAP(msg) printk("%s buffer overlap\n", msg)
#else
#define SECUREC_ERROR_INVALID_PARAMTER(msg) printf("%s invalid argument\n", msg)
#define SECUREC_ERROR_INVALID_RANGE(msg) printf("%s invalid dest buffer size\n", msg)
#define SECUREC_ERROR_BUFFER_OVERLAP(msg) printf("%s buffer overlap\n", msg)
#endif
#elif defined(SECUREC_ERROR_HANDLER_BY_FILE_LOG)
#define SECUREC_ERROR_INVALID_PARAMTER(msg) LogSecureCRuntimeError(msg " EINVAL\n")
#define SECUREC_ERROR_INVALID_RANGE(msg) LogSecureCRuntimeError(msg " ERANGE\n")
#define SECUREC_ERROR_BUFFER_OVERLAP(msg) LogSecureCRuntimeError(msg " EOVERLAP\n")
#endif
#endif
/* Default handler is none */
#ifndef SECUREC_ERROR_INVALID_PARAMTER
#define SECUREC_ERROR_INVALID_PARAMTER(msg)
#endif
#ifndef SECUREC_ERROR_INVALID_RANGE
#define SECUREC_ERROR_INVALID_RANGE(msg)
#endif
#ifndef SECUREC_ERROR_BUFFER_OVERLAP
#define SECUREC_ERROR_BUFFER_OVERLAP(msg)
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Assembly language memory copy and memory set for X86 or MIPS ... */
#ifdef SECUREC_USE_ASM
void *memcpy_opt(void *dest, const void *src, size_t n);
void *memset_opt(void *s, int c, size_t n);
#endif
#if defined(SECUREC_ERROR_HANDLER_BY_FILE_LOG)
void LogSecureCRuntimeError(const char *errDetail);
#endif
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif
source/bootloader/u-boot-2020.01/lotus/securec/secureinput_a.c
Executable
+27
View File
@@ -0,0 +1,27 @@
/*
*
*/
#define SECUREC_FORMAT_OUTPUT_INPUT 1
#ifdef SECUREC_FOR_WCHAR
#undef SECUREC_FOR_WCHAR
#endif
#include "secinput.h"
#include "input.inl"
SECUREC_INLINE int SecIsDigit(SecInt ch)
{
/* SecInt to unsigned char clear 571, use bit mask to clear negative return of ch */
return isdigit((int)((unsigned int)(unsigned char)(ch) & 0xffU));
}
SECUREC_INLINE int SecIsXdigit(SecInt ch)
{
return isxdigit((int)((unsigned int)(unsigned char)(ch) & 0xffU));
}
SECUREC_INLINE int SecIsSpace(SecInt ch)
{
return isspace((int)((unsigned int)(unsigned char)(ch) & 0xffU));
}
source/bootloader/u-boot-2020.01/lotus/securec/secureinput_w.c
Executable
+65
View File
@@ -0,0 +1,65 @@
/*
*
*/
/* If some platforms don't have wchar.h, dont't include it */
#if !(defined(SECUREC_VXWORKS_PLATFORM))
/* If there is no macro below, it will cause vs2010 compiling alarm */
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
#ifndef __STDC_WANT_SECURE_LIB__
/* The order of adjustment is to eliminate alarm of Duplicate Block */
#define __STDC_WANT_SECURE_LIB__ 0
#endif
#ifndef _CRTIMP_ALTERNATIVE
#define _CRTIMP_ALTERNATIVE /* Comment microsoft *_s function */
#endif
#endif
//#include <wchar.h>
#endif
/* Disable wchar func to clear vs warning */
#define SECUREC_ENABLE_WCHAR_FUNC 0
#define SECUREC_FORMAT_OUTPUT_INPUT 1
#ifndef SECUREC_FOR_WCHAR
#define SECUREC_FOR_WCHAR
#endif
#include "secinput.h"
#include "input.inl"
SECUREC_INLINE unsigned int SecWcharHighBits(SecInt ch)
{
/* Convert int to unsigned int clear 571 */
return ((unsigned int)(int)ch & (~0xffU));
}
SECUREC_INLINE unsigned char SecWcharLowByte(SecInt ch)
{
/* Convert int to unsigned int clear 571 */
return (unsigned char)((unsigned int)(int)ch & 0xffU);
}
SECUREC_INLINE int SecIsDigit(SecInt ch)
{
if (SecWcharHighBits(ch) != 0) {
return 0; /* Same as isdigit */
}
return isdigit((int)SecWcharLowByte(ch));
}
SECUREC_INLINE int SecIsXdigit(SecInt ch)
{
if (SecWcharHighBits(ch) != 0) {
return 0; /* Same as isxdigit */
}
return isxdigit((int)SecWcharLowByte(ch));
}
SECUREC_INLINE int SecIsSpace(SecInt ch)
{
return iswspace((wint_t)(int)(ch));
}
source/bootloader/u-boot-2020.01/lotus/securec/secureprintoutput.h
Executable
+111
View File
@@ -0,0 +1,111 @@
/*
*
*/
#ifndef SECUREPRINTOUTPUT_H_E950DA2C_902F_4B15_BECD_948E99090D9C
#define SECUREPRINTOUTPUT_H_E950DA2C_902F_4B15_BECD_948E99090D9C
#include "securecutil.h"
/*
* Flag definitions.
* Using macros instead of enumerations is because some of the enumerated types under the compiler are 16bit.
*/
#define SECUREC_FLAG_SIGN 0x00001U
#define SECUREC_FLAG_SIGN_SPACE 0x00002U
#define SECUREC_FLAG_LEFT 0x00004U
#define SECUREC_FLAG_LEADZERO 0x00008U
#define SECUREC_FLAG_LONG 0x00010U
#define SECUREC_FLAG_SHORT 0x00020U
#define SECUREC_FLAG_SIGNED 0x00040U
#define SECUREC_FLAG_ALTERNATE 0x00080U
#define SECUREC_FLAG_NEGATIVE 0x00100U
#define SECUREC_FLAG_FORCE_OCTAL 0x00200U
#define SECUREC_FLAG_LONG_DOUBLE 0x00400U
#define SECUREC_FLAG_WIDECHAR 0x00800U
#define SECUREC_FLAG_LONGLONG 0x01000U
#define SECUREC_FLAG_CHAR 0x02000U
#define SECUREC_FLAG_POINTER 0x04000U
#define SECUREC_FLAG_I64 0x08000U
#define SECUREC_FLAG_PTRDIFF 0x10000U
#define SECUREC_FLAG_SIZE 0x20000U
#ifdef SECUREC_COMPATIBLE_LINUX_FORMAT
#define SECUREC_FLAG_INTMAX 0x40000U
#endif
/* State definitions. Identify the status of the current format */
typedef enum {
STAT_NORMAL,
STAT_PERCENT,
STAT_FLAG,
STAT_WIDTH,
STAT_DOT,
STAT_PRECIS,
STAT_SIZE,
STAT_TYPE,
STAT_INVALID
} SecFmtState;
/* Format output buffer pointer and available size */
typedef struct {
int count;
char *cur;
} SecPrintfStream;
#ifndef SECUREC_BUFFER_SIZE
#if SECUREC_IN_KERNEL
#define SECUREC_BUFFER_SIZE 32
#elif defined(SECUREC_STACK_SIZE_LESS_THAN_1K)
/*
* SECUREC BUFFER SIZE Can not be less than 23
* The length of the octal representation of 64-bit integers with zero lead
*/
#define SECUREC_BUFFER_SIZE 256
#else
#define SECUREC_BUFFER_SIZE 512
#endif
#endif
#if SECUREC_BUFFER_SIZE < 23
#error SECUREC_BUFFER_SIZE Can not be less than 23
#endif
/* Buffer size for wchar, use 4 to make the compiler aligns as 8 bytes as possible */
#define SECUREC_WCHAR_BUFFER_SIZE 4
#define SECUREC_MAX_PRECISION SECUREC_BUFFER_SIZE
/* Max. # bytes in multibyte char ,see MB_LEN_MAX */
#define SECUREC_MB_LEN 16
/* The return value of the internal function, which is returned when truncated */
#define SECUREC_PRINTF_TRUNCATE (-2)
#define SECUREC_VSPRINTF_PARAM_ERROR(format, strDest, destMax, maxLimit) \
((format) == NULL || (strDest) == NULL || (destMax) == 0 || (destMax) > (maxLimit))
#define SECUREC_VSPRINTF_CLEAR_DEST(strDest, destMax, maxLimit) do { \
if ((strDest) != NULL && (destMax) > 0 && (destMax) <= (maxLimit)) { \
*(strDest) = '\0'; \
} \
} SECUREC_WHILE_ZERO
#ifdef SECUREC_COMPATIBLE_WIN_FORMAT
#define SECUREC_VSNPRINTF_PARAM_ERROR(format, strDest, destMax, count, maxLimit) \
(((format) == NULL || (strDest) == NULL || (destMax) == 0 || (destMax) > (maxLimit)) || \
((count) > (SECUREC_STRING_MAX_LEN - 1) && (count) != (size_t)(-1)))
#else
#define SECUREC_VSNPRINTF_PARAM_ERROR(format, strDest, destMax, count, maxLimit) \
(((format) == NULL || (strDest) == NULL || (destMax) == 0 || (destMax) > (maxLimit)) || \
((count) > (SECUREC_STRING_MAX_LEN - 1)))
#endif
#ifdef __cplusplus
extern "C" {
#endif
int SecVsnprintfImpl(char *string, size_t count, const char *format, va_list argList);
#ifdef SECUREC_FOR_WCHAR
int SecVswprintfImpl(wchar_t *string, size_t sizeInWchar, const wchar_t *format, va_list argList);
#endif
#ifdef __cplusplus
}
#endif
#endif
source/bootloader/u-boot-2020.01/lotus/securec/secureprintoutput_a.c
Executable
+163
View File
@@ -0,0 +1,163 @@
/*
*
*/
#define SECUREC_FORMAT_OUTPUT_INPUT 1
#ifdef SECUREC_FOR_WCHAR
#undef SECUREC_FOR_WCHAR
#endif
#include <vsprintf.h>
#include "secureprintoutput.h"
#if SECUREC_WARP_OUTPUT
#define SECUREC_FORMAT_FLAG_TABLE_SIZE 128
SECUREC_INLINE const char *SecSkipKnownFlags(const char *format)
{
static const unsigned char flagTable[SECUREC_FORMAT_FLAG_TABLE_SIZE] = {
/*
* Known flag is "0123456789 +-#hlLwZzjqt*I$"
*/
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00,
0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00
};
const char *fmt = format;
while (*fmt != '\0') {
char fmtChar = *fmt;
if ((unsigned char)fmtChar > 0x7f) { /* 0x7f is upper limit of format char value */
break;
}
if (flagTable[(unsigned char)fmtChar] == 0) {
break;
}
++fmt;
}
return fmt;
}
SECUREC_INLINE int SecFormatContainN(const char *format)
{
const char *fmt = format;
while (*fmt != '\0') {
++fmt;
/* Skip normal char */
if (*(fmt - 1) != '%') {
continue;
}
/* Meet %% */
if (*fmt == '%') {
++fmt; /* Point to the character after the %. Correct handling %%xx */
continue;
}
/* Now parse %..., fmt point to the character after the % */
fmt = SecSkipKnownFlags(fmt);
if (*fmt == 'n') {
return 1;
}
}
return 0;
}
/*
* Multi character formatted output implementation, the count include \0 character, must be greater than zero
*/
int SecVsnprintfImpl(char *string, size_t count, const char *format, va_list argList)
{
int retVal;
if (SecFormatContainN(format) != 0) {
string[0] = '\0';
return -1;
}
retVal = vsnprintf(string, count, format, argList);
if (retVal >= (int)count) { /* The size_t to int is ok, count max is SECUREC_STRING_MAX_LEN */
/* The buffer was too small; we return truncation */
string[count - 1] = '\0';
return SECUREC_PRINTF_TRUNCATE;
}
if (retVal < 0) {
string[0] = '\0'; /* Empty the dest strDest */
return -1;
}
return retVal;
}
#else
#if SECUREC_IN_KERNEL
#include <linux/ctype.h>
#endif
#ifndef EOF
#define EOF (-1)
#endif
#include "output.inl"
/*
* Multi character formatted output implementation
*/
int SecVsnprintfImpl(char *string, size_t count, const char *format, va_list argList)
{
SecPrintfStream str;
int retVal;
str.count = (int)count; /* The count include \0 character, must be greater than zero */
str.cur = string;
retVal = SecOutputS(&str, format, argList);
if (retVal >= 0) {
if (SecPutZeroChar(&str) == 0) {
return retVal;
}
}
if (str.count < 0) {
/* The buffer was too small, then truncate */
string[count - 1] = '\0';
return SECUREC_PRINTF_TRUNCATE;
}
string[0] = '\0'; /* Empty the dest string */
return -1;
}
/*
* Write a wide character
*/
SECUREC_INLINE void SecWriteMultiChar(char ch, int num, SecPrintfStream *f, int *pnumwritten)
{
int count;
for (count = num; count > 0; --count) {
--f->count; /* f -> count may be negative,indicating insufficient space */
if (f->count < 0) {
*pnumwritten = -1;
return;
}
*(f->cur) = ch;
++f->cur;
*pnumwritten = *pnumwritten + 1;
}
}
/*
* Write string function, where this function is called, make sure that len is greater than 0
*/
SECUREC_INLINE void SecWriteString(const char *string, int len, SecPrintfStream *f, int *pnumwritten)
{
const char *str = string;
int count;
for (count = len; count > 0; --count) {
--f->count; /* f -> count may be negative,indicating insufficient space */
if (f->count < 0) {
*pnumwritten = -1;
return;
}
*(f->cur) = *str;
++f->cur;
++str;
}
*pnumwritten = *pnumwritten + (int)(size_t)(str - string);
}
#endif
source/bootloader/u-boot-2020.01/lotus/securec/secureprintoutput_w.c
Executable
+136
View File
@@ -0,0 +1,136 @@
/*
*
*/
/* If some platforms don't have wchar.h, dont't include it */
#if !(defined(SECUREC_VXWORKS_PLATFORM))
/* If there is no macro above, it will cause compiling alarm */
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
#ifndef _CRTIMP_ALTERNATIVE
#define _CRTIMP_ALTERNATIVE /* Comment microsoft *_s function */
#endif
#ifndef __STDC_WANT_SECURE_LIB__
#define __STDC_WANT_SECURE_LIB__ 0
#endif
#endif
//#include <wchar.h>
#include <vsprintf.h>
#endif
/* Disable wchar func to clear vs warning */
#define SECUREC_ENABLE_WCHAR_FUNC 0
#define SECUREC_FORMAT_OUTPUT_INPUT 1
#ifndef SECUREC_FOR_WCHAR
#define SECUREC_FOR_WCHAR
#endif
#if defined(SECUREC_WARP_OUTPUT) && SECUREC_WARP_OUTPUT
#undef SECUREC_WARP_OUTPUT
#define SECUREC_WARP_OUTPUT 0
#endif
#include "secureprintoutput.h"
SECUREC_INLINE void SecWriteCharW(wchar_t ch, SecPrintfStream *f, int *pnumwritten);
SECUREC_INLINE int SecPutWcharStrEndingZero(SecPrintfStream *str, int zeroCount);
#include "output.inl"
/*
* Wide character formatted output implementation
*/
int SecVswprintfImpl(wchar_t *string, size_t sizeInWchar, const wchar_t *format, va_list argList)
{
SecPrintfStream str;
int retVal; /* If initialization causes e838 */
str.cur = (char *)string;
/* This count include \0 character, Must be greater than zero */
str.count = (int)(sizeInWchar * sizeof(wchar_t));
retVal = SecOutputSW(&str, format, argList);
if (retVal >= 0) {
if (SecPutWcharStrEndingZero(&str, (int)sizeof(wchar_t)) == 0) {
return retVal;
}
}
if (str.count < 0) {
/* The buffer was too small, then truncate */
string[sizeInWchar - 1] = L'\0';
return SECUREC_PRINTF_TRUNCATE;
}
string[0] = L'\0'; /* Empty the dest string */
return -1;
}
/*
* Output a wide character zero end into the SecPrintfStream structure
*/
SECUREC_INLINE int SecPutWcharStrEndingZero(SecPrintfStream *str, int zeroCount)
{
int count;
for (count = zeroCount; count > 0; --count) {
if (SecPutZeroChar(str) != 0) {
return -1;
}
}
return 0;
}
/*
* Output a wide character into the SecPrintfStream structure
*/
SECUREC_INLINE int SecPutCharW(wchar_t ch, SecPrintfStream *f)
{
f->count -= (int)sizeof(wchar_t); /* f -> count may be negative,indicating insufficient space */
if (f->count >= 0) {
*(wchar_t *)(void *)(f->cur) = ch;
f->cur += sizeof(wchar_t);
return 0;
}
return -1;
}
/*
* Output a wide character into the SecPrintfStream structure, returns the number of characters written
*/
SECUREC_INLINE void SecWriteCharW(wchar_t ch, SecPrintfStream *f, int *pnumwritten)
{
if (SecPutCharW(ch, f) == 0) {
*pnumwritten = *pnumwritten + 1;
} else {
*pnumwritten = -1;
}
}
/*
* Output multiple wide character into the SecPrintfStream structure, returns the number of characters written
*/
SECUREC_INLINE void SecWriteMultiCharW(wchar_t ch, int num, SecPrintfStream *f, int *pnumwritten)
{
int count;
for (count = num; count > 0; --count) {
SecWriteCharW(ch, f, pnumwritten);
if (*pnumwritten == -1) {
break;
}
}
}
/*
* Output a wide string into the SecPrintfStream structure, returns the number of characters written
*/
SECUREC_INLINE void SecWriteStringW(const wchar_t *string, int len, SecPrintfStream *f, int *pnumwritten)
{
const wchar_t *str = string;
int count;
for (count = len; count > 0; --count) {
SecWriteCharW(*str, f, pnumwritten);
++str;
if (*pnumwritten == -1) {
break;
}
}
}
source/bootloader/u-boot-2020.01/lotus/securec/snprintf_s.c
Executable
+100
View File
@@ -0,0 +1,100 @@
/*
*
*/
#include "linux/lotus/securec.h"
#if SECUREC_ENABLE_SNPRINTF
/*
* <FUNCTION DESCRIPTION>
* The snprintf_s function is equivalent to the snprintf function
* except for the parameter destMax/count and the explicit runtime-constraints violation
* The snprintf_s function formats and stores count or fewer characters in
* strDest and appends a terminating null. Each argument (if any) is converted
* and output according to the corresponding format specification in format.
* The formatting is consistent with the printf family of functions; If copying
* occurs between strings that overlap, the behavior is undefined.
*
* <INPUT PARAMETERS>
* strDest Storage location for the output.
* destMax The size of the storage location for output. Size
* in bytes for snprintf_s or size in words for snwprintf_s.
* count Maximum number of character to store.
* format Format-control string.
* ... Optional arguments.
*
* <OUTPUT PARAMETERS>
* strDest is updated
*
* <RETURN VALUE>
* return the number of characters written, not including the terminating null
* return -1 if an error occurs.
* return -1 if count < destMax and the output string has been truncated
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*
*/
int snprintf_s(char *strDest, size_t destMax, size_t count, const char *format, ...)
{
int ret; /* If initialization causes e838 */
va_list argList;
va_start(argList, format);
ret = vsnprintf_s(strDest, destMax, count, format, argList);
va_end(argList);
(void)argList; /* To clear e438 last value assigned not used , the compiler will optimize this code */
return ret;
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(snprintf_s);
#endif
#endif
#if SECUREC_SNPRINTF_TRUNCATED
/*
* <FUNCTION DESCRIPTION>
* The snprintf_truncated_s function is equivalent to the snprintf function
* except for the parameter destMax/count and the explicit runtime-constraints violation
* The snprintf_truncated_s function formats and stores count or fewer characters in
* strDest and appends a terminating null. Each argument (if any) is converted
* and output according to the corresponding format specification in format.
* The formatting is consistent with the printf family of functions; If copying
* occurs between strings that overlap, the behavior is undefined.
*
* <INPUT PARAMETERS>
* strDest Storage location for the output.
* destMax The size of the storage location for output. Size
* in bytes for snprintf_truncated_s or size in words for snwprintf_s.
* format Format-control string.
* ... Optional arguments.
*
* <OUTPUT PARAMETERS>
* strDest is updated
*
* <RETURN VALUE>
* return the number of characters written, not including the terminating null
* return -1 if an error occurs.
* return destMax-1 if output string has been truncated
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*
*/
int snprintf_truncated_s(char *strDest, size_t destMax, const char *format, ...)
{
int ret; /* If initialization causes e838 */
va_list argList;
va_start(argList, format);
ret = vsnprintf_truncated_s(strDest, destMax, format, argList);
va_end(argList);
(void)argList; /* To clear e438 last value assigned not used , the compiler will optimize this code */
return ret;
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(snprintf_truncated_s);
#endif
#endif
source/bootloader/u-boot-2020.01/lotus/securec/sprintf_s.c
Executable
+48
View File
@@ -0,0 +1,48 @@
/*
*
*/
#include "linux/lotus/securec.h"
/*
* <FUNCTION DESCRIPTION>
* The sprintf_s function is equivalent to the sprintf function
* except for the parameter destMax and the explicit runtime-constraints violation
* The sprintf_s function formats and stores a series of characters and values
* in strDest. Each argument (if any) is converted and output according to
* the corresponding format specification in format. The format consists of
* ordinary characters and has the same form and function as the format argument
* for printf. A null character is appended after the last character written.
* If copying occurs between strings that overlap, the behavior is undefined.
*
* <INPUT PARAMETERS>
* strDest Storage location for output.
* destMax Maximum number of characters to store.
* format Format-control string.
* ... Optional arguments
*
* <OUTPUT PARAMETERS>
* strDest is updated
*
* <RETURN VALUE>
* return the number of bytes stored in strDest, not counting the terminating null character.
* return -1 if an error occurred.
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*/
int sprintf_s(char *strDest, size_t destMax, const char *format, ...)
{
int ret; /* If initialization causes e838 */
va_list argList;
va_start(argList, format);
ret = vsprintf_s(strDest, destMax, format, argList);
va_end(argList);
(void)argList; /* To clear e438 last value assigned not used , the compiler will optimize this code */
return ret;
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(sprintf_s);
#endif
source/bootloader/u-boot-2020.01/lotus/securec/sscanf_s.c
Executable
+48
View File
@@ -0,0 +1,48 @@
/*
*
*/
#include "linux/lotus/securec.h"
/*
* <FUNCTION DESCRIPTION>
* The sscanf_s function is equivalent to fscanf_s,
* except that input is obtained from a string (specified by the argument buffer) rather than from a stream
* The sscanf function reads data from buffer into the location given by each
* argument. Every argument must be a pointer to a variable with a type that
* corresponds to a type specifier in format. The format argument controls the
* interpretation of the input fields and has the same form and function as
* the format argument for the scanf function.
* If copying takes place between strings that overlap, the behavior is undefined.
*
* <INPUT PARAMETERS>
* buffer Stored data.
* format Format control string, see Format Specifications.
* ... Optional arguments.
*
* <OUTPUT PARAMETERS>
* ... The converted value stored in user assigned address
*
* <RETURN VALUE>
* Each of these functions returns the number of fields successfully converted
* and assigned; the return value does not include fields that were read but
* not assigned.
* A return value of 0 indicates that no fields were assigned.
* return -1 if an error occurs.
*/
int sscanf_s(const char *buffer, const char *format, ...)
{
int ret; /* If initialization causes e838 */
va_list argList;
va_start(argList, format);
ret = vsscanf_s(buffer, format, argList);
va_end(argList);
(void)argList; /* To clear e438 last value assigned not used , the compiler will optimize this code */
return ret;
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(sscanf_s);
#endif
source/bootloader/u-boot-2020.01/lotus/securec/strcat_s.c
Executable
+91
View File
@@ -0,0 +1,91 @@
/*
*
*/
#include "securecutil.h"
/*
* Befor this function, the basic parameter checking has been done
*/
SECUREC_INLINE errno_t SecDoCat(char *strDest, size_t destMax, const char *strSrc)
{
size_t destLen;
size_t srcLen;
size_t maxSrcLen;
SECUREC_CALC_STR_LEN(strDest, destMax, &destLen);
/* Only optimize strSrc, do not apply this function to strDest */
maxSrcLen = destMax - destLen;
SECUREC_CALC_STR_LEN_OPT(strSrc, maxSrcLen, &srcLen);
if (SECUREC_CAT_STRING_IS_OVERLAP(strDest, destLen, strSrc, srcLen)) {
strDest[0] = '\0';
if (strDest + destLen <= strSrc && destLen == destMax) {
SECUREC_ERROR_INVALID_PARAMTER("strcat_s");
return EINVAL_AND_RESET;
}
SECUREC_ERROR_BUFFER_OVERLAP("strcat_s");
return EOVERLAP_AND_RESET;
}
if (srcLen + destLen >= destMax || strDest == strSrc) {
strDest[0] = '\0';
if (destLen == destMax) {
SECUREC_ERROR_INVALID_PARAMTER("strcat_s");
return EINVAL_AND_RESET;
}
SECUREC_ERROR_INVALID_RANGE("strcat_s");
return ERANGE_AND_RESET;
}
SECUREC_MEMCPY_WARP_OPT(strDest + destLen, strSrc, srcLen + 1); /* Single character length include \0 */
return EOK;
}
/*
* <FUNCTION DESCRIPTION>
* The strcat_s function appends a copy of the string pointed to by strSrc (including the terminating null character)
* to the end of the string pointed to by strDest.
* The initial character of strSrc overwrites the terminating null character of strDest.
* strcat_s will return EOVERLAP_AND_RESET if the source and destination strings overlap.
*
* Note that the second parameter is the total size of the buffer, not the
* remaining size.
*
* <INPUT PARAMETERS>
* strDest Null-terminated destination string buffer.
* destMax Size of the destination string buffer.
* strSrc Null-terminated source string buffer.
*
* <OUTPUT PARAMETERS>
* strDest is updated
*
* <RETURN VALUE>
* EOK Success
* EINVAL strDest is NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN
* EINVAL_AND_RESET (strDest unterminated and all other parameters are valid) or
* (strDest != NULL and strSrc is NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN)
* ERANGE destMax is 0 and destMax > SECUREC_STRING_MAX_LEN
* ERANGE_AND_RESET strDest have not enough space and all other parameters are valid and not overlap
* EOVERLAP_AND_RESET dest buffer and source buffer are overlapped and all parameters are valid
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*/
errno_t strcat_s(char *strDest, size_t destMax, const char *strSrc)
{
if (destMax == 0 || destMax > SECUREC_STRING_MAX_LEN) {
SECUREC_ERROR_INVALID_RANGE("strcat_s");
return ERANGE;
}
if (strDest == NULL || strSrc == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("strcat_s");
if (strDest != NULL) {
strDest[0] = '\0';
return EINVAL_AND_RESET;
}
return EINVAL;
}
return SecDoCat(strDest, destMax, strSrc);
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(strcat_s);
#endif
source/bootloader/u-boot-2020.01/lotus/securec/strcpy_s.c
Executable
+343
View File
@@ -0,0 +1,343 @@
/*
*
*/
/*
* [Standardize-exceptions] Use unsafe function: Performance-sensitive
* [reason] Always used in the performance critical path,
* and sufficient input validation is performed before calling
*/
#include "securecutil.h"
#ifndef SECUREC_STRCPY_WITH_PERFORMANCE
#define SECUREC_STRCPY_WITH_PERFORMANCE 1
#endif
#define SECUREC_STRCPY_PARAM_OK(strDest, destMax, strSrc) ((destMax) > 0 && \
(destMax) <= SECUREC_STRING_MAX_LEN && (strDest) != NULL && (strSrc) != NULL && (strDest) != (strSrc))
#if (!SECUREC_IN_KERNEL) && SECUREC_STRCPY_WITH_PERFORMANCE
#ifndef SECUREC_STRCOPY_THRESHOLD_SIZE
#define SECUREC_STRCOPY_THRESHOLD_SIZE 32UL
#endif
/* The purpose of converting to void is to clean up the alarm */
#define SECUREC_SMALL_STR_COPY(strDest, strSrc, lenWithTerm) do { \
if (SECUREC_ADDR_ALIGNED_8(strDest) && SECUREC_ADDR_ALIGNED_8(strSrc)) { \
/* Use struct assignment */ \
switch (lenWithTerm) { \
case 1: \
*(strDest) = *(strSrc); \
break; \
case 2: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 2); \
break; \
case 3: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 3); \
break; \
case 4: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 4); \
break; \
case 5: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 5); \
break; \
case 6: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 6); \
break; \
case 7: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 7); \
break; \
case 8: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 8); \
break; \
case 9: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 9); \
break; \
case 10: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 10); \
break; \
case 11: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 11); \
break; \
case 12: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 12); \
break; \
case 13: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 13); \
break; \
case 14: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 14); \
break; \
case 15: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 15); \
break; \
case 16: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 16); \
break; \
case 17: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 17); \
break; \
case 18: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 18); \
break; \
case 19: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 19); \
break; \
case 20: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 20); \
break; \
case 21: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 21); \
break; \
case 22: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 22); \
break; \
case 23: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 23); \
break; \
case 24: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 24); \
break; \
case 25: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 25); \
break; \
case 26: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 26); \
break; \
case 27: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 27); \
break; \
case 28: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 28); \
break; \
case 29: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 29); \
break; \
case 30: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 30); \
break; \
case 31: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 31); \
break; \
case 32: \
SECUREC_COPY_VALUE_BY_STRUCT((strDest), (strSrc), 32); \
break; \
default: \
/* Do nothing */ \
break; \
} /* END switch */ \
} else { \
char *tmpStrDest_ = (char *)(strDest); \
const char *tmpStrSrc_ = (const char *)(strSrc); \
switch (lenWithTerm) { \
case 32: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 31: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 30: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 29: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 28: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 27: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 26: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 25: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 24: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 23: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 22: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 21: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 20: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 19: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 18: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 17: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 16: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 15: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 14: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 13: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 12: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 11: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 10: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 9: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 8: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 7: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 6: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 5: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 4: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 3: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 2: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
case 1: \
*(tmpStrDest_++) = *(tmpStrSrc_++); \
/* fall-through */ /* FALLTHRU */ \
default: \
/* Do nothing */ \
break; \
} \
} \
} SECUREC_WHILE_ZERO
#endif
#if SECUREC_IN_KERNEL || (!SECUREC_STRCPY_WITH_PERFORMANCE)
#define SECUREC_STRCPY_OPT(dest, src, lenWithTerm) SECUREC_MEMCPY_WARP_OPT((dest), (src), (lenWithTerm))
#else
/*
* Performance optimization. lenWithTerm include '\0'
*/
#define SECUREC_STRCPY_OPT(dest, src, lenWithTerm) do { \
if ((lenWithTerm) > SECUREC_STRCOPY_THRESHOLD_SIZE) { \
SECUREC_MEMCPY_WARP_OPT((dest), (src), (lenWithTerm)); \
} else { \
SECUREC_SMALL_STR_COPY((dest), (src), (lenWithTerm)); \
} \
} SECUREC_WHILE_ZERO
#endif
/*
* Check Src Range
*/
SECUREC_INLINE errno_t CheckSrcRange(char *strDest, size_t destMax, const char *strSrc)
{
size_t tmpDestMax = destMax;
const char *tmpSrc = strSrc;
/* Use destMax as boundary checker and destMax must be greater than zero */
while (*tmpSrc != '\0' && tmpDestMax > 0) {
++tmpSrc;
--tmpDestMax;
}
if (tmpDestMax == 0) {
strDest[0] = '\0';
SECUREC_ERROR_INVALID_RANGE("strcpy_s");
return ERANGE_AND_RESET;
}
return EOK;
}
/*
* Handling errors
*/
errno_t strcpy_error(char *strDest, size_t destMax, const char *strSrc)
{
if (destMax == 0 || destMax > SECUREC_STRING_MAX_LEN) {
SECUREC_ERROR_INVALID_RANGE("strcpy_s");
return ERANGE;
}
if (strDest == NULL || strSrc == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("strcpy_s");
if (strDest != NULL) {
strDest[0] = '\0';
return EINVAL_AND_RESET;
}
return EINVAL;
}
return CheckSrcRange(strDest, destMax, strSrc);
}
/*
* <FUNCTION DESCRIPTION>
* The strcpy_s function copies the string pointed to strSrc
* (including the terminating null character) into the array pointed to by strDest
* The destination string must be large enough to hold the source string,
* including the terminating null character. strcpy_s will return EOVERLAP_AND_RESET
* if the source and destination strings overlap.
*
* <INPUT PARAMETERS>
* strDest Location of destination string buffer
* destMax Size of the destination string buffer.
* strSrc Null-terminated source string buffer.
*
* <OUTPUT PARAMETERS>
* strDest is updated.
*
* <RETURN VALUE>
* EOK Success
* EINVAL strDest is NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN
* EINVAL_AND_RESET strDest != NULL and strSrc is NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN
* ERANGE destMax is 0 and destMax > SECUREC_STRING_MAX_LEN
* ERANGE_AND_RESET strDest have not enough space and all other parameters are valid and not overlap
* EOVERLAP_AND_RESET dest buffer and source buffer are overlapped and all parameters are valid
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*/
errno_t strcpy_s(char *strDest, size_t destMax, const char *strSrc)
{
if (SECUREC_STRCPY_PARAM_OK(strDest, destMax, strSrc)) {
size_t srcStrLen;
SECUREC_CALC_STR_LEN(strSrc, destMax, &srcStrLen);
++srcStrLen; /* The length include '\0' */
if (srcStrLen <= destMax) {
/* Use mem overlap check include '\0' */
if (SECUREC_MEMORY_NO_OVERLAP(strDest, strSrc, srcStrLen)) {
/* Performance optimization srcStrLen include '\0' */
SECUREC_STRCPY_OPT(strDest, strSrc, srcStrLen);
return EOK;
} else {
strDest[0] = '\0';
SECUREC_ERROR_BUFFER_OVERLAP("strcpy_s");
return EOVERLAP_AND_RESET;
}
}
}
return strcpy_error(strDest, destMax, strSrc);
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(strcpy_s);
#endif
source/bootloader/u-boot-2020.01/lotus/securec/strncat_s.c
Executable
+109
View File
@@ -0,0 +1,109 @@
/*
*
*/
#include "securecutil.h"
/*
* Befor this function, the basic parameter checking has been done
*/
SECUREC_INLINE errno_t SecDoCatLimit(char *strDest, size_t destMax, const char *strSrc, size_t count)
{
size_t destLen;
size_t srcLen;
SECUREC_CALC_STR_LEN(strDest, destMax, &destLen);
/*
* The strSrc is no longer optimized. The reason is that when count is small,
* the efficiency of strnlen is higher than that of self realization.
*/
SECUREC_CALC_STR_LEN(strSrc, count, &srcLen);
if (SECUREC_CAT_STRING_IS_OVERLAP(strDest, destLen, strSrc, srcLen)) {
strDest[0] = '\0';
if (strDest + destLen <= strSrc && destLen == destMax) {
SECUREC_ERROR_INVALID_PARAMTER("strncat_s");
return EINVAL_AND_RESET;
}
SECUREC_ERROR_BUFFER_OVERLAP("strncat_s");
return EOVERLAP_AND_RESET;
}
if (srcLen + destLen >= destMax || strDest == strSrc) {
strDest[0] = '\0';
if (destLen == destMax) {
SECUREC_ERROR_INVALID_PARAMTER("strncat_s");
return EINVAL_AND_RESET;
}
SECUREC_ERROR_INVALID_RANGE("strncat_s");
return ERANGE_AND_RESET;
}
SECUREC_MEMCPY_WARP_OPT(strDest + destLen, strSrc, srcLen); /* No terminator */
*(strDest + destLen + srcLen) = '\0';
return EOK;
}
/*
* <FUNCTION DESCRIPTION>
* The strncat_s function appends not more than n successive characters
* (not including the terminating null character)
* from the array pointed to by strSrc to the end of the string pointed to by strDest
* The strncat_s function try to append the first D characters of strSrc to
* the end of strDest, where D is the lesser of count and the length of strSrc.
* If appending those D characters will fit within strDest (whose size is given
* as destMax) and still leave room for a null terminator, then those characters
* are appended, starting at the original terminating null of strDest, and a
* new terminating null is appended; otherwise, strDest[0] is set to the null
* character.
*
* <INPUT PARAMETERS>
* strDest Null-terminated destination string.
* destMax Size of the destination buffer.
* strSrc Null-terminated source string.
* count Number of character to append, or truncate.
*
* <OUTPUT PARAMETERS>
* strDest is updated
*
* <RETURN VALUE>
* EOK Success
* EINVAL strDest is NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN
* EINVAL_AND_RESET (strDest unterminated and all other parameters are valid)or
* (strDest != NULL and strSrc is NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN)
* ERANGE destMax is 0 and destMax > SECUREC_STRING_MAX_LEN
* ERANGE_AND_RESET strDest have not enough space and all other parameters are valid and not overlap
* EOVERLAP_AND_RESET dest buffer and source buffer are overlapped and all parameters are valid
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*/
errno_t strncat_s(char *strDest, size_t destMax, const char *strSrc, size_t count)
{
if (destMax == 0 || destMax > SECUREC_STRING_MAX_LEN) {
SECUREC_ERROR_INVALID_RANGE("strncat_s");
return ERANGE;
}
if (strDest == NULL || strSrc == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("strncat_s");
if (strDest != NULL) {
strDest[0] = '\0';
return EINVAL_AND_RESET;
}
return EINVAL;
}
if (count > SECUREC_STRING_MAX_LEN) {
#ifdef SECUREC_COMPATIBLE_WIN_FORMAT
if (count == (size_t)(-1)) {
/* Windows internal functions may pass in -1 when calling this function */
return SecDoCatLimit(strDest, destMax, strSrc, destMax);
}
#endif
strDest[0] = '\0';
SECUREC_ERROR_INVALID_RANGE("strncat_s");
return ERANGE_AND_RESET;
}
return SecDoCatLimit(strDest, destMax, strSrc, count);
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(strncat_s);
#endif
source/bootloader/u-boot-2020.01/lotus/securec/strncpy_s.c
Executable
+135
View File
@@ -0,0 +1,135 @@
/*
*
*/
/*
* [Standardize-exceptions] Use unsafe function: Performance-sensitive
* [reason] Always used in the performance critical path,
* and sufficient input validation is performed before calling
*/
#include "securecutil.h"
#if defined(SECUREC_COMPATIBLE_WIN_FORMAT)
#define SECUREC_STRNCPY_PARAM_OK(strDest, destMax, strSrc, count) \
(((destMax) > 0 && (destMax) <= SECUREC_STRING_MAX_LEN && (strDest) != NULL && (strSrc) != NULL && \
((count) <= SECUREC_STRING_MAX_LEN || (count) == ((size_t)(-1))) && (count) > 0))
#else
#define SECUREC_STRNCPY_PARAM_OK(strDest, destMax, strSrc, count) \
(((destMax) > 0 && (destMax) <= SECUREC_STRING_MAX_LEN && (strDest) != NULL && (strSrc) != NULL && \
(count) <= SECUREC_STRING_MAX_LEN && (count) > 0))
#endif
/*
* Check Src Count Range
*/
SECUREC_INLINE errno_t CheckSrcCountRange(char *strDest, size_t destMax, const char *strSrc, size_t count)
{
size_t tmpDestMax = destMax;
size_t tmpCount = count;
const char *endPos = strSrc;
/* Use destMax and count as boundary checker and destMax must be greater than zero */
while (*(endPos) != '\0' && tmpDestMax > 0 && tmpCount > 0) {
++endPos;
--tmpCount;
--tmpDestMax;
}
if (tmpDestMax == 0) {
strDest[0] = '\0';
SECUREC_ERROR_INVALID_RANGE("strncpy_s");
return ERANGE_AND_RESET;
}
return EOK;
}
/*
* Handling errors, when dest euqal src return EOK
*/
errno_t strncpy_error(char *strDest, size_t destMax, const char *strSrc, size_t count)
{
if (destMax == 0 || destMax > SECUREC_STRING_MAX_LEN) {
SECUREC_ERROR_INVALID_RANGE("strncpy_s");
return ERANGE;
}
if (strDest == NULL || strSrc == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("strncpy_s");
if (strDest != NULL) {
strDest[0] = '\0';
return EINVAL_AND_RESET;
}
return EINVAL;
}
if (count > SECUREC_STRING_MAX_LEN) {
strDest[0] = '\0'; /* Clear dest string */
SECUREC_ERROR_INVALID_RANGE("strncpy_s");
return ERANGE_AND_RESET;
}
if (count == 0) {
strDest[0] = '\0';
return EOK;
}
return CheckSrcCountRange(strDest, destMax, strSrc, count);
}
/*
* <FUNCTION DESCRIPTION>
* The strncpy_s function copies not more than n successive characters (not including the terminating null character)
* from the array pointed to by strSrc to the array pointed to by strDest.
*
* <INPUT PARAMETERS>
* strDest Destination string.
* destMax The size of the destination string, in characters.
* strSrc Source string.
* count Number of characters to be copied.
*
* <OUTPUT PARAMETERS>
* strDest is updated
*
* <RETURN VALUE>
* EOK Success
* EINVAL strDest is NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN
* EINVAL_AND_RESET strDest != NULL and strSrc is NULL and destMax != 0 and destMax <= SECUREC_STRING_MAX_LEN
* ERANGE destMax is 0 and destMax > SECUREC_STRING_MAX_LEN
* ERANGE_AND_RESET strDest have not enough space and all other parameters are valid and not overlap
* EOVERLAP_AND_RESET dest buffer and source buffer are overlapped and all parameters are valid
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*/
errno_t strncpy_s(char *strDest, size_t destMax, const char *strSrc, size_t count)
{
if (SECUREC_STRNCPY_PARAM_OK(strDest, destMax, strSrc, count)) {
size_t minCpLen; /* Use it to store the maxi length limit */
if (count < destMax) {
SECUREC_CALC_STR_LEN(strSrc, count, &minCpLen); /* No ending terminator */
} else {
size_t tmpCount = destMax;
#ifdef SECUREC_COMPATIBLE_WIN_FORMAT
if (count == ((size_t)(-1))) {
tmpCount = destMax - 1;
}
#endif
SECUREC_CALC_STR_LEN(strSrc, tmpCount, &minCpLen); /* No ending terminator */
if (minCpLen == destMax) {
strDest[0] = '\0';
SECUREC_ERROR_INVALID_RANGE("strncpy_s");
return ERANGE_AND_RESET;
}
}
if (SECUREC_STRING_NO_OVERLAP(strDest, strSrc, minCpLen) || strDest == strSrc) {
/* Not overlap */
SECUREC_MEMCPY_WARP_OPT(strDest, strSrc, minCpLen); /* Copy string without terminator */
strDest[minCpLen] = '\0';
return EOK;
} else {
strDest[0] = '\0';
SECUREC_ERROR_BUFFER_OVERLAP("strncpy_s");
return EOVERLAP_AND_RESET;
}
}
return strncpy_error(strDest, destMax, strSrc, count);
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(strncpy_s);
#endif
source/bootloader/u-boot-2020.01/lotus/securec/strtok_s.c
Executable
+106
View File
@@ -0,0 +1,106 @@
/*
*
*/
#include "securecutil.h"
SECUREC_INLINE int SecIsInDelimit(char ch, const char *strDelimit)
{
const char *ctl = strDelimit;
while (*ctl != '\0' && *ctl != ch) {
++ctl;
}
return (int)(*ctl != '\0');
}
/*
* Find beginning of token (skip over leading delimiters).
* Note that there is no token if this loop sets string to point to the terminal null.
*/
SECUREC_INLINE char *SecFindBegin(char *strToken, const char *strDelimit)
{
char *token = strToken;
while (*token != '\0') {
if (SecIsInDelimit(*token, strDelimit) != 0) {
++token;
continue;
}
/* Don't find any delimiter in string header, break the loop */
break;
}
return token;
}
/*
* Find rest of token
*/
SECUREC_INLINE char *SecFindRest(char *strToken, const char *strDelimit)
{
/* Find the rest of the token. If it is not the end of the string, put a null there */
char *token = strToken;
while (*token != '\0') {
if (SecIsInDelimit(*token, strDelimit) != 0) {
/* Find a delimiter, set string termintor */
*token = '\0';
++token;
break;
}
++token;
}
return token;
}
/*
* Find the final position pointer
*/
SECUREC_INLINE char *SecUpdateToken(char *strToken, const char *strDelimit, char **context)
{
/* Point to updated position. Record string position for next search in the context */
*context = SecFindRest(strToken, strDelimit);
/* Determine if a token has been found. */
if (*context == strToken) {
return NULL;
}
return strToken;
}
/*
* <FUNCTION DESCRIPTION>
* The strtok_s function parses a string into a sequence of strToken,
* replace all characters in strToken string that match to strDelimit set with 0.
* On the first call to strtok_s the string to be parsed should be specified in strToken.
* In each subsequent call that should parse the same string, strToken should be NULL
* <INPUT PARAMETERS>
* strToken String containing token or tokens.
* strDelimit Set of delimiter characters.
* context Used to store position information between calls
* to strtok_s
* <OUTPUT PARAMETERS>
* context is updated
* <RETURN VALUE>
* On the first call returns the address of the first non \0 character, otherwise NULL is returned.
* In subsequent calls, the strtoken is set to NULL, and the context set is the same as the previous call,
* return NULL if the *context string length is equal 0, otherwise return *context.
*/
char *strtok_s(char *strToken, const char *strDelimit, char **context)
{
char *orgToken = strToken;
/* Validate delimiter and string context */
if (context == NULL || strDelimit == NULL) {
return NULL;
}
/* Valid input string and string pointer from where to search */
if (orgToken == NULL && *context == NULL) {
return NULL;
}
/* If string is null, continue searching from previous string position stored in context */
if (orgToken == NULL) {
orgToken = *context;
}
orgToken = SecFindBegin(orgToken, strDelimit);
return SecUpdateToken(orgToken, strDelimit, context);
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(strtok_s);
#endif
source/bootloader/u-boot-2020.01/lotus/securec/swprintf_s.c
Executable
+38
View File
@@ -0,0 +1,38 @@
/*
*
*/
#include "linux/lotus/securec.h"
/*
* <FUNCTION DESCRIPTION>
* The swprintf_s function is the wide-character equivalent of the sprintf_s function
*
* <INPUT PARAMETERS>
* strDest Storage location for the output.
* destMax Maximum number of characters to store.
* format Format-control string.
* ... Optional arguments
*
* <OUTPUT PARAMETERS>
* strDest is updated
*
* <RETURN VALUE>
* return the number of wide characters stored in strDest, not counting the terminating null wide character.
* return -1 if an error occurred.
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*/
int swprintf_s(wchar_t *strDest, size_t destMax, const wchar_t *format, ...)
{
int ret; /* If initialization causes e838 */
va_list argList;
va_start(argList, format);
ret = vswprintf_s(strDest, destMax, format, argList);
va_end(argList);
(void)argList; /* To clear e438 last value assigned not used , the compiler will optimize this code */
return ret;
}
source/bootloader/u-boot-2020.01/lotus/securec/swscanf_s.c
Executable
+44
View File
@@ -0,0 +1,44 @@
/*
*
*/
#include "linux/lotus/securec.h"
/*
* <FUNCTION DESCRIPTION>
* The swscanf_s function is the wide-character equivalent of the sscanf_s function
* The swscanf_s function reads data from buffer into the location given by
* each argument. Every argument must be a pointer to a variable with a type
* that corresponds to a type specifier in format. The format argument controls
* the interpretation of the input fields and has the same form and function
* as the format argument for the scanf function. If copying takes place between
* strings that overlap, the behavior is undefined.
*
* <INPUT PARAMETERS>
* buffer Stored data.
* format Format control string, see Format Specifications.
* ... Optional arguments.
*
* <OUTPUT PARAMETERS>
* ... the converted value stored in user assigned address
*
* <RETURN VALUE>
* Each of these functions returns the number of fields successfully converted
* and assigned; The return value does not include fields that were read but not
* assigned.
* A return value of 0 indicates that no fields were assigned.
* return -1 if an error occurs.
*/
int swscanf_s(const wchar_t *buffer, const wchar_t *format, ...)
{
int ret; /* If initialization causes e838 */
va_list argList;
va_start(argList, format);
ret = vswscanf_s(buffer, format, argList);
va_end(argList);
(void)argList; /* To clear e438 last value assigned not used , the compiler will optimize this code */
return ret;
}
source/bootloader/u-boot-2020.01/lotus/securec/vfscanf_s.c
Executable
+54
View File
@@ -0,0 +1,54 @@
/*
*
*/
#include "secinput.h"
/*
* <FUNCTION DESCRIPTION>
* The vfscanf_s function is equivalent to fscanf_s, with the variable argument list replaced by argList
* The vfscanf_s function reads data from the current position of stream into
* the locations given by argument (if any). Each argument must be a pointer
* to a variable of a type that corresponds to a type specifier in format.
* format controls the interpretation of the input fields and has the same
* form and function as the format argument for scanf.
*
* <INPUT PARAMETERS>
* stream Pointer to FILE structure.
* format Format control string, see Format Specifications.
* argList pointer to list of arguments
*
* <OUTPUT PARAMETERS>
* argList the converted value stored in user assigned address
*
* <RETURN VALUE>
* Each of these functions returns the number of fields successfully converted
* and assigned; the return value does not include fields that were read but
* not assigned. A return value of 0 indicates that no fields were assigned.
* return -1 if an error occurs.
*/
int vfscanf_s(FILE *stream, const char *format, va_list argList)
{
int retVal; /* If initialization causes e838 */
SecFileStream fStr;
if (stream == NULL || format == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("vfscanf_s");
return SECUREC_SCANF_EINVAL;
}
if (stream == SECUREC_STREAM_STDIN) {
return vscanf_s(format, argList);
}
SECUREC_LOCK_FILE(stream);
SECUREC_FILE_STREAM_FROM_FILE(&fStr, stream);
retVal = SecInputS(&fStr, format, argList);
SECUREC_UNLOCK_FILE(stream);
if (retVal < 0) {
SECUREC_ERROR_INVALID_PARAMTER("vfscanf_s");
return SECUREC_SCANF_EINVAL;
}
return retVal;
}
source/bootloader/u-boot-2020.01/lotus/securec/vfwscanf_s.c
Executable
+57
View File
@@ -0,0 +1,57 @@
/*
*
*/
#ifndef SECUREC_FOR_WCHAR
#define SECUREC_FOR_WCHAR
#endif
#include "secinput.h"
/*
* <FUNCTION DESCRIPTION>
* The vfwscanf_s function is the wide-character equivalent of the vfscanf_s function
* The vfwscanf_s function reads data from the current position of stream into
* the locations given by argument (if any). Each argument must be a pointer
* to a variable of a type that corresponds to a type specifier in format.
* format controls the interpretation of the input fields and has the same form
* and function as the format argument for scanf.
*
* <INPUT PARAMETERS>
* stream Pointer to FILE structure.
* format Format control string, see Format Specifications.
* argList pointer to list of arguments
*
* <OUTPUT PARAMETERS>
* argList the converted value stored in user assigned address
*
* <RETURN VALUE>
* Each of these functions returns the number of fields successfully converted
* and assigned; the return value does not include fields that were read but
* not assigned. A return value of 0 indicates that no fields were assigned.
* return -1 if an error occurs.
*/
int vfwscanf_s(FILE *stream, const wchar_t *format, va_list argList)
{
int retVal; /* If initialization causes e838 */
SecFileStream fStr;
if (stream == NULL || format == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("vfwscanf_s");
return SECUREC_SCANF_EINVAL;
}
if (stream == SECUREC_STREAM_STDIN) {
return vwscanf_s(format, argList);
}
SECUREC_LOCK_FILE(stream);
SECUREC_FILE_STREAM_FROM_FILE(&fStr, stream);
retVal = SecInputSW(&fStr, format, argList);
SECUREC_UNLOCK_FILE(stream);
if (retVal < 0) {
SECUREC_ERROR_INVALID_PARAMTER("vfwscanf_s");
return SECUREC_SCANF_EINVAL;
}
return retVal;
}
source/bootloader/u-boot-2020.01/lotus/securec/vscanf_s.c
Executable
+53
View File
@@ -0,0 +1,53 @@
/*
*
*/
#include "secinput.h"
/*
* <FUNCTION DESCRIPTION>
* The vscanf_s function is equivalent to scanf_s, with the variable argument list replaced by argList,
* The vscanf_s function reads data from the standard input stream stdin and
* writes the data into the location that's given by argument. Each argument
* must be a pointer to a variable of a type that corresponds to a type specifier
* in format. If copying occurs between strings that overlap, the behavior is
* undefined.
*
* <INPUT PARAMETERS>
* format Format control string.
* argList pointer to list of arguments
*
* <OUTPUT PARAMETERS>
* argList the converted value stored in user assigned address
*
* <RETURN VALUE>
* Returns the number of fields successfully converted and assigned;
* the return value does not include fields that were read but not assigned.
* A return value of 0 indicates that no fields were assigned.
* return -1 if an error occurs.
*/
int vscanf_s(const char *format, va_list argList)
{
int retVal; /* If initialization causes e838 */
SecFileStream fStr;
SECUREC_FILE_STREAM_FROM_STDIN(&fStr);
/*
* The "va_list" has different definition on different platform, so we can't use argList == NULL
* To determine it's invalid. If you has fixed platform, you can check some fields to validate it,
* such as "argList == NULL" or argList.xxx != NULL or *(size_t *)&argList != 0.
*/
if (format == NULL || fStr.pf == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("vscanf_s");
return SECUREC_SCANF_EINVAL;
}
SECUREC_LOCK_STDIN(0, fStr.pf);
retVal = SecInputS(&fStr, format, argList);
SECUREC_UNLOCK_STDIN(0, fStr.pf);
if (retVal < 0) {
SECUREC_ERROR_INVALID_PARAMTER("vscanf_s");
return SECUREC_SCANF_EINVAL;
}
return retVal;
}
source/bootloader/u-boot-2020.01/lotus/securec/vsnprintf_s.c
Executable
+128
View File
@@ -0,0 +1,128 @@
/*
*
*/
#include "secureprintoutput.h"
#if SECUREC_ENABLE_VSNPRINTF
/*
* <FUNCTION DESCRIPTION>
* The vsnprintf_s function is equivalent to the vsnprintf function
* except for the parameter destMax/count and the explicit runtime-constraints violation
* The vsnprintf_s function takes a pointer to an argument list, then formats
* and writes up to count characters of the given data to the memory pointed
* to by strDest and appends a terminating null.
*
* <INPUT PARAMETERS>
* strDest Storage location for the output.
* destMax The size of the strDest for output.
* count Maximum number of character to write(not including
* the terminating NULL)
* format Format-control string.
* argList pointer to list of arguments.
*
* <OUTPUT PARAMETERS>
* strDest is updated
*
* <RETURN VALUE>
* return the number of characters written, not including the terminating null
* return -1 if an error occurs.
* return -1 if count < destMax and the output string has been truncated
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*/
int vsnprintf_s(char *strDest, size_t destMax, size_t count, const char *format, va_list argList)
{
int retVal;
if (SECUREC_VSNPRINTF_PARAM_ERROR(format, strDest, destMax, count, SECUREC_STRING_MAX_LEN)) {
SECUREC_VSPRINTF_CLEAR_DEST(strDest, destMax, SECUREC_STRING_MAX_LEN);
SECUREC_ERROR_INVALID_PARAMTER("vsnprintf_s");
return -1;
}
if (destMax > count) {
retVal = SecVsnprintfImpl(strDest, count + 1, format, argList);
if (retVal == SECUREC_PRINTF_TRUNCATE) { /* To keep dest buffer not destroyed 2014.2.18 */
/* The string has been truncated, return -1 */
return -1; /* To skip error handler, return strlen(strDest) or -1 */
}
} else {
retVal = SecVsnprintfImpl(strDest, destMax, format, argList);
#ifdef SECUREC_COMPATIBLE_WIN_FORMAT
if (retVal == SECUREC_PRINTF_TRUNCATE && count == (size_t)(-1)) {
return -1;
}
#endif
}
if (retVal < 0) {
strDest[0] = '\0'; /* Empty the dest strDest */
if (retVal == SECUREC_PRINTF_TRUNCATE) {
/* Buffer too small */
SECUREC_ERROR_INVALID_RANGE("vsnprintf_s");
}
SECUREC_ERROR_INVALID_PARAMTER("vsnprintf_s");
return -1;
}
return retVal;
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(vsnprintf_s);
#endif
#endif
#if SECUREC_SNPRINTF_TRUNCATED
/*
* <FUNCTION DESCRIPTION>
* The vsnprintf_truncated_s function is equivalent to the vsnprintf function
* except for the parameter destMax/count and the explicit runtime-constraints violation
* The vsnprintf_truncated_s function takes a pointer to an argument list, then formats
* and writes up to count characters of the given data to the memory pointed
* to by strDest and appends a terminating null.
*
* <INPUT PARAMETERS>
* strDest Storage location for the output.
* destMax The size of the strDest for output.
* the terminating NULL)
* format Format-control string.
* argList pointer to list of arguments.
*
* <OUTPUT PARAMETERS>
* strDest is updated
*
* <RETURN VALUE>
* return the number of characters written, not including the terminating null
* return -1 if an error occurs.
* return destMax-1 if output string has been truncated
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*/
int vsnprintf_truncated_s(char *strDest, size_t destMax, const char *format, va_list argList)
{
int retVal;
if (SECUREC_VSPRINTF_PARAM_ERROR(format, strDest, destMax, SECUREC_STRING_MAX_LEN)) {
SECUREC_VSPRINTF_CLEAR_DEST(strDest, destMax, SECUREC_STRING_MAX_LEN);
SECUREC_ERROR_INVALID_PARAMTER("vsnprintf_truncated_s");
return -1;
}
retVal = SecVsnprintfImpl(strDest, destMax, format, argList);
if (retVal < 0) {
if (retVal == SECUREC_PRINTF_TRUNCATE) {
return (int)(destMax - 1); /* To skip error handler, return strlen(strDest) */
}
strDest[0] = '\0'; /* Empty the dest strDest */
SECUREC_ERROR_INVALID_PARAMTER("vsnprintf_truncated_s");
return -1;
}
return retVal;
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(vsnprintf_truncated_s);
#endif
#endif
source/bootloader/u-boot-2020.01/lotus/securec/vsprintf_s.c
Executable
+57
View File
@@ -0,0 +1,57 @@
/*
*
*/
#include "secureprintoutput.h"
/*
* <FUNCTION DESCRIPTION>
* The vsprintf_s function is equivalent to the vsprintf function
* except for the parameter destMax and the explicit runtime-constraints violation
* The vsprintf_s function takes a pointer to an argument list, and then formats
* and writes the given data to the memory pointed to by strDest.
* The function differ from the non-secure versions only in that the secure
* versions support positional parameters.
*
* <INPUT PARAMETERS>
* strDest Storage location for the output.
* destMax Size of strDest
* format Format specification.
* argList pointer to list of arguments
*
* <OUTPUT PARAMETERS>
* strDest is updated
*
* <RETURN VALUE>
* return the number of characters written, not including the terminating null character,
* return -1 if an error occurs.
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*/
int vsprintf_s(char *strDest, size_t destMax, const char *format, va_list argList)
{
int retVal; /* If initialization causes e838 */
if (SECUREC_VSPRINTF_PARAM_ERROR(format, strDest, destMax, SECUREC_STRING_MAX_LEN)) {
SECUREC_VSPRINTF_CLEAR_DEST(strDest, destMax, SECUREC_STRING_MAX_LEN);
SECUREC_ERROR_INVALID_PARAMTER("vsprintf_s");
return -1;
}
retVal = SecVsnprintfImpl(strDest, destMax, format, argList);
if (retVal < 0) {
strDest[0] = '\0';
if (retVal == SECUREC_PRINTF_TRUNCATE) {
/* Buffer is too small */
SECUREC_ERROR_INVALID_RANGE("vsprintf_s");
}
SECUREC_ERROR_INVALID_PARAMTER("vsprintf_s");
return -1;
}
return retVal;
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(vsprintf_s);
#endif
source/bootloader/u-boot-2020.01/lotus/securec/vsscanf_s.c
Executable
+77
View File
@@ -0,0 +1,77 @@
/*
*
*/
#include "secinput.h"
#if defined(SECUREC_VXWORKS_PLATFORM) && !SECUREC_IN_KERNEL && \
(!defined(SECUREC_SYSAPI4VXWORKS) && !defined(SECUREC_CTYPE_MACRO_ADAPT))
#include <ctype.h>
#endif
/*
* <NAME>
* vsscanf_s
*
*
* <FUNCTION DESCRIPTION>
* The vsscanf_s function is equivalent to sscanf_s, with the variable argument list replaced by argList
* The vsscanf_s function reads data from buffer into the location given by
* each argument. Every argument must be a pointer to a variable with a type
* that corresponds to a type specifier in format. The format argument controls
* the interpretation of the input fields and has the same form and function
* as the format argument for the scanf function.
* If copying takes place between strings that overlap, the behavior is undefined.
*
* <INPUT PARAMETERS>
* buffer Stored data
* format Format control string, see Format Specifications.
* argList pointer to list of arguments
*
* <OUTPUT PARAMETERS>
* argList the converted value stored in user assigned address
*
* <RETURN VALUE>
* Each of these functions returns the number of fields successfully converted
* and assigned; the return value does not include fields that were read but
* not assigned. A return value of 0 indicates that no fields were assigned.
* return -1 if an error occurs.
*/
int vsscanf_s(const char *buffer, const char *format, va_list argList)
{
size_t count; /* If initialization causes e838 */
int retVal;
SecFileStream fStr;
/* Validation section */
if (buffer == NULL || format == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("vsscanf_s");
return SECUREC_SCANF_EINVAL;
}
count = strlen(buffer);
if (count == 0 || count > SECUREC_STRING_MAX_LEN) {
SecClearDestBuf(buffer, format, argList);
SECUREC_ERROR_INVALID_PARAMTER("vsscanf_s");
return SECUREC_SCANF_EINVAL;
}
#if defined(SECUREC_VXWORKS_PLATFORM) && !SECUREC_IN_KERNEL
/*
* On vxworks platform when buffer is white string, will set first %s argument tu zero.like following useage:
* " \v\f\t\r\n", "%s", str, strSize
* Do not check all character, just first and last character then consider it is white string
*/
if (isspace((int)(unsigned char)buffer[0]) != 0 && isspace((int)(unsigned char)buffer[count - 1]) != 0) {
SecClearDestBuf(buffer, format, argList);
}
#endif
SECUREC_FILE_STREAM_FROM_STRING(&fStr, buffer, count);
retVal = SecInputS(&fStr, format, argList);
if (retVal < 0) {
SECUREC_ERROR_INVALID_PARAMTER("vsscanf_s");
return SECUREC_SCANF_EINVAL;
}
return retVal;
}
#if SECUREC_IN_KERNEL
EXPORT_SYMBOL(vsscanf_s);
#endif
source/bootloader/u-boot-2020.01/lotus/securec/vswprintf_s.c
Executable
+52
View File
@@ -0,0 +1,52 @@
/*
*
*/
#ifndef SECUREC_FOR_WCHAR
#define SECUREC_FOR_WCHAR
#endif
#include "secureprintoutput.h"
/*
* <FUNCTION DESCRIPTION>
* The vswprintf_s function is the wide-character equivalent of the vsprintf_s function
*
* <INPUT PARAMETERS>
* strDest Storage location for the output.
* destMax Maximum number of characters to store
* format Format specification.
* argList pointer to list of arguments
*
* <OUTPUT PARAMETERS>
* strDest is updated
*
* <RETURN VALUE>
* return the number of wide characters stored in strDest, not counting the terminating null wide character.
* return -1 if an error occurred.
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*/
int vswprintf_s(wchar_t *strDest, size_t destMax, const wchar_t *format, va_list argList)
{
int retVal; /* If initialization causes e838 */
if (SECUREC_VSPRINTF_PARAM_ERROR(format, strDest, destMax, SECUREC_WCHAR_STRING_MAX_LEN)) {
SECUREC_VSPRINTF_CLEAR_DEST(strDest, destMax, SECUREC_WCHAR_STRING_MAX_LEN);
SECUREC_ERROR_INVALID_PARAMTER("vswprintf_s");
return -1;
}
retVal = SecVswprintfImpl(strDest, destMax, format, argList);
if (retVal < 0) {
strDest[0] = L'\0';
if (retVal == SECUREC_PRINTF_TRUNCATE) {
/* Buffer too small */
SECUREC_ERROR_INVALID_RANGE("vswprintf_s");
}
SECUREC_ERROR_INVALID_PARAMTER("vswprintf_s");
return -1;
}
return retVal;
}
source/bootloader/u-boot-2020.01/lotus/securec/vswscanf_s.c
Executable
+69
View File
@@ -0,0 +1,69 @@
/*
*
*/
#ifndef SECUREC_FOR_WCHAR
#define SECUREC_FOR_WCHAR
#endif
#include "secinput.h"
SECUREC_INLINE size_t SecWcslen(const wchar_t *s)
{
const wchar_t *end = s;
while (*end != L'\0') {
++end;
}
return ((size_t)((end - s)));
}
/*
* <FUNCTION DESCRIPTION>
* The vswscanf_s function is the wide-character equivalent of the vsscanf_s function
* The vsscanf_s function reads data from buffer into the location given by
* each argument. Every argument must be a pointer to a variable with a type
* that corresponds to a type specifier in format.
* The format argument controls the interpretation of the input fields and
* has the same form and function as the format argument for the scanf function.
* If copying takes place between strings that overlap, the behavior is undefined.
*
* <INPUT PARAMETERS>
* buffer Stored data
* format Format control string, see Format Specifications.
* argList pointer to list of arguments
*
* <OUTPUT PARAMETERS>
* argList the converted value stored in user assigned address
*
* <RETURN VALUE>
* Each of these functions returns the number of fields successfully converted
* and assigned; the return value does not include fields that were read but
* not assigned. A return value of 0 indicates that no fields were assigned.
* return -1 if an error occurs.
*/
int vswscanf_s(const wchar_t *buffer, const wchar_t *format, va_list argList)
{
size_t count; /* If initialization causes e838 */
SecFileStream fStr;
int retVal;
/* Validation section */
if (buffer == NULL || format == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("vswscanf_s");
return SECUREC_SCANF_EINVAL;
}
count = SecWcslen(buffer);
if (count == 0 || count > SECUREC_WCHAR_STRING_MAX_LEN) {
SecClearDestBufW(buffer, format, argList);
SECUREC_ERROR_INVALID_PARAMTER("vswscanf_s");
return SECUREC_SCANF_EINVAL;
}
SECUREC_FILE_STREAM_FROM_STRING(&fStr, (const char *)buffer, count * sizeof(wchar_t));
retVal = SecInputSW(&fStr, format, argList);
if (retVal < 0) {
SECUREC_ERROR_INVALID_PARAMTER("vswscanf_s");
return SECUREC_SCANF_EINVAL;
}
return retVal;
}
source/bootloader/u-boot-2020.01/lotus/securec/vwscanf_s.c
Executable
+54
View File
@@ -0,0 +1,54 @@
/*
*
*/
#ifndef SECUREC_FOR_WCHAR
#define SECUREC_FOR_WCHAR
#endif
#include "secinput.h"
/*
* <FUNCTION DESCRIPTION>
* The vwscanf_s function is the wide-character equivalent of the vscanf_s function
* The vwscanf_s function is the wide-character version of vscanf_s. The
* function reads data from the standard input stream stdin and writes the
* data into the location that's given by argument. Each argument must be a
* pointer to a variable of a type that corresponds to a type specifier in
* format. If copying occurs between strings that overlap, the behavior is
* undefined.
*
* <INPUT PARAMETERS>
* format Format control string.
* argList pointer to list of arguments
*
* <OUTPUT PARAMETERS>
* argList the converted value stored in user assigned address
*
* <RETURN VALUE>
* Returns the number of fields successfully converted and assigned;
* the return value does not include fields that were read but not assigned.
* A return value of 0 indicates that no fields were assigned.
* return -1 if an error occurs.
*/
int vwscanf_s(const wchar_t *format, va_list argList)
{
int retVal; /* If initialization causes e838 */
SecFileStream fStr;
SECUREC_FILE_STREAM_FROM_STDIN(&fStr);
if (format == NULL || fStr.pf == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("vwscanf_s");
return SECUREC_SCANF_EINVAL;
}
SECUREC_LOCK_STDIN(0, fStr.pf);
retVal = SecInputSW(&fStr, format, argList);
SECUREC_UNLOCK_STDIN(0, fStr.pf);
if (retVal < 0) {
SECUREC_ERROR_INVALID_PARAMTER("vwscanf_s");
return SECUREC_SCANF_EINVAL;
}
return retVal;
}
source/bootloader/u-boot-2020.01/lotus/securec/wcscat_s.c
Executable
+97
View File
@@ -0,0 +1,97 @@
/*
*
*/
#include "securecutil.h"
/*
* Befor this function, the basic parameter checking has been done
*/
SECUREC_INLINE errno_t SecDoCatW(wchar_t *strDest, size_t destMax, const wchar_t *strSrc)
{
size_t destLen;
size_t srcLen;
size_t maxCount; /* Store the maximum available count */
/* To calculate the length of a wide character, the parameter must be a wide character */
SECUREC_CALC_WSTR_LEN(strDest, destMax, &destLen);
maxCount = destMax - destLen;
SECUREC_CALC_WSTR_LEN(strSrc, maxCount, &srcLen);
if (SECUREC_CAT_STRING_IS_OVERLAP(strDest, destLen, strSrc, srcLen)) {
strDest[0] = L'\0';
if (strDest + destLen <= strSrc && destLen == destMax) {
SECUREC_ERROR_INVALID_PARAMTER("wcscat_s");
return EINVAL_AND_RESET;
}
SECUREC_ERROR_BUFFER_OVERLAP("wcscat_s");
return EOVERLAP_AND_RESET;
}
if (srcLen + destLen >= destMax || strDest == strSrc) {
strDest[0] = L'\0';
if (destLen == destMax) {
SECUREC_ERROR_INVALID_PARAMTER("wcscat_s");
return EINVAL_AND_RESET;
}
SECUREC_ERROR_INVALID_RANGE("wcscat_s");
return ERANGE_AND_RESET;
}
/* Copy single character length include \0 */
SECUREC_MEMCPY_WARP_OPT(strDest + destLen, strSrc, (srcLen + 1) * sizeof(wchar_t));
return EOK;
}
/*
* <FUNCTION DESCRIPTION>
* The wcscat_s function appends a copy of the wide string pointed to by strSrc
* (including the terminating null wide character)
* to the end of the wide string pointed to by strDest.
* The arguments and return value of wcscat_s are wide-character strings.
*
* The wcscat_s function appends strSrc to strDest and terminates the resulting
* string with a null character. The initial character of strSrc overwrites the
* terminating null character of strDest. wcscat_s will return EOVERLAP_AND_RESET if the
* source and destination strings overlap.
*
* Note that the second parameter is the total size of the buffer, not the
* remaining size.
*
* <INPUT PARAMETERS>
* strDest Null-terminated destination string buffer.
* destMax Size of the destination string buffer.
* strSrc Null-terminated source string buffer.
*
* <OUTPUT PARAMETERS>
* strDest is updated
*
* <RETURN VALUE>
* EOK Success
* EINVAL strDest is NULL and destMax != 0 and destMax <= SECUREC_WCHAR_STRING_MAX_LEN
* EINVAL_AND_RESET (strDest unterminated and all other parameters are valid) or
* (strDest != NULL and strSrc is NULLL and destMax != 0
* and destMax <= SECUREC_WCHAR_STRING_MAX_LEN)
* ERANGE destMax > SECUREC_WCHAR_STRING_MAX_LEN or destMax is 0
* ERANGE_AND_RESET strDest have not enough space and all other parameters are valid and not overlap
* EOVERLAP_AND_RESET dest buffer and source buffer are overlapped and all parameters are valid
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*/
errno_t wcscat_s(wchar_t *strDest, size_t destMax, const wchar_t *strSrc)
{
if (destMax == 0 || destMax > SECUREC_WCHAR_STRING_MAX_LEN) {
SECUREC_ERROR_INVALID_RANGE("wcscat_s");
return ERANGE;
}
if (strDest == NULL || strSrc == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("wcscat_s");
if (strDest != NULL) {
strDest[0] = L'\0';
return EINVAL_AND_RESET;
}
return EINVAL;
}
return SecDoCatW(strDest, destMax, strSrc);
}
source/bootloader/u-boot-2020.01/lotus/securec/wcscpy_s.c
Executable
+76
View File
@@ -0,0 +1,76 @@
/*
*
*/
#include "securecutil.h"
SECUREC_INLINE errno_t SecDoCpyW(wchar_t *strDest, size_t destMax, const wchar_t *strSrc)
{
size_t srcStrLen;
SECUREC_CALC_WSTR_LEN(strSrc, destMax, &srcStrLen);
if (srcStrLen == destMax) {
strDest[0] = L'\0';
SECUREC_ERROR_INVALID_RANGE("wcscpy_s");
return ERANGE_AND_RESET;
}
if (strDest == strSrc) {
return EOK;
}
if (SECUREC_STRING_NO_OVERLAP(strDest, strSrc, srcStrLen)) {
/* Performance optimization, srcStrLen is single character length include '\0' */
SECUREC_MEMCPY_WARP_OPT(strDest, strSrc, (srcStrLen + 1) * sizeof(wchar_t));
return EOK;
} else {
strDest[0] = L'\0';
SECUREC_ERROR_BUFFER_OVERLAP("wcscpy_s");
return EOVERLAP_AND_RESET;
}
}
/*
* <FUNCTION DESCRIPTION>
* The wcscpy_s function copies the wide string pointed to by strSrc
* (including theterminating null wide character) into the array pointed to by strDest
* <INPUT PARAMETERS>
* strDest Destination string buffer
* destMax Size of the destination string buffer.
* strSrc Null-terminated source string buffer.
*
* <OUTPUT PARAMETERS>
* strDest is updated.
*
* <RETURN VALUE>
* EOK Success
* EINVAL strDest is NULL and destMax != 0 and destMax <= SECUREC_WCHAR_STRING_MAX_LEN
* EINVAL_AND_RESET strDest != NULL and strSrc is NULLL and destMax != 0
* and destMax <= SECUREC_WCHAR_STRING_MAX_LEN
* ERANGE destMax > SECUREC_WCHAR_STRING_MAX_LEN or destMax is 0
* ERANGE_AND_RESET destMax <= length of strSrc and strDest != strSrc
* and strDest != NULL and strSrc != NULL and destMax != 0
* and destMax <= SECUREC_WCHAR_STRING_MAX_LEN and not overlap
* EOVERLAP_AND_RESET dest buffer and source buffer are overlapped and destMax != 0
* and destMax <= SECUREC_WCHAR_STRING_MAX_LEN
* and strDest != NULL and strSrc !=NULL and strDest != strSrc
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*/
errno_t wcscpy_s(wchar_t *strDest, size_t destMax, const wchar_t *strSrc)
{
if (destMax == 0 || destMax > SECUREC_WCHAR_STRING_MAX_LEN) {
SECUREC_ERROR_INVALID_RANGE("wcscpy_s");
return ERANGE;
}
if (strDest == NULL || strSrc == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("wcscpy_s");
if (strDest != NULL) {
strDest[0] = L'\0';
return EINVAL_AND_RESET;
}
return EINVAL;
}
return SecDoCpyW(strDest, destMax, strSrc);
}
source/bootloader/u-boot-2020.01/lotus/securec/wcsncat_s.c
Executable
+103
View File
@@ -0,0 +1,103 @@
/*
*
*/
#include "securecutil.h"
/*
* Befor this function, the basic parameter checking has been done
*/
SECUREC_INLINE errno_t SecDoCatLimitW(wchar_t *strDest, size_t destMax, const wchar_t *strSrc, size_t count)
{
/* To calculate the length of a wide character, the parameter must be a wide character */
size_t destLen;
size_t srcLen;
SECUREC_CALC_WSTR_LEN(strDest, destMax, &destLen);
SECUREC_CALC_WSTR_LEN(strSrc, count, &srcLen);
if (SECUREC_CAT_STRING_IS_OVERLAP(strDest, destLen, strSrc, srcLen)) {
strDest[0] = L'\0';
if (strDest + destLen <= strSrc && destLen == destMax) {
SECUREC_ERROR_INVALID_PARAMTER("wcsncat_s");
return EINVAL_AND_RESET;
}
SECUREC_ERROR_BUFFER_OVERLAP("wcsncat_s");
return EOVERLAP_AND_RESET;
}
if (srcLen + destLen >= destMax || strDest == strSrc) {
strDest[0] = L'\0';
if (destLen == destMax) {
SECUREC_ERROR_INVALID_PARAMTER("wcsncat_s");
return EINVAL_AND_RESET;
}
SECUREC_ERROR_INVALID_RANGE("wcsncat_s");
return ERANGE_AND_RESET;
}
SECUREC_MEMCPY_WARP_OPT(strDest + destLen, strSrc, srcLen * sizeof(wchar_t)); /* no terminator */
*(strDest + destLen + srcLen) = L'\0';
return EOK;
}
/*
* <FUNCTION DESCRIPTION>
* The wcsncat_s function appends not more than n successive wide characters
* (not including the terminating null wide character)
* from the array pointed to by strSrc to the end of the wide string pointed to by strDest.
*
* The wcsncat_s function try to append the first D characters of strSrc to
* the end of strDest, where D is the lesser of count and the length of strSrc.
* If appending those D characters will fit within strDest (whose size is
* given as destMax) and still leave room for a null terminator, then those
* characters are appended, starting at the original terminating null of
* strDest, and a new terminating null is appended; otherwise, strDest[0] is
* set to the null character.
*
* <INPUT PARAMETERS>
* strDest Null-terminated destination string.
* destMax Size of the destination buffer.
* strSrc Null-terminated source string.
* count Number of character to append, or truncate.
*
* <OUTPUT PARAMETERS>
* strDest is updated
*
* <RETURN VALUE>
* EOK Success
* EINVAL strDest is NULL and destMax != 0 and destMax <= SECUREC_WCHAR_STRING_MAX_LEN
* EINVAL_AND_RESET (strDest unterminated and all other parameters are valid) or
* (strDest != NULL and strSrc is NULLL and destMax != 0 and
* destMax <= SECUREC_WCHAR_STRING_MAX_LEN)
* ERANGE destMax > SECUREC_WCHAR_STRING_MAX_LEN or destMax is 0
* ERANGE_AND_RESET strDest have not enough space and all other parameters are valid and not overlap
* EOVERLAP_AND_RESET dest buffer and source buffer are overlapped and all parameters are valid
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*/
errno_t wcsncat_s(wchar_t *strDest, size_t destMax, const wchar_t *strSrc, size_t count)
{
if (destMax == 0 || destMax > SECUREC_WCHAR_STRING_MAX_LEN) {
SECUREC_ERROR_INVALID_RANGE("wcsncat_s");
return ERANGE;
}
if (strDest == NULL || strSrc == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("wcsncat_s");
if (strDest != NULL) {
strDest[0] = L'\0';
return EINVAL_AND_RESET;
}
return EINVAL;
}
if (count > SECUREC_WCHAR_STRING_MAX_LEN) {
#ifdef SECUREC_COMPATIBLE_WIN_FORMAT
if (count == ((size_t)(-1))) {
/* Windows internal functions may pass in -1 when calling this function */
return SecDoCatLimitW(strDest, destMax, strSrc, destMax);
}
#endif
strDest[0] = L'\0';
SECUREC_ERROR_INVALID_RANGE("wcsncat_s");
return ERANGE_AND_RESET;
}
return SecDoCatLimitW(strDest, destMax, strSrc, count);
}
source/bootloader/u-boot-2020.01/lotus/securec/wcsncpy_s.c
Executable
+97
View File
@@ -0,0 +1,97 @@
/*
*
*/
#include "securecutil.h"
SECUREC_INLINE errno_t SecDoCpyLimitW(wchar_t *strDest, size_t destMax, const wchar_t *strSrc, size_t count)
{
size_t srcStrLen;
if (count < destMax) {
SECUREC_CALC_WSTR_LEN(strSrc, count, &srcStrLen);
} else {
SECUREC_CALC_WSTR_LEN(strSrc, destMax, &srcStrLen);
}
if (srcStrLen == destMax) {
strDest[0] = L'\0';
SECUREC_ERROR_INVALID_RANGE("wcsncpy_s");
return ERANGE_AND_RESET;
}
if (strDest == strSrc) {
return EOK;
}
if (SECUREC_STRING_NO_OVERLAP(strDest, strSrc, srcStrLen)) {
/* Performance optimization srcStrLen not include '\0' */
SECUREC_MEMCPY_WARP_OPT(strDest, strSrc, srcStrLen * sizeof(wchar_t));
*(strDest + srcStrLen) = L'\0';
return EOK;
} else {
strDest[0] = L'\0';
SECUREC_ERROR_BUFFER_OVERLAP("wcsncpy_s");
return EOVERLAP_AND_RESET;
}
}
/*
* <FUNCTION DESCRIPTION>
* The wcsncpy_s function copies not more than n successive wide characters
* (not including the terminating null wide character)
* from the array pointed to by strSrc to the array pointed to by strDest
*
* <INPUT PARAMETERS>
* strDest Destination string.
* destMax The size of the destination string, in characters.
* strSrc Source string.
* count Number of characters to be copied.
*
* <OUTPUT PARAMETERS>
* strDest is updated
*
* <RETURN VALUE>
* EOK Success
* EINVAL strDest is NULL and destMax != 0 and destMax <= SECUREC_WCHAR_STRING_MAX_LEN
* EINVAL_AND_RESET strDest != NULL and strSrc is NULLL and destMax != 0
* and destMax <= SECUREC_WCHAR_STRING_MAX_LEN
* ERANGE destMax > SECUREC_WCHAR_STRING_MAX_LEN or destMax is 0
* ERANGE_AND_RESET count > SECUREC_WCHAR_STRING_MAX_LEN or
* (destMax <= length of strSrc and destMax <= count and strDest != strSrc
* and strDest != NULL and strSrc != NULL and destMax != 0 and
* destMax <= SECUREC_WCHAR_STRING_MAX_LEN and not overlap)
* EOVERLAP_AND_RESET dest buffer and source buffer are overlapped and all parameters are valid
*
*
* If there is a runtime-constraint violation, strDest[0] will be set to the '\0' when strDest and destMax valid
*/
errno_t wcsncpy_s(wchar_t *strDest, size_t destMax, const wchar_t *strSrc, size_t count)
{
if (destMax == 0 || destMax > SECUREC_WCHAR_STRING_MAX_LEN) {
SECUREC_ERROR_INVALID_RANGE("wcsncpy_s");
return ERANGE;
}
if (strDest == NULL || strSrc == NULL) {
SECUREC_ERROR_INVALID_PARAMTER("wcsncpy_s");
if (strDest != NULL) {
strDest[0] = L'\0';
return EINVAL_AND_RESET;
}
return EINVAL;
}
if (count > SECUREC_WCHAR_STRING_MAX_LEN) {
#ifdef SECUREC_COMPATIBLE_WIN_FORMAT
if (count == (size_t)(-1)) {
return SecDoCpyLimitW(strDest, destMax, strSrc, destMax - 1);
}
#endif
strDest[0] = L'\0'; /* Clear dest string */
SECUREC_ERROR_INVALID_RANGE("wcsncpy_s");
return ERANGE_AND_RESET;
}
if (count == 0) {
strDest[0] = L'\0';
return EOK;
}
return SecDoCpyLimitW(strDest, destMax, strSrc, count);
}
source/bootloader/u-boot-2020.01/lotus/securec/wcstok_s.c
Executable
+102
View File
@@ -0,0 +1,102 @@
/*
*
*/
#include "securecutil.h"
SECUREC_INLINE int SecIsInDelimitW(wchar_t ch, const wchar_t *strDelimit)
{
const wchar_t *ctl = strDelimit;
while (*ctl != L'\0' && *ctl != ch) {
++ctl;
}
return (int)(*ctl != L'\0');
}
/*
* Find beginning of token (skip over leading delimiters).
* Note that there is no token if this loop sets string to point to the terminal null.
*/
SECUREC_INLINE wchar_t *SecFindBeginW(wchar_t *strToken, const wchar_t *strDelimit)
{
wchar_t *token = strToken;
while (*token != L'\0') {
if (SecIsInDelimitW(*token, strDelimit) != 0) {
++token;
continue;
}
/* Don't find any delimiter in string header, break the loop */
break;
}
return token;
}
/*
* Find the end of the token. If it is not the end of the string, put a null there.
*/
SECUREC_INLINE wchar_t *SecFindRestW(wchar_t *strToken, const wchar_t *strDelimit)
{
wchar_t *token = strToken;
while (*token != L'\0') {
if (SecIsInDelimitW(*token, strDelimit) != 0) {
/* Find a delimiter, set string termintor */
*token = L'\0';
++token;
break;
}
++token;
}
return token;
}
/*
* Update Token wide character function
*/
SECUREC_INLINE wchar_t *SecUpdateTokenW(wchar_t *strToken, const wchar_t *strDelimit, wchar_t **context)
{
/* Point to updated position. Record string position for next search in the context */
*context = SecFindRestW(strToken, strDelimit);
/* Determine if a token has been found */
if (*context == strToken) {
return NULL;
}
return strToken;
}
/*
* <NAME>
* wcstok_s
*
*
* <FUNCTION DESCRIPTION>
* The wcstok_s function is the wide-character equivalent of the strtok_s function
*
* <INPUT PARAMETERS>
* strToken String containing token or tokens.
* strDelimit Set of delimiter characters.
* context Used to store position information between calls to
* wcstok_s.
*
* <OUTPUT PARAMETERS>
* context is updated
* <RETURN VALUE>
* The wcstok_s function is the wide-character equivalent of the strtok_s function
*/
wchar_t *wcstok_s(wchar_t *strToken, const wchar_t *strDelimit, wchar_t **context)
{
wchar_t *orgToken = strToken;
/* Validation section */
if (context == NULL || strDelimit == NULL) {
return NULL;
}
if (orgToken == NULL && *context == NULL) {
return NULL;
}
/* If string==NULL, continue with previous string */
if (orgToken == NULL) {
orgToken = *context;
}
orgToken = SecFindBeginW(orgToken, strDelimit);
return SecUpdateTokenW(orgToken, strDelimit, context);
}
source/bootloader/u-boot-2020.01/lotus/securec/wmemcpy_s.c
Executable
+61
View File
@@ -0,0 +1,61 @@
/*
*
*/
/*
* [Standardize-exceptions] Use unsafe function: Portability
* [reason] Use unsafe function to implement security function to maintain platform compatibility.
* And sufficient input validation is performed before calling
*/
#include "securecutil.h"
/*
* <FUNCTION DESCRIPTION>
* The wmemcpy_s function copies n successive wide characters
* from the object pointed to by src into the object pointed to by dest.t.
*
* <INPUT PARAMETERS>
* dest Destination buffer.
* destMax Size of the destination buffer.
* src Buffer to copy from.
* count Number of characters to copy.
*
* <OUTPUT PARAMETERS>
* dest buffer is uptdated.
*
* <RETURN VALUE>
* EOK Success
* EINVAL dest is NULL and destMax != 0 and count <= destMax
* and destMax <= SECUREC_WCHAR_MEM_MAX_LEN
* EINVAL_AND_RESET dest != NULL and src is NULLL and destMax != 0
* and destMax <= SECUREC_WCHAR_MEM_MAX_LEN and count <= destMax
* ERANGE destMax > SECUREC_WCHAR_MEM_MAX_LEN or destMax is 0 or
* (count > destMax and dest is NULL and destMax != 0
* and destMax <= SECUREC_WCHAR_MEM_MAX_LEN)
* ERANGE_AND_RESET count > destMax and dest != NULL and destMax != 0
* and destMax <= SECUREC_WCHAR_MEM_MAX_LEN
* EOVERLAP_AND_RESET dest buffer and source buffer are overlapped and
* count <= destMax destMax != 0 and destMax <= SECUREC_WCHAR_MEM_MAX_LEN
* and dest != NULL and src != NULL and dest != src
*
* if an error occured, dest will be filled with 0 when dest and destMax valid .
* If the source and destination overlap, the behavior of wmemcpy_s is undefined.
* Use wmemmove_s to handle overlapping regions.
*/
errno_t wmemcpy_s(wchar_t *dest, size_t destMax, const wchar_t *src, size_t count)
{
if (destMax == 0 || destMax > SECUREC_WCHAR_MEM_MAX_LEN) {
SECUREC_ERROR_INVALID_PARAMTER("wmemcpy_s");
return ERANGE;
}
if (count > destMax) {
SECUREC_ERROR_INVALID_PARAMTER("wmemcpy_s");
if (dest != NULL) {
(void)memset(dest, 0, destMax * sizeof(wchar_t));
return ERANGE_AND_RESET;
}
return ERANGE;
}
return memcpy_s(dest, destMax * sizeof(wchar_t), src, count * sizeof(wchar_t));
}
source/bootloader/u-boot-2020.01/lotus/securec/wmemmove_s.c
Executable
+60
View File
@@ -0,0 +1,60 @@
/*
*
*/
/*
* [Standardize-exceptions] Use unsafe function: Portability
* [reason] Use unsafe function to implement security function to maintain platform compatibility.
* And sufficient input validation is performed before calling
*/
#include "securecutil.h"
/*
* <FUNCTION DESCRIPTION>
* The wmemmove_s function copies n successive wide characters from the object pointed
* to by src into the object pointed to by dest.
*
* <INPUT PARAMETERS>
* dest Destination buffer.
* destMax Size of the destination buffer.
* src Source object.
* count Number of bytes or character to copy.
*
* <OUTPUT PARAMETERS>
* dest is updated.
*
* <RETURN VALUE>
* EOK Success
* EINVAL dest is NULL and destMax != 0 and count <= destMax
* and destMax <= SECUREC_WCHAR_MEM_MAX_LEN
* EINVAL_AND_RESET dest != NULL and src is NULLL and destMax != 0
* and destMax <= SECUREC_WCHAR_MEM_MAX_LEN and count <= destMax
* ERANGE destMax > SECUREC_WCHAR_MEM_MAX_LEN or destMax is 0 or
* (count > destMax and dest is NULL and destMax != 0
* and destMax <= SECUREC_WCHAR_MEM_MAX_LEN)
* ERANGE_AND_RESET count > destMax and dest != NULL and destMax != 0
* and destMax <= SECUREC_WCHAR_MEM_MAX_LEN
*
*
* If an error occured, dest will be filled with 0 when dest and destMax valid.
* If some regions of the source area and the destination overlap, wmemmove_s
* ensures that the original source bytes in the overlapping region are copied
* before being overwritten
*/
errno_t wmemmove_s(wchar_t *dest, size_t destMax, const wchar_t *src, size_t count)
{
if (destMax == 0 || destMax > SECUREC_WCHAR_MEM_MAX_LEN) {
SECUREC_ERROR_INVALID_PARAMTER("wmemmove_s");
return ERANGE;
}
if (count > destMax) {
SECUREC_ERROR_INVALID_PARAMTER("wmemmove_s");
if (dest != NULL) {
(void)memset(dest, 0, destMax * sizeof(wchar_t));
return ERANGE_AND_RESET;
}
return ERANGE;
}
return memmove_s(dest, destMax * sizeof(wchar_t), src, count * sizeof(wchar_t));
}
source/bootloader/u-boot-2020.01/lotus/securec/wscanf_s.c
Executable
+42
View File
@@ -0,0 +1,42 @@
/*
*
*/
#include "linux/lotus/securec.h"
/*
* <NAME>
* <FUNCTION DESCRIPTION>
* The wscanf_s function is the wide-character equivalent of the scanf_s function
* The wscanf_s function reads data from the standard input stream stdin and
* writes the data into the location that's given by argument. Each argument
* must be a pointer to a variable of a type that corresponds to a type specifier
* in format. If copying occurs between strings that overlap, the behavior is
* undefined.
*
* <INPUT PARAMETERS>
* format Format control string.
* ... Optional arguments.
*
* <OUTPUT PARAMETERS>
* ... the converted value stored in user assigned address
*
* <RETURN VALUE>
* Returns the number of fields successfully converted and assigned;
* the return value does not include fields that were read but not assigned.
* A return value of 0 indicates that no fields were assigned.
* return -1 if an error occurs.
*/
int wscanf_s(const wchar_t *format, ...)
{
int ret; /* If initialization causes e838 */
va_list argList;
va_start(argList, format);
ret = vwscanf_s(format, argList);
va_end(argList);
(void)argList; /* To clear e438 last value assigned not used , the compiler will optimize this code */
return ret;
}