469 lines
12 KiB
C
469 lines
12 KiB
C
|
/*******************************************************************************
|
||
|
|
* Copyright @ Huawei Technologies Co., Ltd. 1998-2014. All rights reserved.
|
||
|
|
* File name: securecutil.c
|
||
|
|
* Decription:
|
||
|
|
* provides internal functions used by this library, such as memory
|
||
|
|
* copy and memory move. Besides, include some helper function for
|
||
|
|
* printf family API, such as vsnprintf_helper, SECUREC_PUTC_NOLOCK,
|
||
|
|
* __putwc_nolock. Also includes some folat converting function, such
|
||
|
|
* as cvt, ecvtbuf, fcvtbuf, cfltcvt.
|
||
|
|
* History:
|
||
|
|
* 1. Date: 2014/4/10
|
||
|
|
* Author: LiShunda
|
||
|
|
* Modification: move vswprintf_helper() function from this file to vswprintf.c,
|
||
|
|
* which make this file only contain ANSI string function. This will
|
||
|
|
* facilitate the ANSI string API building.
|
||
|
|
* 2. Date: 2014/4/10
|
||
|
|
* Author: LiShunda
|
||
|
|
* Modification: add int putWcharStrEndingZero(SECUREC_XPRINTF_STREAM* str, int zerosNum)
|
||
|
|
* function. In vswprintf.c, the original code use (SECUREC_PUTC_NOLOCK('\0', str) != EOF )
|
||
|
|
* four times and a do-while wrapper which is NOT easy to read and understand,
|
||
|
|
* so abstract this function.
|
||
|
|
* 3. Date: 2014/4/10
|
||
|
|
* Author: LiShunda
|
||
|
|
* Modification: change a variabel name "exp" in function "cfltcvt" to "expVal", for "exp" is a function name in <math.h>,
|
||
|
|
* which make pclint warning.
|
||
|
|
* 4. Date: 2014/4/10
|
||
|
|
* Author: LiShunda
|
||
|
|
* Modification: remove 'char* s__nullstring = "(null)"' and 'wchar_t* s__wnullstring = L"(null)"' to
|
||
|
|
* to avoid pclint warning on "redundant statement declared symbol's__nullstring'".
|
||
|
|
* 4. Date: 2014/5/7
|
||
|
|
* Author: LiShunda
|
||
|
|
* Modification: replace memcpy with memcpy_s at line 558
|
||
|
|
* 5. Date: 2014/5/20
|
||
|
|
* Author: LiShunda
|
||
|
|
* Modification: change the return type of function "__putwc_nolock" from unsigned short to
|
||
|
|
* wchar_t.
|
||
|
|
* 6. Date: 2014/6/4
|
||
|
|
* Author: LiShunda
|
||
|
|
* Modification: change the function name from "fcvtbuf" to "fcvtbuf_hw", and add "static" modifier.
|
||
|
|
* change the function name from "ecvtbuf" to "ecvtbuf_hw", and add "static" modifier.
|
||
|
|
* 7. Date: 2014/6/8
|
||
|
|
* Author: LiShunda
|
||
|
|
* Modification: move the functions of __putwc_nolock, write_char_w, write_multi_char_w
|
||
|
|
* and write_string_w from this file to secureprintoutput_w.c. In ANSI mode build,
|
||
|
|
* these functions are NOT needed, which can reduce code generation size
|
||
|
|
* and let securecutil.c NOT include <wchar.h>.
|
||
|
|
* 8. Date: 2014/7/1
|
||
|
|
* Author: LiShunda
|
||
|
|
* Modification: move "securec__lookuptable_s[]" from this file to output.inl, which is to avoid
|
||
|
|
* redefinition when multiple secure c library are integrated.
|
||
|
|
********************************************************************************
|
||
|
|
*/
|
||
|
|
|
||
|
|
//#include <math.h>
|
||
|
|
#include "securec.h"
|
||
|
|
#include "securecutil.h"
|
||
|
|
#include "secureprintoutput.h"
|
||
|
|
|
||
|
|
#define EOF (-1)
|
||
|
|
//#include <string.h>
|
||
|
|
#include <stdarg.h>
|
||
|
|
|
||
|
|
#ifdef ANDROID
|
||
|
|
#include <wchar.h>
|
||
|
|
|
||
|
|
int wctomb(char *s, wchar_t wc)
|
||
|
|
{
|
||
|
|
return wcrtomb(s, wc, NULL);
|
||
|
|
}
|
||
|
|
int mbtowc(wchar_t *pwc, const char *s, size_t n)
|
||
|
|
{
|
||
|
|
return mbrtowc(pwc, s, n, NULL);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/*verNumber<->verStr like:0X502<->SPC002;0X503<->SPC003...;0X510<->SPC010;0X511<->SPC011...*/
|
||
|
|
void getHwSecureCVersion(char *verStr, int bufSize, unsigned short *verNumber)
|
||
|
|
{
|
||
|
|
if (verStr != NULL && bufSize > 0) {
|
||
|
|
(void)strcpy_s(verStr, (size_t)bufSize, "Huawei Secure C V100R001C01SPC003");
|
||
|
|
}
|
||
|
|
if (verNumber != NULL) {
|
||
|
|
*verNumber = (5 << 8 | 3);/*high Num << 8 | num of spc Ver*/
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void util_memmove(void *dst, const void *src, size_t count)
|
||
|
|
{
|
||
|
|
UINT8T *pDest = (UINT8T *)dst;
|
||
|
|
UINT8T *pSrc = (UINT8T *)src;
|
||
|
|
|
||
|
|
if (dst <= src || pDest >= (pSrc + count)) _CHECK_BUFFER_OVERLAP {
|
||
|
|
/*
|
||
|
|
* Non-Overlapping Buffers
|
||
|
|
* copy from lower addresses to higher addresses
|
||
|
|
*/
|
||
|
|
while (count--) {
|
||
|
|
*pDest = *(UINT8T *)pSrc;
|
||
|
|
++pDest;
|
||
|
|
++pSrc;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
/*
|
||
|
|
* Overlapping Buffers
|
||
|
|
* copy from higher addresses to lower addresses
|
||
|
|
*/
|
||
|
|
pDest = pDest + count - 1;
|
||
|
|
pSrc = pSrc + count - 1;
|
||
|
|
|
||
|
|
while (count--) {
|
||
|
|
*pDest = *pSrc;
|
||
|
|
|
||
|
|
--pDest;
|
||
|
|
--pSrc;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/*put a char to output stream */
|
||
|
|
#define SECUREC_PUTC_NOLOCK(_c,_stream) (--(_stream)->_cnt >= 0 ? 0xff & (*(_stream)->_ptr++ = (char)(_c)) : EOF)
|
||
|
|
|
||
|
|
int putWcharStrEndingZero(SECUREC_XPRINTF_STREAM *str, int zerosNum)
|
||
|
|
{
|
||
|
|
int succeed = 0, i = 0;
|
||
|
|
|
||
|
|
for (; i < zerosNum && (SECUREC_PUTC_NOLOCK('\0', str) != EOF); ++i) {
|
||
|
|
}
|
||
|
|
if (i == zerosNum) {
|
||
|
|
succeed = 1;
|
||
|
|
}
|
||
|
|
return succeed;
|
||
|
|
}
|
||
|
|
|
||
|
|
int vsnprintf_helper(char *string, size_t count, const char *format, va_list arglist)
|
||
|
|
{
|
||
|
|
SECUREC_XPRINTF_STREAM str;
|
||
|
|
int retval;
|
||
|
|
|
||
|
|
str._cnt = (int)count;
|
||
|
|
str._ptr = string;
|
||
|
|
|
||
|
|
retval = securec_output_s(&str, format, arglist);
|
||
|
|
if ((retval >= 0) && (SECUREC_PUTC_NOLOCK('\0', &str) != EOF)) {
|
||
|
|
return (retval);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (string != NULL) {
|
||
|
|
string[count - 1] = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (str._cnt < 0) {
|
||
|
|
/* the buffer was too small; we return -2 to indicate truncation */
|
||
|
|
return -2;
|
||
|
|
}
|
||
|
|
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
remove it */
|
||
|
|
void write_char_a(char ch, SECUREC_XPRINTF_STREAM *f, int *pnumwritten)
|
||
|
|
{
|
||
|
|
if (SECUREC_PUTC_NOLOCK(ch, f) == EOF) {
|
||
|
|
*pnumwritten = -1;
|
||
|
|
} else {
|
||
|
|
++(*pnumwritten);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void write_multi_char_a(char ch, int num, SECUREC_XPRINTF_STREAM *f, int *pnumwritten)
|
||
|
|
{
|
||
|
|
while (num-- > 0) {
|
||
|
|
if (SECUREC_PUTC_NOLOCK(ch, f) == EOF) {
|
||
|
|
*pnumwritten = -1;
|
||
|
|
break;
|
||
|
|
} else {
|
||
|
|
++(*pnumwritten);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
void write_string_a(char *string, int len, SECUREC_XPRINTF_STREAM *f, int *pnumwritten)
|
||
|
|
{
|
||
|
|
while (len-- > 0) {
|
||
|
|
if (SECUREC_PUTC_NOLOCK(*string, f) == EOF) {
|
||
|
|
*pnumwritten = -1;
|
||
|
|
break;
|
||
|
|
} else {
|
||
|
|
++(*pnumwritten);
|
||
|
|
++string;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Following function "U64Div32" realized the operation of division between an unsigned 64-bits
|
||
|
|
* number and an unsigned 32-bits number.
|
||
|
|
* these codes are contributed by Dopra team in syslib.
|
||
|
|
*/
|
||
|
|
#if defined(VXWORKS_VERSION)
|
||
|
|
|
||
|
|
#define SEC_MAX_SHIFT_NUM 32
|
||
|
|
#define SEC_MASK_BIT_ALL 0xFFFFFFFF
|
||
|
|
#define SEC_MASK_BIT_32 0x80000000
|
||
|
|
#define SEC_MASK_BIT_01 0x00000001
|
||
|
|
#define SEC_MASK_HI_NBITS(x) (SEC_MASK_BIT_ALL << (SEC_MAX_SHIFT_NUM - (x)))
|
||
|
|
|
||
|
|
typedef enum tagbit64SecCompareResult {
|
||
|
|
SEC_BIT64_GREAT,
|
||
|
|
SEC_BIT64_EQUAL,
|
||
|
|
SEC_BIT64_LESS
|
||
|
|
} bit64SecCompareResult;
|
||
|
|
|
||
|
|
#define SEC_BIT64_SUB(argAHi, argALo, argBHi, argBLo) \
|
||
|
|
do \
|
||
|
|
{ \
|
||
|
|
if ((argALo) < (argBLo)) \
|
||
|
|
{ \
|
||
|
|
(argAHi) -= ((argBHi) + 1); \
|
||
|
|
} \
|
||
|
|
else \
|
||
|
|
{ \
|
||
|
|
(argAHi) -= (argBHi); \
|
||
|
|
} \
|
||
|
|
(argALo) -= (argBLo); \
|
||
|
|
} while (0)
|
||
|
|
|
||
|
|
#define SEC_BIT64_COMPARE(argAHi, argALo, argBHi, argBLo, result) \
|
||
|
|
do \
|
||
|
|
{ \
|
||
|
|
if ((argAHi) > (argBHi)) \
|
||
|
|
{ \
|
||
|
|
result = SEC_BIT64_GREAT; \
|
||
|
|
} \
|
||
|
|
else if (((argAHi) == (argBHi)) && ((argALo) > (argBLo))) \
|
||
|
|
{ \
|
||
|
|
result = SEC_BIT64_GREAT; \
|
||
|
|
} \
|
||
|
|
else if (((argAHi) == (argBHi)) && ((argALo) == (argBLo))) \
|
||
|
|
{ \
|
||
|
|
result = SEC_BIT64_EQUAL; \
|
||
|
|
} \
|
||
|
|
else \
|
||
|
|
{ \
|
||
|
|
result = SEC_BIT64_LESS; \
|
||
|
|
} \
|
||
|
|
} while (0)
|
||
|
|
|
||
|
|
INT32T U64Div64(UINT32T uiDividendHigh,
|
||
|
|
UINT32T uiDividendLow,
|
||
|
|
UINT32T uiDivisorHigh,
|
||
|
|
UINT32T uiDivisorLow,
|
||
|
|
UINT32T *puiQuotientHigh,
|
||
|
|
UINT32T *puiQuotientLow,
|
||
|
|
UINT32T *puiRemainderHigh,
|
||
|
|
UINT32T *puiRemainderLow)
|
||
|
|
{
|
||
|
|
INT8T scShiftNumHi = 0, scShiftNumLo = 0;
|
||
|
|
UINT32T uiTmpQuoHi, uiTmpQuoLo;
|
||
|
|
UINT32T uiTmpDividendHi, uiTmpDividendLo;
|
||
|
|
UINT32T uiTmpDivisorHi, uiTmpDivisorLo;
|
||
|
|
bit64SecCompareResult etmpResult;
|
||
|
|
|
||
|
|
if ((NULL == puiQuotientHigh) || (NULL == puiQuotientLow)) {
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (0 == uiDivisorHigh) {
|
||
|
|
if (0 == uiDivisorLow) {
|
||
|
|
return -1;
|
||
|
|
} else if (1 == uiDivisorLow) {
|
||
|
|
*puiQuotientHigh = uiDividendHigh;
|
||
|
|
*puiQuotientLow = uiDividendLow;
|
||
|
|
|
||
|
|
if (NULL != puiRemainderHigh
|
||
|
|
&& NULL != puiRemainderLow) {
|
||
|
|
*puiRemainderHigh = 0;
|
||
|
|
*puiRemainderLow = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
uiTmpQuoHi = uiTmpQuoLo = 0;
|
||
|
|
uiTmpDividendHi = uiDividendHigh;
|
||
|
|
uiTmpDividendLo = uiDividendLow;
|
||
|
|
|
||
|
|
/* if divisor is larger than dividend, quotient equals to zero,
|
||
|
|
* remainder equals to dividends */
|
||
|
|
SEC_BIT64_COMPARE(uiDividendHigh, uiDividendLow,
|
||
|
|
uiDivisorHigh, uiDivisorLow, etmpResult);
|
||
|
|
|
||
|
|
if (SEC_BIT64_LESS == etmpResult) {
|
||
|
|
goto returnHandle;
|
||
|
|
}
|
||
|
|
|
||
|
|
else if (SEC_BIT64_EQUAL == etmpResult) {
|
||
|
|
*puiQuotientHigh = 0;
|
||
|
|
*puiQuotientLow = 1;
|
||
|
|
|
||
|
|
if ((NULL != puiRemainderHigh) && (NULL != puiRemainderLow)) {
|
||
|
|
*puiRemainderHigh = 0;
|
||
|
|
*puiRemainderLow = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* get shift number to implement divide arithmetic */
|
||
|
|
if (uiDivisorHigh > 0) {
|
||
|
|
for (scShiftNumHi = 0; scShiftNumHi < SEC_MAX_SHIFT_NUM; scShiftNumHi++) {
|
||
|
|
if ((uiDivisorHigh << scShiftNumHi) & SEC_MASK_BIT_32) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
for (scShiftNumLo = 0; scShiftNumLo < SEC_MAX_SHIFT_NUM; scShiftNumLo++) {
|
||
|
|
if ((uiDivisorLow << scShiftNumLo) & SEC_MASK_BIT_32) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (uiDivisorHigh > 0) {
|
||
|
|
/* divisor's high 32 bits doesn't equal to zero */
|
||
|
|
|
||
|
|
for (; scShiftNumHi >= 0; scShiftNumHi--) {
|
||
|
|
|
||
|
|
if (0 == scShiftNumHi) {
|
||
|
|
uiTmpDivisorHi = uiDivisorHigh;
|
||
|
|
} else {
|
||
|
|
uiTmpDivisorHi = (uiDivisorHigh << scShiftNumHi)
|
||
|
|
| (uiDivisorLow >> (SEC_MAX_SHIFT_NUM - scShiftNumHi));
|
||
|
|
}
|
||
|
|
|
||
|
|
uiTmpDivisorLo = uiDivisorLow << scShiftNumHi;
|
||
|
|
|
||
|
|
SEC_BIT64_COMPARE(uiTmpDividendHi, uiTmpDividendLo,
|
||
|
|
uiTmpDivisorHi, uiTmpDivisorLo, etmpResult);
|
||
|
|
|
||
|
|
if (SEC_BIT64_LESS != etmpResult) {
|
||
|
|
SEC_BIT64_SUB(uiTmpDividendHi, uiTmpDividendLo,
|
||
|
|
uiTmpDivisorHi, uiTmpDivisorLo);
|
||
|
|
|
||
|
|
uiTmpQuoLo |= (1 << scShiftNumHi);
|
||
|
|
|
||
|
|
if ((0 == uiTmpDividendHi) && (0 == uiTmpDividendLo)) {
|
||
|
|
goto returnHandle;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (0 == scShiftNumHi)
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
} else {
|
||
|
|
/* divisor's high 32 bits equals to zero */
|
||
|
|
|
||
|
|
scShiftNumHi = scShiftNumLo;
|
||
|
|
|
||
|
|
for (; scShiftNumHi >= 0; scShiftNumHi--) {
|
||
|
|
uiTmpDivisorHi = uiDivisorLow << scShiftNumHi;
|
||
|
|
SEC_BIT64_COMPARE(uiTmpDividendHi, uiTmpDividendLo,
|
||
|
|
uiTmpDivisorHi, 0, etmpResult);
|
||
|
|
|
||
|
|
if (SEC_BIT64_LESS != etmpResult) {
|
||
|
|
UINT32T uiTmp = 0;
|
||
|
|
SEC_BIT64_SUB(uiTmpDividendHi, uiTmpDividendLo,
|
||
|
|
uiTmpDivisorHi, uiTmp);
|
||
|
|
|
||
|
|
uiTmpQuoHi |= (1 << scShiftNumHi);
|
||
|
|
|
||
|
|
if ((0 == uiTmpDividendHi) && (0 == uiTmpDividendLo)) {
|
||
|
|
goto returnHandle;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (0 == scShiftNumHi)
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (scShiftNumHi = SEC_MAX_SHIFT_NUM - 1; scShiftNumHi >= 0; scShiftNumHi--) {
|
||
|
|
if (0 == scShiftNumHi) {
|
||
|
|
uiTmpDivisorHi = 0;
|
||
|
|
} else {
|
||
|
|
uiTmpDivisorHi = uiDivisorLow >> (SEC_MAX_SHIFT_NUM - scShiftNumHi);
|
||
|
|
}
|
||
|
|
|
||
|
|
uiTmpDivisorLo = uiDivisorLow << scShiftNumHi;
|
||
|
|
|
||
|
|
SEC_BIT64_COMPARE(uiTmpDividendHi, uiTmpDividendLo,
|
||
|
|
uiTmpDivisorHi, uiTmpDivisorLo, etmpResult);
|
||
|
|
|
||
|
|
if (SEC_BIT64_LESS != etmpResult) {
|
||
|
|
SEC_BIT64_SUB(uiTmpDividendHi, uiTmpDividendLo,
|
||
|
|
uiTmpDivisorHi, uiTmpDivisorLo);
|
||
|
|
|
||
|
|
uiTmpQuoLo |= (1 << scShiftNumHi);
|
||
|
|
|
||
|
|
if ((0 == uiTmpDividendHi) && (0 == uiTmpDividendLo)) {
|
||
|
|
goto returnHandle;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (0 == scShiftNumHi)
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
returnHandle:
|
||
|
|
|
||
|
|
*puiQuotientHigh = uiTmpQuoHi;
|
||
|
|
*puiQuotientLow = uiTmpQuoLo;
|
||
|
|
|
||
|
|
if ((NULL != puiRemainderHigh)
|
||
|
|
&& (NULL != puiRemainderLow)) {
|
||
|
|
*puiRemainderHigh = uiTmpDividendHi;
|
||
|
|
*puiRemainderLow = uiTmpDividendLo;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
INT32T U64Div32(UINT32T uiDividendHigh,
|
||
|
|
UINT32T uiDividendLow,
|
||
|
|
UINT32T uiDivisor,
|
||
|
|
UINT32T *puiQuotientHigh,
|
||
|
|
UINT32T *puiQuotientLow,
|
||
|
|
UINT32T *puiRemainder)
|
||
|
|
{
|
||
|
|
UINT32T uiTmpRemainderHi = 0, uiTmpRemainderLo = 0;
|
||
|
|
UINT32T uiRet = 0;
|
||
|
|
|
||
|
|
if ((NULL == puiQuotientHigh)
|
||
|
|
|| (NULL == puiQuotientLow)
|
||
|
|
|| 0 == uiDivisor || NULL == puiRemainder) {
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
uiDividendHigh &= SEC_MASK_BIT_ALL;
|
||
|
|
uiDividendLow &= SEC_MASK_BIT_ALL;
|
||
|
|
uiDivisor &= SEC_MASK_BIT_ALL;
|
||
|
|
*puiQuotientHigh = 0;
|
||
|
|
*puiQuotientLow = 0;
|
||
|
|
*puiRemainder = 0;
|
||
|
|
|
||
|
|
uiRet = U64Div64(uiDividendHigh,
|
||
|
|
uiDividendLow,
|
||
|
|
0,
|
||
|
|
uiDivisor,
|
||
|
|
puiQuotientHigh,
|
||
|
|
puiQuotientLow,
|
||
|
|
&uiTmpRemainderHi,
|
||
|
|
&uiTmpRemainderLo);
|
||
|
|
if (0 != uiRet) {
|
||
|
|
return uiRet;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (NULL != puiRemainder) {
|
||
|
|
if (0 != uiTmpRemainderHi) {
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
*puiRemainder = uiTmpRemainderLo;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
#endif
|