openharmony/security_huks
1
0
Fork 0
mirror of https://gitee.com/openharmony/security_huks synced 2024-11-30 10:21:22 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

!1003 修改锁屏状态错误码

Browse Source 
Merge pull request !1003 from CooperTang/fix_errno
This commit is contained in:
openharmony_ci 2023-12-25 11:28:36 +00:00 committed by Gitee
commit af2c37bffa
No known key found for this signature in database
GPG Key ID: 173E9B9CA92EEF8F
15 changed files with 141 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
services/huks_standard/huks_service/main/core/src/hks_storage.c
View File

@ -391,19 +391,19 @@ static int32_t HksStorageWriteFile(
#endif
}
static uint32_t HksStorageReadFile(
const char *path, const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len)
static int32_t HksStorageReadFile(
const char *path, const char *fileName, uint32_t offset, struct HksBlob *blob, uint32_t *size)
{
#ifdef HKS_SUPPORT_THREAD
HksStorageFileLock *lock = CreateStorageFileLock(path, fileName);
HksStorageFileLockRead(lock);
uint32_t size = HksFileRead(path, fileName, offset, buf, len);
int32_t ret = HksFileRead(path, fileName, offset, blob, size);
HksStorageFileUnlockRead(lock);
HksStorageFileLockRelease(lock);
#else
uint32_t size = HksFileRead(path, fileName, offset, buf, len);
int32_t ret = HksFileRead(path, fileName, offset, blob, size);
#endif
return size;
return ret;
}
#ifdef HKS_ENABLE_CLEAN_FILE
@ -508,11 +508,17 @@ static int32_t CopyKeyBlobFromSrc(const char *srcPath, const char *srcFileName,
(void)memset_s(buffer, size, 0, size);
struct HksBlob blob = { .size = size, .data = buffer };
int32_t ret;
do {
size = HksStorageReadFile(srcPath, srcFileName, 0, buffer, size);
if (size == 0) {
HKS_LOG_E("read file failed, ret = %" LOG_PUBLIC "u.", size);
ret = HksStorageReadFile(srcPath, srcFileName, 0, &blob, &size);
if (ret != HKS_SUCCESS) {
if (ret == HKS_ERROR_NO_PERMISSION) {
HKS_LOG_E("Check Permission failed, ret = %" LOG_PUBLIC "d.", ret);
break;
}
HKS_LOG_E("read file failed, ret = %" LOG_PUBLIC "d.", ret);
ret = HKS_ERROR_READ_FILE_FAIL;
break;
}
@ -567,12 +573,15 @@ static int32_t GetKeyBlobFromFile(const char *path, const char *fileName, struct
return HKS_ERROR_INSUFFICIENT_DATA;
}
size = HksStorageReadFile(path, fileName, 0, keyBlob->data, keyBlob->size);
if (size == 0) {
HKS_LOG_E("file read failed, ret = %" LOG_PUBLIC "u.", size);
int32_t ret = HksStorageReadFile(path, fileName, 0, keyBlob, &size);
if (ret != HKS_SUCCESS) {
if (ret == HKS_ERROR_NO_PERMISSION) {
HKS_LOG_E("Check Permission failed, ret = %" LOG_PUBLIC "d.", ret);
return ret;
}
HKS_LOG_E("read file failed, ret = %" LOG_PUBLIC "d.", ret);
return HKS_ERROR_READ_FILE_FAIL;
}
keyBlob->size = size;
return HKS_SUCCESS;
}

19
services/huks_standard/huks_service/main/core/src/hks_storage_lite.c
View File

@ -177,8 +177,10 @@ static int32_t FreshImageBuffer(const char *fileName)
uint8_t *buf = (uint8_t *)HksMalloc(totalLen);
HKS_IF_NULL_RETURN(buf, HKS_ERROR_MALLOC_FAIL)
fileLen = HksFileRead(HKS_KEY_STORE_PATH, fileName, offset, buf, totalLen);
if (fileLen == 0) {
struct HksBlob blob = { .size = totalLen, .data = buf };
int32_t ret = HksFileRead(HKS_KEY_STORE_PATH, fileName, offset, &blob, &fileLen);
if (ret != HKS_SUCCESS) {
HKS_FREE_PTR(buf);
return HKS_ERROR_READ_FILE_FAIL;
}
@ -236,13 +238,13 @@ static int32_t LoadFileToBuffer(const char *fileName)
{
/* 1. read key info header */
uint32_t offset = HksGetStoreFileOffset();
uint32_t len = HksFileRead(HKS_KEY_STORE_PATH, fileName, offset,
g_storageImageBuffer.data, g_storageImageBuffer.size);
uint32_t len = 0;
int32_t ret = HksFileRead(HKS_KEY_STORE_PATH, fileName, offset,
&g_storageImageBuffer, &len);
int32_t ret;
do {
/* 2. file not exist or read nothing, init image */
if (len == 0) {
if (ret != HKS_SUCCESS) {
HKS_LOG_I("file not exist, init buffer.");
ret = InitImageBuffer();
HKS_IF_NOT_SUCC_BREAK(ret) /* init fail, need free global buf */
@ -582,9 +584,10 @@ static int32_t GetRootMaterial(const struct HksBlob *name, struct HksBlob *buffe
int32_t ret = GetFileName(name, &fileName);
HKS_IF_NOT_SUCC_RETURN(ret, ret)
uint32_t len = HksFileRead(HKS_KEY_STORE_PATH, fileName, 0, buffer->data, buffer->size);
uint32_t len = 0;
ret = HksFileRead(HKS_KEY_STORE_PATH, fileName, 0, buffer, &len);
HKS_FREE_PTR(fileName);
if (len == 0) {
if (ret != HKS_SUCCESS) {
return HKS_ERROR_READ_FILE_FAIL;
}
return HKS_SUCCESS;

3
test/unittest/huks_common_test/include/hks_test_file_operator_c.h
View File

@ -29,12 +29,13 @@
#include "securec.h"
#define HKS_MAX_FILE_NAME_LEN 512
#define REQUIRED_KEY_NOT_AVAILABLE 126
int32_t GetFileName(const char *path, const char *fileName, char *fullFileName, uint32_t fullFileNameLen);
int32_t IsFileExist(const char *fileName);
uint32_t FileRead(const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len);
int32_t FileRead(const char *fileName, uint32_t offset, struct HksBlob *blob, uint32_t *size);
uint32_t FileSize(const char *fileName);

24
test/unittest/huks_common_test/src/hks_test_file_operator_func.c
View File

@ -50,33 +50,37 @@ int32_t IsFileExist(const char *fileName)
return HKS_SUCCESS;
}
uint32_t FileRead(const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len)
int32_t FileRead(const char *fileName, uint32_t offset, struct HksBlob *blob, uint32_t *size)
{
(void)offset;
if (IsFileExist(fileName) != HKS_SUCCESS) {
return 0;
return HKS_ERROR_NOT_EXIST;
}
char filePath[PATH_MAX + 1] = {0};
(void)realpath(fileName, filePath);
if (strstr(filePath, "../") != NULL) {
HKS_TEST_LOG_E("invalid filePath, path %s", filePath);
return 0;
return HKS_ERROR_INVALID_ARGUMENT;
}
FILE *fp = fopen(filePath, "rb");
if (fp == NULL) {
HKS_TEST_LOG_E("failed to open file");
return 0;
if (fp == NULL) {
if (errno == REQUIRED_KEY_NOT_AVAILABLE) {
HKS_TEST_LOG_E("Check Permission failed!");
return HKS_ERROR_NO_PERMISSION;
}
HKS_TEST_LOG_E("open file fail, errno = 0x%x", errno);
return HKS_ERROR_OPEN_FILE_FAIL;
}
uint32_t size = fread(buf, 1, len, fp);
uint32_t len = fread(blob->data, 1, blob->size, fp);
if (fclose(fp) < 0) {
HKS_TEST_LOG_E("failed to close file");
return 0;
return HKS_ERROR_CLOSE_FILE_FAIL;
}
return size;
*size = len;
return HKS_SUCCESS;
}
uint32_t FileSize(const char *fileName)

35
test/unittest/huks_lite_test/common/hks_test_file_operator.c
View File

@ -66,7 +66,7 @@ int32_t HksTestIsFileExist(const char *path, const char *fileName)
return ret;
}
#else
static uint32_t FileRead(const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len)
static int32_t FileRead(const char *fileName, uint32_t offset, struct HksBlob *blob, uint32_t *size)
{
/* now offset is 0, but we maybe extend hi1131 file interfaces in the future */
if (offset != 0) {
@ -77,28 +77,27 @@ static uint32_t FileRead(const char *fileName, uint32_t offset, uint8_t *buf, ui
int32_t ret = UtilsFileStat(fileName, &fileSize);
if (ret < 0) {
HKS_TEST_LOG_E("stat file failed, errno = 0x%x", ret);
return 0;
return HKS_ERROR_INVALID_ARGUMENT;
}
if (len > fileSize) {
HKS_TEST_LOG_E("read data over file size!\n, file size = %d\n, buf len = %d\n", fileSize, len);
return 0;
if (blob->size > fileSize) {
HKS_TEST_LOG_E("read data over file size!\n, file size = %d\n, buf len = %d\n", fileSize, blob->size);
return HKS_ERROR_INVALID_ARGUMENT;
}
int fd = UtilsFileOpen(fileName, O_RDONLY_FS, 0);
if (fd < 0) {
HKS_TEST_LOG_E("failed to open file, errno = 0x%x", fd);
return 0;
HKS_LOG_E("open file fail, errno = 0x%" LOG_PUBLIC "x", fd);
return HKS_ERROR_OPEN_FILE_FAIL;
}
ret = UtilsFileRead(fd, buf, len);
ret = UtilsFileRead(fd, blob->data, blob->size);
UtilsFileClose(fd);
if (ret < 0) {
HKS_TEST_LOG_E("failed to read file, errno = 0x%x", ret);
return 0;
return HKS_ERROR_READ_FILE_FAIL;
}
return len;
*size = blob->size;
return HKS_SUCCESS;
}
static int32_t FileWrite(const char *fileName, uint32_t offset, const uint8_t *buf, uint32_t len)
@ -152,21 +151,21 @@ int32_t HksTestFileRemove(const char *path, const char *fileName)
}
#endif
uint32_t HksTestFileRead(const char *path, const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len)
int32_t HksTestFileRead(const char *path, const char *fileName, uint32_t offset, struct HksBlob *blob, uint32_t *size)
{
if ((fileName == NULL) || (buf == NULL) || (len == 0)) {
return 0;
if ((fileName == NULL) || (blob == NULL) || (blob->data == NULL) || (blob->size == 0) || (size == NULL)) {
return HKS_ERROR_INVALID_ARGUMENT;
}
char *fullFileName = NULL;
int32_t ret = GetFullFileName(path, fileName, &fullFileName);
if (ret != HKS_SUCCESS) {
return 0;
return ret;
}
uint32_t size = FileRead(fullFileName, offset, buf, len);
ret = FileRead(fullFileName, offset, blob, size);
HksTestFree(fullFileName);
return size;
return ret;
}
int32_t HksTestFileWrite(const char *path, const char *fileName, uint32_t offset, const uint8_t *buf, uint32_t len)

2
test/unittest/huks_lite_test/common/include/hks_test_file_operator.h
View File

@ -26,7 +26,7 @@ int32_t HksTestIsFileExist(const char *path, const char *fileName);
uint32_t HksTestFileSize(const char *path, const char *fileName);
uint32_t HksTestFileRead(const char *path, const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len);
int32_t HksTestFileRead(const char *path, const char *fileName, uint32_t offset, struct HksBlob *blob, uint32_t *size);
int32_t HksTestFileWrite(const char *path, const char *fileName, uint32_t offset, const uint8_t *buf, uint32_t len);

2
test/unittest/huks_standard_test/interface_inner_test/sdk_test/include/hks_test_file_operator.h
View File

@ -26,7 +26,7 @@ int32_t HksIsFileExist(const char *path, const char *fileName);
uint32_t HksFileSize(const char *path, const char *fileName);
uint32_t HksFileRead(const char *path, const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len);
int32_t HksFileRead(const char *path, const char *fileName, uint32_t offset, struct HksBlob *blob, uint32_t *size);
int32_t HksFileWrite(const char *path, const char *fileName, uint32_t offset, const uint8_t *buf, uint32_t len);

6
test/unittest/huks_standard_test/interface_inner_test/sdk_test/src/hks_modify_key_test.cpp
View File

@ -68,10 +68,12 @@ static int32_t ModifyKey(struct HksBlob *keyAlias)
if (bufOne == nullptr) {
return HKS_ERROR_MALLOC_FAIL;
}
uint32_t sizeRead = HksFileRead(g_storePath, (char *)keyAlias->data, 0, bufOne, sizeOne);
struct HksBlob blobOne = { .size = sizeOne, .data = bufOne };
uint32_t sizeRead = 0;
int32_t ret = HksFileRead(g_storePath, (char *)keyAlias->data, 0, &blobOne, &sizeRead);
(void)memset_s(bufOne, sizeRead, 0, sizeRead);
int32_t ret = HksFileWrite(g_storePath, (char *)keyAlias->data, 0, bufOne, sizeOne);
ret = HksFileWrite(g_storePath, (char *)keyAlias->data, 0, bufOne, sizeOne);
HksTestFree(bufOne);
return ret;

9
test/unittest/huks_standard_test/interface_inner_test/sdk_test/src/hks_safe_cipher_key_test.cpp
View File

@ -66,7 +66,9 @@ static int32_t CompareTwoKey(const struct HksBlob *keyAliasOne, const struct Hks
if (bufOne == nullptr) {
return HKS_ERROR_MALLOC_FAIL;
}
uint32_t sizeRead = HksFileRead(g_storePath, (char *)keyAliasOne->data, 0, bufOne, sizeOne);
struct HksBlob blobOne = { .size = sizeOne, .data = bufOne };
uint32_t sizeRead = 0;
int32_t ret = HksFileRead(g_storePath, (char *)keyAliasOne->data, 0, &blobOne, &sizeRead);
uint32_t sizeTwo = HksFileSize(g_storePath, (char *)keyAliasTwo->data);
uint8_t *bufTwo = (uint8_t *)HksTestMalloc(sizeTwo);
@ -74,8 +76,9 @@ static int32_t CompareTwoKey(const struct HksBlob *keyAliasOne, const struct Hks
HksTestFree(bufOne);
return HKS_ERROR_MALLOC_FAIL;
}
sizeRead = HksFileRead(g_storePath, (char *)keyAliasTwo->data, 0, bufTwo, sizeOne);
int32_t ret = memcmp(bufOne, bufTwo, sizeRead);
struct HksBlob blobTwo = { .size = sizeOne, .data = bufTwo };
ret = HksFileRead(g_storePath, (char *)keyAliasTwo->data, 0, &blobTwo, &sizeRead);
ret = memcmp(bufOne, bufTwo, sizeRead);
HksTestFree(bufOne);
HksTestFree(bufTwo);
return ret;

9
test/unittest/huks_standard_test/interface_inner_test/sdk_test/src/hks_safe_compare_key_test.cpp
View File

@ -126,7 +126,9 @@ static int32_t CompareKeyData(struct HksBlob *keyAliasOne, struct HksBlob *keyAl
if (bufOne == nullptr) {
return HKS_ERROR_MALLOC_FAIL;
}
[[maybe_unused]] uint32_t sizeRead = HksFileRead(g_storePath, (char *)keyAliasOne->data, 0, bufOne, sizeOne);
struct HksBlob blobOne = { .size = sizeOne, .data = bufOne };
[[maybe_unused]] uint32_t sizeRead = 0;
int32_t ret = HksFileRead(g_storePath, (char *)keyAliasOne->data, 0, &blobOne, &sizeRead);
uint32_t sizeTwo = HksFileSize(g_storePath, (char *)keyAliasTwo->data);
uint8_t *bufTwo = (uint8_t *)HksTestMalloc(sizeTwo);
@ -134,8 +136,9 @@ static int32_t CompareKeyData(struct HksBlob *keyAliasOne, struct HksBlob *keyAl
HksTestFree(bufOne);
return HKS_ERROR_MALLOC_FAIL;
}
sizeRead = HksFileRead(g_storePath, (char *)keyAliasTwo->data, 0, bufTwo, sizeOne);
int32_t ret = memcmp(bufOne, bufTwo, sizeOne);
struct HksBlob blobTwo = { .size = sizeOne, .data = bufTwo };
ret = HksFileRead(g_storePath, (char *)keyAliasTwo->data, 0, &blobTwo, &sizeRead);
ret = memcmp(bufOne, bufTwo, sizeOne);
HksTestFree(bufOne);
HksTestFree(bufTwo);
return ret;

12
test/unittest/huks_standard_test/interface_inner_test/sdk_test/src/hks_test_file_operator.c
View File

@ -54,21 +54,21 @@ int32_t HksIsFileExist(const char *path, const char *fileName)
return ret;
}
uint32_t HksFileRead(const char *path, const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len)
int32_t HksFileRead(const char *path, const char *fileName, uint32_t offset, struct HksBlob *blob, uint32_t *size)
{
char *fullFileName = NULL;
if ((fileName == NULL) || (buf == NULL) || (len == 0)) {
return 0;
if ((fileName == NULL) || (blob == NULL) || (blob->data == NULL) || (blob->size == 0) || (size == NULL)) {
return HKS_ERROR_INVALID_ARGUMENT;
}
int32_t ret = GetFullFileName(path, fileName, &fullFileName);
if (ret != HKS_SUCCESS) {
return 0;
return ret;
}
uint32_t size = FileRead(fullFileName, offset, buf, len);
ret = FileRead(fullFileName, offset, blob, size);
HKS_FREE_PTR(fullFileName);
return size;
return ret;
}
int32_t HksFileWrite(const char *path, const char *fileName, uint32_t offset, const uint8_t *buf, uint32_t len)

4
test/unittest/huks_standard_test/module_test/utils_test/src/hks_file_operator_test.cpp
View File

@ -88,8 +88,8 @@ HWTEST_F(HksFileOperatorTest, HksFileOperatorTest002, TestSize.Level0)
HWTEST_F(HksFileOperatorTest, HksFileOperatorTest003, TestSize.Level0)
{
HKS_LOG_I("enter HksFileOperatorTest003");
int32_t ret = HksFileRead(nullptr, nullptr, 0, nullptr, 0);
ASSERT_EQ(ret, 0) << "HksFileRead failed, ret = " << ret;
int32_t ret = HksFileRead(nullptr, nullptr, 0, nullptr, nullptr);
ASSERT_EQ(ret, HKS_ERROR_INVALID_ARGUMENT) << "HksFileRead failed, ret = " << ret;
}
/**

43
utils/file_operator/hks_file_operator.c
View File

@ -85,32 +85,39 @@ static int32_t IsFileExist(const char *fileName)
return HKS_SUCCESS;
}
static uint32_t FileRead(const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len)
static int32_t FileRead(const char *fileName, uint32_t offset, struct HksBlob *blob, uint32_t *size)
{
(void)offset;
HKS_IF_NOT_SUCC_RETURN(IsFileExist(fileName), 0)
HKS_IF_NOT_SUCC_RETURN(IsFileExist(fileName), HKS_ERROR_NOT_EXIST)
if (strstr(fileName, "../") != NULL) {
HKS_LOG_E("invalid filePath, path %" LOG_PUBLIC "s", fileName);
return 0;
return HKS_ERROR_INVALID_ARGUMENT;
}
char filePath[PATH_MAX + 1] = {0};
if (realpath(fileName, filePath) == NULL) {
HKS_LOG_E("invalid filePath, path %" LOG_PUBLIC "s", fileName);
return 0;
return HKS_ERROR_INVALID_ARGUMENT;
}
FILE *fp = fopen(filePath, "rb");
HKS_IF_NULL_LOGE_RETURN(fp, 0, "failed to open file, errno = 0x%" LOG_PUBLIC "x", errno)
uint32_t size = fread(buf, 1, len, fp);
if (fclose(fp) < 0) {
HKS_LOG_E("failed to close file, errno = 0x%" LOG_PUBLIC "x", errno);
return 0;
if (fp == NULL) {
if (errno == REQUIRED_KEY_NOT_AVAILABLE) {
HKS_LOG_E("Check Permission failed!");
return HKS_ERROR_NO_PERMISSION;
}
HKS_LOG_E("open file fail, errno = 0x%" LOG_PUBLIC "x", errno);
return HKS_ERROR_OPEN_FILE_FAIL;
}
return size;
uint32_t len = fread(blob->data, 1, blob->size, fp);
if (fclose(fp) < 0) {
HKS_LOG_E("failed to close file, errno = 0x%" LOG_PUBLIC "x", errno);
return HKS_ERROR_CLOSE_FILE_FAIL;
}
*size = len;
return HKS_SUCCESS;
}
static uint32_t FileSize(const char *fileName)
@ -132,7 +139,7 @@ static int32_t GetRealPath(const char *fileName, char *filePath)
if (memcpy_s(filePath, PATH_MAX, fileName, strlen(fileName)) != EOK) {
return HKS_ERROR_INSUFFICIENT_MEMORY;
}
if (strstr(filePath, "../") != NULL) {
HKS_LOG_E("invalid filePath!");
return HKS_ERROR_INVALID_KEY_FILE;
@ -471,19 +478,19 @@ int32_t HksDeleteDir(const char *path)
return ret;
}
uint32_t HksFileRead(const char *path, const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len)
int32_t HksFileRead(const char *path, const char *fileName, uint32_t offset, struct HksBlob *blob, uint32_t *size)
{
if ((fileName == NULL) || (buf == NULL) || (len == 0)) {
return 0;
if ((fileName == NULL) || (blob == NULL) || (blob->data == NULL) || (blob->size == 0) || (size == NULL)) {
return HKS_ERROR_INVALID_ARGUMENT;
}
char *fullFileName = NULL;
int32_t ret = GetFullFileName(path, fileName, &fullFileName);
HKS_IF_NOT_SUCC_RETURN(ret, 0)
HKS_IF_NOT_SUCC_RETURN(ret, ret)
uint32_t size = FileRead(fullFileName, offset, buf, len);
ret = FileRead(fullFileName, offset, blob, size);
HKS_FREE_PTR(fullFileName);
return size;
return ret;
}
int32_t HksFileWrite(const char *path, const char *fileName, uint32_t offset, const uint8_t *buf, uint32_t len)

2
utils/file_operator/hks_file_operator.h
View File

@ -81,7 +81,7 @@ enum HksStoragePathType {
extern "C" {
#endif
uint32_t HksFileRead(const char *path, const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len);
int32_t HksFileRead(const char *path, const char *fileName, uint32_t offset, struct HksBlob *blob, uint32_t *size);
int32_t HksFileWrite(const char *path, const char *fileName, uint32_t offset, const uint8_t *buf, uint32_t len);

48
utils/file_operator/hks_file_operator_lite.c
View File

@ -108,7 +108,7 @@ static int32_t IsFileExist(const char *fileName)
return HKS_SUCCESS;
}
static uint32_t FileRead(const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len)
static int32_t FileRead(const char *fileName, uint32_t offset, struct HksBlob *blob, uint32_t *size)
{
(void)offset;
int32_t fd = open(fileName, O_RDONLY);
@ -117,20 +117,20 @@ static uint32_t FileRead(const char *fileName, uint32_t offset, uint8_t *buf, ui
#ifdef HUKS_LOG_MINI_EXT_ENABLED
HILOG_ERROR(HILOG_MODULE_SCY, "failed to open file, errno = 0x%{public}X", errno);
#endif
return 0;
return HKS_ERROR_OPEN_FILE_FAIL;
}
int32_t size = read(fd, buf, len);
int32_t len = read(fd, blob->data, blob->size);
close(fd);
if (size < 0) {
if (len < 0) {
HKS_LOG_E("failed to read file, errno = 0x%" LOG_PUBLIC "x", errno);
#ifdef HUKS_LOG_MINI_EXT_ENABLED
HILOG_ERROR(HILOG_MODULE_SCY, "failed to read file, errno = 0x%{public}X", errno);
#endif
return 0;
return HKS_ERROR_READ_FILE_FAIL;
}
return (uint32_t)size;
*size = (uint32_t)len;
return HKS_SUCCESS;
}
static uint32_t FileSize(const char *fileName)
@ -325,40 +325,40 @@ static int32_t IsFileExist(const char *fileName)
return HKS_SUCCESS;
}
static uint32_t FileRead(const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len)
static int32_t FileRead(const char *fileName, uint32_t offset, struct HksBlob *blob, uint32_t *size)
{
/* now offset is 0, but we maybe extend hi1131 file interfaces in the future */
if (offset != 0) {
return 0;
return HKS_ERROR_INVALID_ARGUMENT;
}
unsigned int fileSize;
int32_t ret = UtilsFileStat(fileName, &fileSize);
if (ret < 0) {
HKS_LOG_E("stat file failed, errno = 0x%" LOG_PUBLIC "x", ret);
return 0;
return HKS_ERROR_INVALID_ARGUMENT;
}
if (len > fileSize) {
if (blob->size > fileSize) {
HKS_LOG_E("read data over file size!\n, file size = %" LOG_PUBLIC "d\n, buf len = %" LOG_PUBLIC "d\n",
fileSize, len);
return 0;
fileSize, blob->size);
return HKS_ERROR_INVALID_ARGUMENT;
}
int fd = UtilsFileOpen(fileName, O_RDONLY_FS, 0);
if (fd < 0) {
HKS_LOG_E("failed to open file, errno = 0x%" LOG_PUBLIC "x", fd);
return 0;
return HKS_ERROR_OPEN_FILE_FAIL;
}
ret = UtilsFileRead(fd, (char *)buf, len);
ret = UtilsFileRead(fd, (char *)blob->data, blob->size);
UtilsFileClose(fd);
if (ret < 0) {
HKS_LOG_E("failed to read file, errno = 0x%" LOG_PUBLIC "x", ret);
return 0;
return HKS_ERROR_READ_FILE_FAIL;
}
return len;
*size = blob->size;
return HKS_SUCCESS;
}
static int32_t FileWrite(const char *fileName, uint32_t offset, const uint8_t *buf, uint32_t len)
@ -407,19 +407,19 @@ static int32_t FileRemove(const char *fileName)
#endif
uint32_t HksFileRead(const char *path, const char *fileName, uint32_t offset, uint8_t *buf, uint32_t len)
int32_t HksFileRead(const char *path, const char *fileName, uint32_t offset, struct HksBlob *blob, uint32_t *size)
{
if ((fileName == NULL) || (buf == NULL) || (len == 0)) {
return 0;
if ((fileName == NULL) || (blob == NULL) || (blob->data == NULL) || (blob->size == 0) || (size == NULL)) {
return HKS_ERROR_INVALID_ARGUMENT;
}
char *fullFileName = NULL;
int32_t ret = GetFullFileName(path, fileName, &fullFileName);
HKS_IF_NOT_SUCC_RETURN(ret, 0)
HKS_IF_NOT_SUCC_RETURN(ret, ret)
uint32_t size = FileRead(fullFileName, offset, buf, len);
ret = FileRead(fullFileName, offset, blob, size);
HKS_FREE_PTR(fullFileName);
return size;
return ret;
}
int32_t HksFileWrite(const char *path, const char *fileName, uint32_t offset, const uint8_t *buf, uint32_t len)