diff --git a/common_lib/impl/src/hc_string_vector.c b/common_lib/impl/src/hc_string_vector.c new file mode 100644 index 0000000..d0de80b --- /dev/null +++ b/common_lib/impl/src/hc_string_vector.c @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hc_string_vector.h" + +IMPLEMENT_HC_VECTOR(StringVector, HcString, 1) + +StringVector CreateStrVector(void) +{ + return CreateStringVector(); +} + +void DestroyStrVector(StringVector *vec) +{ + uint32_t index; + HcString *strItemPtr = NULL; + FOR_EACH_HC_VECTOR(*vec, index, strItemPtr) { + DeleteString(strItemPtr); + } + DESTROY_HC_VECTOR(StringVector, vec); +} \ No newline at end of file diff --git a/common_lib/interfaces/hc_string_vector.h b/common_lib/interfaces/hc_string_vector.h new file mode 100644 index 0000000..0eb1347 --- /dev/null +++ b/common_lib/interfaces/hc_string_vector.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef HC_STRING_VECTOR_H +#define HC_STRING_VECTOR_H + +#include "hc_string.h" +#include "hc_vector.h" + +#ifdef __cplusplus +extern "C" { +#endif + +DECLARE_HC_VECTOR(StringVector, HcString) + +StringVector CreateStrVector(void); +void DestroyStrVector(StringVector *vec); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/common_lib/interfaces/hc_vector.h b/common_lib/interfaces/hc_vector.h index eb0cce0..b1f62c4 100644 --- a/common_lib/interfaces/hc_vector.h +++ b/common_lib/interfaces/hc_vector.h @@ -156,8 +156,8 @@ void Destroy##ClassName(ClassName* obj) \ } /* Use these two macros to create and destroy vector */ -#define CREATE_HC_VECTOR(classname) Create##classname(); -#define DESTROY_HC_VECTOR(classname, obj) Destroy##classname(obj); +#define CREATE_HC_VECTOR(classname) Create##classname() +#define DESTROY_HC_VECTOR(classname, obj) Destroy##classname(obj) #define FOR_EACH_HC_VECTOR(vec, index, iter) for (index = 0; index < (vec).size(&(vec)) && \ (iter = (vec).getp(&(vec), index)); ++index) diff --git a/deps_adapter/deviceauth_hals.gni b/deps_adapter/deviceauth_hals.gni index ed732bc..82b1b96 100644 --- a/deps_adapter/deviceauth_hals.gni +++ b/deps_adapter/deviceauth_hals.gni @@ -42,6 +42,7 @@ hal_common_files = [ "${common_lib_path}/impl/src/clib_types.c", "${common_lib_path}/impl/src/hc_parcel.c", "${common_lib_path}/impl/src/hc_string.c", + "${common_lib_path}/impl/src/hc_string_vector.c", "${common_lib_path}/impl/src/hc_tlv_parser.c", "${common_lib_path}/impl/src/json_utils.c", "${common_lib_path}/impl/src/string_util.c", diff --git a/deps_adapter/key_management_adapter/impl/src/mini/huks_adapter.c b/deps_adapter/key_management_adapter/impl/src/mini/huks_adapter.c index bfecac9..18f066f 100644 --- a/deps_adapter/key_management_adapter/impl/src/mini/huks_adapter.c +++ b/deps_adapter/key_management_adapter/impl/src/mini/huks_adapter.c @@ -84,7 +84,7 @@ static int32_t InitHks(void) LOGD("Hks: The local hks file needs to be refreshed!"); LOGI("Start to delete local database file!"); - HcFileRemove(FILE_ID_GROUP); + HcFileRemove(GetStoragePath()); LOGI("Delete local database file successfully!"); res = HksRefreshKeyInfo(); if (res != HKS_SUCCESS) { diff --git a/deps_adapter/key_management_adapter/impl/src/standard/huks_adapter.c b/deps_adapter/key_management_adapter/impl/src/standard/huks_adapter.c index 3c54a20..44b9665 100644 --- a/deps_adapter/key_management_adapter/impl/src/standard/huks_adapter.c +++ b/deps_adapter/key_management_adapter/impl/src/standard/huks_adapter.c @@ -21,6 +21,14 @@ #include "hks_type.h" #include "string_util.h" +#define BASE_IMPORT_PARAMS_LEN 7 +#define EXT_IMPORT_PARAMS_LEN 2 + +static enum HksKeyPurpose g_purposeToHksKeyPurpose[] = { + HKS_KEY_PURPOSE_MAC, + HKS_KEY_PURPOSE_DERIVE +}; + static enum HksKeyAlg g_algToHksAlgorithm[] = { HKS_ALG_ED25519, HKS_ALG_X25519, @@ -1121,13 +1129,106 @@ static bool CheckDlPublicKey(const Uint8Buff *key, const char *primeHex) return true; } +static int32_t CheckImportSymmetricKeyParam(const Uint8Buff *keyAlias, const Uint8Buff *authToken) +{ + const Uint8Buff *inParams[] = { keyAlias, authToken }; + const char *paramTags[] = { "keyAlias", "authToken" }; + return BaseCheckParams(inParams, paramTags, CAL_ARRAY_SIZE(inParams)); +} + +static int32_t ConstructImportSymmetricKeyParam(struct HksParamSet **paramSet, uint32_t keyLen, KeyPurpose purpose, + const ExtraInfo *exInfo) +{ + struct HksParam *importParam = NULL; + struct HksBlob authIdBlob = { 0, NULL }; + union KeyRoleInfoUnion roleInfoUnion; + (void)memset_s(&roleInfoUnion, sizeof(roleInfoUnion), 0, sizeof(roleInfoUnion)); + uint32_t idx = 0; + if (exInfo != NULL) { + CHECK_PTR_RETURN_HAL_ERROR_CODE(exInfo->authId.val, "authId"); + CHECK_LEN_ZERO_RETURN_ERROR_CODE(exInfo->authId.length, "authId"); + CHECK_LEN_HIGHER_RETURN(exInfo->pairType, PAIR_TYPE_END - 1, "pairType"); + importParam = (struct HksParam *)HcMalloc(sizeof(struct HksParam) * + (BASE_IMPORT_PARAMS_LEN + EXT_IMPORT_PARAMS_LEN), 0); + if (importParam == NULL) { + LOGE("Malloc for importParam failed."); + return HAL_ERR_BAD_ALLOC; + } + authIdBlob.size = exInfo->authId.length; + authIdBlob.data = exInfo->authId.val; + roleInfoUnion.roleInfoStruct.userType = (uint8_t)exInfo->userType; + roleInfoUnion.roleInfoStruct.pairType = (uint8_t)exInfo->pairType; + importParam[idx].tag = HKS_TAG_KEY_AUTH_ID; + importParam[idx++].blob = authIdBlob; + importParam[idx].tag = HKS_TAG_KEY_ROLE; + importParam[idx++].uint32Param = roleInfoUnion.roleInfo; + } else { + importParam = (struct HksParam *)HcMalloc(sizeof(struct HksParam) * BASE_IMPORT_PARAMS_LEN, 0); + if (importParam == NULL) { + LOGE("Malloc for importParam failed."); + return HAL_ERR_BAD_ALLOC; + } + } + + importParam[idx].tag = HKS_TAG_ALGORITHM; + importParam[idx++].uint32Param = HKS_ALG_AES; + importParam[idx].tag = HKS_TAG_KEY_SIZE; + importParam[idx++].uint32Param = keyLen * BITS_PER_BYTE; + importParam[idx].tag = HKS_TAG_PADDING; + importParam[idx++].uint32Param = HKS_PADDING_NONE; + importParam[idx].tag = HKS_TAG_IS_ALLOWED_WRAP; + importParam[idx++].boolParam = false; + importParam[idx].tag = HKS_TAG_PURPOSE; + importParam[idx++].uint32Param = g_purposeToHksKeyPurpose[purpose]; + importParam[idx].tag = HKS_TAG_BLOCK_MODE; + importParam[idx++].uint32Param = HKS_MODE_GCM; + importParam[idx].tag = HKS_TAG_DIGEST; + importParam[idx++].uint32Param = HKS_DIGEST_SHA256; + + int ret = ConstructParamSet(paramSet, importParam, idx); + if (ret != HAL_SUCCESS) { + LOGE("Construct decrypt param set failed, ret = %d.", ret); + } + + HcFree(importParam); + return ret; +} + +static int32_t ImportSymmetricKey(const Uint8Buff *keyAlias, const Uint8Buff *authToken, KeyPurpose purpose, + const ExtraInfo *exInfo) +{ + int32_t ret = CheckImportSymmetricKeyParam(keyAlias, authToken); + if (ret != HAL_SUCCESS) { + return ret; + } + + struct HksBlob keyAliasBlob = { keyAlias->length, keyAlias->val }; + struct HksBlob symKeyBlob = { authToken->length, authToken->val }; + struct HksParamSet *paramSet = NULL; + ret = ConstructImportSymmetricKeyParam(¶mSet, authToken->length, purpose, exInfo); + if (ret != HAL_SUCCESS) { + LOGE("construct param set failed, ret = %d", ret); + return ret; + } + + ret = HksImportKey(&keyAliasBlob, paramSet, &symKeyBlob); + if (ret != HKS_SUCCESS) { + LOGE("HksImportKey failed, ret: %d", ret); + HksFreeParamSet(¶mSet); + return ret; + } + + HksFreeParamSet(¶mSet); + return HAL_SUCCESS; +} + static const AlgLoader g_huksLoader = { .initAlg = InitHks, .sha256 = Sha256, .generateRandom = GenerateRandom, .computeHmac = ComputeHmac, .computeHkdf = ComputeHkdf, - .importSymmetricKey = NULL, + .importSymmetricKey = ImportSymmetricKey, .checkKeyExist = CheckKeyExist, .deleteKey = DeleteKey, .aesGcmEncrypt = AesGcmEncrypt, diff --git a/deps_adapter/os_adapter/impl/src/linux/hc_file.c b/deps_adapter/os_adapter/impl/src/linux/hc_file.c index 025f4e2..1e7ffa3 100644 --- a/deps_adapter/os_adapter/impl/src/linux/hc_file.c +++ b/deps_adapter/os_adapter/impl/src/linux/hc_file.c @@ -14,9 +14,10 @@ */ #include "hc_file.h" +#include +#include #include #include -#include #include #include "securec.h" #include "hc_log.h" @@ -29,29 +30,6 @@ extern "C" { #define MAX_FILE_PATH_SIZE 256 #define MAX_FOLDER_NAME_SIZE 128 -typedef struct { - FileIdEnum fileId; - const char *filePath; -} FileDefInfo; - -static char g_groupPath[MAX_FILE_PATH_SIZE] = { 0 }; - -static FileDefInfo g_fileDefInfo[FILE_ID_LAST] = { - { FILE_ID_GROUP, "/data/data/deviceauth/hcgroup.dat" }, - { FILE_ID_CRED_DATA, "" } -}; - -void SetFilePath(FileIdEnum fileId, const char *path) -{ - if (path == NULL) { - LOGE("Invalid path param"); - return; - } - if (sprintf_s(g_groupPath, MAX_FILE_PATH_SIZE, "%s", path) != -1) { - g_fileDefInfo[fileId].filePath = g_groupPath; - } -} - static int32_t CreateDirectory(const char *filePath) { int32_t ret; @@ -84,15 +62,13 @@ static int32_t CreateDirectory(const char *filePath) return 0; } -static FILE *HcFileOpenRead(int fileId, const char *path) +static FILE *HcFileOpenRead(const char *path) { - (void)fileId; return fopen(path, "rb"); } -static FILE *HcFileOpenWrite(int32_t fileId, const char *path) +static FILE *HcFileOpenWrite(const char *path) { - (void)fileId; if (access(path, F_OK) != 0) { int32_t ret = CreateDirectory(path); if (ret != 0) { @@ -102,15 +78,15 @@ static FILE *HcFileOpenWrite(int32_t fileId, const char *path) return fopen(path, "w+"); } -int HcFileOpen(int fileId, int mode, FileHandle *file) +int HcFileOpen(const char *path, int mode, FileHandle *file) { - if (fileId < 0 || fileId >= FILE_ID_LAST || file == NULL) { + if (path == NULL || file == NULL) { return -1; } if (mode == MODE_FILE_READ) { - file->pfd = HcFileOpenRead(fileId, g_fileDefInfo[fileId].filePath); + file->pfd = HcFileOpenRead(path); } else { - file->pfd = HcFileOpenWrite(fileId, g_fileDefInfo[fileId].filePath); + file->pfd = HcFileOpenWrite(path); } if (file->pfd == NULL) { return -1; @@ -185,16 +161,41 @@ void HcFileClose(FileHandle file) return; } - fclose(fp); + (void)fclose(fp); } -void HcFileRemove(int fileId) +void HcFileRemove(const char *path) { - if (fileId >= FILE_ID_LAST) { - LOGE("Invalid fileId:%d", fileId); + if (path == NULL) { + LOGE("Invalid file path"); return; } - unlink(g_fileDefInfo[fileId].filePath); + (void)remove(path); +} + +void HcFileGetSubFileName(const char *path, StringVector *nameVec) +{ + DIR *dir = NULL; + struct dirent *entry = NULL; + if ((dir = opendir(path)) == NULL) { + LOGI("opendir failed!"); + return; + } + while ((entry = readdir(dir)) != NULL) { + if ((strcmp(entry->d_name, ".") == 0) || (strcmp(entry->d_name, "..") == 0)) { + continue; + } + HcString subFileName = CreateString(); + if (!StringSetPointer(&subFileName, entry->d_name)) { + LOGE("Failed to copy subFileName!"); + DeleteString(&subFileName); + continue; + } + if (nameVec->pushBackT(nameVec, subFileName) == NULL) { + LOGE("Failed to push path to pathVec!"); + DeleteString(&subFileName); + } + } } #ifdef __cplusplus diff --git a/deps_adapter/os_adapter/impl/src/liteos/hc_file.c b/deps_adapter/os_adapter/impl/src/liteos/hc_file.c deleted file mode 100644 index 9cdf40f..0000000 --- a/deps_adapter/os_adapter/impl/src/liteos/hc_file.c +++ /dev/null @@ -1,216 +0,0 @@ -/* - * Copyright (C) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "hc_file.h" -#include -#include -#include -#include -#include -#include -#include "common_defs.h" -#include "hal_error.h" -#include "hc_log.h" - -#define MAX_FILE_PATH_SIZE 256 -#define MAX_FOLDER_NAME_SIZE 128 -#define GET_FOLDER_OK 0 -#define GET_FOLDER_FAILED (-1) -#define GET_FILE_OK 1 -#define DEFAULT_FILE_PERMISSION 0666 - -typedef struct { - FileIdEnum fileId; - const char* filePath; -} FileDefInfo; - -static FileDefInfo g_fileDefInfo[FILE_ID_LAST] = { - { FILE_ID_GROUP, "user/Hichain/hcgroup.dat" }, - { FILE_ID_CRED_DATA, "" } -}; - -static char g_groupPath[MAX_FILE_PATH_SIZE] = { 0 }; - -void SetFilePath(FileIdEnum fileId, const char *path) -{ - if (path == NULL) { - LOGE("Invalid path param"); - return; - } - if (sprintf_s(g_groupPath, MAX_FILE_PATH_SIZE, "%s", path) != -1) { - g_fileDefInfo[fileId].filePath = g_groupPath; - } -} - -int GetNextFolder(const char *filePath, int *beginPos, char *dst, int size) -{ - int pos = (*beginPos); - while (1) { - char c = filePath[pos++]; - if (c == '\0') { - if (memcpy_s(dst, size, filePath, pos - 1) != EOK) { - return GET_FOLDER_FAILED; - } - dst[pos - 1] = '\0'; - (*beginPos) = pos; - return GET_FILE_OK; - } else if (c == '/') { - if (memcpy_s(dst, size, filePath, pos - 1) != EOK) { - return GET_FOLDER_FAILED; - } - dst[pos - 1] = '\0'; - (*beginPos) = pos; - return GET_FOLDER_OK; - } else { - if (pos >= size) { - (*beginPos) = pos; - return GET_FOLDER_FAILED; - } - } - } -} - -int HcFileOpenRead(const char *path) -{ - return open(path, O_RDONLY); -} - -static int IsFileValid(const char *path) -{ - struct stat fileStat; - int32_t ret = stat(path, &fileStat); - if (ret == -1) { - if (errno == ENOENT) { - return HAL_ERR_FILE_NOT_EXIST; - } else { - LOGE("file stat failed, errno = 0x%x", errno); - return HAL_ERR_FILE; - } - } - - return 0; -} - -int HcFileOpenWrite(const char *path) -{ - char filePath[MAX_FOLDER_NAME_SIZE + 1]; - int beginPos = 0; - while (1) { - int ret = GetNextFolder(path, &beginPos, filePath, sizeof(filePath)); - if (ret == GET_FOLDER_OK) { - if (IsFileValid(filePath) == 0) { - continue; - } - if (mkdir(filePath, DEFAULT_FILE_PERMISSION) != 0) { - return -1; - } - } else if (ret == GET_FOLDER_FAILED) { - return -1; - } else { - int fd = open(filePath, O_RDWR | O_CREAT); - if (fd == -1) { - LOGE("file stat failed, errno = 0x%x", errno); - } - return fd; - } - } -} - -int HcFileOpen(int fileId, int mode, FileHandle *file) -{ - if (fileId < 0 || fileId >= FILE_ID_LAST || file == NULL) { - return -1; - } - if (mode == MODE_FILE_READ) { - file->fileHandle.fd = HcFileOpenRead(g_fileDefInfo[fileId].filePath); - } else { - file->fileHandle.fd = HcFileOpenWrite(g_fileDefInfo[fileId].filePath); - } - if (file->fileHandle.fd == -1) { - return -1; - } - return 0; -} - -int HcFileSize(FileHandle file) -{ - int fp = file.fileHandle.fd; - int size = lseek(fp, 0, SEEK_END); - (void)lseek(fp, 0, SEEK_SET); - return size; -} - -int HcFileRead(FileHandle file, void *dst, int dstSize) -{ - int fp = file.fileHandle.fd; - if (fp == -1 || dstSize < 0 || dst == NULL) { - return -1; - } - - char *dstBuffer = (char *)dst; - int total = 0; - while (total < dstSize) { - int readCount = read(fp, dstBuffer + total, dstSize - total); - if (readCount < 0 || readCount > (dstSize - total)) { - LOGE("read errno :%x", errno); - return -1; - } - if (readCount == 0) { - LOGE("read errno :%x", errno); - return total; - } - total += readCount; - } - - return total; -} - -int HcFileWrite(FileHandle file, const void *src, int srcSize) -{ - int fp = file.fileHandle.fd; - if (fp == -1 || srcSize < 0 || src == NULL) { - return -1; - } - - const char *srcBuffer = (const char *)src; - int total = 0; - while (total < srcSize) { - int writeCount = write(fp, srcBuffer + total, srcSize - total); - if (writeCount < 0 || writeCount > (srcSize - total)) { - return -1; - } - total += writeCount; - } - return total; -} - -void HcFileClose(FileHandle file) -{ - int fp = file.fileHandle.fd; - if (fp == 0) { - return; - } - - close(fp); -} - -void HcFileRemove(int fileId) -{ - if (fileId >= FILE_ID_LAST) { - LOGE("Invalid fileId:%d", fileId); - return; - } - unlink(g_fileDefInfo[fileId].filePath); -} \ No newline at end of file diff --git a/deps_adapter/os_adapter/impl/src/liteos/mini/hc_file.c b/deps_adapter/os_adapter/impl/src/liteos/mini/hc_file.c index e1347e5..d40b680 100644 --- a/deps_adapter/os_adapter/impl/src/liteos/mini/hc_file.c +++ b/deps_adapter/os_adapter/impl/src/liteos/mini/hc_file.c @@ -14,67 +14,49 @@ */ #include "hc_file.h" +#include #include #include #include #include +#include #include "hal_error.h" #include "hc_log.h" #include "utils_file.h" -#define MAX_FILE_PATH_SIZE 64 #define MAX_FOLDER_NAME_SIZE 128 #define GET_FOLDER_OK 0 #define GET_FOLDER_FAILED (-1) #define GET_FILE_OK 1 #define DEFAULT_FILE_PERMISSION 0666 -typedef struct { - FileIdEnum fileId; - char filePath[MAX_FILE_PATH_SIZE]; -} FileDefInfo; - -static FileDefInfo g_fileDefInfo[FILE_ID_LAST] = { - { FILE_ID_GROUP, "/data/hcgroup.dat" }, - { FILE_ID_CRED_DATA, "" } -}; - -void SetFilePath(FileIdEnum fileId, const char *path) -{ - if (fileId < 0 || fileId >= FILE_ID_LAST || path == NULL) { - LOGE("Invalid path param"); - return; - } - if (sprintf_s(g_fileDefInfo[fileId].filePath, MAX_FILE_PATH_SIZE, "%s", path) == HAL_FAILED) { - LOGE("Set file path failed fileId:%d", fileId); - } -} - -int HcFileOpenRead(const char *path) +static int HcFileOpenRead(const char *path) { int ret = UtilsFileOpen(path, O_RDONLY, 0); LOGI("ret = %d", ret); return ret; } -int HcFileOpenWrite(const char *path) +static int HcFileOpenWrite(const char *path) { int ret = UtilsFileOpen(path, O_RDWR_FS | O_CREAT_FS | O_TRUNC_FS, 0); LOGI("ret = %d", ret); return ret; } -int HcFileOpen(int fileId, int mode, FileHandle *file) +int HcFileOpen(const char *path, int mode, FileHandle *file) { - if (fileId < 0 || fileId >= FILE_ID_LAST || file == NULL) { + if (path == NULL || file == NULL) { + return -1; + } + if (strcpy_s(file->filePath, MAX_FILE_PATH_SIZE, path) != EOK) { + LOGE("Failed to copy filePath!"); return HAL_FAILED; } if (mode == MODE_FILE_READ) { - file->fileHandle.fd = HcFileOpenRead(g_fileDefInfo[fileId].filePath); - file->filePath = g_fileDefInfo[fileId].filePath; + file->fileHandle.fd = HcFileOpenRead(path); } else { - file->fileHandle.fd = HcFileOpenWrite(g_fileDefInfo[fileId].filePath); - file->filePath = g_fileDefInfo[fileId].filePath; + file->fileHandle.fd = HcFileOpenWrite(path); } if (file->fileHandle.fd == HAL_FAILED) { return HAL_FAILED; @@ -89,8 +71,6 @@ int HcFileSize(FileHandle file) LOGI("ret = %d, fileSize = %d\n", ret, fileSize); if (ret == HAL_SUCCESS) { return fileSize; - } else { - return HAL_FAILED; } return HAL_FAILED; } @@ -127,12 +107,37 @@ void HcFileClose(FileHandle file) LOGI("ret = %d", ret); } -void HcFileRemove(int fileId) +void HcFileRemove(const char *path) { - if (fileId >= FILE_ID_LAST) { - LOGE("Invalid fileId:%d", fileId); + if (path == NULL) { + LOGE("Invalid file path"); return; } - int ret = UtilsFileDelete(g_fileDefInfo[fileId].filePath); + int ret = UtilsFileDelete(path); LOGI("File delete result:%d", ret); } + +void HcFileGetSubFileName(const char *path, StringVector *nameVec) +{ + DIR *dir = NULL; + struct dirent *entry = NULL; + if ((dir = opendir(path)) == NULL) { + LOGI("opendir failed!"); + return; + } + while ((entry = readdir(dir)) != NULL) { + if ((strcmp(entry->d_name, ".") == 0) || (strcmp(entry->d_name, "..") == 0)) { + continue; + } + HcString subFileName = CreateString(); + if (!StringSetPointer(&subFileName, entry->d_name)) { + LOGE("Failed to copy subFileName!"); + DeleteString(&subFileName); + continue; + } + if (nameVec->pushBackT(nameVec, subFileName) == NULL) { + LOGE("Failed to push path to pathVec!"); + DeleteString(&subFileName); + } + } +} \ No newline at end of file diff --git a/deps_adapter/os_adapter/interfaces/linux/hc_file.h b/deps_adapter/os_adapter/interfaces/linux/hc_file.h index 2399a8c..8818644 100644 --- a/deps_adapter/os_adapter/interfaces/linux/hc_file.h +++ b/deps_adapter/os_adapter/interfaces/linux/hc_file.h @@ -16,6 +16,8 @@ #ifndef HC_FILE_H #define HC_FILE_H +#include "hc_string_vector.h" + #ifdef __cplusplus extern "C" { #endif @@ -25,24 +27,18 @@ typedef union { int fd; } FileHandle; -typedef enum FileIdEnumT { - FILE_ID_GROUP = 0, - FILE_ID_CRED_DATA, - FILE_ID_LAST, -} FileIdEnum; - #define MODE_FILE_READ 0 #define MODE_FILE_WRITE 1 // 0 indicates success // -1 indicates fail -int HcFileOpen(int fileId, int mode, FileHandle *file); +int HcFileOpen(const char *path, int mode, FileHandle *file); int HcFileSize(FileHandle file); int HcFileRead(FileHandle file, void *dst, int dstSize); int HcFileWrite(FileHandle file, const void *src, int srcSize); void HcFileClose(FileHandle file); -void HcFileRemove(int fileId); -void SetFilePath(FileIdEnum fileId, const char *path); +void HcFileRemove(const char *path); +void HcFileGetSubFileName(const char *path, StringVector *nameVec); #ifdef __cplusplus } diff --git a/deps_adapter/os_adapter/interfaces/liteos/hc_file.h b/deps_adapter/os_adapter/interfaces/liteos/hc_file.h index ffcfdc5..b0e4c08 100644 --- a/deps_adapter/os_adapter/interfaces/liteos/hc_file.h +++ b/deps_adapter/os_adapter/interfaces/liteos/hc_file.h @@ -16,30 +16,35 @@ #ifndef HC_FILE_H #define HC_FILE_H +#include "hc_string_vector.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define MAX_FILE_PATH_SIZE 64 + typedef struct { union { void *pfd; int fd; } fileHandle; - const char *filePath; + char filePath[MAX_FILE_PATH_SIZE]; } FileHandle; -typedef enum FileIdEnumT { - FILE_ID_GROUP = 0, - FILE_ID_CRED_DATA, - FILE_ID_LAST, -} FileIdEnum; - #define MODE_FILE_READ 0 #define MODE_FILE_WRITE 1 /* 0 indicates success, -1 indicates fail */ -int HcFileOpen(int fileId, int mode, FileHandle *file); +int HcFileOpen(const char *path, int mode, FileHandle *file); int HcFileSize(FileHandle file); int HcFileRead(FileHandle file, void *dst, int dstSize); int HcFileWrite(FileHandle file, const void *src, int srcSize); void HcFileClose(FileHandle file); -void HcFileRemove(int fileId); -void SetFilePath(FileIdEnum fileId, const char *path); +void HcFileRemove(const char *path); +void HcFileGetSubFileName(const char *path, StringVector *nameVec); +#ifdef __cplusplus +} +#endif #endif \ No newline at end of file diff --git a/frameworks/inc/ipc_sdk.h b/frameworks/inc/ipc_sdk.h index b12f351..6416e04 100755 --- a/frameworks/inc/ipc_sdk.h +++ b/frameworks/inc/ipc_sdk.h @@ -60,6 +60,8 @@ extern "C" { #define PARAM_TYPE_DEVICE_INFO 29 #define PARAM_TYPE_AUTH_PARAMS 30 #define PARAM_TYPE_CB_OBJECT 31 +#define PARAM_TYPE_OS_ACCOUNT_ID 32 +#define PARAM_TYPE_RETURN_DATA 33 enum { IPC_CALL_ID_REG_CB = 1, @@ -96,7 +98,9 @@ enum { IPC_CALL_ID_IS_TRUST_DEVICE, IPC_CALL_ID_GET_AUTH_STATE, IPC_CALL_ID_AUTH_DEVICE, - IPC_CALL_ID_INFORM_DEV_DISCONN + IPC_CALL_ID_INFORM_DEV_DISCONN, + IPC_CALL_ID_CHECK_ACCESS_TO_GROUP, + IPC_CALL_ID_GET_PK_INFO_LIST, }; #ifdef __cplusplus diff --git a/frameworks/inc/lite/ipc_dev_auth_stub.h b/frameworks/inc/lite/ipc_dev_auth_stub.h index 44f25d6..8d264ff 100755 --- a/frameworks/inc/lite/ipc_dev_auth_stub.h +++ b/frameworks/inc/lite/ipc_dev_auth_stub.h @@ -29,8 +29,8 @@ typedef struct { IpcServiceCall method; int32_t methodId; } IpcServiceCallMap; -#define MAX_CALLMAP_SIZE 32 -#define MAX_CBSTUB_SIZE 32 +#define MAX_CALLMAP_SIZE 64 +#define MAX_CBSTUB_SIZE 64 typedef LiteIpcCallService DevAuthService; diff --git a/frameworks/inc/standard/ipc_dev_auth_stub.h b/frameworks/inc/standard/ipc_dev_auth_stub.h index 8b95384..9212b67 100755 --- a/frameworks/inc/standard/ipc_dev_auth_stub.h +++ b/frameworks/inc/standard/ipc_dev_auth_stub.h @@ -25,8 +25,8 @@ typedef struct { IpcServiceCall method; int32_t methodId; } IpcServiceCallMap; -const int32_t MAX_CALLMAP_SIZE = 32; -const int32_t MAX_CBSTUB_SIZE = 32; +const int32_t MAX_CALLMAP_SIZE = 64; +const int32_t MAX_CBSTUB_SIZE = 64; class ServiceDevAuth : public IRemoteStub { public: diff --git a/frameworks/src/ipc_sdk.c b/frameworks/src/ipc_sdk.c index 6318f32..8ab7647 100644 --- a/frameworks/src/ipc_sdk.c +++ b/frameworks/src/ipc_sdk.c @@ -97,6 +97,7 @@ static void GetIpcReplyByType(const IpcDataInfo *ipcData, case PARAM_TYPE_FRIEND_APPID: case PARAM_TYPE_DEVICE_INFO: case PARAM_TYPE_GROUP_INFO: + case PARAM_TYPE_RETURN_DATA: *(uint8_t **)outCache = ipcData[i].val; if (cacheLen != NULL) { *cacheLen = ipcData[i].valSz; @@ -275,7 +276,7 @@ static int32_t IpcGmUnRegDataChangeListener(const char *appId) return HC_SUCCESS; } -static int32_t IpcGmCreateGroup(int64_t requestId, const char *appid, const char *createParams) +static int32_t IpcGmCreateGroup(int32_t osAccountId, int64_t requestId, const char *appid, const char *createParams) { uintptr_t callCtx = 0x0; int32_t ret; @@ -295,7 +296,13 @@ static int32_t IpcGmCreateGroup(int64_t requestId, const char *appid, const char LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } - + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId)); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID); @@ -330,7 +337,7 @@ static int32_t IpcGmCreateGroup(int64_t requestId, const char *appid, const char return ret; } -static int32_t IpcGmDelGroup(int64_t requestId, const char *appId, const char *delParams) +static int32_t IpcGmDelGroup(int32_t osAccountId, int64_t requestId, const char *appId, const char *delParams) { uintptr_t callCtx = 0x0; int32_t ret; @@ -351,6 +358,13 @@ static int32_t IpcGmDelGroup(int64_t requestId, const char *appId, const char *d return HC_ERR_IPC_INIT; } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId)); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID); @@ -384,7 +398,7 @@ static int32_t IpcGmDelGroup(int64_t requestId, const char *appId, const char *d return ret; } -static int32_t IpcGmAddMemberToGroup(int64_t requestId, const char *appId, const char *addParams) +static int32_t IpcGmAddMemberToGroup(int32_t osAccountId, int64_t requestId, const char *appId, const char *addParams) { uintptr_t callCtx = 0x0; int32_t ret; @@ -404,7 +418,13 @@ static int32_t IpcGmAddMemberToGroup(int64_t requestId, const char *appId, const LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } - + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId)); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID); @@ -438,7 +458,7 @@ static int32_t IpcGmAddMemberToGroup(int64_t requestId, const char *appId, const return ret; } -static int32_t IpcGmDelMemberFromGroup(int64_t requestId, const char *appId, const char *delParams) +static int32_t IpcGmDelMemberFromGroup(int32_t osAccountId, int64_t requestId, const char *appId, const char *delParams) { uintptr_t callCtx = 0x0; int32_t ret; @@ -458,7 +478,13 @@ static int32_t IpcGmDelMemberFromGroup(int64_t requestId, const char *appId, con LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } - + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId)); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID); @@ -512,14 +538,12 @@ static int32_t IpcGmProcessData(int64_t requestId, const uint8_t *data, uint32_t LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } - ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId)); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID); DestroyCallCtx(&callCtx, NULL); return HC_ERR_IPC_BUILD_PARAM; } - ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_COMM_DATA, data, dataLen); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_COMM_DATA); @@ -541,7 +565,7 @@ static int32_t IpcGmProcessData(int64_t requestId, const uint8_t *data, uint32_t return ret; } -static int32_t IpcGmConfirmRequest(int64_t requestId, const char *appId, const char *cfmParams) +static int32_t IpcGmConfirmRequest(int32_t osAccountId, int64_t requestId, const char *appId, const char *cfmParams) { uintptr_t callCtx = 0x0; int32_t ret; @@ -561,7 +585,13 @@ static int32_t IpcGmConfirmRequest(int64_t requestId, const char *appId, const c LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } - + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)&requestId, sizeof(requestId)); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_REQID); @@ -833,17 +863,62 @@ static int32_t IpcGmGetLocalConnectInfo(char *returnInfo, int32_t bufLen) return HC_ERR_NOT_SUPPORT; } -static int32_t IpcGmCheckAccessToGroup(const char *appId, const char *groupId) +static int32_t IpcGmCheckAccessToGroup(int32_t osAccountId, const char *appId, const char *groupId) { + uintptr_t callCtx = 0x0; + int32_t ret; + int32_t inOutLen; + IpcDataInfo replyCache = {0}; + LOGI("starting ..."); - if ((appId == NULL) || (groupId == NULL)) { + if (!IS_STRING_VALID(appId) || !IS_STRING_VALID(groupId)) { return HC_ERR_INVALID_PARAMS; } - - return HC_ERR_NOT_SUPPORT; + if (!IsServiceRunning()) { + LOGE("service is not activity"); + return HC_ERROR; + } + ret = CreateCallCtx(&callCtx, NULL); + if (ret != HC_SUCCESS) { + LOGE("CreateCallCtx failed, ret %d", ret); + return HC_ERR_IPC_INIT; + } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, strlen(groupId) + 1); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } + ret = DoBinderCall(callCtx, IPC_CALL_ID_CHECK_ACCESS_TO_GROUP, true); + if (ret == HC_ERR_IPC_INTERNAL_FAILED) { + LOGE("ipc call failed"); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_PROC_FAILED; + } + DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache)); + ret = HC_ERR_IPC_UNKNOW_REPLY; + inOutLen = sizeof(int32_t); + GetIpcReplyByType(&replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen); + LOGI("process done, ret %d", ret); + DestroyCallCtx(&callCtx, NULL); + return ret; } -static int32_t IpcGmAddGroupManager(const char *appId, const char *groupId, const char *managerAppId) +static int32_t IpcGmAddGroupManager(int32_t osAccountId, const char *appId, const char *groupId, + const char *managerAppId) { uintptr_t callCtx = 0x0; int32_t ret; @@ -863,6 +938,13 @@ static int32_t IpcGmAddGroupManager(const char *appId, const char *groupId, cons LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID); @@ -897,7 +979,7 @@ static int32_t IpcGmAddGroupManager(const char *appId, const char *groupId, cons return ret; } -static int32_t IpcGmAddGroupFriend(const char *appId, const char *groupId, const char *friendAppId) +static int32_t IpcGmAddGroupFriend(int32_t osAccountId, const char *appId, const char *groupId, const char *friendAppId) { uintptr_t callCtx = 0x0; int32_t ret; @@ -917,6 +999,13 @@ static int32_t IpcGmAddGroupFriend(const char *appId, const char *groupId, const LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID); @@ -951,7 +1040,7 @@ static int32_t IpcGmAddGroupFriend(const char *appId, const char *groupId, const return ret; } -static int32_t IpcGmDelGroupManager(const char *appId, const char *groupId, const char *managerAppId) +static int32_t IpcGmDelGroupManager(int32_t osAccountId, const char *appId, const char *groupId, const char *managerAppId) { uintptr_t callCtx = 0x0; int32_t ret; @@ -971,6 +1060,13 @@ static int32_t IpcGmDelGroupManager(const char *appId, const char *groupId, cons LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID); @@ -1005,7 +1101,7 @@ static int32_t IpcGmDelGroupManager(const char *appId, const char *groupId, cons return ret; } -static int32_t IpcGmDelGroupFriend(const char *appId, const char *groupId, const char *friendAppId) +static int32_t IpcGmDelGroupFriend(int32_t osAccountId, const char *appId, const char *groupId, const char *friendAppId) { uintptr_t callCtx = 0x0; int32_t ret; @@ -1025,6 +1121,13 @@ static int32_t IpcGmDelGroupFriend(const char *appId, const char *groupId, const LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID); @@ -1060,7 +1163,7 @@ static int32_t IpcGmDelGroupFriend(const char *appId, const char *groupId, const } static int32_t GetGroupManagersIpcResult(const IpcDataInfo *replies, int32_t cacheNum, - char **outManagers, uint32_t *outSize) + char **outManagers, uint32_t *outSize) { int32_t inOutLen; int32_t ret; @@ -1083,7 +1186,8 @@ static int32_t GetGroupManagersIpcResult(const IpcDataInfo *replies, int32_t cac return HC_SUCCESS; } -static int32_t IpcGmGetGroupManagers(const char *appId, const char *groupId, char **outManagers, uint32_t *outSize) +static int32_t IpcGmGetGroupManagers(int32_t osAccountId, const char *appId, const char *groupId, + char **outManagers, uint32_t *outSize) { uintptr_t callCtx = 0x0; int32_t ret; @@ -1103,6 +1207,13 @@ static int32_t IpcGmGetGroupManagers(const char *appId, const char *groupId, cha LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID); @@ -1160,7 +1271,8 @@ static int32_t GetGroupFriendsIpcResult(const IpcDataInfo *replies, return HC_SUCCESS; } -static int32_t IpcGmGetGroupFriends(const char *appId, const char *groupId, char **outFriends, uint32_t *outSize) +static int32_t IpcGmGetGroupFriends(int32_t osAccountId, const char *appId, const char *groupId, + char **outFriends, uint32_t *outSize) { uintptr_t callCtx = 0x0; int32_t ret; @@ -1180,6 +1292,13 @@ static int32_t IpcGmGetGroupFriends(const char *appId, const char *groupId, char LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID); @@ -1234,7 +1353,7 @@ static int32_t GroupInfoIpcResult(const IpcDataInfo *replies, int32_t cacheNum, return HC_SUCCESS; } -static int32_t IpcGmGetGroupInfoById(const char *appId, const char *groupId, char **outGroupInfo) +static int32_t IpcGmGetGroupInfoById(int32_t osAccountId, const char *appId, const char *groupId, char **outGroupInfo) { uintptr_t callCtx = 0x0; int32_t ret; @@ -1254,6 +1373,13 @@ static int32_t IpcGmGetGroupInfoById(const char *appId, const char *groupId, cha LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID); @@ -1287,6 +1413,92 @@ static int32_t IpcGmGetGroupInfoById(const char *appId, const char *groupId, cha return ret; } +static int32_t ParseReturnResult(const IpcDataInfo *replies, int32_t cacheNum, char **returnData, uint32_t *returnNum) +{ + int32_t ret; + int32_t inOutLen; + + inOutLen = sizeof(int32_t); + GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_IPC_RESULT_NUM, (uint8_t *)&ret, &inOutLen); + if ((ret < IPC_RESULT_NUM_2) || (inOutLen != sizeof(int32_t))) { + return HC_ERR_IPC_OUT_DATA_NUM; + } + GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_RETURN_DATA, (uint8_t *)returnData, NULL); + if (*returnData == NULL) { + return HC_ERR_IPC_OUT_DATA; + } + *returnData = strdup(*returnData); + if (*returnData == NULL) { + return HC_ERR_ALLOC_MEMORY; + } + inOutLen = sizeof(int32_t); + GetIpcReplyByType(replies, cacheNum, PARAM_TYPE_DATA_NUM, (uint8_t *)returnNum, &inOutLen); + return HC_SUCCESS; +} + +static int32_t IpcGmGetPkInfoList(int32_t osAccountId, const char *appId, const char *queryParams, + char **returnInfoList, uint32_t *returnInfoNum) +{ + uintptr_t callCtx = 0x0; + int32_t ret; + int32_t inOutLen; + IpcDataInfo replyCache[IPC_DATA_CACHES_4] = {{0}}; + + LOGI("starting ..."); + if (!IS_STRING_VALID(appId) || !IS_STRING_VALID(queryParams) || + (returnInfoList == NULL) || (returnInfoNum == NULL)) { + return HC_ERR_INVALID_PARAMS; + } + if (!IsServiceRunning()) { + LOGE("service is not activity"); + return HC_ERROR; + } + ret = CreateCallCtx(&callCtx, NULL); + if (ret != HC_SUCCESS) { + LOGE("CreateCallCtx failed, ret %d", ret); + return HC_ERR_IPC_INIT; + } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_QUERY_PARAMS, + (const uint8_t *)queryParams, strlen(queryParams) + 1); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_QUERY_PARAMS); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } + ret = DoBinderCall(callCtx, IPC_CALL_ID_GET_PK_INFO_LIST, true); + if (ret == HC_ERR_IPC_INTERNAL_FAILED) { + LOGE("ipc call failed"); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_PROC_FAILED; + } + DecodeCallReply(callCtx, replyCache, REPLAY_CACHE_NUM(replyCache)); + ret = HC_ERR_IPC_UNKNOW_REPLY; + inOutLen = sizeof(int32_t); + GetIpcReplyByType(replyCache, REPLAY_CACHE_NUM(replyCache), PARAM_TYPE_IPC_RESULT, (uint8_t *)&ret, &inOutLen); + LOGI("process done, ret %d", ret); + if (ret != HC_SUCCESS) { + DestroyCallCtx(&callCtx, NULL); + return ret; + } + ret = ParseReturnResult(replyCache, REPLAY_CACHE_NUM(replyCache), returnInfoList, returnInfoNum); + LOGI("proc result done, ret %d", ret); + DestroyCallCtx(&callCtx, NULL); + return ret; +} + static int32_t SearchGroupsIpcResult(const IpcDataInfo *replies, int32_t cacheNum, char **outGroupVec, uint32_t *groupNum) { @@ -1311,7 +1523,8 @@ static int32_t SearchGroupsIpcResult(const IpcDataInfo *replies, return HC_SUCCESS; } -static int32_t IpcGmGetGroupInfo(const char *appId, const char *queryParams, char **outGroupVec, uint32_t *groupNum) +static int32_t IpcGmGetGroupInfo(int32_t osAccountId, const char *appId, const char *queryParams, + char **outGroupVec, uint32_t *groupNum) { uintptr_t callCtx = 0x0; int32_t ret; @@ -1331,6 +1544,13 @@ static int32_t IpcGmGetGroupInfo(const char *appId, const char *queryParams, cha LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID); @@ -1389,7 +1609,8 @@ static int32_t JoinedGroupsIpcResult(const IpcDataInfo *replies, return HC_SUCCESS; } -static int32_t IpcGmGetJoinedGroups(const char *appId, int32_t groupType, char **outGroupVec, uint32_t *groupNum) +static int32_t IpcGmGetJoinedGroups(int32_t osAccountId, const char *appId, int32_t groupType, + char **outGroupVec, uint32_t *groupNum) { uintptr_t callCtx = 0x0; int32_t ret; @@ -1397,8 +1618,7 @@ static int32_t IpcGmGetJoinedGroups(const char *appId, int32_t groupType, char * IpcDataInfo replyCache[IPC_DATA_CACHES_4] = {{0}}; LOGI("starting ..."); - if (!IS_STRING_VALID(appId) || (outGroupVec == NULL) || - (groupNum == NULL) || (groupType != ACROSS_ACCOUNT_AUTHORIZE_GROUP)) { + if (!IS_STRING_VALID(appId) || (outGroupVec == NULL) || (groupNum == NULL)) { return HC_ERR_INVALID_PARAMS; } if (!IsServiceRunning()) { @@ -1410,6 +1630,13 @@ static int32_t IpcGmGetJoinedGroups(const char *appId, int32_t groupType, char * LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID); @@ -1467,7 +1694,8 @@ static int32_t RelatedGroupsIpcResult(const IpcDataInfo *replies, return HC_SUCCESS; } -static int32_t IpcGmGetRelatedGroups(const char *appId, const char *peerUdid, char **outGroupVec, uint32_t *groupNum) +static int32_t IpcGmGetRelatedGroups(int32_t osAccountId, const char *appId, const char *peerUdid, + char **outGroupVec, uint32_t *groupNum) { uintptr_t callCtx = 0x0; int32_t ret; @@ -1487,6 +1715,13 @@ static int32_t IpcGmGetRelatedGroups(const char *appId, const char *peerUdid, ch LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID); @@ -1541,10 +1776,17 @@ static int32_t DevInfoByIdIpcResult(const IpcDataInfo *replies, int32_t cacheNum return HC_SUCCESS; } -static int32_t FormParamsForGettingDeviceInfo(const char *appId, +static int32_t FormParamsForGettingDeviceInfo(int32_t osAccountId, const char *appId, const char *peerUdid, const char *groupId, uintptr_t callCtx) { int32_t ret; + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID); @@ -1563,7 +1805,8 @@ static int32_t FormParamsForGettingDeviceInfo(const char *appId, return HC_SUCCESS; } -static int32_t IpcGmGetDeviceInfoById(const char *appId, const char *peerUdid, const char *groupId, char **outDevInfo) +static int32_t IpcGmGetDeviceInfoById(int32_t osAccountId, const char *appId, const char *peerUdid, const char *groupId, + char **outDevInfo) { uintptr_t callCtx = 0x0; int32_t ret; @@ -1583,7 +1826,7 @@ static int32_t IpcGmGetDeviceInfoById(const char *appId, const char *peerUdid, c LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } - ret = FormParamsForGettingDeviceInfo(appId, peerUdid, groupId, callCtx); + ret = FormParamsForGettingDeviceInfo(osAccountId, appId, peerUdid, groupId, callCtx); if (ret != HC_SUCCESS) { DestroyCallCtx(&callCtx, NULL); return ret; @@ -1632,7 +1875,7 @@ static int32_t TrustedDevIpcResult(const IpcDataInfo *replies, int32_t cacheNum, return HC_SUCCESS; } -static int32_t IpcGmGetTrustedDevices(const char *appId, +static int32_t IpcGmGetTrustedDevices(int32_t osAccountId, const char *appId, const char *groupId, char **outDevInfoVec, uint32_t *deviceNum) { uintptr_t callCtx = 0x0; @@ -1654,6 +1897,13 @@ static int32_t IpcGmGetTrustedDevices(const char *appId, LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID); @@ -1687,7 +1937,7 @@ static int32_t IpcGmGetTrustedDevices(const char *appId, return ret; } -static bool IpcGmIsDeviceInGroup(const char *appId, const char *groupId, const char *udid) +static bool IpcGmIsDeviceInGroup(int32_t osAccountId, const char *appId, const char *groupId, const char *udid) { uintptr_t callCtx = 0x0; int32_t ret; @@ -1696,40 +1946,47 @@ static bool IpcGmIsDeviceInGroup(const char *appId, const char *groupId, const c LOGI("starting ..."); if (!IS_STRING_VALID(appId) || !IS_STRING_VALID(groupId) || !IS_STRING_VALID(udid)) { - return HC_ERR_INVALID_PARAMS; + return false; } if (!IsServiceRunning()) { LOGE("service is not activity"); - return HC_ERROR; + return false; } ret = CreateCallCtx(&callCtx, NULL); if (ret != HC_SUCCESS) { LOGE("CreateCallCtx failed, ret %d", ret); - return HC_ERR_IPC_INIT; + return false; + } + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return false; } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_APPID, (const uint8_t *)appId, strlen(appId) + 1); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_APPID); DestroyCallCtx(&callCtx, NULL); - return HC_ERR_IPC_BUILD_PARAM; + return false; } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_GROUPID, (const uint8_t *)groupId, strlen(groupId) + 1); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_GROUPID); DestroyCallCtx(&callCtx, NULL); - return HC_ERR_IPC_BUILD_PARAM; + return false; } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_UDID, (const uint8_t *)udid, strlen(udid) + 1); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_UDID); DestroyCallCtx(&callCtx, NULL); - return HC_ERR_IPC_BUILD_PARAM; + return false; } ret = DoBinderCall(callCtx, IPC_CALL_ID_IS_DEV_IN_GROUP, true); if (ret == HC_ERR_IPC_INTERNAL_FAILED) { LOGE("ipc call failed"); DestroyCallCtx(&callCtx, NULL); - return HC_ERR_IPC_PROC_FAILED; + return false; } DecodeCallReply(callCtx, &replyCache, REPLAY_CACHE_NUM(replyCache)); ret = HC_ERR_IPC_UNKNOW_REPLY; @@ -1804,6 +2061,7 @@ static void InitIpcGmMethods(DeviceGroupManager *gmMethodObj) gmMethodObj->getTrustedDevices = IpcGmGetTrustedDevices; gmMethodObj->checkAccessToGroup = IpcGmCheckAccessToGroup; gmMethodObj->isDeviceInGroup = IpcGmIsDeviceInGroup; + gmMethodObj->getPkInfoList = IpcGmGetPkInfoList; gmMethodObj->destroyInfo = IpcGmDestroyInfo; gmMethodObj->authKeyAgree = IpcGmAuthKeyAgree; gmMethodObj->processKeyAgreeData = IpcGmProcessKeyAgreeData; @@ -2013,7 +2271,8 @@ static int32_t IpcGaGetAuthState(int64_t authReqId, const char *groupId, return ret; } -static int32_t IpcGaAuthDevice(int64_t authReqId, const char *authParams, const DeviceAuthCallback *callback) +static int32_t IpcGaAuthDevice(int32_t osAccountId, int64_t authReqId, const char *authParams, + const DeviceAuthCallback *callback) { uintptr_t callCtx = 0x0; int32_t ret; @@ -2034,7 +2293,13 @@ static int32_t IpcGaAuthDevice(int64_t authReqId, const char *authParams, const LOGE("CreateCallCtx failed, ret %d", ret); return HC_ERR_IPC_INIT; } - + ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_OS_ACCOUNT_ID, (const uint8_t *)&osAccountId, + sizeof(osAccountId)); + if (ret != HC_SUCCESS) { + LOGE("set request param failed, ret %d, param id %d", ret, PARAM_TYPE_OS_ACCOUNT_ID); + DestroyCallCtx(&callCtx, NULL); + return HC_ERR_IPC_BUILD_PARAM; + } ret = SetCallRequestParamInfo(callCtx, PARAM_TYPE_REQID, (const uint8_t *)(&authReqId), sizeof(authReqId)); if (ret != HC_SUCCESS) { LOGE("set request param failed, ret %d, type %d", ret, PARAM_TYPE_REQID); diff --git a/frameworks/src/ipc_service.c b/frameworks/src/ipc_service.c index 46bd82d..87e004f 100644 --- a/frameworks/src/ipc_service.c +++ b/frameworks/src/ipc_service.c @@ -200,12 +200,19 @@ static int32_t IpcServiceGmCreateGroup(const IpcDataInfo *ipcParams, int32_t par { int32_t callRet; int32_t ret; + int32_t osAccountId; int64_t requestId = 0; int32_t inOutLen; const char *createParams = NULL; const char *appId = NULL; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } inOutLen = sizeof(int64_t); ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&requestId, &inOutLen); if ((inOutLen != sizeof(int64_t)) || (ret != HC_SUCCESS)) { @@ -227,7 +234,7 @@ static int32_t IpcServiceGmCreateGroup(const IpcDataInfo *ipcParams, int32_t par LOGE("bind request id by app id failed"); return ret; } - callRet = g_devGroupMgrMethod.createGroup(requestId, appId, createParams); + callRet = g_devGroupMgrMethod.createGroup(osAccountId, requestId, appId, createParams); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); LOGI("process done, call ret %d, ipc ret %d", callRet, ret); return ret; @@ -237,12 +244,19 @@ static int32_t IpcServiceGmDelGroup(const IpcDataInfo *ipcParams, int32_t paramN { int32_t callRet; int32_t ret; + int32_t osAccountId; int64_t requestId = 0; int32_t inOutLen; const char *appId = NULL; const char *delParams = NULL; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } inOutLen = sizeof(int64_t); ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&requestId, &inOutLen); if ((inOutLen != sizeof(int64_t)) || (ret != HC_SUCCESS)) { @@ -259,8 +273,12 @@ static int32_t IpcServiceGmDelGroup(const IpcDataInfo *ipcParams, int32_t paramN LOGE("get param error, type %d", PARAM_TYPE_DEL_PARAMS); return ret; } - - callRet = g_devGroupMgrMethod.deleteGroup(requestId, appId, delParams); + ret = AddReqIdByAppId(appId, requestId); + if (ret != 0) { + LOGE("bind request id by app id failed"); + return ret; + } + callRet = g_devGroupMgrMethod.deleteGroup(osAccountId, requestId, appId, delParams); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); LOGI("process done, call ret %d, ipc ret %d", callRet, ret); return ret; @@ -271,11 +289,18 @@ static int32_t IpcServiceGmAddMemberToGroup(const IpcDataInfo *ipcParams, int32_ int32_t callRet; int32_t ret; int32_t inOutLen; + int32_t osAccountId; int64_t requestId = 0; const char *addParams = NULL; const char *appId = NULL; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } inOutLen = sizeof(int64_t); ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&requestId, &inOutLen); if ((inOutLen != sizeof(int64_t)) || (ret != HC_SUCCESS)) { @@ -296,8 +321,7 @@ static int32_t IpcServiceGmAddMemberToGroup(const IpcDataInfo *ipcParams, int32_ if (ret != HC_SUCCESS) { return ret; } - - callRet = g_devGroupMgrMethod.addMemberToGroup(requestId, appId, addParams); + callRet = g_devGroupMgrMethod.addMemberToGroup(osAccountId, requestId, appId, addParams); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); LOGI("process done, call ret %d, ipc ret %d", callRet, ret); return ret; @@ -308,11 +332,18 @@ static int32_t IpcServiceGmDelMemberFromGroup(const IpcDataInfo *ipcParams, int3 int32_t callRet; int32_t ret; int32_t inOutLen; + int32_t osAccountId; int64_t requestId = 0; const char *delParams = NULL; const char *appId = NULL; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } inOutLen = sizeof(int64_t); ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&requestId, &inOutLen); if ((inOutLen != sizeof(int64_t)) || (ret != HC_SUCCESS)) { @@ -329,8 +360,12 @@ static int32_t IpcServiceGmDelMemberFromGroup(const IpcDataInfo *ipcParams, int3 LOGE("get param error, type %d", PARAM_TYPE_DEL_PARAMS); return ret; } - - callRet = g_devGroupMgrMethod.deleteMemberFromGroup(requestId, appId, delParams); + ret = AddReqIdByAppId(appId, requestId); + if (ret != 0) { + LOGE("bind request id by app id failed"); + return ret; + } + callRet = g_devGroupMgrMethod.deleteMemberFromGroup(osAccountId, requestId, appId, delParams); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); LOGI("process done, call ret %d, ipc ret %d", callRet, ret); return ret; @@ -374,29 +409,31 @@ static int32_t IpcServiceGmConfirmRequest(const IpcDataInfo *ipcParams, int32_t int32_t callRet; int32_t ret; int32_t inOutLen; + int32_t osAccountId; int64_t requestId = 0; const char *cfmParams = NULL; const char *appId = NULL; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } inOutLen = sizeof(int64_t); ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&requestId, &inOutLen); if ((inOutLen != sizeof(int64_t)) || (ret != HC_SUCCESS)) { LOGE("get param error, type %d", PARAM_TYPE_REQID); return HC_ERR_IPC_BAD_PARAM; } - ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&cfmParams, NULL); - if (ret != HC_SUCCESS) { - LOGE("get param error, type %d", PARAM_TYPE_APPID); - return ret; - } ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQ_CFM, (uint8_t *)&cfmParams, NULL); if (ret != HC_SUCCESS) { LOGE("get param error, type %d", PARAM_TYPE_REQ_CFM); return ret; } - callRet = g_devGroupMgrMethod.confirmRequest(requestId, appId, cfmParams); + callRet = g_devGroupMgrMethod.confirmRequest(osAccountId, requestId, appId, cfmParams); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); LOGI("process done, call ret %d, ipc ret %d", callRet, ret); return ret; @@ -562,15 +599,101 @@ static int32_t IpcServiceGmApplyRegisterInfo(const IpcDataInfo *ipcParams, int32 return (ret == HC_SUCCESS) ? ret : HC_ERROR; } +static int32_t IpcServiceGmCheckAccessToGroup(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache) +{ + int32_t callRet; + int32_t ret; + int32_t inOutLen; + int32_t osAccountId; + const char *appId = NULL; + const char *groupId = NULL; + + LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL); + if ((appId == NULL) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_APPID); + return HC_ERR_IPC_BAD_PARAM; + } + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_GROUPID, (uint8_t *)&groupId, NULL); + if ((groupId == NULL) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_GROUPID); + return HC_ERR_IPC_BAD_PARAM; + } + + callRet = g_devGroupMgrMethod.checkAccessToGroup(osAccountId, appId, groupId); + ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); + LOGI("process done, call ret %d, ipc ret %d", callRet, ret); + return ret; +} + +static int32_t IpcServiceGmGetPkInfoList(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache) +{ + int32_t callRet; + int32_t ret; + int32_t inOutLen; + int32_t osAccountId; + const char *appId = NULL; + const char *queryParams = NULL; + char *returnInfoList = NULL; + uint32_t returnInfoNum = 0; + + LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL); + if ((appId == NULL) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_APPID); + return HC_ERR_IPC_BAD_PARAM; + } + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_QUERY_PARAMS, (uint8_t *)&queryParams, NULL); + if ((queryParams == NULL) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_QUERY_PARAMS); + return HC_ERR_IPC_BAD_PARAM; + } + + callRet = g_devGroupMgrMethod.getPkInfoList(osAccountId, appId, queryParams, &returnInfoList, &returnInfoNum); + ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); + ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM, + (const uint8_t *)&g_ipcResultNum2, sizeof(int32_t)); + if (returnInfoList != NULL) { + ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_RETURN_DATA, (const uint8_t *)returnInfoList, + strlen(returnInfoList) + 1); + } else { + ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_RETURN_DATA, NULL, 0); + } + ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_DATA_NUM, (const uint8_t *)&returnInfoNum, sizeof(int32_t)); + LOGI("process done, call ret %d, ipc ret %d", callRet, ret); + g_devGroupMgrMethod.destroyInfo(&returnInfoList); + return (ret == HC_SUCCESS) ? ret : HC_ERROR; +} + static int32_t IpcServiceGmAddGroupManager(const IpcDataInfo *ipcParams, int32_t paramNum, uintptr_t outCache) { int32_t callRet; int32_t ret; + int32_t inOutLen; + int32_t osAccountId; const char *appId = NULL; const char *groupId = NULL; const char *managerAppId = NULL; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL); if ((appId == NULL) || (ret != HC_SUCCESS)) { LOGE("get param error, type %d", PARAM_TYPE_APPID); @@ -586,7 +709,7 @@ static int32_t IpcServiceGmAddGroupManager(const IpcDataInfo *ipcParams, int32_t LOGE("get param error, type %d", PARAM_TYPE_MGR_APPID); return HC_ERR_IPC_BAD_PARAM; } - callRet = g_devGroupMgrMethod.addGroupManager(appId, groupId, managerAppId); + callRet = g_devGroupMgrMethod.addGroupManager(osAccountId, appId, groupId, managerAppId); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); LOGI("process done, call ret %d, ipc ret %d", callRet, ret); return ret; @@ -596,11 +719,19 @@ static int32_t IpcServiceGmAddGroupFriend(const IpcDataInfo *ipcParams, int32_t { int32_t callRet; int32_t ret; + int32_t inOutLen; + int32_t osAccountId; const char *appId = NULL; const char *groupId = NULL; const char *friendAppId = NULL; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL); if ((appId == NULL) || (ret != HC_SUCCESS)) { LOGE("get param error, type %d", PARAM_TYPE_APPID); @@ -616,7 +747,7 @@ static int32_t IpcServiceGmAddGroupFriend(const IpcDataInfo *ipcParams, int32_t LOGE("get param error, type %d", PARAM_TYPE_FRIEND_APPID); return HC_ERR_IPC_BAD_PARAM; } - callRet = g_devGroupMgrMethod.addGroupFriend(appId, groupId, friendAppId); + callRet = g_devGroupMgrMethod.addGroupFriend(osAccountId, appId, groupId, friendAppId); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); LOGI("process done, call ret %d, ipc ret %d", callRet, ret); return ret; @@ -626,11 +757,19 @@ static int32_t IpcServiceGmDelGroupManager(const IpcDataInfo *ipcParams, int32_t { int32_t callRet; int32_t ret; + int32_t inOutLen; + int32_t osAccountId; const char *appId = NULL; const char *groupId = NULL; const char *managerAppId = NULL; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL); if ((appId == NULL) || (ret != HC_SUCCESS)) { LOGE("get param error, type %d", PARAM_TYPE_APPID); @@ -646,7 +785,7 @@ static int32_t IpcServiceGmDelGroupManager(const IpcDataInfo *ipcParams, int32_t LOGE("get param error, type %d", PARAM_TYPE_MGR_APPID); return HC_ERR_IPC_BAD_PARAM; } - callRet = g_devGroupMgrMethod.deleteGroupManager(appId, groupId, managerAppId); + callRet = g_devGroupMgrMethod.deleteGroupManager(osAccountId, appId, groupId, managerAppId); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); LOGI("process done, call ret %d, ipc ret %d", callRet, ret); return ret; @@ -656,11 +795,19 @@ static int32_t IpcServiceGmDelGroupFriend(const IpcDataInfo *ipcParams, int32_t { int32_t callRet; int32_t ret; + int32_t inOutLen; + int32_t osAccountId; const char *appId = NULL; const char *groupId = NULL; const char *friendAppId = NULL; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL); if ((appId == NULL) || (ret != HC_SUCCESS)) { LOGE("get param error, type %d", PARAM_TYPE_APPID); @@ -676,7 +823,7 @@ static int32_t IpcServiceGmDelGroupFriend(const IpcDataInfo *ipcParams, int32_t LOGE("get param error, type %d", PARAM_TYPE_FRIEND_APPID); return HC_ERR_IPC_BAD_PARAM; } - callRet = g_devGroupMgrMethod.deleteGroupFriend(appId, groupId, friendAppId); + callRet = g_devGroupMgrMethod.deleteGroupFriend(osAccountId, appId, groupId, friendAppId); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); LOGI("process done, call ret %d, ipc ret %d", callRet, ret); return ret; @@ -686,12 +833,20 @@ static int32_t IpcServiceGmGetGroupManagers(const IpcDataInfo *ipcParams, int32_ { int32_t callRet; int32_t ret; + int32_t inOutLen; + int32_t osAccountId; const char *appId = NULL; const char *groupId = NULL; char *managers = NULL; uint32_t managersNum = 0; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL); if ((appId == NULL) || (ret != HC_SUCCESS)) { LOGE("get param error, type %d", PARAM_TYPE_APPID); @@ -703,7 +858,7 @@ static int32_t IpcServiceGmGetGroupManagers(const IpcDataInfo *ipcParams, int32_ return HC_ERR_IPC_BAD_PARAM; } - callRet = g_devGroupMgrMethod.getGroupManagers(appId, groupId, &managers, &managersNum); + callRet = g_devGroupMgrMethod.getGroupManagers(osAccountId, appId, groupId, &managers, &managersNum); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM, (const uint8_t *)&g_ipcResultNum2, sizeof(int32_t)); @@ -722,12 +877,20 @@ static int32_t IpcServiceGmGetGroupFriends(const IpcDataInfo *ipcParams, int32_t { int32_t callRet; int32_t ret; + int32_t inOutLen; + int32_t osAccountId; const char *appId = NULL; const char *groupId = NULL; char *friends = NULL; uint32_t friendsNum = 0; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL); if ((appId == NULL) || (ret != HC_SUCCESS)) { LOGE("get param error, type %d", PARAM_TYPE_APPID); @@ -739,7 +902,7 @@ static int32_t IpcServiceGmGetGroupFriends(const IpcDataInfo *ipcParams, int32_t return HC_ERR_IPC_BAD_PARAM; } - callRet = g_devGroupMgrMethod.getGroupFriends(appId, groupId, &friends, &friendsNum); + callRet = g_devGroupMgrMethod.getGroupFriends(osAccountId, appId, groupId, &friends, &friendsNum); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM, (const uint8_t *)&g_ipcResultNum2, sizeof(int32_t)); @@ -758,11 +921,19 @@ static int32_t IpcServiceGmGetGroupInfoById(const IpcDataInfo *ipcParams, int32_ { int32_t callRet; int32_t ret; + int32_t inOutLen; + int32_t osAccountId; const char *appId = NULL; const char *groupId = NULL; char *groupInfo = NULL; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL); if ((appId == NULL) || (ret != HC_SUCCESS)) { LOGE("get param error, type %d", PARAM_TYPE_APPID); @@ -774,7 +945,7 @@ static int32_t IpcServiceGmGetGroupInfoById(const IpcDataInfo *ipcParams, int32_ return HC_ERR_IPC_BAD_PARAM; } - callRet = g_devGroupMgrMethod.getGroupInfoById(appId, groupId, &groupInfo); + callRet = g_devGroupMgrMethod.getGroupInfoById(osAccountId, appId, groupId, &groupInfo); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM, (const uint8_t *)&g_ipcResultNum1, sizeof(int32_t)); @@ -792,12 +963,20 @@ static int32_t IpcServiceGmGetGroupInfo(const IpcDataInfo *ipcParams, int32_t pa { int32_t callRet; int32_t ret; + int32_t inOutLen; + int32_t osAccountId; const char *appId = NULL; const char *queryParams = NULL; char *outGroups = NULL; uint32_t groupNum = 0; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL); if ((appId == NULL) || (ret != HC_SUCCESS)) { LOGE("get param error, type %d", PARAM_TYPE_APPID); @@ -809,7 +988,7 @@ static int32_t IpcServiceGmGetGroupInfo(const IpcDataInfo *ipcParams, int32_t pa return HC_ERR_IPC_BAD_PARAM; } - callRet = g_devGroupMgrMethod.getGroupInfo(appId, queryParams, &outGroups, &groupNum); + callRet = g_devGroupMgrMethod.getGroupInfo(osAccountId, appId, queryParams, &outGroups, &groupNum); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM, (const uint8_t *)&g_ipcResultNum2, sizeof(int32_t)); @@ -829,12 +1008,19 @@ static int32_t IpcServiceGmGetJoinedGroups(const IpcDataInfo *ipcParams, int32_t int32_t callRet; int32_t ret; int32_t groupType = 0; + int32_t inOutLen; + int32_t osAccountId; const char *appId = NULL; char *outGroups = NULL; uint32_t groupNum = 0; - int32_t inOutLen; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL); if ((appId == NULL) || (ret != HC_SUCCESS)) { LOGE("get param error, type %d", PARAM_TYPE_APPID); @@ -847,7 +1033,7 @@ static int32_t IpcServiceGmGetJoinedGroups(const IpcDataInfo *ipcParams, int32_t return HC_ERR_IPC_BAD_PARAM; } - callRet = g_devGroupMgrMethod.getJoinedGroups(appId, groupType, &outGroups, &groupNum); + callRet = g_devGroupMgrMethod.getJoinedGroups(osAccountId, appId, groupType, &outGroups, &groupNum); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM, (const uint8_t *)&g_ipcResultNum2, sizeof(int32_t)); @@ -866,12 +1052,20 @@ static int32_t IpcServiceGmGetRelatedGroups(const IpcDataInfo *ipcParams, int32_ { int32_t callRet; int32_t ret; + int32_t inOutLen; + int32_t osAccountId; const char *appId = NULL; const char *peerUdid = NULL; char *outGroups = NULL; uint32_t groupNum = 0; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL); if ((appId == NULL) || (ret != HC_SUCCESS)) { LOGE("get param error, type %d", PARAM_TYPE_APPID); @@ -883,7 +1077,7 @@ static int32_t IpcServiceGmGetRelatedGroups(const IpcDataInfo *ipcParams, int32_ return HC_ERR_IPC_BAD_PARAM; } - callRet = g_devGroupMgrMethod.getRelatedGroups(appId, peerUdid, &outGroups, &groupNum); + callRet = g_devGroupMgrMethod.getRelatedGroups(osAccountId, appId, peerUdid, &outGroups, &groupNum); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM, (const uint8_t *)&g_ipcResultNum2, sizeof(int32_t)); @@ -902,12 +1096,20 @@ static int32_t IpcServiceGmGetDeviceInfoById(const IpcDataInfo *ipcParams, int32 { int32_t callRet; int32_t ret; + int32_t inOutLen; + int32_t osAccountId; const char *appId = NULL; const char *peerUdid = NULL; const char *groupId = NULL; char *outDevInfo = NULL; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL); if ((appId == NULL) || (ret != HC_SUCCESS)) { LOGE("get param error, type %d", PARAM_TYPE_APPID); @@ -924,7 +1126,7 @@ static int32_t IpcServiceGmGetDeviceInfoById(const IpcDataInfo *ipcParams, int32 return HC_ERR_IPC_BAD_PARAM; } - callRet = g_devGroupMgrMethod.getDeviceInfoById(appId, peerUdid, groupId, &outDevInfo); + callRet = g_devGroupMgrMethod.getDeviceInfoById(osAccountId, appId, peerUdid, groupId, &outDevInfo); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM, (const uint8_t *)&g_ipcResultNum1, sizeof(int32_t)); @@ -943,12 +1145,20 @@ static int32_t IpcServiceGmGetTrustedDevices(const IpcDataInfo *ipcParams, int32 { int32_t callRet; int32_t ret; + int32_t inOutLen; + int32_t osAccountId; const char *appId = NULL; const char *groupId = NULL; char *outDevInfo = NULL; uint32_t outDevNum = 0; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL); if ((appId == NULL) || (ret != HC_SUCCESS)) { LOGE("get param error, type %d", PARAM_TYPE_APPID); @@ -960,7 +1170,7 @@ static int32_t IpcServiceGmGetTrustedDevices(const IpcDataInfo *ipcParams, int32 return HC_ERR_IPC_BAD_PARAM; } - callRet = g_devGroupMgrMethod.getTrustedDevices(appId, groupId, &outDevInfo, &outDevNum); + callRet = g_devGroupMgrMethod.getTrustedDevices(osAccountId, appId, groupId, &outDevInfo, &outDevNum); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); ret += IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT_NUM, (const uint8_t *)&g_ipcResultNum2, sizeof(int32_t)); @@ -980,12 +1190,20 @@ static int32_t IpcServiceGmIsDeviceInGroup(const IpcDataInfo *ipcParams, int32_t { int32_t callRet; int32_t ret; + int32_t inOutLen; + int32_t osAccountId; bool bRet = false; const char *appId = NULL; const char *udid = NULL; const char *groupId = NULL; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_APPID, (uint8_t *)&appId, NULL); if ((appId == NULL) || (ret != HC_SUCCESS)) { LOGE("get param error, type %d", PARAM_TYPE_APPID); @@ -1002,7 +1220,7 @@ static int32_t IpcServiceGmIsDeviceInGroup(const IpcDataInfo *ipcParams, int32_t return HC_ERR_IPC_BAD_PARAM; } - bRet = g_devGroupMgrMethod.isDeviceInGroup(appId, groupId, udid); + bRet = g_devGroupMgrMethod.isDeviceInGroup(osAccountId, appId, groupId, udid); callRet = ((bRet == true) ? HC_SUCCESS : HC_ERROR); ret = IpcEncodeCallReplay(outCache, PARAM_TYPE_IPC_RESULT, (const uint8_t *)&callRet, sizeof(int32_t)); LOGI("process done, call ret %d, ipc ret %d", callRet, ret); @@ -1139,12 +1357,19 @@ static int32_t IpcServiceGaAuthDevice(const IpcDataInfo *ipcParams, int32_t para int32_t callRet; int32_t ret; DeviceAuthCallback *gaCallback = NULL; + int32_t osAccountId; int64_t authReqId = 0; const char *authParams = NULL; int32_t inOutLen; int32_t cbObjIdx = -1; LOGI("starting ..."); + inOutLen = sizeof(int32_t); + ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_OS_ACCOUNT_ID, (uint8_t *)&osAccountId, &inOutLen); + if ((inOutLen != sizeof(int32_t)) || (ret != HC_SUCCESS)) { + LOGE("get param error, type %d", PARAM_TYPE_OS_ACCOUNT_ID); + return HC_ERR_IPC_BAD_PARAM; + } inOutLen = sizeof(authReqId); ret = GetIpcRequestParamByType(ipcParams, paramNum, PARAM_TYPE_REQID, (uint8_t *)&authReqId, &inOutLen); if ((inOutLen != sizeof(authReqId)) || (ret != HC_SUCCESS)) { @@ -1178,7 +1403,7 @@ static int32_t IpcServiceGaAuthDevice(const IpcDataInfo *ipcParams, int32_t para } AddIpcCbObjByReqId(authReqId, cbObjIdx, CB_TYPE_TMP_DEV_AUTH); InitDeviceAuthCbCtx(&g_authCbAdt, CB_TYPE_TMP_DEV_AUTH); - callRet = g_groupAuthMgrMethod.authDevice(authReqId, authParams, &g_authCbAdt); + callRet = g_groupAuthMgrMethod.authDevice(osAccountId, authReqId, authParams, &g_authCbAdt); if (callRet != HC_SUCCESS) { DelIpcCallBackByReqId(authReqId, CB_TYPE_TMP_DEV_AUTH, true); } @@ -1226,6 +1451,7 @@ static int32_t AddMethodMap(uintptr_t ipcInstance) ret &= SetIpcCallMap(ipcInstance, IpcServiceGmProcessLiteData, IPC_CALL_ID_PROC_LIGHT_DATA); ret &= SetIpcCallMap(ipcInstance, IpcServiceGmSaveCredential, IPC_CALL_ID_SAVE_CREDENTIAL); ret &= SetIpcCallMap(ipcInstance, IpcServiceGmApplyRegisterInfo, IPC_CALL_ID_APPLY_REG_INFO); + ret &= SetIpcCallMap(ipcInstance, IpcServiceGmCheckAccessToGroup, IPC_CALL_ID_CHECK_ACCESS_TO_GROUP); ret &= SetIpcCallMap(ipcInstance, IpcServiceGmAddGroupManager, IPC_CALL_ID_ADD_GROUP_MGR); ret &= SetIpcCallMap(ipcInstance, IpcServiceGmAddGroupFriend, IPC_CALL_ID_ADD_GROUP_FRIEND); ret &= SetIpcCallMap(ipcInstance, IpcServiceGmDelGroupManager, IPC_CALL_ID_DEL_GROUP_MGR); @@ -1239,6 +1465,7 @@ static int32_t AddMethodMap(uintptr_t ipcInstance) ret &= SetIpcCallMap(ipcInstance, IpcServiceGmGetDeviceInfoById, IPC_CALL_ID_GET_DEV_INFO_BY_ID); ret &= SetIpcCallMap(ipcInstance, IpcServiceGmGetTrustedDevices, IPC_CALL_ID_GET_TRUST_DEVICES); ret &= SetIpcCallMap(ipcInstance, IpcServiceGmIsDeviceInGroup, IPC_CALL_ID_IS_DEV_IN_GROUP); + ret &= SetIpcCallMap(ipcInstance, IpcServiceGmGetPkInfoList, IPC_CALL_ID_GET_PK_INFO_LIST); ret &= SetIpcCallMap(ipcInstance, IpcServiceGaProcessData, IPC_CALL_ID_GA_PROC_DATA); ret &= SetIpcCallMap(ipcInstance, IpcServiceGaQueryTrustedDeviceNum, IPC_CALL_ID_QUERY_TRUST_DEV_NUM); ret &= SetIpcCallMap(ipcInstance, IpcServiceGaIsTrustedDevice, IPC_CALL_ID_IS_TRUST_DEVICE); diff --git a/frameworks/src/lite/ipc_adapt.c b/frameworks/src/lite/ipc_adapt.c index 7a3b8a7..6ca50d8 100644 --- a/frameworks/src/lite/ipc_adapt.c +++ b/frameworks/src/lite/ipc_adapt.c @@ -1535,7 +1535,7 @@ static bool IsTypeForSettingPtr(int32_t type) static bool IsTypeForCpyData(int32_t type) { int32_t typeList[] = { - PARAM_TYPE_REQID, PARAM_TYPE_GROUP_TYPE, PARAM_TYPE_OPCODE, PARAM_TYPE_ERRCODE + PARAM_TYPE_REQID, PARAM_TYPE_GROUP_TYPE, PARAM_TYPE_OPCODE, PARAM_TYPE_ERRCODE, PARAM_TYPE_OS_ACCOUNT_ID }; int32_t i; int32_t n = sizeof(typeList) / sizeof(typeList[0]); diff --git a/frameworks/src/standard/ipc_adapt.cpp b/frameworks/src/standard/ipc_adapt.cpp index e9cb5b9..56950ce 100644 --- a/frameworks/src/standard/ipc_adapt.cpp +++ b/frameworks/src/standard/ipc_adapt.cpp @@ -129,6 +129,7 @@ void ResetIpcCallBackNodeByNodeId(int32_t nodeIdx) return; } ResetIpcCallBackNode(g_ipcCallBackList.ctx[nodeIdx]); + g_ipcCallBackList.nodeCnt--; LOGI("done, index %d", nodeIdx); return; } @@ -354,7 +355,7 @@ int32_t AddIpcCallBackByReqId(int64_t reqId, const uint8_t *cbPtr, int32_t cbSz, ServiceDevAuth::ResetRemoteObject(node->proxyId); node->proxyId = -1; } - LOGI("callback added success, request id %lld, type %d", (long long)reqId, type); + LOGI("callback replaced success, request id %lld, type %d", (long long)reqId, type); return HC_SUCCESS; } @@ -1442,7 +1443,7 @@ static bool IsTypeForSettingPtr(int32_t type) static bool IsTypeForCpyData(int32_t type) { int32_t typeList[] = { - PARAM_TYPE_REQID, PARAM_TYPE_GROUP_TYPE, PARAM_TYPE_OPCODE, PARAM_TYPE_ERRCODE + PARAM_TYPE_REQID, PARAM_TYPE_GROUP_TYPE, PARAM_TYPE_OPCODE, PARAM_TYPE_ERRCODE, PARAM_TYPE_OS_ACCOUNT_ID }; int32_t i; int32_t n = sizeof(typeList) / sizeof(typeList[0]); diff --git a/interfaces/innerkits/device_auth.h b/interfaces/innerkits/device_auth.h index 5fc0893..fd6e166 100644 --- a/interfaces/innerkits/device_auth.h +++ b/interfaces/innerkits/device_auth.h @@ -67,6 +67,13 @@ #define FIELD_EXPIRE_TIME "expireTime" #define FIELD_IS_DELETE_ALL "isDeleteAll" #define FIELD_BLE_CHALLENGE "bleChallenge" +#define FIELD_OS_ACCOUNT_ID "osAccountId" + +typedef enum { + DEFAULT_OS_ACCOUNT = 0, + INVALID_OS_ACCOUNT = -1, + ANY_OS_ACCOUNT = -2, +} OsAccountEnum; typedef enum { ALL_GROUP = 0, @@ -145,7 +152,8 @@ typedef struct { bool (*isTrustedDevice)(const char *udid); int32_t (*getAuthState)(int64_t authReqId, const char *groupId, const char *peerUdid, uint8_t *out, uint32_t *outLen); - int32_t (*authDevice)(int64_t authReqId, const char *authParams, const DeviceAuthCallback *gaCallback); + int32_t (*authDevice)(int32_t osAccountId, int64_t authReqId, const char *authParams, + const DeviceAuthCallback *gaCallback); void (*informDeviceDisconnection)(const char *udid); } GroupAuthManager; @@ -154,12 +162,13 @@ typedef struct { int32_t (*unRegCallback)(const char *appId); int32_t (*regDataChangeListener)(const char *appId, const DataChangeListener *listener); int32_t (*unRegDataChangeListener)(const char *appId); - int32_t (*createGroup)(int64_t requestId, const char *appId, const char *createParams); - int32_t (*deleteGroup)(int64_t requestId, const char *appId, const char *disbandParams); - int32_t (*addMemberToGroup)(int64_t requestId, const char *appId, const char *addParams); - int32_t (*deleteMemberFromGroup)(int64_t requestId, const char *appId, const char *deleteParams); + int32_t (*createGroup)(int32_t osAccountId, int64_t requestId, const char *appId, const char *createParams); + int32_t (*deleteGroup)(int32_t osAccountId, int64_t requestId, const char *appId, const char *disbandParams); + int32_t (*addMemberToGroup)(int32_t osAccountId, int64_t requestId, const char *appId, const char *addParams); + int32_t (*deleteMemberFromGroup)(int32_t osAccountId, int64_t requestId, const char *appId, + const char *deleteParams); int32_t (*processData)(int64_t requestId, const uint8_t *data, uint32_t dataLen); - int32_t (*confirmRequest)(int64_t requestId, const char *appId, const char *confirmParams); + int32_t (*confirmRequest)(int32_t osAccountId, int64_t requestId, const char *appId, const char *confirmParams); int32_t (*bindPeer)(int64_t requestId, const char *appId, const char *bindParams); int32_t (*unbindPeer)(int64_t requestId, const char *appId, const char *unbindParams); int32_t (*processLiteData)(int64_t requestId, const char *appId, const uint8_t *data, uint32_t dataLen); @@ -168,21 +177,30 @@ typedef struct { int32_t (*processCredential)(int operationCode, const char *reqJsonStr, char **returnJsonStr); int32_t (*getRegisterInfo)(char **returnRegisterInfo); int32_t (*getLocalConnectInfo)(char *returnInfo, int32_t bufLen); - int32_t (*checkAccessToGroup)(const char *appId, const char *groupId); - int32_t (*addGroupManager)(const char *appId, const char *groupId, const char *managerAppId); - int32_t (*addGroupFriend)(const char *appId, const char *groupId, const char *friendAppId); - int32_t (*deleteGroupManager)(const char *appId, const char *groupId, const char *managerAppId); - int32_t (*deleteGroupFriend)(const char *appId, const char *groupId, const char *friendAppId); - int32_t (*getGroupManagers)(const char *appId, const char *groupId, char **returnManagers, uint32_t *returnSize); - int32_t (*getGroupFriends)(const char *appId, const char *groupId, char **returnFriends, uint32_t *returnSize); - int32_t (*getGroupInfoById)(const char *appId, const char *groupId, char **returnGroupInfo); - int32_t (*getGroupInfo)(const char *appId, const char *queryParams, char **returnGroupVec, uint32_t *groupNum); - int32_t (*getJoinedGroups)(const char *appId, int groupType, char **returnGroupVec, uint32_t *groupNum); - int32_t (*getRelatedGroups)(const char *appId, const char *peerDeviceId, char **returnGroupVec, uint32_t *groupNum); - int32_t (*getDeviceInfoById)(const char *appId, const char *deviceId, const char *groupId, + int32_t (*checkAccessToGroup)(int32_t osAccountId, const char *appId, const char *groupId); + int32_t (*getPkInfoList)(int32_t osAccountId, const char *appId, const char *queryParams, char **returnInfoList, + uint32_t *returnInfoNum); + int32_t (*addGroupManager)(int32_t osAccountId, const char *appId, const char *groupId, const char *managerAppId); + int32_t (*addGroupFriend)(int32_t osAccountId, const char *appId, const char *groupId, const char *friendAppId); + int32_t (*deleteGroupManager)(int32_t osAccountId, const char *appId, const char *groupId, + const char *managerAppId); + int32_t (*deleteGroupFriend)(int32_t osAccountId, const char *appId, const char *groupId, const char *friendAppId); + int32_t (*getGroupManagers)(int32_t osAccountId, const char *appId, const char *groupId, char **returnManagers, + uint32_t *returnSize); + int32_t (*getGroupFriends)(int32_t osAccountId, const char *appId, const char *groupId, + char **returnFriends, uint32_t *returnSize); + int32_t (*getGroupInfoById)(int32_t osAccountId, const char *appId, const char *groupId, char **returnGroupInfo); + int32_t (*getGroupInfo)(int32_t osAccountId, const char *appId, const char *queryParams, + char **returnGroupVec, uint32_t *groupNum); + int32_t (*getJoinedGroups)(int32_t osAccountId, const char *appId, int groupType, + char **returnGroupVec, uint32_t *groupNum); + int32_t (*getRelatedGroups)(int32_t osAccountId, const char *appId, const char *peerDeviceId, + char **returnGroupVec, uint32_t *groupNum); + int32_t (*getDeviceInfoById)(int32_t osAccountId, const char *appId, const char *deviceId, const char *groupId, char **returnDeviceInfo); - int32_t (*getTrustedDevices)(const char *appId, const char *groupId, char **returnDevInfoVec, uint32_t *deviceNum); - bool (*isDeviceInGroup)(const char *appId, const char *groupId, const char *deviceId); + int32_t (*getTrustedDevices)(int32_t osAccountId, const char *appId, const char *groupId, + char **returnDevInfoVec, uint32_t *deviceNum); + bool (*isDeviceInGroup)(int32_t osAccountId, const char *appId, const char *groupId, const char *deviceId); void (*destroyInfo)(char **returnInfo); } DeviceGroupManager; diff --git a/services/BUILD.gn b/services/BUILD.gn index 6d49f49..5591e10 100644 --- a/services/BUILD.gn +++ b/services/BUILD.gn @@ -141,6 +141,8 @@ if (defined(ohos_lite)) { "//foundation/communication/dsoftbus/interfaces/kits/common", "//foundation/communication/dsoftbus/interfaces/kits/transport", "//foundation/communication/dsoftbus/interfaces/inner_kits/transport", + "//third_party/json/include", + "//base/account/os_account/interfaces/innerkits/osaccount/native/include", ] sources = deviceauth_files @@ -160,6 +162,7 @@ if (defined(ohos_lite)) { external_deps = [ "dsoftbus_standard:softbus_client", "hiviewdfx_hilog_native:libhilog", + "os_account_standard:os_account_innerkits", ] } diff --git a/services/authenticators/inc/account_unrelated/das_module.h b/services/authenticators/inc/account_unrelated/das_module.h index ebbfaa0..96b1061 100644 --- a/services/authenticators/inc/account_unrelated/das_module.h +++ b/services/authenticators/inc/account_unrelated/das_module.h @@ -24,7 +24,8 @@ typedef struct DasAuthModuleT { AuthModuleBase moduleBase; int32_t (*registerLocalIdentity)(const char *, const char *, Uint8Buff *, int); int32_t (*unregisterLocalIdentity)(const char *, const char *, Uint8Buff *, int); - int32_t (*deletePeerAuthInfo)(const char *, const char *, Uint8Buff *, int); + int32_t (*deletePeerAuthInfo)(const char *, const char *, Uint8Buff *, int); + int32_t (*getPublicKey)(const char *, const char *, Uint8Buff *, int, Uint8Buff *); } DasAuthModule; bool IsDasSupported(void); diff --git a/services/authenticators/inc/account_unrelated/das_task_main.h b/services/authenticators/inc/account_unrelated/das_task_main.h index f208382..b3f7ae3 100644 --- a/services/authenticators/inc/account_unrelated/das_task_main.h +++ b/services/authenticators/inc/account_unrelated/das_task_main.h @@ -39,5 +39,7 @@ void DestroyDasProtocolEntities(void); int32_t RegisterLocalIdentityInTask(const char *pkgName, const char *serviceType, Uint8Buff *authId, int userType); int32_t UnregisterLocalIdentityInTask(const char *pkgName, const char *serviceType, Uint8Buff *authId, int userType); int32_t DeletePeerAuthInfoInTask(const char *pkgName, const char *serviceType, Uint8Buff *authIdPeer, int userTypePeer); +int32_t GetPublicKeyInTask(const char *pkgName, const char *serviceType, Uint8Buff *authIdPeer, int userTypePeer, + Uint8Buff *returnPk); #endif diff --git a/services/authenticators/inc/account_unrelated/das_token_manager.h b/services/authenticators/inc/account_unrelated/das_token_manager.h index 6b80a62..32d5e4e 100644 --- a/services/authenticators/inc/account_unrelated/das_token_manager.h +++ b/services/authenticators/inc/account_unrelated/das_token_manager.h @@ -20,10 +20,11 @@ #include "pake_base_cur_task.h" typedef struct TokenManagerT { - int (*registerLocalIdentity)(const char *, const char *, Uint8Buff *, int); + int32_t (*registerLocalIdentity)(const char *, const char *, Uint8Buff *, int); int32_t (*unregisterLocalIdentity)(const char *, const char *, Uint8Buff *, int); int32_t (*deletePeerAuthInfo)(const char *, const char *, Uint8Buff *, int); - int (*computeAndSavePsk)(const PakeParams *); + int32_t (*computeAndSavePsk)(const PakeParams *); + int32_t (*getPublicKey)(const char *, const char *, Uint8Buff *, int, Uint8Buff *); } TokenManager; #endif diff --git a/services/authenticators/src/account_unrelated/das_module.c b/services/authenticators/src/account_unrelated/das_module.c index 4759203..ec1ddca 100644 --- a/services/authenticators/src/account_unrelated/das_module.c +++ b/services/authenticators/src/account_unrelated/das_module.c @@ -23,7 +23,7 @@ #define DAS_CLIENT_STEP_MASK 0xF00F #define DAS_CLIENT_FIRST_MESSAGE 0x0001 -DECLARE_HC_VECTOR(TaskInModuleVec, void *) +DECLARE_HC_VECTOR(TaskInModuleVec, void *); IMPLEMENT_HC_VECTOR(TaskInModuleVec, void *, 1) TaskInModuleVec g_taskInModuleVec; @@ -44,6 +44,12 @@ static int32_t DeleteDasPeerAuthInfo(const char *pkgName, const char *serviceTyp return DeletePeerAuthInfoInTask(pkgName, serviceType, authId, userType); } +static int32_t GetDasPublicKey(const char *pkgName, const char *serviceType, Uint8Buff *authId, int userType, + Uint8Buff *returnPk) +{ + return GetPublicKeyInTask(pkgName, serviceType, authId, userType, returnPk); +} + bool IsDasMsgNeedIgnore(const CJson *in) { int32_t message = 0; @@ -87,7 +93,7 @@ static void DestroyDasModule(AuthModuleBase *module) ((Task *)(*ptr))->destroyTask((Task *)(*ptr)); } } - DESTROY_HC_VECTOR(TaskInModuleVec, &g_taskInModuleVec) + DESTROY_HC_VECTOR(TaskInModuleVec, &g_taskInModuleVec); DestroyDasProtocolEntities(); if (module != NULL) { (void)memset_s(module, sizeof(DasAuthModule), 0, sizeof(DasAuthModule)); @@ -147,7 +153,8 @@ AuthModuleBase *CreateDasModule(void) g_dasModule.registerLocalIdentity = RegisterDasLocalIdentity; g_dasModule.unregisterLocalIdentity = UnregisterDasLocalIdentity; g_dasModule.deletePeerAuthInfo = DeleteDasPeerAuthInfo; - g_taskInModuleVec = CREATE_HC_VECTOR(TaskInModuleVec) + g_dasModule.getPublicKey = GetDasPublicKey; + g_taskInModuleVec = CREATE_HC_VECTOR(TaskInModuleVec); if (InitDasProtocolEntities() != HC_SUCCESS) { LOGE("Init das protocol entities failed."); DestroyDasModule((AuthModuleBase *)&g_dasModule); diff --git a/services/authenticators/src/account_unrelated/das_task_main.c b/services/authenticators/src/account_unrelated/das_task_main.c index d5f034a..ef28b11 100644 --- a/services/authenticators/src/account_unrelated/das_task_main.c +++ b/services/authenticators/src/account_unrelated/das_task_main.c @@ -35,7 +35,7 @@ typedef struct DasProtocolEntityT { } DasProtocolEntity; IMPLEMENT_HC_VECTOR(SubTaskVec, void *, 1) -DECLARE_HC_VECTOR(DasProtocolEntityVec, void *) +DECLARE_HC_VECTOR(DasProtocolEntityVec, void *); IMPLEMENT_HC_VECTOR(DasProtocolEntityVec, void *, 1) DasProtocolEntityVec g_protocolEntityVec; @@ -123,7 +123,7 @@ static void DestroyTaskT(Task *task) ((SubTaskBase *)(*ptr))->destroyTask((SubTaskBase *)(*ptr)); } } - DESTROY_HC_VECTOR(SubTaskVec, &(task->vec)) + DESTROY_HC_VECTOR(SubTaskVec, &(task->vec)); HcFree(task); } @@ -367,7 +367,7 @@ Task *CreateTaskT(int32_t *taskId, const CJson *in, CJson *out) res = HC_ERR_ALLOC_MEMORY; goto ERR; } - task->vec = CREATE_HC_VECTOR(SubTaskVec) + task->vec = CREATE_HC_VECTOR(SubTaskVec); task->destroyTask = DestroyTaskT; task->processTask = ProcessTaskT; @@ -469,6 +469,25 @@ int32_t DeletePeerAuthInfoInTask(const char *pkgName, const char *serviceType, U return res; } +int32_t GetPublicKeyInTask(const char *pkgName, const char *serviceType, Uint8Buff *authIdPeer, int userTypePeer, + Uint8Buff *returnPk) +{ + uint32_t index; + void **ptr = NULL; + FOR_EACH_HC_VECTOR(g_protocolEntityVec, index, ptr) { + if (ptr != NULL && (*ptr) != NULL) { + DasProtocolEntity *temp = (DasProtocolEntity *)(*ptr); + if ((temp->tokenManagerInstance == NULL) || (temp->tokenManagerInstance->getPublicKey == NULL)) { + LOGD("Protocol type: %d, unsupported method!", temp->type); + continue; + } + return temp->tokenManagerInstance->getPublicKey(pkgName, serviceType, authIdPeer, userTypePeer, returnPk); + } + } + LOGE("Failed to find valid protocol!"); + return HC_ERR_NOT_SUPPORT; +} + static uint32_t GetPakeAlgInProtocol(int offset) { uint32_t algInProtocol = PSK_SPEKE; @@ -484,7 +503,7 @@ static uint32_t GetPakeAlgInProtocol(int offset) int32_t InitDasProtocolEntities(void) { - g_protocolEntityVec = CREATE_HC_VECTOR(DasProtocolEntityVec) + g_protocolEntityVec = CREATE_HC_VECTOR(DasProtocolEntityVec); DasProtocolEntity *protocol = NULL; if (IsIsoSupported()) { protocol = (DasProtocolEntity *)HcMalloc(sizeof(DasProtocolEntity), 0); @@ -538,5 +557,5 @@ void DestroyDasProtocolEntities(void) *ptr = NULL; } } - DESTROY_HC_VECTOR(DasProtocolEntityVec, &g_protocolEntityVec) + DESTROY_HC_VECTOR(DasProtocolEntityVec, &g_protocolEntityVec); } diff --git a/services/authenticators/src/account_unrelated/iso_task/lite_exchange_task/das_lite_token_manager.c b/services/authenticators/src/account_unrelated/iso_task/lite_exchange_task/das_lite_token_manager.c index adfe560..b5e1e5e 100644 --- a/services/authenticators/src/account_unrelated/iso_task/lite_exchange_task/das_lite_token_manager.c +++ b/services/authenticators/src/account_unrelated/iso_task/lite_exchange_task/das_lite_token_manager.c @@ -74,6 +74,7 @@ TokenManager g_symTokenManagerInstance = { .unregisterLocalIdentity = UnregisterLocalIdentity, .deletePeerAuthInfo = DeletePeerAuthInfo, .computeAndSavePsk = NULL, + .getPublicKey = NULL, }; const TokenManager *GetLiteTokenManagerInstance(void) diff --git a/services/authenticators/src/account_unrelated/pake_task/standard_exchange_task/das_standard_token_manager.c b/services/authenticators/src/account_unrelated/pake_task/standard_exchange_task/das_standard_token_manager.c index 1324166..21a6b28 100644 --- a/services/authenticators/src/account_unrelated/pake_task/standard_exchange_task/das_standard_token_manager.c +++ b/services/authenticators/src/account_unrelated/pake_task/standard_exchange_task/das_standard_token_manager.c @@ -166,11 +166,42 @@ static int32_t ComputeAndSavePsk(const PakeParams *params) return res; } +static int32_t GetPublicKey(const char *pkgName, const char *serviceType, Uint8Buff *authId, int userType, + Uint8Buff *returnPk) +{ + const AlgLoader *loader = GetLoaderInstance(); + Uint8Buff pkgNameBuff = { (uint8_t *)pkgName, strlen(pkgName) }; + Uint8Buff serviceTypeBuff = { (uint8_t *)serviceType, strlen(serviceType) }; + KeyAliasType keyType = userType; + uint8_t keyAliasVal[PAKE_KEY_ALIAS_LEN] = { 0 }; + Uint8Buff keyAliasBuff = { keyAliasVal, PAKE_KEY_ALIAS_LEN }; + int32_t res = GenerateKeyAlias(&pkgNameBuff, &serviceTypeBuff, keyType, authId, &keyAliasBuff); + if (res != HC_SUCCESS) { + LOGE("Failed to generate keyPair alias!"); + return res; + } + + res = loader->checkKeyExist(&keyAliasBuff); + if (res != HC_SUCCESS) { + LOGE("Key pair is not exist!"); + return res; + } + + res = loader->exportPublicKey(&keyAliasBuff, returnPk); + if (res != HC_SUCCESS) { + LOGE("Failed to export public key!"); + return res; + } + LOGI("Get public key successfully!"); + return HC_SUCCESS; +} + TokenManager g_asyTokenManagerInstance = { .registerLocalIdentity = RegisterLocalIdentity, .unregisterLocalIdentity = UnregisterLocalIdentity, .deletePeerAuthInfo = DeletePeerAuthInfo, .computeAndSavePsk = ComputeAndSavePsk, + .getPublicKey = GetPublicKey, }; const TokenManager *GetStandardTokenManagerInstance() diff --git a/services/data_manager/inc/data_manager.h b/services/data_manager/inc/data_manager.h new file mode 100644 index 0000000..5190007 --- /dev/null +++ b/services/data_manager/inc/data_manager.h @@ -0,0 +1,106 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef DATA_MANAGER_H +#define DATA_MANAGER_H + +#include +#include "hc_string.h" +#include "hc_string_vector.h" +#include "hc_tlv_parser.h" +#include "hc_vector.h" + +#define MAX_STRING_LEN 256 +#define MAX_EXPIRE_TIME 90 +#define HC_TRUST_DEV_ENTRY_MAX_NUM 101 +#define HC_TRUST_GROUP_ENTRY_MAX_NUM 100 + +typedef struct { + HcString name; /* group name */ + HcString id; /* group id */ + int32_t type; /* including identical account group(1), peer to peer group(256), across account group(1282) */ + int32_t visibility; /* visibility of the group */ + int32_t expireTime; /* the time of group expired, unit day, user config */ + HcString userIdHash; /* hash result of the user account id */ + StringVector sharedUserIdHashVec; /* vector of hash results for shared user account id */ + StringVector managers; /* group manager vector, group manager can add and delete members, index 0 is the owner */ + StringVector friends; /* group friend vector, group friend can query group information */ +} TrustedGroupEntry; +DECLARE_HC_VECTOR(GroupEntryVec, TrustedGroupEntry*) + +typedef struct { + TrustedGroupEntry *groupEntry; + HcString groupId; + HcString udid; /* unique device id */ + HcString authId; /* id by service defined for authentication */ + HcString serviceType; /* compatible with previous versions, the value is the same as groupId */ + HcParcel ext; /* for caching extern data, user data */ + uint8_t credential; /* 1 - asymmetrical, 2 - symmetrical */ + uint8_t devType; /* 0 - accessory, 1 - controller, 2 - proxy */ + HcString userIdHash; /* hash result of the user account id */ + uint64_t lastTm; /* accessed time of the device of the auth information, absolute time */ +} TrustedDeviceEntry; +DECLARE_HC_VECTOR(DeviceEntryVec, TrustedDeviceEntry*) + +typedef struct { + const char *groupId; + const char *groupName; + const char *ownerName; + int32_t groupType; + int32_t groupVisibility; +} QueryGroupParams; + +typedef struct { + const char *groupId; + const char *udid; + const char *authId; +} QueryDeviceParams; + +#ifdef __cplusplus +extern "C" { +#endif + +int32_t InitDatabase(void); +void DestroyDatabase(void); + +int32_t AddGroup(int32_t osAccountId, const TrustedGroupEntry *groupEntry); +int32_t DelGroup(int32_t osAccountId, const QueryGroupParams *params); +int32_t AddTrustedDevice(int32_t osAccountId, const TrustedDeviceEntry *deviceEntry); +int32_t DelTrustedDevice(int32_t osAccountId, const QueryDeviceParams *params); +int32_t QueryGroups(int32_t osAccountId, const QueryGroupParams *params, GroupEntryVec *vec); +int32_t QueryDevices(int32_t osAccountId, const QueryDeviceParams *params, DeviceEntryVec *vec); +int32_t SaveOsAccountDb(int32_t osAccountId); +bool GenerateGroupEntryFromEntry(const TrustedGroupEntry *entry, TrustedGroupEntry *returnEntry); +bool GenerateDeviceEntryFromEntry(const TrustedDeviceEntry *entry, TrustedDeviceEntry *returnEntry); + +TrustedGroupEntry *DeepCopyGroupEntry(const TrustedGroupEntry *entry); +TrustedDeviceEntry *DeepCopyDeviceEntry(const TrustedDeviceEntry *entry); + +QueryGroupParams InitQueryGroupParams(void); +QueryDeviceParams InitQueryDeviceParams(void); + +TrustedGroupEntry *CreateGroupEntry(void); +TrustedDeviceEntry *CreateDeviceEntry(void); +void DestroyGroupEntry(TrustedGroupEntry *groupEntry); +void DestroyDeviceEntry(TrustedDeviceEntry *groupEntry); +GroupEntryVec CreateGroupEntryVec(void); +DeviceEntryVec CreateDeviceEntryVec(void); +void ClearGroupEntryVec(GroupEntryVec *vec); +void ClearDeviceEntryVec(DeviceEntryVec *vec); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/services/data_manager/inc/database.h b/services/data_manager/inc/database.h deleted file mode 100644 index 763ac2c..0000000 --- a/services/data_manager/inc/database.h +++ /dev/null @@ -1,123 +0,0 @@ -/* - * Copyright (C) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef DATABASE_H -#define DATABASE_H - -#include "common_defs.h" -#include "hc_string.h" -#include "hc_tlv_parser.h" -#include "hc_vector.h" - -#define MAX_STRING_LEN 256 -#define MAX_EXPIRE_TIME 90 - -typedef int32_t (*GenGroupIdFunc)(const char *userIdHash, const char *sharedUserIdHash, char **returnGroupId); - -typedef struct { - HcString name; /* group name */ - HcString id; /* group id */ - int32_t type; /* including identical account group(1), peer to peer group(256), across account group(1282) */ - int32_t visibility; /* visibility of the group */ - int32_t expireTime; /* the time of group expired, unit day, user config */ - HcString userIdHash; /* hash result of the user account id */ - StringVector sharedUserIdHashVec; /* vector of hash results for shared user account id */ - StringVector managers; /* group manager vector, group manager can add and delete members, index 0 is the owner */ - StringVector friends; /* group friend vector, group friend can query group information */ -} TrustedGroupEntry; -DECLARE_HC_VECTOR(TrustedGroupTable, TrustedGroupEntry*) - -typedef struct { - TrustedGroupEntry *groupEntry; - HcString udid; /* unique device id */ - HcString authId; /* id by service defined for authentication */ - HcString serviceType; /* compatible with previous versions, the value is the same as groupId */ - HcParcel ext; /* for caching extern data, user data */ - uint8_t credential; /* 1 - asymmetrical, 2 - symmetrical */ - uint8_t devType; /* 0 - accessory, 1 - controller, 2 - proxy */ - HcString userIdHash; /* hash result of the user account id */ - uint64_t lastTm; /* accessed time of the device of the auth information, absolute time */ -} TrustedDeviceEntry; -DECLARE_HC_VECTOR(TrustedDeviceTable, TrustedDeviceEntry) - -typedef struct { - DECLARE_TLV_STRUCT(9) - TlvString name; - TlvString id; - TlvUint32 type; - TlvInt32 visibility; - TlvInt32 expireTime; - TlvString userIdHash; - TlvBuffer sharedUserIdHashVec; - TlvBuffer managers; - TlvBuffer friends; -} TlvGroupElement; -DECLEAR_INIT_FUNC(TlvGroupElement) -DECLARE_TLV_VECTOR(TlvGroupVec, TlvGroupElement) - -typedef struct { - uint8_t credential; - uint8_t devType; - int64_t userId; - uint64_t lastTm; -} DevAuthFixedLenInfo; -DECLARE_TLV_FIX_LENGTH_TYPE(TlvDevAuthFixedLenInfo, DevAuthFixedLenInfo) -DECLEAR_INIT_FUNC(TlvDevAuthFixedLenInfo) - -typedef struct { - DECLARE_TLV_STRUCT(7) - TlvString groupId; - TlvString udid; - TlvString authId; - TlvString serviceType; - TlvBuffer ext; - TlvDevAuthFixedLenInfo info; - TlvString userIdHash; -} TlvDevAuthElement; -DECLEAR_INIT_FUNC(TlvDevAuthElement) -DECLARE_TLV_VECTOR(TlvDevAuthVec, TlvDevAuthElement) - -typedef struct { - DECLARE_TLV_STRUCT(3) - TlvInt32 version; - TlvGroupVec groups; - TlvDevAuthVec devices; -} HCDataBaseV1; -DECLEAR_INIT_FUNC(HCDataBaseV1) - -typedef struct { - HcString name; /* group name */ - HcString id; /* group id */ - HcString ownerName; /* group owner name */ - int32_t type; /* group type, 0 - invalid, 1 - the same account, 2 - different account, 3 - none account(p2p) */ - int32_t visibility; /* visibility of the group */ - int32_t expireTime; /* the time of group expired, unit day, user config */ - HcString userIdHash; /* hash result of the user account id */ - HcString sharedUserIdHash; /* shared user account id */ -} GroupInfo; -DECLARE_HC_VECTOR(GroupInfoVec, void *) - -typedef struct { - HcString udid; /* unique device id */ - HcString authId; /* id by service defined for authentication */ - uint8_t credential; /* 1 - asymmetrical, 2 - symmetrical */ - uint8_t devType; /* 0 - accessory, 1 - controller, 2 - proxy */ - HcString userIdHash; /* hash result of the user account id */ - HcString groupId; /* map the device authentication data for group */ - HcString serviceType; /* compatible with previous versions, the value is the same as groupId */ -} DeviceInfo; -DECLARE_HC_VECTOR(DeviceInfoVec, void *) - -#endif diff --git a/services/data_manager/inc/database_manager.h b/services/data_manager/inc/database_manager.h deleted file mode 100644 index 7ba447f..0000000 --- a/services/data_manager/inc/database_manager.h +++ /dev/null @@ -1,101 +0,0 @@ -/* - * Copyright (C) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef DATABASE_MANAGER_H -#define DATABASE_MANAGER_H - -#include "common_defs.h" -#include "string_util.h" -#include "database.h" - -#define HC_TRUST_DEV_ENTRY_MAX_NUM 101 -#define HC_TRUST_GROUP_ENTRY_MAX_NUM 100 - -typedef struct { - int32_t type; /* group type */ - int32_t visibility; /* group visibility */ - char *udid; /* unique device id */ - char *authId; /* id by service defined for authentication */ -} GroupQueryParams; - -typedef enum { - GROUP_MANAGER = 1, - GROUP_FRIEND = 2 -} GroupRole; - -#ifdef __cplusplus -extern "C" { -#endif - -int32_t InitDatabase(void); -void DestroyDatabase(void); - -StringVector CreateStrVector(void); -void DestroyStrVector(StringVector *obj); - -int32_t AddGroup(const GroupInfo *addParams); -int32_t DelGroupByGroupId(const char *groupId); -int32_t AddTrustedDevice(const DeviceInfo *deviceInfo, const Uint8Buff *ext); -int32_t DelTrustedDevice(const char *deviceId, bool isUdid, const char *groupId); -int32_t DeleteUserIdExpiredGroups(const char *curUserIdHash); -int32_t DeleteAllAccountGroup(void); -int32_t OnlyAddSharedUserIdVec(const StringVector *sharedUserIdHashVec, CJson *groupIdList); -int32_t ChangeSharedUserIdVec(const StringVector *sharedUserIdHashVec); - -const char *GetLocalDevUdid(void); - -void RegGenerateGroupIdFunc(GenGroupIdFunc func); -void DeregGenerateGroupIdFunc(void); - -int32_t GetTrustedDevNumber(void); -int32_t GetGroupInfoById(const char *groupId, GroupInfo *returnGroupInfo); -int32_t GetGroupInfoIfDevExist(const char *groupId, const char *udid, GroupInfo *returnGroupInfo); -int32_t GetTrustedDevInfoById(const char *deviceId, bool isUdid, const char *groupId, DeviceInfo *deviceInfo); -int32_t GetJoinedGroupInfoVecByDevId(const GroupQueryParams *params, GroupInfoVec *vec); -int32_t GetGroupNumByOwner(const char *ownerName); -int32_t GetCurDeviceNumByGroupId(const char *groupId); -int32_t CompareVisibility(const char *groupId, int groupVisibility); -bool IsGroupOwner(const char *groupId, const char *appId); -bool IsGroupAccessible(const char *groupId, const char *appId); -bool IsGroupEditAllowed(const char *groupId, const char *appId); -bool IsSameNameGroupExist(const char *ownerName, const char *groupName); -bool IsIdenticalGroupExist(void); -bool IsAcrossAccountGroupExist(void); -bool IsGroupExistByGroupId(const char *groupId); -bool IsTrustedDeviceExist(const char *udid); -bool IsTrustedDeviceInGroup(const char *groupId, const char *deviceId, bool isUdid); -int32_t GetJoinedGroups(int groupType, GroupInfoVec *groupInfoVec); -int32_t GetGroupInfo(int groupType, const char *groupId, const char *groupName, const char *groupOwner, - GroupInfoVec *groupInfoVec); -int32_t GetRelatedGroups(const char *peerDeviceId, bool isUdid, GroupInfoVec *groupInfoVec); -int32_t GetTrustedDevices(const char *groupId, DeviceInfoVec *deviceInfoVec); - -int32_t AddGroupRole(const char *groupId, GroupRole roleType, const char *appId); -int32_t RemoveGroupRole(const char *groupId, GroupRole roleType, const char *appId); -int32_t GetGroupRoles(const char *groupId, GroupRole roleType, CJson *returnRoles); - -GroupInfo *CreateGroupInfoStruct(void); -DeviceInfo *CreateDeviceInfoStruct(void); -void DestroyGroupInfoStruct(GroupInfo *groupInfo); -void DestroyDeviceInfoStruct(DeviceInfo *deviceInfo); -void CreateGroupInfoVecStruct(GroupInfoVec *vec); -void DestroyGroupInfoVecStruct(GroupInfoVec *vec); -void CreateDeviceInfoVecStruct(DeviceInfoVec *vec); -void DestroyDeviceInfoVecStruct(DeviceInfoVec *vec); - -#ifdef __cplusplus -} -#endif -#endif \ No newline at end of file diff --git a/services/data_manager/inc/database_util.h b/services/data_manager/inc/database_util.h deleted file mode 100644 index 186a669..0000000 --- a/services/data_manager/inc/database_util.h +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Copyright (C) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef DATABASE_UTIL_H -#define DATABASE_UTIL_H - -#include "database.h" - -#ifdef __cplusplus -extern "C" { -#endif - -bool SetGroupElement(TlvGroupElement *element, TrustedGroupEntry **entry); -bool SetDeviceElement(TlvDevAuthElement *element, TrustedDeviceEntry *entry); - -void RegGenerateGroupIdFunc(GenGroupIdFunc func); -void DeregGenerateGroupIdFunc(void); - -bool LoadStringVectorFromParcel(StringVector *vec, HcParcel *parcel); -bool SaveStringVectorToParcel(const StringVector *vec, HcParcel *parcel); - -StringVector CreateStrVector(void); -void DestroyStrVector(StringVector *vec); -GroupInfo *CreateGroupInfoStruct(void); -void DestroyGroupInfoStruct(GroupInfo *groupInfo); -DeviceInfo *CreateDeviceInfoStruct(void); -void DestroyDeviceInfoStruct(DeviceInfo *deviceInfo); -TrustedGroupEntry *CreateGroupEntryStruct(void); -void DestroyGroupEntryStruct(TrustedGroupEntry *groupEntry); -void DestroyDeviceEntryStruct(TrustedDeviceEntry *deviceEntry); - -int32_t GenerateGroupInfoByEntry(const TrustedGroupEntry *groupEntry, const char *groupId, - const char *sharedUserIdHash, GroupInfo *returnGroupInfo); -int32_t GenerateDeviceInfoByEntry(const TrustedDeviceEntry *deviceEntry, const char *groupId, - DeviceInfo *returnDeviceInfo); - -int32_t GetSharedUserIdFromVecByGroupId(const TrustedGroupEntry *groupEntry, const char *groupId, - const char **returnUserIdHash); -void AddNewSharedUserId(const StringVector *sharedUserIdHashList, TrustedGroupEntry *entry, CJson *groupIdList); -void DeleteExpiredSharedUserId(const StringVector *sharedUserIdHashList, TrustedGroupEntry *entry); - -bool CompareGroupTypeInGroupEntryOrAll(const TrustedGroupEntry *groupEntry, int32_t groupType); -bool CompareDevIdInDeviceEntryOrNull(const TrustedDeviceEntry *deviceEntry, const char *devId, bool isUdid); -bool CompareGroupIdInDeviceEntryOrNull(const TrustedDeviceEntry *deviceEntry, const char *groupId); -bool CompareSearchParams(int32_t groupType, const char *groupId, const char *groupName, const char *groupOwner, - const TrustedGroupEntry *entry); -bool IsGroupIdEquals(const TrustedGroupEntry *groupEntry, const char *groupId); -bool IsGroupNameEquals(const TrustedGroupEntry *groupEntry, const char *groupName); -bool IsGroupManager(const char *appId, const TrustedGroupEntry *entry); -bool IsGroupFriend(const char *appId, const TrustedGroupEntry *entry); -bool SatisfyType(int32_t type, int32_t standardType); -bool SatisfyVisibility(int32_t visibility, int32_t standardVisibility); - -void NotifyGroupCreated(const TrustedGroupEntry *groupEntry, const char *sharedUserIdHash); -void NotifyGroupDeleted(const TrustedGroupEntry *groupEntry, const char *sharedUserIdHash); -void NotifyDeviceBound(const TrustedDeviceEntry *deviceEntry); -void NotifyDeviceUnBound(const TrustedDeviceEntry *deviceEntry); -void NotifyDeviceNotTrusted(const char *peerUdid); -void NotifyLastGroupDeleted(const char *peerUdid, int groupType); -void NotifyTrustedDeviceNumChanged(int trustedDeviceNum); - -#ifdef __cplusplus -} -#endif -#endif \ No newline at end of file diff --git a/services/data_manager/src/data_manager.c b/services/data_manager/src/data_manager.c new file mode 100644 index 0000000..186ba74 --- /dev/null +++ b/services/data_manager/src/data_manager.c @@ -0,0 +1,1126 @@ +/* + * Copyright (C) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "data_manager.h" + +#include "broadcast_manager.h" +#include "common_defs.h" +#include "device_auth.h" +#include "device_auth_defines.h" +#include "hc_dev_info.h" +#include "hc_file.h" +#include "hc_log.h" +#include "hc_mutex.h" +#include "hc_string_vector.h" +#include "hc_types.h" +#include "securec.h" + +typedef struct { + DECLARE_TLV_STRUCT(9) + TlvString name; + TlvString id; + TlvUint32 type; + TlvInt32 visibility; + TlvInt32 expireTime; + TlvString userIdHash; + TlvBuffer sharedUserIdHashVec; + TlvBuffer managers; + TlvBuffer friends; +} TlvGroupElement; +DECLEAR_INIT_FUNC(TlvGroupElement) +DECLARE_TLV_VECTOR(TlvGroupVec, TlvGroupElement) + +typedef struct { + uint8_t credential; + uint8_t devType; + int64_t userId; + uint64_t lastTm; +} DevAuthFixedLenInfo; +DECLARE_TLV_FIX_LENGTH_TYPE(TlvDevAuthFixedLenInfo, DevAuthFixedLenInfo) +DECLEAR_INIT_FUNC(TlvDevAuthFixedLenInfo) + +typedef struct { + DECLARE_TLV_STRUCT(7) + TlvString groupId; + TlvString udid; + TlvString authId; + TlvString serviceType; + TlvBuffer ext; + TlvDevAuthFixedLenInfo info; + TlvString userIdHash; +} TlvDeviceElement; +DECLEAR_INIT_FUNC(TlvDeviceElement) +DECLARE_TLV_VECTOR(TlvDeviceVec, TlvDeviceElement) + +typedef struct { + DECLARE_TLV_STRUCT(3) + TlvInt32 version; + TlvGroupVec groups; + TlvDeviceVec devices; +} HCDataBaseV1; +DECLEAR_INIT_FUNC(HCDataBaseV1) + +DEFINE_TLV_FIX_LENGTH_TYPE(TlvDevAuthFixedLenInfo, NO_REVERT) + +BEGIN_TLV_STRUCT_DEFINE(TlvGroupElement, 0x0001) + TLV_MEMBER(TlvString, name, 0x4001) + TLV_MEMBER(TlvString, id, 0x4002) + TLV_MEMBER(TlvUint32, type, 0x4003) + TLV_MEMBER(TlvInt32, visibility, 0x4004) + TLV_MEMBER(TlvInt32, expireTime, 0x4005) + TLV_MEMBER(TlvString, userIdHash, 0x4006) + TLV_MEMBER(TlvBuffer, sharedUserIdHashVec, 0x4007) + TLV_MEMBER(TlvBuffer, managers, 0x4008) + TLV_MEMBER(TlvBuffer, friends, 0x4009) +END_TLV_STRUCT_DEFINE() +IMPLEMENT_TLV_VECTOR(TlvGroupVec, TlvGroupElement, 1) + +BEGIN_TLV_STRUCT_DEFINE(TlvDeviceElement, 0x0002) + TLV_MEMBER(TlvString, groupId, 0x4101) + TLV_MEMBER(TlvString, udid, 0x4102) + TLV_MEMBER(TlvString, authId, 0x4103) + TLV_MEMBER(TlvString, userIdHash, 0x4107) + TLV_MEMBER(TlvString, serviceType, 0x4104) + TLV_MEMBER(TlvBuffer, ext, 0x4105) + TLV_MEMBER(TlvDevAuthFixedLenInfo, info, 0x4106) +END_TLV_STRUCT_DEFINE() +IMPLEMENT_TLV_VECTOR(TlvDeviceVec, TlvDeviceElement, 1) + +BEGIN_TLV_STRUCT_DEFINE(HCDataBaseV1, 0x0001) + TLV_MEMBER(TlvInt32, version, 0x6001) + TLV_MEMBER(TlvGroupVec, groups, 0x6002) + TLV_MEMBER(TlvDeviceVec, devices, 0x6003) +END_TLV_STRUCT_DEFINE() + +IMPLEMENT_HC_VECTOR(GroupEntryVec, TrustedGroupEntry*, 1) +IMPLEMENT_HC_VECTOR(DeviceEntryVec, TrustedDeviceEntry*, 1) + +typedef struct { + int32_t osAccountId; + GroupEntryVec groups; + DeviceEntryVec devices; +} OsAccountTrustedInfo; + +DECLARE_HC_VECTOR(DeviceAuthDb, OsAccountTrustedInfo) +IMPLEMENT_HC_VECTOR(DeviceAuthDb, OsAccountTrustedInfo, 1) + +#define MAX_DB_PATH_LEN 256 + +static HcMutex *g_databaseMutex = NULL; +static DeviceAuthDb g_deviceauthDb; + +static bool EndWithZero(HcParcel *parcel) +{ + const char *p = GetParcelLastChar(parcel); + if (p == NULL) { + return false; + } + if (*p == '\0') { + return true; + } + return false; +} + +static bool LoadStringVectorFromParcel(StringVector *vec, HcParcel *parcel) +{ + uint32_t strLen = 0; + do { + if (!ParcelReadUint32(parcel, &strLen)) { + return true; + } + if ((strLen == 0) || (strLen > MAX_STRING_LEN)) { + return false; + } + HcString str = CreateString(); + ClearParcel(&str.parcel); + if (!ParcelReadParcel(parcel, &str.parcel, strLen, false) || + !EndWithZero(&str.parcel)) { + DeleteString(&str); + return false; + } else { + if (vec->pushBack(vec, &str) == NULL) { + DeleteString(&str); + return false; + } + } + } while (1); +} + +static bool SaveStringVectorToParcel(const StringVector *vec, HcParcel *parcel) +{ + uint32_t index; + HcString *str = NULL; + FOR_EACH_HC_VECTOR(*vec, index, str) { + uint32_t len = StringLength(str) + sizeof(char); + if (!ParcelWriteUint32(parcel, len)) { + return false; + } + if (!ParcelWrite(parcel, GetParcelData(&str->parcel), GetParcelDataSize(&str->parcel))) { + return false; + } + } + return true; +} + +static OsAccountTrustedInfo *GetTrustedInfoByOsAccountId(int32_t osAccountId) +{ + uint32_t index = 0; + OsAccountTrustedInfo *info = NULL; + FOR_EACH_HC_VECTOR(g_deviceauthDb, index, info) { + if ((info != NULL) && (info->osAccountId == osAccountId)) { + return info; + } + } + LOGI("[DB]: Create a new os account database cache! [Id]: %d", osAccountId); + OsAccountTrustedInfo newInfo; + newInfo.osAccountId = osAccountId; + newInfo.groups = CreateGroupEntryVec(); + newInfo.devices = CreateDeviceEntryVec(); + OsAccountTrustedInfo *returnInfo = g_deviceauthDb.pushBackT(&g_deviceauthDb, newInfo); + if (returnInfo == NULL) { + LOGE("[DB]: Failed to push osAccountInfo to database!"); + DestroyGroupEntryVec(&newInfo.groups); + DestroyDeviceEntryVec(&newInfo.devices); + } + return returnInfo; +} + +static bool GetOsAccountInfoPath(int32_t osAccountId, char *infoPath, uint32_t pathBufferLen) +{ + const char *beginPath = GetStorageDirPath(); + if (beginPath == NULL) { + LOGE("[DB]: Failed to get the stroage path dir!"); + return false; + } + int32_t ret; + if (osAccountId == DEFAULT_OS_ACCOUNT) { + ret = sprintf_s(infoPath, pathBufferLen, "%s/hcgroup.dat", beginPath); + } else { + ret = sprintf_s(infoPath, pathBufferLen, "%s/hcgroup%d.dat", beginPath, osAccountId); + } + if (ret <= 0) { + LOGE("[DB]: sprintf_s fail!"); + return false; + } + return true; +} + +bool GenerateGroupEntryFromEntry(const TrustedGroupEntry *entry, TrustedGroupEntry *returnEntry) +{ + if (HC_VECTOR_SIZE(&entry->managers) <= 0) { + LOGE("[DB]: The group owner is lost!"); + return false; + } + HcString entryOwner = HC_VECTOR_GET(&entry->managers, 0); + if (!StringSet(&returnEntry->name, entry->name)) { + LOGE("[DB]: Failed to copy groupName!"); + return false; + } + if (!StringSet(&returnEntry->id, entry->id)) { + LOGE("[DB]: Failed to copy groupId!"); + return false; + } + if (!StringSet(&returnEntry->userIdHash, entry->userIdHash)) { + LOGE("[DB]: Failed to copy userIdHash!"); + return false; + } + returnEntry->type = entry->type; + returnEntry->visibility = entry->visibility; + returnEntry->expireTime = entry->expireTime; + HcString ownerName = CreateString(); + if (!StringSet(&ownerName, entryOwner)) { + LOGE("[DB]: Failed to copy groupOwner!"); + DeleteString(&ownerName); + return false; + } + if (returnEntry->managers.pushBack(&returnEntry->managers, &ownerName) == NULL) { + LOGE("[DB]: Failed to push groupOwner to managers!"); + DeleteString(&ownerName); + return false; + } + return true; +} + +bool GenerateDeviceEntryFromEntry(const TrustedDeviceEntry *entry, TrustedDeviceEntry *returnEntry) +{ + returnEntry->groupEntry = NULL; + if (!StringSet(&returnEntry->groupId, entry->groupId)) { + LOGE("[DB]: Failed to copy udid!"); + return false; + } + if (!StringSet(&returnEntry->udid, entry->udid)) { + LOGE("[DB]: Failed to copy udid!"); + return false; + } + if (!StringSet(&returnEntry->authId, entry->authId)) { + LOGE("[DB]: Failed to copy authId!"); + return false; + } + if (!StringSet(&returnEntry->serviceType, entry->serviceType)) { + LOGE("[DB]: Failed to copy serviceType!"); + return false; + } + if (!StringSet(&returnEntry->userIdHash, entry->userIdHash)) { + LOGE("[DB]: Failed to copy userIdHash!"); + return false; + } + returnEntry->credential = entry->credential; + returnEntry->devType = entry->devType; + returnEntry->lastTm = entry->lastTm; + return true; +} + +static bool GenerateGroupEntryFromTlv(TlvGroupElement *group, TrustedGroupEntry *entry) +{ + if (!LoadStringVectorFromParcel(&entry->managers, &group->managers.data)) { + return false; + } + if (!LoadStringVectorFromParcel(&entry->friends, &group->friends.data)) { + return false; + } + if (!LoadStringVectorFromParcel(&entry->sharedUserIdHashVec, &group->sharedUserIdHashVec.data)) { + return false; + } + if (!StringSet(&entry->name, group->name.data)) { + return false; + } + if (!StringSet(&entry->id, group->id.data)) { + return false; + } + if (!StringSet(&entry->userIdHash, group->userIdHash.data)) { + return false; + } + entry->type = group->type.data; + entry->visibility = group->visibility.data; + entry->expireTime = group->expireTime.data; + return true; +} + +static bool GenerateDeviceEntryFromTlv(TlvDeviceElement *device, TrustedDeviceEntry *deviceEntry) +{ + deviceEntry->groupEntry = NULL; + if (!StringSet(&deviceEntry->groupId, device->groupId.data)) { + return false; + } + if (!StringSet(&deviceEntry->udid, device->udid.data)) { + return false; + } + if (!StringSet(&deviceEntry->authId, device->authId.data)) { + return false; + } + if (!StringSet(&deviceEntry->serviceType, device->serviceType.data)) { + return false; + } + if (!StringSet(&deviceEntry->userIdHash, device->userIdHash.data)) { + return false; + } + if (!ParcelCopy(&device->ext.data, &deviceEntry->ext)) { + return false; + } + deviceEntry->credential = device->info.data.credential; + deviceEntry->devType = device->info.data.devType; + deviceEntry->lastTm = device->info.data.lastTm; + return true; +} + +static bool LoadGroups(HCDataBaseV1 *db, GroupEntryVec *vec) +{ + uint32_t index; + TlvGroupElement *group = NULL; + FOR_EACH_HC_VECTOR(db->groups.data, index, group) { + TrustedGroupEntry *entry = CreateGroupEntry(); + if (entry == NULL) { + LOGE("[DB]: Failed to allocate entry memory!"); + ClearGroupEntryVec(vec); + return false; + } + if (!GenerateGroupEntryFromTlv(group, entry)) { + DestroyGroupEntry(entry); + ClearGroupEntryVec(vec); + return false; + } + if (vec->pushBackT(vec, entry) == NULL) { + LOGE("[DB]: Failed to push entry to vec!"); + DestroyGroupEntry(entry); + ClearGroupEntryVec(vec); + return false; + } + } + return true; +} + +static bool LoadDevices(HCDataBaseV1 *db, DeviceEntryVec *vec) +{ + uint32_t index; + TlvDeviceElement *device = NULL; + FOR_EACH_HC_VECTOR(db->devices.data, index, device) { + TrustedDeviceEntry *entry = CreateDeviceEntry(); + if (entry == NULL) { + LOGE("[DB]: Failed to allocate entry memory!"); + ClearDeviceEntryVec(vec); + return false; + } + if (!GenerateDeviceEntryFromTlv(device, entry)) { + DestroyDeviceEntry(entry); + ClearDeviceEntryVec(vec); + return false; + } + if (vec->pushBackT(vec, entry) == NULL) { + LOGE("[DB]: Failed to push entry to vec!"); + DestroyDeviceEntry(entry); + ClearDeviceEntryVec(vec); + return false; + } + } + return true; +} + +static bool ReadInfoFromParcel(HcParcel *parcel, OsAccountTrustedInfo *info) +{ + bool ret = false; + HCDataBaseV1 dbv1; + TLV_INIT(HCDataBaseV1, &dbv1) + if (DecodeTlvMessage((TlvBase *)&dbv1, parcel, false)) { + if (!LoadGroups(&dbv1, &info->groups)) { + TLV_DEINIT(dbv1) + return false; + } + if (!LoadDevices(&dbv1, &info->devices)) { + ClearGroupEntryVec(&info->groups); + TLV_DEINIT(dbv1) + return false; + } + ret = true; + } else { + LOGE("[DB]: Decode Tlv Message Failed!"); + } + TLV_DEINIT(dbv1) + return ret; +} + +static bool ReadParcelFromFile(int32_t osAccountId, HcParcel *parcel) +{ + char infoPath[MAX_DB_PATH_LEN] = { 0 }; + if (!GetOsAccountInfoPath(osAccountId, infoPath, MAX_DB_PATH_LEN)) { + return false; + } + FileHandle file; + int ret = HcFileOpen(infoPath, MODE_FILE_READ, &file); + if (ret != 0) { + LOGE("[DB]: Failed to open database file!"); + return false; + } + int fileSize = HcFileSize(file); + if (fileSize <= 0) { + LOGE("[DB]: The databse file size is invalid!"); + HcFileClose(file); + return false; + } + char *fileData = (char *)HcMalloc(fileSize, 0); + if (fileData == NULL) { + LOGE("[DB]: Failed to allocate fileData memroy!"); + HcFileClose(file); + return false; + } + if (HcFileRead(file, fileData, fileSize) != fileSize) { + LOGE("[DB]: Read file error!"); + HcFileClose(file); + HcFree(fileData); + return false; + } + HcFileClose(file); + if (!ParcelWrite(parcel, fileData, fileSize)) { + LOGE("[DB]: parcel write error!"); + HcFree(fileData); + return false; + } + HcFree(fileData); + return true; +} + +static void LoadOsAccountDb(int32_t osAccountId) +{ + HcParcel parcel = CreateParcel(0, 0); + if (!ReadParcelFromFile(osAccountId, &parcel)) { + DeleteParcel(&parcel); + return; + } + OsAccountTrustedInfo info; + info.osAccountId = osAccountId; + info.groups = CreateGroupEntryVec(); + info.devices = CreateDeviceEntryVec(); + if (!ReadInfoFromParcel(&parcel, &info)) { + DestroyGroupEntryVec(&info.groups); + DestroyDeviceEntryVec(&info.devices); + DeleteParcel(&parcel); + return; + } + DeleteParcel(&parcel); + if (g_deviceauthDb.pushBackT(&g_deviceauthDb, info) == NULL) { + LOGE("[DB]: Failed to push osAccountInfo to database!"); + ClearGroupEntryVec(&info.groups); + ClearDeviceEntryVec(&info.devices); + } + LOGI("[DB]: Load os account db successfully! [Id]: %d", osAccountId); +} + +static void LoadDeviceAuthDb(void) +{ + StringVector osAccountDbNameVec = CreateStrVector(); + HcFileGetSubFileName(GetStorageDirPath(), &osAccountDbNameVec); + uint32_t index; + HcString *dbName; + FOR_EACH_HC_VECTOR(osAccountDbNameVec, index, dbName) { + int32_t osAccountId; + const char *osAccountIdStr = StringGet(dbName); + if (osAccountIdStr == NULL) { + continue; + } + if (strcmp(osAccountIdStr, "hcgroup.dat") == 0) { + LoadOsAccountDb(DEFAULT_OS_ACCOUNT); + } else if (sscanf_s(osAccountIdStr, "hcgroup%d.dat", &osAccountId) == 1) { + LoadOsAccountDb(osAccountId); + } + } + DestroyStrVector(&osAccountDbNameVec); +} + +static bool SetGroupElement(TlvGroupElement *element, TrustedGroupEntry *entry) +{ + if (!StringSet(&element->name.data, entry->name)) { + return false; + } + if (!StringSet(&element->id.data, entry->id)) { + return false; + } + if (!StringSet(&element->userIdHash.data, entry->userIdHash)) { + return false; + } + element->type.data = entry->type; + element->visibility.data = entry->visibility; + element->expireTime.data = entry->expireTime; + if (!SaveStringVectorToParcel(&entry->managers, &element->managers.data)) { + return false; + } + if (!SaveStringVectorToParcel(&entry->friends, &element->friends.data)) { + return false; + } + if (!SaveStringVectorToParcel(&entry->sharedUserIdHashVec, &element->sharedUserIdHashVec.data)) { + return false; + } + return true; +} + +static bool SetDeviceElement(TlvDeviceElement *element, TrustedDeviceEntry *entry) +{ + if (!StringSet(&element->groupId.data, entry->groupId)) { + return false; + } + if (!StringSet(&element->udid.data, entry->udid)) { + return false; + } + if (!StringSet(&element->authId.data, entry->authId)) { + return false; + } + if (!StringSet(&element->serviceType.data, entry->serviceType)) { + return false; + } + if (!StringSet(&element->userIdHash.data, entry->userIdHash)) { + return false; + } + if (!ParcelCopy(&element->ext.data, &entry->ext)) { + return false; + } + element->info.data.credential = entry->credential; + element->info.data.devType = entry->devType; + element->info.data.lastTm = entry->lastTm; + return true; +} + +static bool SaveGroups(const GroupEntryVec *vec, HCDataBaseV1 *db) +{ + uint32_t index; + TrustedGroupEntry **entry; + FOR_EACH_HC_VECTOR(*vec, index, entry) { + TlvGroupElement tmp; + TlvGroupElement *element = db->groups.data.pushBack(&db->groups.data, &tmp); + if (element == NULL) { + return false; + } + TLV_INIT(TlvGroupElement, element); + if (!SetGroupElement(element, *entry)) { + TLV_DEINIT((*element)); + return false; + } + } + return true; +} + +static bool SaveDevices(const DeviceEntryVec *vec, HCDataBaseV1 *db) +{ + uint32_t index; + TrustedDeviceEntry **entry; + FOR_EACH_HC_VECTOR(*vec, index, entry) { + TlvDeviceElement tmp; + TlvDeviceElement *element = db->devices.data.pushBack(&db->devices.data, &tmp); + if (element == NULL) { + return false; + } + TLV_INIT(TlvDeviceElement, element); + if (!SetDeviceElement(element, *entry)) { + TLV_DEINIT((*element)); + return false; + } + } + return true; +} + +static bool SaveInfoToParcel(const OsAccountTrustedInfo *info, HcParcel *parcel) +{ + int32_t ret = false; + HCDataBaseV1 dbv1; + TLV_INIT(HCDataBaseV1, &dbv1) + dbv1.version.data = 1; + do { + if (!SaveGroups(&info->groups, &dbv1)) { + break; + } + if (!SaveDevices(&info->devices, &dbv1)) { + break; + } + if (!EncodeTlvMessage((TlvBase *)&dbv1, parcel)) { + LOGE("[DB]: Encode Tlv Message failed!"); + break; + } + ret = true; + } while (0); + TLV_DEINIT(dbv1) + return ret; +} + +static bool SaveParcelToFile(const OsAccountTrustedInfo *info, HcParcel *parcel) +{ + char infoPath[MAX_DB_PATH_LEN] = { 0 }; + if (!GetOsAccountInfoPath(info->osAccountId, infoPath, MAX_DB_PATH_LEN)) { + return false; + } + FileHandle file; + int ret = HcFileOpen(infoPath, MODE_FILE_WRITE, &file); + if (ret != HC_SUCCESS) { + LOGE("[DB]: Failed to open database file!"); + return false; + } + int fileSize = (int)GetParcelDataSize(parcel); + const char *fileData = GetParcelData(parcel); + if (HcFileWrite(file, fileData, fileSize) == fileSize) { + ret = true; + } else { + LOGE("[DB]: write file error!"); + ret = false; + } + HcFileClose(file); + return ret; +} + +static bool CompareQueryGroupParams(const QueryGroupParams *params, const TrustedGroupEntry *entry) +{ + if ((params->groupId != NULL) && (strcmp(params->groupId, StringGet(&entry->id)) != 0)) { + return false; + } + if ((params->groupName != NULL) && (strcmp(params->groupName, StringGet(&entry->name)) != 0)) { + return false; + } + if ((params->groupType != ALL_GROUP) && (params->groupType != entry->type)) { + return false; + } + if ((params->groupVisibility != ALL_GROUP_VISIBILITY) && (params->groupVisibility != entry->visibility)) { + return false; + } + if (params->ownerName != NULL) { + HcString entryOwner = HC_VECTOR_GET(&entry->managers, 0); + if (strcmp(params->ownerName, StringGet(&entryOwner)) != 0) { + return false; + } + } + return true; +} + +static bool CompareQueryDeviceParams(const QueryDeviceParams *params, const TrustedDeviceEntry *entry) +{ + if ((params->groupId != NULL) && (strcmp(params->groupId, StringGet(&entry->groupId)) != 0)) { + return false; + } + if ((params->udid != NULL) && (strcmp(params->udid, StringGet(&entry->udid)) != 0)) { + return false; + } + if ((params->authId != NULL) && (strcmp(params->authId, StringGet(&entry->authId)) != 0)) { + return false; + } + return true; +} + +static TrustedGroupEntry **QueryGroupEntryPtrIfMatch(const GroupEntryVec *vec, const QueryGroupParams *params) +{ + uint32_t index; + TrustedGroupEntry **entry; + FOR_EACH_HC_VECTOR(*vec, index, entry) { + if ((entry != NULL) && (*entry != NULL) && (CompareQueryGroupParams(params, *entry))) { + return entry; + } + } + return NULL; +} + +static TrustedDeviceEntry **QueryDeviceEntryPtrIfMatch(const DeviceEntryVec *vec, const QueryDeviceParams *params) +{ + uint32_t index; + TrustedDeviceEntry **entry; + FOR_EACH_HC_VECTOR(*vec, index, entry) { + if ((entry != NULL) && (*entry != NULL) && (CompareQueryDeviceParams(params, *entry))) { + return entry; + } + } + return NULL; +} + +static void PostGroupCreatedMsg(const TrustedGroupEntry *groupEntry) +{ + GetBroadcaster()->postOnGroupCreated(groupEntry); +} + +static void PostGroupDeletedMsg(const TrustedGroupEntry *groupEntry) +{ + GetBroadcaster()->postOnGroupDeleted(groupEntry); +} + +static void PostDeviceBoundMsg(OsAccountTrustedInfo *info, const TrustedDeviceEntry *deviceEntry) +{ + QueryGroupParams groupParams = InitQueryGroupParams(); + groupParams.groupId = StringGet(&deviceEntry->groupId); + TrustedGroupEntry **groupEntryPtr = QueryGroupEntryPtrIfMatch(&info->groups, &groupParams); + if (groupEntryPtr != NULL) { + GetBroadcaster()->postOnDeviceBound(StringGet(&deviceEntry->udid), *groupEntryPtr); + } +} + +static void PostDeviceUnBoundMsg(OsAccountTrustedInfo *info, const TrustedDeviceEntry *deviceEntry) +{ + QueryGroupParams groupParams = InitQueryGroupParams(); + groupParams.groupId = StringGet(&deviceEntry->groupId); + TrustedGroupEntry **groupEntryPtr = QueryGroupEntryPtrIfMatch(&info->groups, &groupParams); + if (groupEntryPtr != NULL) { + GetBroadcaster()->postOnDeviceUnBound(StringGet(&deviceEntry->udid), *groupEntryPtr); + } +} + +QueryGroupParams InitQueryGroupParams(void) +{ + QueryGroupParams params = { + .groupId = NULL, + .groupName = NULL, + .ownerName = NULL, + .groupType = ALL_GROUP, + .groupVisibility = ALL_GROUP_VISIBILITY + }; + return params; +} + +QueryDeviceParams InitQueryDeviceParams(void) +{ + QueryDeviceParams params = { + .groupId = NULL, + .udid = NULL, + .authId = NULL + }; + return params; +} + +TrustedGroupEntry *CreateGroupEntry(void) +{ + TrustedGroupEntry *ptr = (TrustedGroupEntry *)HcMalloc(sizeof(TrustedGroupEntry), 0); + if (ptr == NULL) { + LOGE("[DB]: Failed to allocate groupEntry memory!"); + return NULL; + } + ptr->name = CreateString(); + ptr->id = CreateString(); + ptr->userIdHash = CreateString(); + ptr->sharedUserIdHashVec = CreateStrVector(); + ptr->managers = CreateStrVector(); + ptr->friends = CreateStrVector(); + return ptr; +} + +void DestroyGroupEntry(TrustedGroupEntry *groupEntry) +{ + DeleteString(&groupEntry->name); + DeleteString(&groupEntry->id); + DeleteString(&groupEntry->userIdHash); + DestroyStrVector(&groupEntry->managers); + DestroyStrVector(&groupEntry->friends); + DestroyStrVector(&groupEntry->sharedUserIdHashVec); + HcFree(groupEntry); +} + +TrustedGroupEntry *DeepCopyGroupEntry(const TrustedGroupEntry *entry) +{ + TrustedGroupEntry *returnEntry = CreateGroupEntry(); + if (returnEntry == NULL) { + return NULL; + } + if (!GenerateGroupEntryFromEntry(entry, returnEntry)) { + DestroyGroupEntry(returnEntry); + return NULL; + } + return returnEntry; +} + +TrustedDeviceEntry *CreateDeviceEntry(void) +{ + TrustedDeviceEntry *ptr = (TrustedDeviceEntry *)HcMalloc(sizeof(TrustedDeviceEntry), 0); + if (ptr == NULL) { + LOGE("[DB]: Failed to allocate deviceEntry memory!"); + return NULL; + } + ptr->groupId = CreateString(); + ptr->udid = CreateString(); + ptr->authId = CreateString(); + ptr->serviceType = CreateString(); + ptr->userIdHash = CreateString(); + ptr->ext = CreateParcel(0, 0); + return ptr; +} + +void DestroyDeviceEntry(TrustedDeviceEntry *deviceEntry) +{ + DeleteString(&deviceEntry->groupId); + DeleteString(&deviceEntry->udid); + DeleteString(&deviceEntry->authId); + DeleteString(&deviceEntry->serviceType); + DeleteString(&deviceEntry->userIdHash); + DeleteParcel(&deviceEntry->ext); + HcFree(deviceEntry); +} + +TrustedDeviceEntry *DeepCopyDeviceEntry(const TrustedDeviceEntry *entry) +{ + TrustedDeviceEntry *returnEntry = CreateDeviceEntry(); + if (returnEntry == NULL) { + return NULL; + } + if (!GenerateDeviceEntryFromEntry(entry, returnEntry)) { + DestroyDeviceEntry(returnEntry); + return NULL; + } + return returnEntry; +} + +void ClearGroupEntryVec(GroupEntryVec *vec) +{ + uint32_t index; + TrustedGroupEntry **entry; + FOR_EACH_HC_VECTOR(*vec, index, entry) { + DestroyGroupEntry(*entry); + } + DESTROY_HC_VECTOR(GroupEntryVec, vec); +} + +void ClearDeviceEntryVec(DeviceEntryVec *vec) +{ + uint32_t index; + TrustedDeviceEntry **entry; + FOR_EACH_HC_VECTOR(*vec, index, entry) { + DestroyDeviceEntry(*entry); + } + DESTROY_HC_VECTOR(DeviceEntryVec, vec); +} + +int32_t AddGroup(int32_t osAccountId, const TrustedGroupEntry *groupEntry) +{ + LOGI("[DB]: Start to add a group to database!"); + if (groupEntry == NULL) { + LOGE("[DB]: The input groupEntry is NULL!"); + return HC_ERR_NULL_PTR; + } + g_databaseMutex->lock(g_databaseMutex); + OsAccountTrustedInfo *info = GetTrustedInfoByOsAccountId(osAccountId); + if (info == NULL) { + g_databaseMutex->unlock(g_databaseMutex); + return HC_ERR_INVALID_PARAMS; + } + TrustedGroupEntry *newEntry = DeepCopyGroupEntry(groupEntry); + if (newEntry == NULL) { + g_databaseMutex->unlock(g_databaseMutex); + return HC_ERR_MEMORY_COPY; + } + QueryGroupParams params = InitQueryGroupParams(); + params.groupId = StringGet(&groupEntry->id); + TrustedGroupEntry **oldEntryPtr = QueryGroupEntryPtrIfMatch(&info->groups, ¶ms); + if (oldEntryPtr != NULL) { + DestroyGroupEntry(*oldEntryPtr); + *oldEntryPtr = newEntry; + PostGroupCreatedMsg(newEntry); + g_databaseMutex->unlock(g_databaseMutex); + LOGI("[DB]: Replace an old group successfully! [GroupType]: %d", groupEntry->type); + return HC_SUCCESS; + } + if (info->groups.pushBackT(&info->groups, newEntry) == NULL) { + DestroyGroupEntry(newEntry); + g_databaseMutex->unlock(g_databaseMutex); + LOGE("[DB]: Failed to push groupEntry to vec!"); + return HC_ERR_MEMORY_COPY; + } + PostGroupCreatedMsg(newEntry); + g_databaseMutex->unlock(g_databaseMutex); + LOGI("[DB]: Add a group to database successfully! [GroupType]: %d", groupEntry->type); + return HC_SUCCESS; +} + +int32_t AddTrustedDevice(int32_t osAccountId, const TrustedDeviceEntry *deviceEntry) +{ + LOGI("[DB]: Start to add a trusted device to database!"); + if (deviceEntry == NULL) { + LOGE("[DB]: The input deviceEntry is NULL!"); + return HC_ERR_NULL_PTR; + } + g_databaseMutex->lock(g_databaseMutex); + OsAccountTrustedInfo *info = GetTrustedInfoByOsAccountId(osAccountId); + if (info == NULL) { + g_databaseMutex->unlock(g_databaseMutex); + return HC_ERR_INVALID_PARAMS; + } + TrustedDeviceEntry *newEntry = DeepCopyDeviceEntry(deviceEntry); + if (newEntry == NULL) { + g_databaseMutex->unlock(g_databaseMutex); + return HC_ERR_MEMORY_COPY; + } + QueryDeviceParams params = InitQueryDeviceParams(); + params.udid = StringGet(&deviceEntry->udid); + params.groupId = StringGet(&deviceEntry->groupId); + TrustedDeviceEntry **oldEntryPtr = QueryDeviceEntryPtrIfMatch(&info->devices, ¶ms); + if (oldEntryPtr != NULL) { + DestroyDeviceEntry(*oldEntryPtr); + *oldEntryPtr = newEntry; + PostDeviceBoundMsg(info, newEntry); + g_databaseMutex->unlock(g_databaseMutex); + LOGI("[DB]: Replace an old trusted device successfully!"); + return HC_SUCCESS; + } + if (info->devices.pushBackT(&info->devices, newEntry) == NULL) { + DestroyDeviceEntry(newEntry); + g_databaseMutex->unlock(g_databaseMutex); + LOGE("[DB]: Failed to push deviceEntry to vec!"); + return HC_ERR_MEMORY_COPY; + } + PostDeviceBoundMsg(info, newEntry); + g_databaseMutex->unlock(g_databaseMutex); + LOGI("[DB]: Add a trusted device to database successfully!"); + return HC_SUCCESS; +} + +int32_t DelGroup(int32_t osAccountId, const QueryGroupParams *params) +{ + LOGI("[DB]: Start to delete groups from database!"); + if (params == NULL) { + LOGE("[DB]: The input params is NULL!"); + return HC_ERR_NULL_PTR; + } + g_databaseMutex->lock(g_databaseMutex); + OsAccountTrustedInfo *info = GetTrustedInfoByOsAccountId(osAccountId); + if (info == NULL) { + g_databaseMutex->unlock(g_databaseMutex); + return HC_ERR_INVALID_PARAMS; + } + int32_t count = 0; + uint32_t index = 0; + TrustedGroupEntry **entry = NULL; + while (index < HC_VECTOR_SIZE(&info->groups)) { + entry = info->groups.getp(&info->groups, index); + if ((entry == NULL) || (*entry == NULL) || (!CompareQueryGroupParams(params, *entry))) { + index++; + continue; + } + TrustedGroupEntry *popEntry; + HC_VECTOR_POPELEMENT(&info->groups, &popEntry, index); + PostGroupDeletedMsg(popEntry); + LOGI("[DB]: Delete a group from database successfully! [GroupType]: %d", popEntry->type); + DestroyGroupEntry(popEntry); + count++; + } + g_databaseMutex->unlock(g_databaseMutex); + LOGI("[DB]: Number of groups deleted: %d", count); + return HC_SUCCESS; +} + +int32_t DelTrustedDevice(int32_t osAccountId, const QueryDeviceParams *params) +{ + LOGI("[DB]: Start to delete devices from database!"); + if (params == NULL) { + LOGE("[DB]: The input params is NULL!"); + return HC_ERR_NULL_PTR; + } + g_databaseMutex->lock(g_databaseMutex); + OsAccountTrustedInfo *info = GetTrustedInfoByOsAccountId(osAccountId); + if (info == NULL) { + g_databaseMutex->unlock(g_databaseMutex); + return HC_ERR_INVALID_PARAMS; + } + int32_t count = 0; + uint32_t index = 0; + TrustedDeviceEntry **entry = NULL; + while (index < HC_VECTOR_SIZE(&info->devices)) { + entry = info->devices.getp(&info->devices, index); + if ((entry == NULL) || (*entry == NULL) || (!CompareQueryDeviceParams(params, *entry))) { + index++; + continue; + } + TrustedDeviceEntry *popEntry; + HC_VECTOR_POPELEMENT(&info->devices, &popEntry, index); + PostDeviceUnBoundMsg(info, popEntry); + LOGI("[DB]: Delete a trusted device from database successfully!"); + DestroyDeviceEntry(popEntry); + count++; + } + g_databaseMutex->unlock(g_databaseMutex); + LOGI("[DB]: Number of trusted devices deleted: %d", count); + return HC_SUCCESS; +} + +int32_t QueryGroups(int32_t osAccountId, const QueryGroupParams *params, GroupEntryVec *vec) +{ + if ((params == NULL) || (vec == NULL)) { + LOGE("[DB]: The input params or vec is NULL!"); + return HC_ERR_NULL_PTR; + } + g_databaseMutex->lock(g_databaseMutex); + OsAccountTrustedInfo *info = GetTrustedInfoByOsAccountId(osAccountId); + if (info == NULL) { + g_databaseMutex->unlock(g_databaseMutex); + return HC_ERR_INVALID_PARAMS; + } + uint32_t index; + TrustedGroupEntry **entry; + FOR_EACH_HC_VECTOR(info->groups, index, entry) { + if ((entry == NULL) || (*entry == NULL) || (!CompareQueryGroupParams(params, *entry))) { + continue; + } + TrustedGroupEntry *newEntry = DeepCopyGroupEntry(*entry); + if (newEntry == NULL) { + continue; + } + if (vec->pushBackT(vec, newEntry) == NULL) { + LOGE("[DB]: Faild to push entry to vec!"); + DestroyGroupEntry(newEntry); + } + } + g_databaseMutex->unlock(g_databaseMutex); + LOGI("[DB]: Number of groups queried: %d", vec->size(vec)); + return HC_SUCCESS; +} + +int32_t QueryDevices(int32_t osAccountId, const QueryDeviceParams *params, DeviceEntryVec *vec) +{ + if ((params == NULL) || (vec == NULL)) { + LOGE("[DB]: The input params or vec is NULL!"); + return HC_ERR_NULL_PTR; + } + g_databaseMutex->lock(g_databaseMutex); + OsAccountTrustedInfo *info = GetTrustedInfoByOsAccountId(osAccountId); + if (info == NULL) { + g_databaseMutex->unlock(g_databaseMutex); + return HC_ERR_INVALID_PARAMS; + } + uint32_t index; + TrustedDeviceEntry **entry; + FOR_EACH_HC_VECTOR(info->devices, index, entry) { + if ((entry == NULL) || (*entry == NULL) || (!CompareQueryDeviceParams(params, *entry))) { + continue; + } + TrustedDeviceEntry *newEntry = DeepCopyDeviceEntry(*entry); + if (newEntry == NULL) { + continue; + } + if (vec->pushBackT(vec, newEntry) == NULL) { + LOGE("[DB]: Faild to push entry to vec!"); + DestroyDeviceEntry(newEntry); + } + } + g_databaseMutex->unlock(g_databaseMutex); + LOGI("[DB]: Number of trusted devices queried: %d", vec->size(vec)); + return HC_SUCCESS; +} + +int32_t SaveOsAccountDb(int32_t osAccountId) +{ + g_databaseMutex->lock(g_databaseMutex); + OsAccountTrustedInfo *info = GetTrustedInfoByOsAccountId(osAccountId); + if (info == NULL) { + g_databaseMutex->unlock(g_databaseMutex); + return HC_ERR_INVALID_PARAMS; + } + HcParcel parcel = CreateParcel(0, 0); + if (!SaveInfoToParcel(info, &parcel)) { + DeleteParcel(&parcel); + g_databaseMutex->unlock(g_databaseMutex); + return HC_ERR_MEMORY_COPY; + } + if (!SaveParcelToFile(info, &parcel)) { + DeleteParcel(&parcel); + g_databaseMutex->unlock(g_databaseMutex); + return HC_ERR_MEMORY_COPY; + } + DeleteParcel(&parcel); + g_databaseMutex->unlock(g_databaseMutex); + LOGI("[DB]: Save an os account database successfully! [Id]: %d", osAccountId); + return HC_SUCCESS; +} + +int32_t InitDatabase(void) +{ + if (g_databaseMutex == NULL) { + g_databaseMutex = (HcMutex *)HcMalloc(sizeof(HcMutex), 0); + if (g_databaseMutex == NULL) { + LOGE("[DB]: Alloc databaseMutex failed"); + return HC_ERR_ALLOC_MEMORY; + } + if (InitHcMutex(g_databaseMutex) != HC_SUCCESS) { + LOGE("[DB]: Init mutex failed"); + HcFree(g_databaseMutex); + g_databaseMutex = NULL; + return HC_ERROR; + } + } + g_deviceauthDb = CREATE_HC_VECTOR(DeviceAuthDb); + LoadDeviceAuthDb(); + return HC_SUCCESS; +} + +void DestroyDatabase(void) +{ + g_databaseMutex->lock(g_databaseMutex); + uint32_t index; + OsAccountTrustedInfo *info; + FOR_EACH_HC_VECTOR(g_deviceauthDb, index, info) { + ClearGroupEntryVec(&info->groups); + ClearDeviceEntryVec(&info->devices); + } + DESTROY_HC_VECTOR(DeviceAuthDb, &g_deviceauthDb); + g_databaseMutex->unlock(g_databaseMutex); + if (g_databaseMutex != NULL) { + DestroyHcMutex(g_databaseMutex); + HcFree(g_databaseMutex); + g_databaseMutex = NULL; + } +} \ No newline at end of file diff --git a/services/data_manager/src/database_manager.c b/services/data_manager/src/database_manager.c index 86951b4..a00c85b 100644 --- a/services/data_manager/src/database_manager.c +++ b/services/data_manager/src/database_manager.c @@ -13,7 +13,7 @@ * limitations under the License. */ -#include "database_manager.h" +#include "data_manager.h" #include "database_util.h" #include "device_auth.h" @@ -441,7 +441,7 @@ static int32_t GenerateGroupEntryByInfo(const GroupInfo *groupInfo, TrustedGroup return HC_SUCCESS; } -static int32_t GenerateDeviceEntryByInfo(const DeviceInfo *deviceInfo, const Uint8Buff *ext, +static int32_t GenerateDeviceEntryByInfo(const TrustedDeviceEntry *deviceInfo, const Uint8Buff *ext, TrustedDeviceEntry *deviceEntry) { deviceEntry->udid = CreateString(); @@ -747,7 +747,7 @@ static int32_t PushGroupInfoToVec(const TrustedGroupEntry *entry, const char *gr static int32_t PushDevInfoToVec(const TrustedDeviceEntry *entry, const char *groupId, DeviceInfoVec *deviceInfoVec) { - DeviceInfo *deviceInfo = CreateDeviceInfoStruct(); + TrustedDeviceEntry *deviceInfo = CreateDeviceInfoStruct(); if (deviceInfo == NULL) { LOGE("[DB]: Failed to allocate deviceInfo memory!"); return HC_ERR_ALLOC_MEMORY; @@ -839,7 +839,7 @@ int32_t DelGroupByGroupId(const char *groupId) return HC_SUCCESS; } -int32_t AddTrustedDevice(const DeviceInfo *deviceInfo, const Uint8Buff *ext) +int32_t AddTrustedDevice(const TrustedDeviceEntry *deviceInfo, const Uint8Buff *ext) { LOGI("[DB]: Start to add a trusted device to database!"); if (deviceInfo == NULL) { @@ -1253,7 +1253,7 @@ bool IsGroupExistByGroupId(const char *groupId) return isExists; } -int32_t GetTrustedDevInfoById(const char *deviceId, bool isUdid, const char *groupId, DeviceInfo *deviceInfo) +int32_t GetTrustedDevInfoById(const char *deviceId, bool isUdid, const char *groupId, TrustedDeviceEntry *deviceInfo) { if ((deviceId == NULL) || (groupId == NULL) || (deviceInfo == NULL)) { LOGE("[DB]: The input parameters contains NULL value!"); @@ -1343,7 +1343,7 @@ void CreateGroupInfoVecStruct(GroupInfoVec *vec) if (vec == NULL) { return; } - *vec = CREATE_HC_VECTOR(GroupInfoVec) + *vec = CREATE_HC_VECTOR(GroupInfoVec); } void DestroyGroupInfoVecStruct(GroupInfoVec *vec) @@ -1355,7 +1355,7 @@ void DestroyGroupInfoVecStruct(GroupInfoVec *vec) DestroyGroupInfoStruct(*entry); } } - DESTROY_HC_VECTOR(GroupInfoVec, vec) + DESTROY_HC_VECTOR(GroupInfoVec, vec); } void CreateDeviceInfoVecStruct(DeviceInfoVec *vec) @@ -1363,7 +1363,7 @@ void CreateDeviceInfoVecStruct(DeviceInfoVec *vec) if (vec == NULL) { return; } - *vec = CREATE_HC_VECTOR(DeviceInfoVec) + *vec = CREATE_HC_VECTOR(DeviceInfoVec); } void DestroyDeviceInfoVecStruct(DeviceInfoVec *vec) @@ -1375,7 +1375,7 @@ void DestroyDeviceInfoVecStruct(DeviceInfoVec *vec) DestroyDeviceInfoStruct(*entry); } } - DESTROY_HC_VECTOR(DeviceInfoVec, vec) + DESTROY_HC_VECTOR(DeviceInfoVec, vec); } int32_t GetJoinedGroupInfoVecByDevId(const GroupQueryParams *params, GroupInfoVec *vec) diff --git a/services/data_manager/src/database_util.c b/services/data_manager/src/database_util.c index b51f629..898944b 100644 --- a/services/data_manager/src/database_util.c +++ b/services/data_manager/src/database_util.c @@ -123,7 +123,7 @@ static int32_t GenerateAcrossAccountGroupInfoByUserIdHash(const TrustedGroupEntr return GenerateGroupInfoSharedUserIdHash(sharedUserIdHash, returnGroupInfo); } -static int32_t GenerateDeviceInfoCommonByEntry(const TrustedDeviceEntry *entry, DeviceInfo *returnDeviceInfo) +static int32_t GenerateDeviceInfoCommonByEntry(const TrustedDeviceEntry *entry, TrustedDeviceEntry *returnDeviceInfo) { if (!StringSet(&returnDeviceInfo->udid, entry->udid)) { LOGE("[DB]: Failed to copy udid!"); @@ -146,7 +146,7 @@ static int32_t GenerateDeviceInfoCommonByEntry(const TrustedDeviceEntry *entry, return HC_SUCCESS; } -static int32_t GenerateDeviceInfoId(const char *groupId, DeviceInfo *returnDeviceInfo) +static int32_t GenerateDeviceInfoId(const char *groupId, TrustedDeviceEntry *returnDeviceInfo) { if (!StringSetPointer(&(returnDeviceInfo->groupId), groupId)) { LOGE("[DB]: Failed to copy groupId!"); @@ -240,7 +240,7 @@ void DestroyStrVector(StringVector *vec) FOR_EACH_HC_VECTOR(*vec, index, strItemPtr) { DeleteString(strItemPtr); } - DESTROY_HC_VECTOR(StringVector, vec) + DESTROY_HC_VECTOR(StringVector, vec); } GroupInfo *CreateGroupInfoStruct(void) @@ -271,9 +271,9 @@ void DestroyGroupInfoStruct(GroupInfo *groupInfo) HcFree(groupInfo); } -DeviceInfo *CreateDeviceInfoStruct(void) +TrustedDeviceEntry *CreateDeviceInfoStruct(void) { - DeviceInfo *deviceInfo = (DeviceInfo *)HcMalloc(sizeof(DeviceInfo), 0); + TrustedDeviceEntry *deviceInfo = (TrustedDeviceEntry *)HcMalloc(sizeof(DeviceInfo), 0); if (deviceInfo == NULL) { LOGE("[DB]: Failed to allocate deviceInfo memory!"); return NULL; @@ -286,7 +286,7 @@ DeviceInfo *CreateDeviceInfoStruct(void) return deviceInfo; } -void DestroyDeviceInfoStruct(DeviceInfo *deviceInfo) +void DestroyDeviceInfoStruct(TrustedDeviceEntry *deviceInfo) { if (deviceInfo == NULL) { return; @@ -358,7 +358,7 @@ int32_t GenerateGroupInfoByEntry(const TrustedGroupEntry *groupEntry, const char } int32_t GenerateDeviceInfoByEntry(const TrustedDeviceEntry *deviceEntry, const char *groupId, - DeviceInfo *returnDeviceInfo) + TrustedDeviceEntry *returnDeviceInfo) { int32_t result = GenerateDeviceInfoCommonByEntry(deviceEntry, returnDeviceInfo); if (result != HC_SUCCESS) { diff --git a/services/device_auth.c b/services/device_auth.c index 847b43e..3cf50c0 100644 --- a/services/device_auth.c +++ b/services/device_auth.c @@ -26,6 +26,7 @@ #include "hc_log.h" #include "json_utils.h" #include "lcm_adapter.h" +#include "os_account_adapter.h" #include "session_manager.h" #include "task_manager.h" @@ -38,7 +39,7 @@ static void DestroyGroupAuthTask(HcTaskBase *task) FreeJson(realTask->authParams); } -static bool InitAuthDeviceTask(AuthDeviceTask *task, int64_t authReqId, CJson *authParams, +static bool InitAuthDeviceTask(int32_t osAccountId, AuthDeviceTask *task, int64_t authReqId, CJson *authParams, const DeviceAuthCallback *gaCallback) { task->base.doAction = DoAuthDevice; @@ -48,6 +49,10 @@ static bool InitAuthDeviceTask(AuthDeviceTask *task, int64_t authReqId, CJson *a LOGE("Failed to add requestId to json!"); return false; } + if (AddIntToJson(authParams, FIELD_OS_ACCOUNT_ID, osAccountId) != HC_SUCCESS) { + LOGE("Failed to add os accountId to json for auth device!"); + return false; + } task->authParams = authParams; task->callback = gaCallback; if (task->callback == NULL) { @@ -57,8 +62,8 @@ static bool InitAuthDeviceTask(AuthDeviceTask *task, int64_t authReqId, CJson *a return true; } -static bool InitProcessDataTask(AuthDeviceTask *task, int64_t authReqId, CJson *receivedData, - const DeviceAuthCallback *gaCallback) +static bool InitProcessDataTask(AuthDeviceTask *task, int64_t authReqId, + CJson *receivedData, const DeviceAuthCallback *gaCallback) { task->base.doAction = DoProcessAuthData; task->base.destroy = DestroyGroupAuthTask; @@ -80,9 +85,11 @@ static bool InitProcessDataTask(AuthDeviceTask *task, int64_t authReqId, CJson * return true; } -static int32_t AuthDevice(int64_t authReqId, const char *authParams, const DeviceAuthCallback *gaCallback) +static int32_t AuthDevice(int32_t osAccountId, int64_t authReqId, const char *authParams, + const DeviceAuthCallback *gaCallback) { LOGI("Begin AuthDevice."); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); if (authParams == NULL) { LOGE("The input auth params is null!"); return HC_ERR_INVALID_PARAMS; @@ -98,7 +105,7 @@ static int32_t AuthDevice(int64_t authReqId, const char *authParams, const Devic LOGE("Failed to allocate memory for task!"); return HC_ERR_ALLOC_MEMORY; } - if (!InitAuthDeviceTask(task, authReqId, jsonParams, gaCallback)) { + if (!InitAuthDeviceTask(osAccountId, task, authReqId, jsonParams, gaCallback)) { LOGE("Failed to init task!"); FreeJson(jsonParams); HcFree(task); @@ -296,6 +303,7 @@ DEVICE_AUTH_API_PUBLIC const DeviceGroupManager *GetGmInstance(void) g_groupManagerInstance->getDeviceInfoById = GetDeviceInfoByIdImpl; g_groupManagerInstance->getTrustedDevices = GetTrustedDevicesImpl; g_groupManagerInstance->isDeviceInGroup = IsDeviceInGroupImpl; + g_groupManagerInstance->getPkInfoList = GetPkInfoListImpl; g_groupManagerInstance->destroyInfo = DestroyInfoImpl; return g_groupManagerInstance; } diff --git a/services/deviceauth.gni b/services/deviceauth.gni index 0c3c5c5..243f201 100644 --- a/services/deviceauth.gni +++ b/services/deviceauth.gni @@ -49,6 +49,7 @@ inc_path = [ "${dev_frameworks_path}/inc/", "${dev_frameworks_path}/inc/module", "${dev_frameworks_path}/inc/session", + "${dev_frameworks_path}/inc/os_account_adapter", "${dev_frameworks_path}/inc/task_manager", "${authenticators_path}/inc/account_related", "${authenticators_path}/inc/account_unrelated", @@ -91,7 +92,13 @@ dev_frameworks_files = [ "${dev_frameworks_path}/src/task_manager/task_manager.c", ] +os_account_adapter_files = + [ "${dev_frameworks_path}/src/os_account_adapter/os_account_adapter.cpp" ] + +os_account_adapter_lite_files = [ "${dev_frameworks_path}/src/os_account_adapter_mock/os_account_adapter_mock.cpp" ] + group_auth_files = [ + "${group_auth_path}/src/group_auth_manager/group_auth_data_operation.c", "${group_auth_path}/src/group_auth_manager/group_auth_manager.c", "${group_auth_path}/src/session/auth_session/auth_session_client.c", "${group_auth_path}/src/session/auth_session/auth_session_common.c", @@ -113,8 +120,9 @@ group_auth_account_unrelated_mock_files = [ "${group_auth_path}/src/group_auth_m group_auth_account_related_mock_files = [ "${group_auth_path}/src/group_auth_manager/account_related_group_auth_mock/account_related_group_auth_mock.c" ] database_manager_files = [ - "${data_manager_path}/src/database_manager.c", - "${data_manager_path}/src/database_util.c", + # "${data_manager_path}/src/database_manager.c", + # "${data_manager_path}/src/database_util.c", + "${data_manager_path}/src/data_manager.c", ] database_manager_lite_files = [] @@ -306,6 +314,12 @@ if (enable_broadcast == true) { deviceauth_files += broadcast_manager_mock_files } +if (defined(ohos_lite)) { + deviceauth_files += os_account_adapter_lite_files +} else { + deviceauth_files += os_account_adapter_files +} + #build_flags = [ "-Wrestrict" ] build_flags = [ "-Werror" ] diff --git a/services/frameworks/inc/common_defs.h b/services/frameworks/inc/common_defs.h index 1c31f86..c76e8c7 100644 --- a/services/frameworks/inc/common_defs.h +++ b/services/frameworks/inc/common_defs.h @@ -71,6 +71,7 @@ #define FIELD_NONCE "nonce" #define FIELD_OPERATION_CODE "operationCode" #define FIELD_OPERATION_PARAMS "operationParams" +#define FIELD_OS_ACCOUNT_ID "osAccountId" #define FIELD_OWNER_ID "ownerId" #define FIELD_OWNER_NAME "ownerName" #define FIELD_PERMISSION "Permission" @@ -220,6 +221,4 @@ typedef enum { SECURE_CLONE = 8, } OperationCode; -DECLARE_HC_VECTOR(StringVector, HcString) - #endif diff --git a/services/frameworks/inc/module/dev_auth_module_manager.h b/services/frameworks/inc/module/dev_auth_module_manager.h index 535a96d..9eb1ce6 100644 --- a/services/frameworks/inc/module/dev_auth_module_manager.h +++ b/services/frameworks/inc/module/dev_auth_module_manager.h @@ -31,6 +31,13 @@ typedef struct AuthModuleBaseT { void (*destroyModule)(struct AuthModuleBaseT *module); } AuthModuleBase; +typedef struct { + const char *pkgName; + const char *serviceType; + Uint8Buff *authId; + int userType; +} AuthModuleParams; + int32_t InitModules(void); void DestroyModules(void); @@ -46,6 +53,7 @@ int32_t UnregisterLocalIdentity(const char *pkgName, const char *serviceType, Ui int moduleType); int32_t DeletePeerAuthInfo(const char *pkgName, const char *serviceType, Uint8Buff *authId, int userType, int moduleType); +int32_t GetPublicKey(int moduleType, AuthModuleParams *params, Uint8Buff *returnPk); // for ACCOUNT int32_t ProcessCredentials(int credentialOpCode, const CJson *in, CJson *out, int moduleType); diff --git a/services/frameworks/inc/os_account_adapter/os_account_adapter.h b/services/frameworks/inc/os_account_adapter/os_account_adapter.h new file mode 100644 index 0000000..b7213ac --- /dev/null +++ b/services/frameworks/inc/os_account_adapter/os_account_adapter.h @@ -0,0 +1,30 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OS_ACCOUNT_ADAPTER_H +#define OS_ACCOUNT_ADAPTER_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +int32_t DevAuthGetRealOsAccountLocalId(int32_t inputId); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/services/frameworks/src/module/dev_auth_module_manager.c b/services/frameworks/src/module/dev_auth_module_manager.c index a58b396..9b63b02 100644 --- a/services/frameworks/src/module/dev_auth_module_manager.c +++ b/services/frameworks/src/module/dev_auth_module_manager.c @@ -21,7 +21,7 @@ #include "account_module.h" #include "version_util.h" -DECLARE_HC_VECTOR(AuthModuleVec, void *) +DECLARE_HC_VECTOR(AuthModuleVec, void *); IMPLEMENT_HC_VECTOR(AuthModuleVec, void *, 1) static AuthModuleVec g_authModuleVec; @@ -146,6 +146,29 @@ int32_t DeletePeerAuthInfo(const char *pkgName, const char *serviceType, Uint8Bu return HC_SUCCESS; } +int32_t GetPublicKey(int moduleType, AuthModuleParams *params, Uint8Buff *returnPk) +{ + if (params == NULL || returnPk == NULL || + !IsParamsForDasTokenManagerValid(params->pkgName, params->serviceType, + params->authId, params->userType, moduleType)) { + LOGE("Params for GetPublicKey is invalid."); + return HC_ERR_INVALID_PARAMS; + } + AuthModuleBase *module = GetModule(moduleType); + if (module == NULL) { + LOGE("Failed to get module for das."); + return HC_ERR_MODULE_NOT_FOUNT; + } + DasAuthModule *dasModule = (DasAuthModule *)module; + int32_t res = dasModule->getPublicKey(params->pkgName, params->serviceType, + params->authId, params->userType, returnPk); + if (res != HC_SUCCESS) { + LOGE("Get public key failed, res: %d", res); + return res; + } + return HC_SUCCESS; +} + int32_t ProcessTask(int taskId, const CJson *in, CJson *out, int32_t *status, int moduleType) { if (in == NULL || out == NULL || status == NULL) { @@ -236,7 +259,7 @@ static int32_t InitAccountModule(void) int32_t InitModules(void) { - g_authModuleVec = CREATE_HC_VECTOR(AuthModuleVec) + g_authModuleVec = CREATE_HC_VECTOR(AuthModuleVec); InitGroupAndModuleVersion(&g_version); int res; if (IsDasSupported()) { @@ -270,7 +293,7 @@ void DestroyModules(void) ((AuthModuleBase *)(*module))->destroyModule((AuthModuleBase *)*module); } } - DESTROY_HC_VECTOR(AuthModuleVec, &g_authModuleVec) + DESTROY_HC_VECTOR(AuthModuleVec, &g_authModuleVec); (void)memset_s(&g_version, sizeof(VersionStruct), 0, sizeof(VersionStruct)); } diff --git a/services/frameworks/src/os_account_adapter/os_account_adapter.cpp b/services/frameworks/src/os_account_adapter/os_account_adapter.cpp new file mode 100644 index 0000000..9a83a89 --- /dev/null +++ b/services/frameworks/src/os_account_adapter/os_account_adapter.cpp @@ -0,0 +1,44 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "os_account_adapter.h" + +#include +#include "device_auth.h" +#include "hc_log.h" +#include "os_account_manager.h" + +int32_t DevAuthGetRealOsAccountLocalId(int32_t inputId) +{ + if (inputId == ANY_OS_ACCOUNT) { + std::vector activatedOsAccountIds; + LOGI("[OsAccountManager][In]: QueryActiveOsAccountIds!"); + OHOS::ErrCode res = OHOS::AccountSA::OsAccountManager::QueryActiveOsAccountIds(activatedOsAccountIds); + LOGI("[OsAccountManager][Out]: QueryActiveOsAccountIds! res: %d", res); + if ((res != OHOS::ERR_OK) || (activatedOsAccountIds.size() <= 0)) { + LOGE("[Account]: QueryActiveOsAccountIds fail! res: %d", res); + return INVALID_OS_ACCOUNT; + } + int osAccountId = activatedOsAccountIds[0]; + LOGI("[Account]: Use activated os account! [Id]: %d", osAccountId); + return osAccountId; + } else if (inputId >= 0) { + LOGI("[Account]: Use input os account! [Id]: %d", inputId); + return inputId; + } else { + LOGE("[Account]: The input os account is invalid! [Id]: %d", inputId); + return INVALID_OS_ACCOUNT; + } +} diff --git a/services/frameworks/src/os_account_adapter_mock/os_account_adapter_mock.cpp b/services/frameworks/src/os_account_adapter_mock/os_account_adapter_mock.cpp new file mode 100644 index 0000000..5cc6df1 --- /dev/null +++ b/services/frameworks/src/os_account_adapter_mock/os_account_adapter_mock.cpp @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "os_account_adapter.h" +#include "device_auth.h" + +int32_t DevAuthGetRealOsAccountLocalId(int32_t inputId) +{ + (void)inputId; + return DEFAULT_OS_ACCOUNT; +} diff --git a/services/frameworks/src/session/session_manager.c b/services/frameworks/src/session/session_manager.c index c525b58..7fb204b 100644 --- a/services/frameworks/src/session/session_manager.c +++ b/services/frameworks/src/session/session_manager.c @@ -38,10 +38,10 @@ typedef struct { int64_t sessionId; } RequestInfo; -DECLARE_HC_VECTOR(SessionManagerVec, void *) +DECLARE_HC_VECTOR(SessionManagerVec, void *); IMPLEMENT_HC_VECTOR(SessionManagerVec, void *, 1) -DECLARE_HC_VECTOR(RequestInfoVec, RequestInfo) +DECLARE_HC_VECTOR(RequestInfoVec, RequestInfo); IMPLEMENT_HC_VECTOR(RequestInfoVec, RequestInfo, 1) static SessionManagerVec g_sessionManagerVec; @@ -113,8 +113,8 @@ static void DestroyRequest(int64_t requestId) void InitSessionManager(void) { - g_sessionManagerVec = CREATE_HC_VECTOR(SessionManagerVec) - g_requestVec = CREATE_HC_VECTOR(RequestInfoVec) + g_sessionManagerVec = CREATE_HC_VECTOR(SessionManagerVec); + g_requestVec = CREATE_HC_VECTOR(RequestInfoVec); } void DestroySessionManager(void) @@ -127,8 +127,8 @@ void DestroySessionManager(void) temp->destroy(temp); } } - DESTROY_HC_VECTOR(SessionManagerVec, &g_sessionManagerVec) - DESTROY_HC_VECTOR(RequestInfoVec, &g_requestVec) + DESTROY_HC_VECTOR(SessionManagerVec, &g_sessionManagerVec); + DESTROY_HC_VECTOR(RequestInfoVec, &g_requestVec); } bool IsRequestExist(int64_t requestId) diff --git a/services/group_auth/inc/account_related_group_auth/account_related_group_auth.h b/services/group_auth/inc/account_related_group_auth/account_related_group_auth.h index d739e58..076094b 100644 --- a/services/group_auth/inc/account_related_group_auth/account_related_group_auth.h +++ b/services/group_auth/inc/account_related_group_auth/account_related_group_auth.h @@ -18,10 +18,10 @@ #include #include "base_group_auth.h" -#include "database_manager.h" +#include "data_manager.h" -typedef void (*GetAccountCandidateGroupFunc)(const CJson *param, const GroupQueryParams *queryParams, - GroupInfoVec *vec); +typedef void (*GetAccountCandidateGroupFunc)(const CJson *param, const QueryGroupParams *queryParams, + GroupEntryVec *vec); typedef struct { BaseGroupAuth base; diff --git a/services/group_auth/inc/base_group_auth.h b/services/group_auth/inc/base_group_auth.h index 52f798c..5f750cb 100644 --- a/services/group_auth/inc/base_group_auth.h +++ b/services/group_auth/inc/base_group_auth.h @@ -18,14 +18,15 @@ #include #include "auth_session_common_defines.h" -#include "database_manager.h" +#include "data_manager.h" #include "device_auth.h" #include "json_utils.h" typedef struct { void (*onFinish)(int64_t requestId, const CJson *authParam, const CJson *out, const DeviceAuthCallback *callback); void (*onError)(int64_t requestId, const AuthSession *session, int errorCode); - int32_t (*fillDeviceAuthInfo)(const GroupInfo *entry, const DeviceInfo *localAuthInfo, CJson *paramsData); + int32_t (*fillDeviceAuthInfo)(int32_t osAccountId, const TrustedGroupEntry *entry, + const TrustedDeviceEntry *localAuthInfo, CJson *paramsData); int32_t (*getAuthParamForServer)(const CJson *dataFromClient, ParamsVec *authParamsVec); int32_t (*getReqParams)(const CJson *receiveData, CJson *reqParam); int32_t (*combineServerConfirmParams)(const CJson *confirmationJson, CJson *dataFromClient); diff --git a/services/group_auth/inc/group_auth_data_operation.h b/services/group_auth/inc/group_auth_data_operation.h new file mode 100644 index 0000000..ac335bc --- /dev/null +++ b/services/group_auth/inc/group_auth_data_operation.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef GROUP_AUTH_DATA_OPERATION_H +#define GROUP_AUTH_DATA_OPERATION_H + +#include "data_manager.h" + +#ifdef __cplusplus +extern "C" { +#endif + +bool GaIsGroupAccessible(int32_t osAccountId, const char *groupId, const char *appId); +int32_t GaGetTrustedDeviceEntryById(int32_t osAccountId, const char *deviceId, + bool isUdid, const char *groupId, TrustedDeviceEntry *returnDeviceEntry); +bool GaIsDeviceInGroup(int32_t groupType, int32_t osAccountId, const char *peerUdid, const char *peerAuthId, + const char *groupId); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/services/group_auth/inc/session/auth_session/auth_session_common.h b/services/group_auth/inc/session/auth_session/auth_session_common.h index 959c7ff..9996240 100644 --- a/services/group_auth/inc/session/auth_session/auth_session_common.h +++ b/services/group_auth/inc/session/auth_session/auth_session_common.h @@ -25,7 +25,7 @@ extern "C" { void InformLocalAuthError(const CJson *param, const DeviceAuthCallback *callback); void InformPeerAuthError(const CJson *param, const DeviceAuthCallback *callback); int32_t InformAuthError(AuthSession *session, const CJson *out, int errorCode); -int32_t GetAuthParamsList(const CJson *param, ParamsVec *authParamsVec); +int32_t GetAuthParamsList(int32_t osAccountId, const CJson *param, ParamsVec *authParamsVec); int32_t ProcessTaskStatusForAuth(const AuthSession *session, const CJson *param, CJson *out, int32_t status); int32_t CreateAndProcessTask(AuthSession *session, CJson *paramInSession, CJson *out, int32_t *status); void ProcessDeviceLevel(const CJson *receiveData, CJson *authParam); diff --git a/services/group_auth/inc/session/auth_session/auth_session_util.h b/services/group_auth/inc/session/auth_session/auth_session_util.h index 2fa2ebf..0a88168 100644 --- a/services/group_auth/inc/session/auth_session/auth_session_util.h +++ b/services/group_auth/inc/session/auth_session/auth_session_util.h @@ -24,10 +24,13 @@ #ifdef __cplusplus extern "C" { #endif + BaseGroupAuth *GetGroupAuth(int32_t groupAuthType); int32_t GetAuthModuleType(const CJson *in); int32_t GetInfoHash(const uint8_t *info, uint32_t infoLen, char *str, uint32_t strLen); bool IsBleAuthForAcrossAccount(const CJson *authParam); +int32_t GroupTypeToAuthForm(int32_t groupType); + #ifdef __cplusplus } #endif diff --git a/services/group_auth/src/group_auth_manager/account_unrelated_group_auth/account_unrelated_group_auth.c b/services/group_auth/src/group_auth_manager/account_unrelated_group_auth/account_unrelated_group_auth.c index 0be2d70..230e754 100644 --- a/services/group_auth/src/group_auth_manager/account_unrelated_group_auth/account_unrelated_group_auth.c +++ b/services/group_auth/src/group_auth_manager/account_unrelated_group_auth/account_unrelated_group_auth.c @@ -18,13 +18,16 @@ #include "auth_session_common_util.h" #include "common_defs.h" #include "device_auth_defines.h" +#include "group_auth_data_operation.h" #include "hc_log.h" #include "hc_types.h" #include "json_utils.h" +#include "os_account_adapter.h" static void OnDasFinish(int64_t requestId, const CJson *authParam, const CJson *out, const DeviceAuthCallback *callback); -static int32_t FillNonAccountAuthInfo(const GroupInfo *entry, const DeviceInfo *localAuthInfo, CJson *paramsData); +static int32_t FillNonAccountAuthInfo(int32_t osAccountId, const TrustedGroupEntry *entry, + const TrustedDeviceEntry *localAuthInfo, CJson *paramsData); static void OnDasError(int64_t requestId, const AuthSession *session, int errorCode); static int32_t GetDasAuthParamForServer(const CJson *dataFromClient, ParamsVec *authParamsVec); static int32_t GetDasReqParams(const CJson *receiveData, CJson *reqParam); @@ -228,26 +231,34 @@ static int32_t DasOnFinishToSelf(int64_t requestId, const CJson *authParam, cons return res; } -static int32_t AddNonAccountPkgName(const GroupInfo *entry, CJson *paramsData) +static int32_t AddNonAccountPkgName(const TrustedGroupEntry *entry, CJson *paramsData) { - int32_t res = HC_SUCCESS; int32_t groupType = entry->type; if (groupType == COMPATIBLE_GROUP) { - if (AddStringToJson(paramsData, FIELD_SERVICE_PKG_NAME, StringGet(&entry->ownerName)) - != HC_SUCCESS) { + if ((entry->managers).size(&(entry->managers)) == 0) { + LOGE("The manager size is 0!"); + return HC_ERR_DB; + } + HcString ownerName = (entry->managers).get(&(entry->managers), 0); + const char *ownerNameStr = StringGet(&ownerName); + if (ownerNameStr == NULL) { + LOGE("Failed to get ownerName!"); + return HC_ERR_DB; + } + if (AddStringToJson(paramsData, FIELD_SERVICE_PKG_NAME, ownerNameStr) != HC_SUCCESS) { LOGE("Failed to add ownerName to json!"); - res = HC_ERR_JSON_FAIL; + return HC_ERR_JSON_FAIL; } } else { if (AddStringToJson(paramsData, FIELD_SERVICE_PKG_NAME, GROUP_MANAGER_PACKAGE_NAME) != HC_SUCCESS) { LOGE("Failed to add group manager name to json!"); - res = HC_ERR_JSON_FAIL; + return HC_ERR_JSON_FAIL; } } - return res; + return HC_SUCCESS; } -static int32_t AddNonAccountAuthInfo(const DeviceInfo *localAuthInfo, const DeviceInfo *peerAuthInfo, +static int32_t AddNonAccountAuthInfo(const TrustedDeviceEntry *localAuthInfo, const TrustedDeviceEntry *peerAuthInfo, CJson *paramsData) { int32_t keyLen = DEFAULT_RETURN_KEY_LENGTH; @@ -327,11 +338,12 @@ static void OnDasError(int64_t requestId, const AuthSession *session, int errorC FreeJsonString(returnStr); } -static int32_t FillNonAccountAuthInfo(const GroupInfo *entry, const DeviceInfo *localAuthInfo, CJson *paramsData) +static int32_t FillNonAccountAuthInfo(int32_t osAccountId, const TrustedGroupEntry *entry, + const TrustedDeviceEntry *localAuthInfo, CJson *paramsData) { int32_t res; const char *groupId = StringGet(&entry->id); - DeviceInfo *peerAuthInfo = CreateDeviceInfoStruct(); + TrustedDeviceEntry *peerAuthInfo = CreateDeviceEntry(); if (peerAuthInfo == NULL) { LOGE("Failed to allocate devEntry memory for peerAuthInfo!"); return HC_ERR_ALLOC_MEMORY; @@ -339,9 +351,9 @@ static int32_t FillNonAccountAuthInfo(const GroupInfo *entry, const DeviceInfo * const char *peerUdid = GetStringFromJson(paramsData, FIELD_PEER_CONN_DEVICE_ID); const char *peeAuthId = GetStringFromJson(paramsData, FIELD_PEER_AUTH_ID); if (peerUdid != NULL) { - res = GetTrustedDevInfoById(peerUdid, true, groupId, peerAuthInfo); + res = GaGetTrustedDeviceEntryById(osAccountId, peerUdid, true, groupId, peerAuthInfo); } else if (peeAuthId != NULL) { - res = GetTrustedDevInfoById(peeAuthId, false, groupId, peerAuthInfo); + res = GaGetTrustedDeviceEntryById(osAccountId, peeAuthId, false, groupId, peerAuthInfo); } else { LOGE("Invalid input, both peer udid and peer authId are null!"); res = HC_ERR_NULL_PTR; @@ -362,7 +374,7 @@ static int32_t FillNonAccountAuthInfo(const GroupInfo *entry, const DeviceInfo * break; } } while (0); - DestroyDeviceInfoStruct(peerAuthInfo); + DestroyDeviceEntry(peerAuthInfo); return res; } @@ -424,7 +436,12 @@ static int32_t CombineDasServerConfirmParams(const CJson *confirmationJson, CJso static int32_t GetDasAuthParamForServer(const CJson *dataFromClient, ParamsVec *authParamsVec) { LOGI("Begin get non-account auth params for server."); - int32_t res = GetAuthParamsList(dataFromClient, authParamsVec); + int32_t osAccountId = ANY_OS_ACCOUNT; + if (GetIntFromJson(dataFromClient, FIELD_OS_ACCOUNT_ID, &osAccountId) != HC_SUCCESS) { + LOGE("Failed to get os accountId from dataFromClient!"); + return HC_ERR_JSON_GET; + } + int32_t res = GetAuthParamsList(osAccountId, dataFromClient, authParamsVec); if (res != HC_SUCCESS) { LOGE("Failed to get non-account auth params!"); } diff --git a/services/group_auth/src/group_auth_manager/group_auth_data_operation.c b/services/group_auth/src/group_auth_manager/group_auth_data_operation.c new file mode 100644 index 0000000..f45e83e --- /dev/null +++ b/services/group_auth/src/group_auth_manager/group_auth_data_operation.c @@ -0,0 +1,238 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "group_auth_data_operation.h" +#include "auth_session_util.h" +#include "common_defs.h" +#include "device_auth.h" +#include "device_auth_defines.h" +#include "hc_log.h" +#include "hc_string.h" +#include "hc_vector.h" + +static bool GaDeepCopyDeviceEntry(const TrustedDeviceEntry *entry, TrustedDeviceEntry *returnEntry) +{ + returnEntry->groupEntry = NULL; + if (!StringSet(&returnEntry->groupId, entry->groupId)) { + LOGE("[GA]: Failed to copy udid!"); + return false; + } + if (!StringSet(&returnEntry->udid, entry->udid)) { + LOGE("[GA]: Failed to copy udid!"); + return false; + } + if (!StringSet(&returnEntry->authId, entry->authId)) { + LOGE("[GA]: Failed to copy authId!"); + return false; + } + if (!StringSet(&returnEntry->serviceType, entry->serviceType)) { + LOGE("[GA]: Failed to copy serviceType!"); + return false; + } + if (!StringSet(&returnEntry->userIdHash, entry->userIdHash)) { + LOGE("[GA]: Failed to copy userIdHash!"); + return false; + } + returnEntry->credential = entry->credential; + returnEntry->devType = entry->devType; + returnEntry->lastTm = entry->lastTm; + return true; +} + +static bool GaDeepCopyGroupEntry(const TrustedGroupEntry *entry, TrustedGroupEntry *returnEntry) +{ + if (HC_VECTOR_SIZE(&entry->managers) <= 0) { + LOGE("[GA]: The group owner is lost!"); + return false; + } + HcString entryOwner = HC_VECTOR_GET(&entry->managers, 0); + if (!StringSet(&returnEntry->name, entry->name)) { + LOGE("[GA]: Failed to copy groupName!"); + return false; + } + if (!StringSet(&returnEntry->id, entry->id)) { + LOGE("[GA]: Failed to copy groupId!"); + return false; + } + if (!StringSet(&returnEntry->userIdHash, entry->userIdHash)) { + LOGE("[GA]: Failed to copy userIdHash!"); + return false; + } + returnEntry->type = entry->type; + returnEntry->visibility = entry->visibility; + returnEntry->expireTime = entry->expireTime; + HcString ownerName = CreateString(); + if (!StringSet(&ownerName, entryOwner)) { + LOGE("[GA]: Failed to copy groupOwner!"); + DeleteString(&ownerName); + return false; + } + if (returnEntry->managers.pushBack(&returnEntry->managers, &ownerName) == NULL) { + LOGE("[GA]: Failed to push groupOwner to managers!"); + DeleteString(&ownerName); + return false; + } + return true; +} + +static bool GaIsGroupManager(const char *appId, const TrustedGroupEntry *entry) +{ + uint32_t index; + HcString *manager = NULL; + const char *managerStr = NULL; + FOR_EACH_HC_VECTOR(entry->managers, index, manager) { + managerStr = StringGet(manager); + if ((managerStr != NULL) && (strcmp(managerStr, appId) == 0)) { + return true; + } + } + return false; +} + +static bool GaIsGroupFriend(const char *appId, const TrustedGroupEntry *entry) +{ + uint32_t index; + HcString *trustedFriend = NULL; + const char *friendStr = NULL; + FOR_EACH_HC_VECTOR(entry->friends, index, trustedFriend) { + friendStr = StringGet(trustedFriend); + if ((friendStr != NULL) && (strcmp(friendStr, appId) == 0)) { + return true; + } + } + return false; +} + +static int32_t GetGroupEntryById(int32_t osAccountId, const char *groupId, TrustedGroupEntry *returnEntry) +{ + if (returnEntry == NULL) { + LOGE("The input returnEntry is NULL!"); + return HC_ERR_INVALID_PARAMS; + } + uint32_t groupIndex; + TrustedGroupEntry **entry = NULL; + GroupEntryVec groupEntryVec = CreateGroupEntryVec(); + QueryGroupParams groupParams = InitQueryGroupParams(); + groupParams.groupId = groupId; + if (QueryGroups(osAccountId, &groupParams, &groupEntryVec) != HC_SUCCESS) { + LOGE("query groups failed!"); + ClearGroupEntryVec(&groupEntryVec); + return HC_ERR_GROUP_NOT_EXIST; + } + FOR_EACH_HC_VECTOR(groupEntryVec, groupIndex, entry) { + if ((entry != NULL) && (*entry != NULL)) { + if (!GaDeepCopyGroupEntry(*entry, returnEntry)) { + ClearGroupEntryVec(&groupEntryVec); + return HC_ERR_GROUP_NOT_EXIST; + } + ClearGroupEntryVec(&groupEntryVec); + return HC_SUCCESS; + } + } + ClearGroupEntryVec(&groupEntryVec); + return HC_ERR_GROUP_NOT_EXIST; +} + +bool GaIsGroupAccessible(int32_t osAccountId, const char *groupId, const char *appId) +{ + if ((groupId == NULL) || (appId == NULL)) { + LOGE("The input groupId or appId is NULL!"); + return false; + } + TrustedGroupEntry *entry = CreateGroupEntry(); + if (entry == NULL) { + LOGE("Failed to create group entry!"); + return false; + } + int32_t res = GetGroupEntryById(osAccountId, groupId, entry); + if (res != HC_SUCCESS) { + LOGE("Failed to get group entry by groupId!"); + DestroyGroupEntry(entry); + return false; + } + if ((entry->visibility == GROUP_VISIBILITY_PUBLIC) || + (GaIsGroupManager(appId, entry)) || + (GaIsGroupFriend(appId, entry))) { + DestroyGroupEntry(entry); + return true; + } + DestroyGroupEntry(entry); + return false; +} + +int32_t GaGetTrustedDeviceEntryById(int32_t osAccountId, const char *deviceId, + bool isUdid, const char *groupId, TrustedDeviceEntry *returnDeviceEntry) +{ + if (returnDeviceEntry == NULL) { + LOGE("The input returnEntry is NULL!"); + return HC_ERR_INVALID_PARAMS; + } + uint32_t index; + TrustedDeviceEntry **deviceEntry = NULL; + DeviceEntryVec deviceEntryVec = CREATE_HC_VECTOR(DeviceEntryVec); + QueryDeviceParams params = InitQueryDeviceParams(); + params.groupId = groupId; + if (isUdid) { + params.udid = deviceId; + } else { + params.authId = deviceId; + } + if (QueryDevices(osAccountId, ¶ms, &deviceEntryVec) != HC_SUCCESS) { + LOGE("query trusted devices failed!"); + ClearDeviceEntryVec(&deviceEntryVec); + return HC_ERR_DEVICE_NOT_EXIST; + } + FOR_EACH_HC_VECTOR(deviceEntryVec, index, deviceEntry) { + if ((deviceEntry != NULL) && (*deviceEntry != NULL)) { + if (!GaDeepCopyDeviceEntry(*deviceEntry, returnDeviceEntry)) { + ClearDeviceEntryVec(&deviceEntryVec); + return HC_ERR_GROUP_NOT_EXIST; + } + ClearDeviceEntryVec(&deviceEntryVec); + return HC_SUCCESS; + } + } + ClearDeviceEntryVec(&deviceEntryVec); + return HC_ERR_DEVICE_NOT_EXIST; +} + +bool GaIsDeviceInGroup(int32_t groupType, int32_t osAccountId, const char *peerUdid, const char *peerAuthId, + const char *groupId) +{ + int32_t res; + int32_t authForm = GroupTypeToAuthForm(groupType); + if ((authForm == AUTH_FORM_ACROSS_ACCOUNT) || (authForm == AUTH_FORM_IDENTICAL_ACCOUNT)) { + LOGD("Auth for account related type."); + return true; /* Do not check whether account related devices is in account. */ + } + TrustedDeviceEntry *deviceEntry = CreateDeviceEntry(); + if (deviceEntry == NULL) { + LOGE("Failed to allocate memory for deviceEntry!"); + return false; + } + if (peerUdid != NULL) { + res = GaGetTrustedDeviceEntryById(osAccountId, peerUdid, true, groupId, deviceEntry); + } else if (peerAuthId != NULL) { + res = GaGetTrustedDeviceEntryById(osAccountId, peerAuthId, false, groupId, deviceEntry); + } else { + LOGE("Both the input udid and authId is null!"); + res = HC_ERROR; + } + DestroyDeviceEntry(deviceEntry); + if (res != HC_SUCCESS) { + return false; + } + return true; +} \ No newline at end of file diff --git a/services/group_auth/src/group_auth_manager/group_auth_manager.c b/services/group_auth/src/group_auth_manager/group_auth_manager.c index fcd1bcf..9147461 100644 --- a/services/group_auth/src/group_auth_manager/group_auth_manager.c +++ b/services/group_auth/src/group_auth_manager/group_auth_manager.c @@ -15,7 +15,6 @@ #include "group_auth_manager.h" #include "common_defs.h" -#include "database_manager.h" #include "dev_auth_module_manager.h" #include "device_auth_defines.h" #include "hc_log.h" @@ -59,12 +58,14 @@ bool IsTrustedDevice(const char *udid) LOGE("Invalid params in IsTrustedDevice"); return false; } - return IsTrustedDeviceExist(udid); + LOGE("Group auth do not support func currently: %s!", __func__); + return false; } int32_t QueryTrustedDeviceNum(void) { - return GetTrustedDevNumber(); + LOGE("Group auth do not support func currently: %s!", __func__); + return HC_ERR_NOT_SUPPORT; } void DoAuthDevice(HcTaskBase *task) diff --git a/services/group_auth/src/session/auth_session/auth_session_client.c b/services/group_auth/src/session/auth_session/auth_session_client.c index 4c8a62c..2d1865f 100644 --- a/services/group_auth/src/session/auth_session/auth_session_client.c +++ b/services/group_auth/src/session/auth_session/auth_session_client.c @@ -21,6 +21,7 @@ #include "hc_types.h" #include "json_utils.h" #include "session_common.h" +#include "string_util.h" static int32_t ProcessClientAuthSession(Session *session, CJson *in); @@ -106,6 +107,20 @@ int32_t CheckClientGroupAuthMsg(AuthSession *session, const CJson *in) return HC_ERR_PEER_ERROR; } +static void PrintErrorInputInfo(const CJson *param) +{ + const char *peerUdid = GetStringFromJson(param, FIELD_PEER_CONN_DEVICE_ID); + const char *peerAuthId = GetStringFromJson(param, FIELD_PEER_AUTH_ID); + char *anonyPeerUdid = NULL; + char *anonyPeerAuthId = NULL; + ConvertToAnonymousStr(peerUdid, &anonyPeerUdid); + ConvertToAnonymousStr(peerAuthId, &anonyPeerAuthId); + LOGE("[PrintErrorInputInfo] [peerUdid]: %s", ((anonyPeerUdid == NULL) ? "NULL" : anonyPeerUdid)); + LOGE("[PrintErrorInputInfo] [peerAuthId]: %s", ((anonyPeerAuthId == NULL) ? "NULL" : anonyPeerAuthId)); + HcFree(anonyPeerUdid); + HcFree(anonyPeerAuthId); +} + static int32_t ProcessClientAuthSession(Session *session, CJson *in) { LOGI("Begin process client authSession."); @@ -141,15 +156,16 @@ static int32_t ProcessClientAuthSession(Session *session, CJson *in) return res; } -static Session *CreateClientAuthSessionInner(CJson *param, const DeviceAuthCallback *callback) +static Session *CreateClientAuthSessionInner(int32_t osAccountId, CJson *param, const DeviceAuthCallback *callback) { ParamsVec authParamsVec; CreateAuthParamsVec(&authParamsVec); - int32_t res = GetAuthParamsList(param, &authParamsVec); + int32_t res = GetAuthParamsList(osAccountId, param, &authParamsVec); if ((res != HC_SUCCESS) || (authParamsVec.size(&authParamsVec) == 0)) { LOGE("Failed to get auth param list, candidate group = %u!", authParamsVec.size(&authParamsVec)); DestroyAuthParamsVec(&authParamsVec); InformLocalAuthError(param, callback); + PrintErrorInputInfo(param); return NULL; } @@ -195,7 +211,13 @@ Session *CreateClientAuthSession(CJson *param, const DeviceAuthCallback *callbac InformLocalAuthError(param, callback); return NULL; } - session = CreateClientAuthSessionInner(param, callback); + int32_t osAccountId = INVALID_OS_ACCOUNT; + if (GetIntFromJson(param, FIELD_OS_ACCOUNT_ID, &osAccountId) != HC_SUCCESS) { + LOGE("Failed to get osAccountId for create client session!"); + InformLocalAuthError(param, callback); + return NULL; + } + session = CreateClientAuthSessionInner(osAccountId, param, callback); if (session == NULL) { LOGE("Failed to create client auth session!"); return NULL; diff --git a/services/group_auth/src/session/auth_session/auth_session_common.c b/services/group_auth/src/session/auth_session/auth_session_common.c index 33b073c..188c042 100644 --- a/services/group_auth/src/session/auth_session/auth_session_common.c +++ b/services/group_auth/src/session/auth_session/auth_session_common.c @@ -20,8 +20,10 @@ #include "auth_session_util.h" #include "common_defs.h" #include "string_util.h" -#include "database_manager.h" +#include "data_manager.h" #include "dev_auth_module_manager.h" +#include "group_auth_data_operation.h" +#include "hc_dev_info.h" #include "hc_log.h" #include "json_utils.h" @@ -83,40 +85,16 @@ static int32_t UnifyOldFormatParams(const CJson *param, ParamsVec *paramsVec) return res; } -static bool IsGroupAvailable(const char *groupId, const char *pkgName) +static bool IsGroupAvailable(int32_t osAccountId, const char *groupId, const char *pkgName) { - if (IsGroupAccessible(groupId, pkgName)) { + if (GaIsGroupAccessible(osAccountId, groupId, pkgName)) { return true; } - LOGD("%s don't have enough right for group: %s!", pkgName, groupId); + LOGD("%s don't have enough right in group: %s, os account:%d!", pkgName, groupId, osAccountId); return false; } -static int32_t GroupTypeToAuthForm(int32_t groupType) -{ - int32_t authForm; - switch (groupType) { - case PEER_TO_PEER_GROUP: - authForm = AUTH_FORM_ACCOUNT_UNRELATED; - break; - case COMPATIBLE_GROUP: - authForm = AUTH_FORM_ACCOUNT_UNRELATED; - break; - case IDENTICAL_ACCOUNT_GROUP: - authForm = AUTH_FORM_IDENTICAL_ACCOUNT; - break; - case ACROSS_ACCOUNT_AUTHORIZE_GROUP: - authForm = AUTH_FORM_ACROSS_ACCOUNT; - break; - default: - LOGE("Invalid group type!"); - authForm = AUTH_FORM_INVALID_TYPE; - break; - } - return authForm; -} - -static int32_t AddGeneralParams(const char *groupId, int32_t groupType, const DeviceInfo *localAuthInfo, +static int32_t AddGeneralParams(const char *groupId, int32_t groupType, const TrustedDeviceEntry *localAuthInfo, CJson *paramsData) { int32_t authForm = GroupTypeToAuthForm(groupType); @@ -141,25 +119,34 @@ static int32_t AddGeneralParams(const char *groupId, int32_t groupType, const De return HC_SUCCESS; } -static int32_t GetLocalDeviceInfoFromDatabase(const char *groupId, DeviceInfo *localAuthInfo) +static int32_t GetLocalDeviceInfoFromDatabase(int32_t osAccountId, const char *groupId, + TrustedDeviceEntry *localAuthInfo) { - int32_t res; - const char *localUdidStr = GetLocalDevUdid(); - if (localUdidStr == NULL) { - LOGE("Failed to get local udid!"); - return HC_ERR_DB; + char *localUdid = (char *)HcMalloc(INPUT_UDID_LEN, 0); + if (localUdid == NULL) { + LOGE("Failed to malloc for local udid!"); + return HC_ERR_ALLOC_MEMORY; } - res = GetTrustedDevInfoById(localUdidStr, true, groupId, localAuthInfo); + int32_t res = HcGetUdid((uint8_t *)localUdid, INPUT_UDID_LEN); + if (res != HC_SUCCESS) { + LOGE("[DB]: Failed to get local udid! res: %d", res); + HcFree(localUdid); + return res; + } + + res = GaGetTrustedDeviceEntryById(osAccountId, localUdid, true, groupId, localAuthInfo); + HcFree(localUdid); if (res != HC_SUCCESS) { LOGE("Failed to get local device info from database!"); } return res; } -static int32_t ExtractAndAddParams(const char *groupId, const GroupInfo *groupInfo, CJson *paramsData) +static int32_t ExtractAndAddParams(int32_t osAccountId, const char *groupId, + const TrustedGroupEntry *groupInfo, CJson *paramsData) { int32_t res; - DeviceInfo *localAuthInfo = CreateDeviceInfoStruct(); + TrustedDeviceEntry *localAuthInfo = CreateDeviceEntry(); if (localAuthInfo == NULL) { LOGE("Failed to allocate memory for localAuthInfo!"); return HC_ERR_ALLOC_MEMORY; @@ -167,7 +154,7 @@ static int32_t ExtractAndAddParams(const char *groupId, const GroupInfo *groupIn int32_t groupType = groupInfo->type; int32_t authForm = GroupTypeToAuthForm(groupType); do { - res = GetLocalDeviceInfoFromDatabase(groupId, localAuthInfo); + res = GetLocalDeviceInfoFromDatabase(osAccountId, groupId, localAuthInfo); if (res != HC_SUCCESS) { break; } @@ -181,35 +168,41 @@ static int32_t ExtractAndAddParams(const char *groupId, const GroupInfo *groupIn LOGE("Failed to get group auth handle!"); break; } - res = groupAuth->fillDeviceAuthInfo(groupInfo, localAuthInfo, paramsData); + res = groupAuth->fillDeviceAuthInfo(osAccountId, groupInfo, localAuthInfo, paramsData); if (res != HC_SUCCESS) { LOGE("Failed to fill device auth info!"); break; } } while (0); - DestroyDeviceInfoStruct(localAuthInfo); + DestroyDeviceEntry(localAuthInfo); return res; } -static int32_t FillAuthParams(const CJson *param, const GroupInfoVec *vec, ParamsVec *paramsVec) +static int32_t FillAuthParams(int32_t osAccountId, const CJson *param, + const GroupEntryVec *vec, ParamsVec *paramsVec) { + const char *peerUdid = GetStringFromJson(param, FIELD_PEER_CONN_DEVICE_ID); + const char *peerAuthId = GetStringFromJson(param, FIELD_PEER_AUTH_ID); const char *pkgName = GetStringFromJson(param, FIELD_SERVICE_PKG_NAME); if (pkgName == NULL) { LOGE("Pkg name is null, can't extract params from db!"); return HC_ERR_NULL_PTR; } uint32_t index; - void **ptr = NULL; + TrustedGroupEntry **ptr = NULL; FOR_EACH_HC_VECTOR(*vec, index, ptr) { if ((ptr == NULL) || (*ptr == NULL)) { continue; } - const GroupInfo *groupInfo = (GroupInfo *)(*ptr); + const TrustedGroupEntry *groupInfo = (TrustedGroupEntry *)(*ptr); const char *groupId = StringGet(&(groupInfo->id)); if (groupId == NULL) { continue; } - if (!IsGroupAvailable(groupId, pkgName)) { + if (!IsGroupAvailable(osAccountId, groupId, pkgName)) { + continue; + } + if (!GaIsDeviceInGroup(groupInfo->type, osAccountId, peerUdid, peerAuthId, groupId)) { continue; } CJson *paramsData = DuplicateJson(param); @@ -217,7 +210,7 @@ static int32_t FillAuthParams(const CJson *param, const GroupInfoVec *vec, Param LOGE("Failed to duplicate auth param data!"); return HC_ERR_JSON_FAIL; } - int32_t res = ExtractAndAddParams(groupId, groupInfo, paramsData); + int32_t res = ExtractAndAddParams(osAccountId, groupId, groupInfo, paramsData); if (res != HC_SUCCESS) { LOGE("Failed to extract and add param!"); FreeJson(paramsData); @@ -228,73 +221,25 @@ static int32_t FillAuthParams(const CJson *param, const GroupInfoVec *vec, Param return HC_SUCCESS; } -static void GetCandidateGroupByOrder(const CJson *param, GroupQueryParams *queryParams, GroupInfoVec *vec) +static void GetCandidateGroupByOrder(int32_t osAccountId, const CJson *param, + QueryGroupParams *queryParams, GroupEntryVec *vec) { BaseGroupAuth *groupAuth = GetGroupAuth(ACCOUNT_RELATED_GROUP_AUTH_TYPE); if (groupAuth != NULL) { AccountRelatedGroupAuth *realGroupAuth = (AccountRelatedGroupAuth *)groupAuth; realGroupAuth->getAccountCandidateGroup(param, queryParams, vec); } - queryParams->type = PEER_TO_PEER_GROUP; - if (GetJoinedGroupInfoVecByDevId(queryParams, vec) != HC_SUCCESS) { + queryParams->groupType = PEER_TO_PEER_GROUP; + if (QueryGroups(osAccountId, queryParams, vec) != HC_SUCCESS) { LOGD("No peer to peer group in db."); } - queryParams->type = COMPATIBLE_GROUP; - if (GetJoinedGroupInfoVecByDevId(queryParams, vec) != HC_SUCCESS) { + queryParams->groupType = COMPATIBLE_GROUP; + if (QueryGroups(osAccountId, queryParams, vec) != HC_SUCCESS) { LOGD("No compatible group in db."); } } -static int32_t InitGroupQueryParams(const char *peerUdid, const char *peerAuthId, GroupQueryParams *queryParams) -{ - uint32_t peerUdidLen = HcStrlen(peerUdid) + 1; - uint32_t peerAuthIdLen = HcStrlen(peerAuthId) + 1; - queryParams->type = ALL_GROUP; - queryParams->visibility = ALL_GROUP_VISIBILITY; - queryParams->udid = NULL; - queryParams->authId = NULL; - if (peerUdid != NULL) { - queryParams->udid = (char *)HcMalloc(peerUdidLen, 0); - if (queryParams->udid == NULL) { - LOGE("Failed to allocate memory for queryParams of udid!"); - return HC_ERR_ALLOC_MEMORY; - } - if (strcpy_s(queryParams->udid, peerUdidLen, peerUdid) != EOK) { - LOGE("Failed to copy udid for queryParams!"); - HcFree(queryParams->udid); - queryParams->udid = NULL; - return HC_ERR_MEMORY_COPY; - } - } else if (peerAuthId != NULL) { - queryParams->authId = (char *)HcMalloc(peerAuthIdLen, 0); - if (queryParams->authId == NULL) { - LOGE("Failed to allocate memory for queryParams of authId!"); - return HC_ERR_ALLOC_MEMORY; - } - if (strcpy_s(queryParams->authId, peerAuthIdLen, peerAuthId) != EOK) { - LOGE("Failed to copy authId for queryParams!"); - HcFree(queryParams->authId); - queryParams->authId = NULL; - return HC_ERR_MEMORY_COPY; - } - } - return HC_SUCCESS; -} - -static void DestroyGroupQueryParams(GroupQueryParams *queryParams) -{ - if (queryParams->udid != NULL) { - HcFree(queryParams->udid); - queryParams->udid = NULL; - } - if (queryParams->authId != NULL) { - HcFree(queryParams->authId); - queryParams->authId = NULL; - } -} - -static void GetCandidateGroupInfo(const CJson *param, const char *peerUdid, - const char *peerAuthId, GroupInfoVec *vec) +static void GetCandidateGroupInfo(int32_t osAccountId, const CJson *param, GroupEntryVec *vec) { LOGI("No input of groupId, extract group info without groupId."); bool deviceLevelFlag = false; @@ -304,40 +249,27 @@ static void GetCandidateGroupInfo(const CJson *param, const char *peerUdid, LOGE("Failed to get the value: isClient!"); return; } - GroupQueryParams queryParams = { 0 }; - if (InitGroupQueryParams(peerUdid, peerAuthId, &queryParams) != HC_SUCCESS) { - LOGE("Failed to init group query params!"); - return; - } + QueryGroupParams queryParams = InitQueryGroupParams(); if (deviceLevelFlag && isClient) { LOGI("Try to get device-level candidate groups for auth."); } else { - queryParams.visibility = GROUP_VISIBILITY_PUBLIC; + queryParams.groupVisibility = GROUP_VISIBILITY_PUBLIC; } - GetCandidateGroupByOrder(param, &queryParams, vec); - DestroyGroupQueryParams(&queryParams); + GetCandidateGroupByOrder(osAccountId, param, &queryParams, vec); } -static void GetGroupInfoByGroupId(const char *groupId, const char *peerUdid, const char *peerAuthId, GroupInfoVec *vec) +static void GetGroupInfoByGroupId(int32_t osAccountId, const char *groupId, + GroupEntryVec *groupEntryVec) { - GroupInfo *entry = CreateGroupInfoStruct(); - if (entry == NULL) { - LOGE("Failed to create entry struct!"); + if (groupId == NULL) { + LOGE("GroupId is null!"); return; } - int32_t res = HC_SUCCESS; - if (peerUdid != NULL) { - res = GetGroupInfoIfDevExist(groupId, peerUdid, entry); - } else { - if (IsTrustedDeviceInGroup(groupId, peerAuthId, false)) { - res = GetGroupInfoById(groupId, entry); - } - } - if (res == HC_SUCCESS) { - vec->pushBackT(vec, (void *)entry); - } else { - LOGE("Failed to get group entry!"); - DestroyGroupInfoStruct(entry); + QueryGroupParams queryParams = InitQueryGroupParams(); + queryParams.groupId = groupId; + if (QueryGroups(osAccountId, &queryParams, groupEntryVec) != HC_SUCCESS) { + LOGE("Failed to query groups for groupId %s!", groupId); + return; } } @@ -357,36 +289,22 @@ static int32_t GetBleGroupInfoAndAuthParams(const CJson *param, ParamsVec *param return HC_SUCCESS; } -static int32_t GetCandidateAuthInfo(const char *groupId, const CJson *param, ParamsVec *authParamsVec) +static int32_t GetCandidateAuthInfo(int32_t osAccountId, const char *groupId, + const CJson *param, ParamsVec *authParamsVec) { - const char *peerUdid = GetStringFromJson(param, FIELD_PEER_CONN_DEVICE_ID); - const char *peerAuthId = GetStringFromJson(param, FIELD_PEER_AUTH_ID); - GroupInfoVec vec; - CreateGroupInfoVecStruct(&vec); + GroupEntryVec vec = CreateGroupEntryVec(); if (groupId == NULL) { - GetCandidateGroupInfo(param, peerUdid, peerAuthId, &vec); + GetCandidateGroupInfo(osAccountId, param, &vec); } else { - GetGroupInfoByGroupId(groupId, peerUdid, peerAuthId, &vec); + GetGroupInfoByGroupId(osAccountId, groupId, &vec); } if (vec.size(&vec) == 0) { LOGE("No satisfied candidate group!"); - DestroyGroupInfoVecStruct(&vec); - char *anonyPeerUdid = NULL; - char *anonyPeerAuthId = NULL; - ConvertToAnonymousStr(peerUdid, &anonyPeerUdid); - ConvertToAnonymousStr(peerAuthId, &anonyPeerAuthId); - LOGE("[GetCandidateAuthInfo] [peerUdid]: %s", ((anonyPeerUdid == NULL) ? "NULL" : anonyPeerUdid)); - LOGE("[GetCandidateAuthInfo] [peerAuthId]: %s", ((anonyPeerAuthId == NULL) ? "NULL" : anonyPeerAuthId)); - HcFree(anonyPeerUdid); - HcFree(anonyPeerAuthId); - if (peerUdid != NULL) { - LOGE("[GetCandidateAuthInfo] peerUdid-IsTrustedDeviceExist = %s", - (IsTrustedDeviceExist(peerUdid) == true) ? "true" : "false"); - } + ClearGroupEntryVec(&vec); return HC_ERR_NO_CANDIDATE_GROUP; } - int32_t res = FillAuthParams(param, &vec, authParamsVec); - DestroyGroupInfoVecStruct(&vec); + int32_t res = FillAuthParams(osAccountId, param, &vec, authParamsVec); + ClearGroupEntryVec(&vec); return res; } @@ -471,7 +389,7 @@ static int32_t ReturnTransmitData(const AuthSession *session, CJson *out) return ret; } -int32_t GetAuthParamsList(const CJson *param, ParamsVec *authParamsVec) +int32_t GetAuthParamsList(int32_t osAccountId, const CJson *param, ParamsVec *authParamsVec) { int32_t ret; const char *groupId = GetStringFromJson(param, FIELD_GROUP_ID); @@ -485,7 +403,7 @@ int32_t GetAuthParamsList(const CJson *param, ParamsVec *authParamsVec) LOGD("This is across-account auth for ble device."); ret = GetBleGroupInfoAndAuthParams(param, authParamsVec); } else { - ret = GetCandidateAuthInfo(groupId, param, authParamsVec); + ret = GetCandidateAuthInfo(osAccountId, groupId, param, authParamsVec); } return ret; } @@ -921,17 +839,17 @@ void DestroyAuthSession(Session *session) FreeJson((CJson *)*paramsData); } } - DESTROY_HC_VECTOR(ParamsVec, &(realSession->paramsList)) + DESTROY_HC_VECTOR(ParamsVec, &(realSession->paramsList)); HcFree(realSession); realSession = NULL; } void CreateAuthParamsVec(ParamsVec *vec) { - *vec = CREATE_HC_VECTOR(ParamsVec) + *vec = CREATE_HC_VECTOR(ParamsVec); } void DestroyAuthParamsVec(ParamsVec *vec) { - DESTROY_HC_VECTOR(ParamsVec, vec) + DESTROY_HC_VECTOR(ParamsVec, vec); } diff --git a/services/group_auth/src/session/auth_session/auth_session_server.c b/services/group_auth/src/session/auth_session/auth_session_server.c index 67ca156..1ba4adc 100644 --- a/services/group_auth/src/session/auth_session/auth_session_server.c +++ b/services/group_auth/src/session/auth_session/auth_session_server.c @@ -23,6 +23,7 @@ #include "device_auth_defines.h" #include "hc_log.h" #include "hc_types.h" +#include "os_account_adapter.h" #include "session_common.h" static int32_t ProcessServerAuthSession(Session *session, CJson *in); @@ -34,6 +35,16 @@ static int32_t CombineServerParams(const CJson *confirmationJson, CJson *dataFro LOGE("Failed to get auth form in data sent by client for the first time!"); return HC_ERR_JSON_GET; } + int32_t osAccountId = ANY_OS_ACCOUNT; + (void)GetIntFromJson(confirmationJson, FIELD_OS_ACCOUNT_ID, &osAccountId); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if (osAccountId == INVALID_OS_ACCOUNT) { + return HC_ERR_INVALID_PARAMS; + } + if (AddIntToJson(dataFromClient, FIELD_OS_ACCOUNT_ID, osAccountId) != HC_SUCCESS) { + LOGE("Failed to add os accountId for server in onRequest confirm!"); + return HC_ERR_JSON_ADD; + } int32_t groupAuthType = GetGroupAuthType(authForm); BaseGroupAuth *groupAuthHandle = GetGroupAuth(groupAuthType); if (groupAuthHandle == NULL) { diff --git a/services/group_auth/src/session/auth_session/auth_session_util.c b/services/group_auth/src/session/auth_session/auth_session_util.c index 0e598d3..3122111 100644 --- a/services/group_auth/src/session/auth_session/auth_session_util.c +++ b/services/group_auth/src/session/auth_session/auth_session_util.c @@ -112,4 +112,28 @@ int32_t GetInfoHash(const uint8_t *info, uint32_t infoLen, char *str, uint32_t s HcFree(infoHash.val); infoHash.val = NULL; return res; +} + +int32_t GroupTypeToAuthForm(int32_t groupType) +{ + int32_t authForm; + switch (groupType) { + case PEER_TO_PEER_GROUP: + authForm = AUTH_FORM_ACCOUNT_UNRELATED; + break; + case COMPATIBLE_GROUP: + authForm = AUTH_FORM_ACCOUNT_UNRELATED; + break; + case IDENTICAL_ACCOUNT_GROUP: + authForm = AUTH_FORM_IDENTICAL_ACCOUNT; + break; + case ACROSS_ACCOUNT_AUTHORIZE_GROUP: + authForm = AUTH_FORM_ACROSS_ACCOUNT; + break; + default: + LOGE("Invalid group type!"); + authForm = AUTH_FORM_INVALID_TYPE; + break; + } + return authForm; } \ No newline at end of file diff --git a/services/group_manager/inc/base_group.h b/services/group_manager/inc/base_group.h index 333fca5..a76ef1c 100644 --- a/services/group_manager/inc/base_group.h +++ b/services/group_manager/inc/base_group.h @@ -21,8 +21,8 @@ typedef struct { int type; - int32_t (*createGroup)(CJson *jsonParams, char **returnJsonStr); - int32_t (*deleteGroup)(CJson *jsonParams, char **returnJsonStr); + int32_t (*createGroup)(int32_t osAccountId, CJson *jsonParams, char **returnJsonStr); + int32_t (*deleteGroup)(int32_t osAccountId, CJson *jsonParams, char **returnJsonStr); } BaseGroup; #endif diff --git a/services/group_manager/inc/base_group_manager_task.h b/services/group_manager/inc/base_group_manager_task.h index c277801..5edbb7c 100644 --- a/services/group_manager/inc/base_group_manager_task.h +++ b/services/group_manager/inc/base_group_manager_task.h @@ -23,9 +23,18 @@ typedef struct { HcTaskBase base; int64_t reqId; + int32_t osAccountId; int32_t opCode; CJson *params; const DeviceAuthCallback *cb; } GroupManagerTask; +typedef struct { + int64_t reqId; + int32_t osAccountId; + int32_t opCode; + CJson *params; + const DeviceAuthCallback *cb; +} GMTaskParams; + #endif diff --git a/services/group_manager/inc/broadcast_manager/broadcast_manager.h b/services/group_manager/inc/broadcast_manager/broadcast_manager.h index 9492f86..cf47887 100644 --- a/services/group_manager/inc/broadcast_manager/broadcast_manager.h +++ b/services/group_manager/inc/broadcast_manager/broadcast_manager.h @@ -16,7 +16,7 @@ #ifndef BROADCAST_MANAGER_H #define BROADCAST_MANAGER_H -#include "database.h" +#include "data_manager.h" #include "device_auth.h" #ifdef __cplusplus @@ -24,10 +24,10 @@ extern "C" { #endif typedef struct { - void (*postOnGroupCreated)(const GroupInfo *groupInfo); - void (*postOnGroupDeleted)(const GroupInfo *groupInfo); - void (*postOnDeviceBound)(const char *peerUdid, const GroupInfo *groupInfo); - void (*postOnDeviceUnBound)(const char *peerUdid, const GroupInfo *groupInfo); + void (*postOnGroupCreated)(const TrustedGroupEntry *groupEntry); + void (*postOnGroupDeleted)(const TrustedGroupEntry *groupEntry); + void (*postOnDeviceBound)(const char *peerUdid, const TrustedGroupEntry *groupEntry); + void (*postOnDeviceUnBound)(const char *peerUdid, const TrustedGroupEntry *groupEntry); void (*postOnDeviceNotTrusted)(const char *peerUdid); void (*postOnLastGroupDeleted)(const char *peerUdid, int groupType); void (*postOnTrustedDeviceNumChanged)(int curTrustedDeviceNum); diff --git a/services/group_manager/inc/group_manager.h b/services/group_manager/inc/group_manager.h index d1290f0..94ba799 100644 --- a/services/group_manager/inc/group_manager.h +++ b/services/group_manager/inc/group_manager.h @@ -26,34 +26,43 @@ extern "C" { int32_t InitGroupManager(void); void DestroyGroupManager(void); -int32_t CreateGroupImpl(int64_t requestId, const char *appId, const char *createParams); -int32_t DeleteGroupImpl(int64_t requestId, const char *appId, const char *disbandParams); -int32_t AddMemberToGroupImpl(int64_t requestId, const char *appId, const char *addParams); -int32_t DeleteMemberFromGroupImpl(int64_t requestId, const char *appId, const char *deleteParams); +int32_t CreateGroupImpl(int32_t osAccountId, int64_t requestId, const char *appId, const char *createParams); +int32_t DeleteGroupImpl(int32_t osAccountId, int64_t requestId, const char *appId, const char *disbandParams); +int32_t AddMemberToGroupImpl(int32_t osAccountId, int64_t requestId, const char *appId, const char *addParams); +int32_t DeleteMemberFromGroupImpl(int32_t osAccountId, int64_t requestId, const char *appId, const char *deleteParams); int32_t ProcessBindDataImpl(int64_t requestId, const uint8_t *data, uint32_t dataLen); -int32_t ConfirmRequestImpl(int64_t requestId, const char *appId, const char *confirmParams); +int32_t ConfirmRequestImpl(int32_t osAccountId, int64_t requestId, const char *appId, const char *confirmParams); int32_t GenerateAccountGroupIdImpl(int32_t groupType, const char *userIdHash, const char *sharedUserIdHash, char **returnGroupId); int32_t SyncAcrossAccountGroupImpl(const char *appId, const char *userIdHash, const char *deviceId, const CJson *sharedUserIdHashList); -int32_t AddGroupManagerImpl(const char *appId, const char *groupId, const char *managerAppId); -int32_t AddGroupFriendImpl(const char *appId, const char *groupId, const char *friendAppId); -int32_t DeleteGroupManagerImpl(const char *appId, const char *groupId, const char *managerAppId); -int32_t DeleteGroupFriendImpl(const char *appId, const char *groupId, const char *friendAppId); -int32_t GetGroupManagersImpl(const char *appId, const char *groupId, char **returnManagers, uint32_t *returnSize); -int32_t GetGroupFriendsImpl(const char *appId, const char *groupId, char **returnFriends, uint32_t *returnSize); +int32_t AddGroupManagerImpl(int32_t osAccountId, const char *appId, const char *groupId, const char *managerAppId); +int32_t AddGroupFriendImpl(int32_t osAccountId, const char *appId, const char *groupId, const char *friendAppId); +int32_t DeleteGroupManagerImpl(int32_t osAccountId, const char *appId, const char *groupId, const char *managerAppId); +int32_t DeleteGroupFriendImpl(int32_t osAccountId, const char *appId, const char *groupId, const char *friendAppId); +int32_t GetGroupManagersImpl(int32_t osAccountId, const char *appId, const char *groupId, + char **returnManagers, uint32_t *returnSize); +int32_t GetGroupFriendsImpl(int32_t osAccountId, const char *appId, const char *groupId, + char **returnFriends, uint32_t *returnSize); int32_t RegListenerImpl(const char *appId, const DataChangeListener *listener); int32_t UnRegListenerImpl(const char *appId); -int32_t CheckAccessToGroupImpl(const char *appId, const char *groupId); -int32_t GetGroupInfoByIdImpl(const char *appId, const char *groupId, char **returnGroupInfo); -int32_t GetGroupInfoImpl(const char *appId, const char *queryParams, char **returnGroupVec, uint32_t *groupNum); -int32_t GetJoinedGroupsImpl(const char *appId, int groupType, char **returnGroupVec, uint32_t *groupNum); -int32_t GetRelatedGroupsImpl(const char *appId, const char *peerDeviceId, char **returnGroupVec, uint32_t *groupNum); -int32_t GetDeviceInfoByIdImpl(const char *appId, const char *deviceId, const char *groupId, char **returnDeviceInfo); -int32_t GetTrustedDevicesImpl(const char *appId, const char *groupId, char **returnDevInfoVec, uint32_t *deviceNum); -bool IsDeviceInGroupImpl(const char *appId, const char *groupId, const char *deviceId); +int32_t CheckAccessToGroupImpl(int32_t osAccountId, const char *appId, const char *groupId); +int32_t GetGroupInfoByIdImpl(int32_t osAccountId, const char *appId, const char *groupId, char **returnGroupInfo); +int32_t GetGroupInfoImpl(int32_t osAccountId, const char *appId, const char *queryParams, + char **returnGroupVec, uint32_t *groupNum); +int32_t GetJoinedGroupsImpl(int32_t osAccountId, const char *appId, int groupType, + char **returnGroupVec, uint32_t *groupNum); +int32_t GetRelatedGroupsImpl(int32_t osAccountId, const char *appId, const char *peerDeviceId, + char **returnGroupVec, uint32_t *groupNum); +int32_t GetDeviceInfoByIdImpl(int32_t osAccountId, const char *appId, const char *deviceId, const char *groupId, + char **returnDeviceInfo); +int32_t GetTrustedDevicesImpl(int32_t osAccountId, const char *appId, const char *groupId, + char **returnDevInfoVec, uint32_t *deviceNum); +bool IsDeviceInGroupImpl(int32_t osAccountId, const char *appId, const char *groupId, const char *deviceId); +int32_t GetPkInfoListImpl(int32_t osAccountId, const char *appId, const char *queryParams, + char **returnInfoList, uint32_t *returnInfoNum); void DestroyInfoImpl(char **returnInfo); int32_t BindPeerImpl(int64_t requestId, const char *appId, const char *bindParams); diff --git a/services/group_manager/inc/group_manager_common.h b/services/group_manager/inc/group_manager_common.h index 4873609..3e7a10d 100644 --- a/services/group_manager/inc/group_manager_common.h +++ b/services/group_manager/inc/group_manager_common.h @@ -29,7 +29,7 @@ void DestroyGroupManagerTask(HcTaskBase *task); int32_t BindCallbackToTask(GroupManagerTask *task, const CJson *jsonParams); int32_t AddReqInfoToJson(int64_t requestId, const char *appId, CJson *jsonParams); int32_t AddBindParamsToJson(int operationCode, int64_t requestId, const char *appId, CJson *jsonParams); -int32_t InitAndPushGMTask(int32_t opCode, int64_t reqId, CJson *params, TaskFunc func); +int32_t InitAndPushGMTask(int32_t osAccountId, int32_t opCode, int64_t reqId, CJson *params, TaskFunc func); #ifdef __cplusplus } diff --git a/services/group_manager/inc/group_operation.h b/services/group_manager/inc/group_operation.h index 0e78b2e..500ab29 100644 --- a/services/group_manager/inc/group_operation.h +++ b/services/group_manager/inc/group_operation.h @@ -24,34 +24,41 @@ extern "C" { #endif typedef struct { - int32_t (*createGroup)(int64_t requestId, const char *appId, const char *createParams); - int32_t (*deleteGroup)(int64_t requestId, const char *appId, const char *disbandParams); - int32_t (*addMember)(int64_t requestId, const char *appId, const char *addParams); - int32_t (*deleteMember)(int64_t requestId, const char *appId, const char *deleteParams); + int32_t (*createGroup)(int32_t osAccountId, int64_t requestId, const char *appId, const char *createParams); + int32_t (*deleteGroup)(int32_t osAccountId, int64_t requestId, const char *appId, const char *disbandParams); + int32_t (*addMember)(int32_t osAccountId, int64_t requestId, const char *appId, const char *addParams); + int32_t (*deleteMember)(int32_t osAccountId, int64_t requestId, const char *appId, const char *deleteParams); int32_t (*processBindData)(int64_t requestId, const uint8_t *data, uint32_t dataLen); - int32_t (*confirmRequest)(int64_t requestId, const char *appId, const char *confirmParams); + int32_t (*confirmRequest)(int32_t osAccountId, int64_t requestId, const char *appId, const char *confirmParams); int32_t (*generateAccountGroupId)(int32_t groupType, const char *userIdHash, const char *sharedUserIdHash, char **returnGroupId); int32_t (*syncAcrossAccountGroup)(const char *appId, const char *userIdHash, const char *deviceId, const CJson *sharedUserIdHashList); - int32_t (*addGroupRole)(bool isManager, const char *appId, const char *groupId, const char *roleAppId); - int32_t (*deleteGroupRole)(bool isManager, const char *appId, const char *groupId, const char *roleAppId); - int32_t (*getGroupRoles)(bool isManager, const char *appId, const char *groupId, char **returnJsonStr, - uint32_t *returnSize); + int32_t (*addGroupRole)(int32_t osAccountId, bool isManager, const char *appId, const char *groupId, + const char *roleAppId); + int32_t (*deleteGroupRole)(int32_t osAccountId, bool isManager, const char *appId, const char *groupId, + const char *roleAppId); + int32_t (*getGroupRoles)(int32_t osAccuntId, bool isManager, const char *appId, const char *groupId, + char **returnJsonStr, uint32_t *returnSize); int32_t (*regListener)(const char *appId, const DataChangeListener *listener); int32_t (*unRegListener)(const char *appId); - int32_t (*checkAccessToGroup)(const char *appId, const char *groupId); - int32_t (*getAccessibleGroupInfoById)(const char *appId, const char *groupId, char **returnGroupInfo); - int32_t (*getAccessibleGroupInfo)(const char *appId, const char *queryParams, char **returnGroupVec, - uint32_t *groupNum); - int32_t (*getAccessibleJoinedGroups)(const char *appId, int groupType, char **returnGroupVec, uint32_t *groupNum); - int32_t (*getAccessibleRelatedGroups)(const char *appId, const char *peerDeviceId, bool isUdid, + int32_t (*checkAccessToGroup)(int32_t osAccountId, const char *appId, const char *groupId); + int32_t (*getAccessibleGroupInfoById)(int32_t osAccountId, const char *appId, const char *groupId, + char **returnGroupInfo); + int32_t (*getAccessibleGroupInfo)(int32_t osAccountId, const char *appId, const char *queryParams, char **returnGroupVec, uint32_t *groupNum); - int32_t (*getAccessibleDeviceInfoById)(const char *appId, const char *deviceId, bool isUdid, + int32_t (*getAccessibleJoinedGroups)(int32_t osAccountId, const char *appId, int groupType, + char **returnGroupVec, uint32_t *groupNum); + int32_t (*getAccessibleRelatedGroups)(int32_t osAccountId, const char *appId, const char *peerDeviceId, bool isUdid, + char **returnGroupVec, uint32_t *groupNum); + int32_t (*getAccessibleDeviceInfoById)(int32_t osAccountId, const char *appId, const char *deviceId, bool isUdid, const char *groupId, char **returnDeviceInfo); - int32_t (*getAccessibleTrustedDevices)(const char *appId, const char *groupId, + int32_t (*getAccessibleTrustedDevices)(int32_t osAccountId, const char *appId, const char *groupId, char **returnDevInfoVec, uint32_t *deviceNum); - bool (*isDeviceInAccessibleGroup)(const char *appId, const char *groupId, const char *deviceId, bool isUdid); + bool (*isDeviceInAccessibleGroup)(int32_t osAccountId, const char *appId, const char *groupId, + const char *deviceId, bool isUdid); + int32_t (*getPkInfoList)(int32_t osAccountId, const char *appId, const char *queryParams, char **returnInfoList, + uint32_t *returnInfoNum); void (*destroyInfo)(char **returnInfo); } GroupImpl; diff --git a/services/group_manager/inc/group_operation_common.h b/services/group_manager/inc/group_operation_common.h index f926337..392f3c0 100644 --- a/services/group_manager/inc/group_operation_common.h +++ b/services/group_manager/inc/group_operation_common.h @@ -17,7 +17,7 @@ #define GROUP_OPERATION_COMMON_H #include "string_util.h" -#include "database.h" +#include "data_manager.h" #include "json_utils.h" #ifdef __cplusplus @@ -25,8 +25,8 @@ extern "C" { #endif bool IsAccountRelatedGroup(int groupType); -int32_t GenerateReturnGroupInfo(const GroupInfo *groupInfo, CJson *returnJson); -int32_t GenerateReturnDevInfo(const DeviceInfo *devInfo, CJson *returnJson); +int32_t GenerateReturnGroupInfo(const TrustedGroupEntry *groupInfo, CJson *returnJson); +int32_t GenerateReturnDevInfo(const TrustedDeviceEntry *devInfo, CJson *returnJson); bool IsUserTypeValid(int userType); bool IsExpireTimeValid(int expireTime); @@ -36,46 +36,64 @@ int32_t ProcessKeyPair(int action, const CJson *jsonParams, const char *groupId) int32_t GetHashMessage(const Uint8Buff *first, const Uint8Buff *second, uint8_t **hashMessage, uint32_t *messageSize); int32_t AssertUserIdHashExist(const CJson *jsonParams); -int32_t CheckGroupExist(const char *groupId); -int32_t CheckGroupNumLimit(int32_t groupType, const char *appId); -int32_t CheckDeviceNumLimit(const char *groupId, const char *peerUdid); +int32_t CheckGroupExist(int32_t osAccountId, const char *groupId); +int32_t CheckGroupNumLimit(int32_t osAccountId, int32_t groupType, const char *appId); +int32_t CheckDeviceNumLimit(int32_t osAccountId, const char *groupId, const char *peerUdid); int32_t CheckUserTypeIfExist(const CJson *jsonParams); int32_t CheckGroupVisibilityIfExist(const CJson *jsonParams); int32_t CheckExpireTimeIfExist(const CJson *jsonParams); -int32_t CheckPermForGroup(int actionType, const char *callerPkgName, const char *groupId); +int32_t CheckPermForGroup(int32_t osAccountId, int actionType, const char *callerPkgName, const char *groupId); -int32_t AddGroupNameToParams(const char *groupName, GroupInfo *groupParams); -int32_t AddGroupIdToParams(const char *groupId, GroupInfo *groupParams); -int32_t AddGroupOwnerToParams(const char *owner, GroupInfo *groupParams); -int32_t AddGroupTypeToParams(int groupType, GroupInfo *groupParams); -int32_t AddGroupVisibilityOrDefault(const CJson *jsonParams, GroupInfo *groupParams); -int32_t AddExpireTimeOrDefault(const CJson *jsonParams, GroupInfo *groupParams); -int32_t AddUserIdHashToGroupParams(const CJson *jsonParams, GroupInfo *groupParams); +int32_t AddGroupNameToParams(const char *groupName, TrustedGroupEntry *groupParams); +int32_t AddGroupIdToParams(const char *groupId, TrustedGroupEntry *groupParams); +int32_t AddGroupOwnerToParams(const char *owner, TrustedGroupEntry *groupParams); +int32_t AddGroupTypeToParams(int groupType, TrustedGroupEntry *groupParams); +int32_t AddGroupVisibilityOrDefault(const CJson *jsonParams, TrustedGroupEntry *groupParams); +int32_t AddExpireTimeOrDefault(const CJson *jsonParams, TrustedGroupEntry *groupParams); +int32_t AddUserIdHashToGroupParams(const CJson *jsonParams, TrustedGroupEntry *groupParams); -int32_t AddUdidToParams(DeviceInfo *devParams); -int32_t AddAuthIdToParamsOrDefault(const CJson *jsonParams, DeviceInfo *devParams); -int32_t AddUserTypeToParamsOrDefault(const CJson *jsonParams, DeviceInfo *devParams); -int32_t AddServiceTypeToParams(const char *groupId, DeviceInfo *devParams); -int32_t AddGroupIdToDevParams(const char *groupId, DeviceInfo *devParams); -int32_t AddUserIdHashToDevParams(const CJson *jsonParams, DeviceInfo *devParams); +int32_t AddUdidToParams(TrustedDeviceEntry *devParams); +int32_t AddAuthIdToParamsOrDefault(const CJson *jsonParams, TrustedDeviceEntry *devParams); +int32_t AddUserTypeToParamsOrDefault(const CJson *jsonParams, TrustedDeviceEntry *devParams); +int32_t AddServiceTypeToParams(const char *groupId, TrustedDeviceEntry *devParams); +int32_t AddGroupIdToDevParams(const char *groupId, TrustedDeviceEntry *devParams); +int32_t AddUserIdHashToDevParams(const CJson *jsonParams, TrustedDeviceEntry *devParams); -int32_t AddGroupToDatabaseByJson(int32_t (*generateGroupParams)(const CJson*, const char *, GroupInfo*), - const CJson *jsonParams, const char *groupId); -int32_t AddDeviceToDatabaseByJson(int32_t (*generateDevParams)(const CJson*, const char*, DeviceInfo*), - const CJson *jsonParams, const char *groupId); -int32_t DelGroupFromDatabase(const char *groupId); +int32_t AddGroupToDatabaseByJson(int32_t osAccountId, int32_t (*generateGroupParams)(const CJson*, + const char *, TrustedGroupEntry*), const CJson *jsonParams, const char *groupId); +int32_t AddDeviceToDatabaseByJson(int32_t osAccountId, int32_t (*generateDevParams)(const CJson*, const char*, + TrustedDeviceEntry*), const CJson *jsonParams, const char *groupId); +int32_t DelGroupFromDb(int32_t osAccountId, const char *groupId); int32_t ConvertGroupIdToJsonStr(const char *groupId, char **returnJsonStr); int32_t GenerateBindSuccessData(const char *peerAuthId, const char *groupId, char **returnDataStr); int32_t GenerateUnbindSuccessData(const char *peerAuthId, const char *groupId, char **returnDataStr); -int32_t GetGroupTypeFromDb(const char *groupId, int32_t *returnGroupType); +int32_t GetGroupTypeFromDb(int32_t osAccountId, const char *groupId, int32_t *returnGroupType); int32_t GetUserIdHashFromJson(const CJson *jsonParams, char **userIdHash); int32_t GetGroupIdFromJson(const CJson *jsonParams, const char **groupId); int32_t GetAppIdFromJson(const CJson *jsonParams, const char **appId); int32_t GetHashResult(const uint8_t *info, uint32_t infoLen, char *hash, uint32_t hashLen); +bool IsTrustedDeviceInGroup(int32_t osAccountId, const char *groupId, const char *deviceId, bool isUdid); +int32_t GetGroupInfoById(int32_t osAccountId, const char *groupId, TrustedGroupEntry *returnGroupEntry); +bool IsGroupOwner(int32_t osAccountId, const char *groupId, const char *appId); +bool IsGroupAccessible(int32_t osAccountId, const char *groupId, const char *appId); +bool IsGroupExistByGroupId(int32_t osAccountId, const char *groupId); +bool IsGroupEditAllowed(int32_t osAccountId, const char *groupId, const char *appId); +int32_t GetGroupInfo(int32_t osAccountId, int groupType, const char *groupId, const char *groupName, + const char *groupOwner, GroupEntryVec *groupEntryVec); +int32_t GetJoinedGroups(int32_t osAccountId, int groupType, GroupEntryVec *groupEntryVec); +int32_t GetTrustedDevInfoById(int32_t osAccountId, const char *deviceId, bool isUdid, const char *groupId, + TrustedDeviceEntry *deviceEntry); +int32_t GetTrustedDevices(int32_t osAccountId, const char *groupId, DeviceEntryVec *deviceEntryVec); +int32_t GetRelatedGroups(int32_t osAccountId, const char *peerDeviceId, bool isUdid, GroupEntryVec *groupEntryVec); + +TrustedGroupEntry *GetGroupEntryById(int32_t osAccountId, const char *groupId); +TrustedDeviceEntry *GetTrustedDeviceEntryById(int32_t osAccountId, const char *deviceId, bool isUdid, + const char *groupId); + #ifdef __cplusplus } #endif diff --git a/services/group_manager/inc/peer_to_peer_group.h b/services/group_manager/inc/peer_to_peer_group.h index 070b22e..33a93cb 100644 --- a/services/group_manager/inc/peer_to_peer_group.h +++ b/services/group_manager/inc/peer_to_peer_group.h @@ -24,13 +24,18 @@ extern "C" { typedef struct { BaseGroup base; - int32_t (*addMember)(int64_t requestId, CJson *jsonParams, const DeviceAuthCallback *callback); - int32_t (*deleteMember)(int64_t requestId, CJson *jsonParams, const DeviceAuthCallback *callback); - int32_t (*processData)(int64_t requestId, CJson *jsonParams, const DeviceAuthCallback *callback); - int32_t (*addGroupRole)(bool isManager, const char *appId, const char *groupId, const char *roleAppId); - int32_t (*deleteGroupRole)(bool isManager, const char *appId, const char *groupId, const char *roleAppId); - int32_t (*getGroupRoles)(bool isManager, const char *appId, const char *groupId, char **returnJsonStr, - uint32_t *returnSize); + int32_t (*addMember)(int32_t osAccountId, int64_t requestId, CJson *jsonParams, + const DeviceAuthCallback *callback); + int32_t (*deleteMember)(int32_t osAccountId, int64_t requestId, CJson *jsonParams, + const DeviceAuthCallback *callback); + int32_t (*processData)(int64_t requestId, CJson *jsonParams, + const DeviceAuthCallback *callback); + int32_t (*addGroupRole)(int32_t osAccountId, bool isManager, const char *appId, const char *groupId, + const char *roleAppId); + int32_t (*deleteGroupRole)(int32_t osAccountId, bool isManager, const char *appId, const char *groupId, + const char *roleAppId); + int32_t (*getGroupRoles)(int32_t osAccountId, bool isManager, const char *appId, const char *groupId, + char **returnJsonStr, uint32_t *returnSize); } PeerToPeerGroup; BaseGroup *GetPeerToPeerGroupInstance(void); diff --git a/services/group_manager/inc/session/bind_session/bind_session_common.h b/services/group_manager/inc/session/bind_session/bind_session_common.h index 28b2043..2ace16f 100644 --- a/services/group_manager/inc/session/bind_session/bind_session_common.h +++ b/services/group_manager/inc/session/bind_session/bind_session_common.h @@ -20,7 +20,7 @@ int32_t AddInfoToSendData(bool isNeedCompatibleInfo, const BindSession *session, CJson *data); int32_t GenerateBasicModuleParams(bool isClient, BindSession *session, CJson *moduleParams); -int32_t GenerateBindParams(int isClient, const CJson *jsonParams, BindSession *session); +int32_t GenerateBindParams(int32_t osAccountId, int isClient, const CJson *jsonParams, BindSession *session); bool NeedCreateGroup(int isClient, int operationCode); bool NeedForceDelete(const BindSession *session); int32_t ForceUnbindDevice(const BindSession *session); diff --git a/services/group_manager/inc/session/bind_session_common_defines.h b/services/group_manager/inc/session/bind_session_common_defines.h index 6321b6f..a90ddc6 100644 --- a/services/group_manager/inc/session/bind_session_common_defines.h +++ b/services/group_manager/inc/session/bind_session_common_defines.h @@ -33,6 +33,7 @@ typedef struct { int32_t opCode; int32_t channelType; int32_t moduleType; + int32_t osAccountId; int64_t reqId; int64_t channelId; } BindSession; diff --git a/services/group_manager/src/broadcast_manager/broadcast_manager.c b/services/group_manager/src/broadcast_manager/broadcast_manager.c index fe71c0b..365f8b0 100644 --- a/services/group_manager/src/broadcast_manager/broadcast_manager.c +++ b/services/group_manager/src/broadcast_manager/broadcast_manager.c @@ -28,19 +28,19 @@ typedef struct { DataChangeListener *listener; } ListenerEntry; -DECLARE_HC_VECTOR(ListenerEntryVec, ListenerEntry) -IMPLEMENT_HC_VECTOR(ListenerEntryVec, ListenerEntry, 1) +DECLARE_HC_VECTOR(ListenerEntryVec, ListenerEntry); +IMPLEMENT_HC_VECTOR(ListenerEntryVec, ListenerEntry, 1); static ListenerEntryVec g_listenerEntryVec; static HcMutex *g_broadcastMutex = NULL; -static int32_t GenerateMessage(const GroupInfo *groupInfo, char **returnGroupInfo) +static int32_t GenerateMessage(const TrustedGroupEntry *groupEntry, char **returnGroupInfo) { CJson *message = CreateJson(); if (message == NULL) { LOGE("Failed to allocate message memory!"); return HC_ERR_ALLOC_MEMORY; } - int32_t result = GenerateReturnGroupInfo(groupInfo, message); + int32_t result = GenerateReturnGroupInfo(groupEntry, message); if (result != HC_SUCCESS) { FreeJson(message); return result; @@ -55,14 +55,14 @@ static int32_t GenerateMessage(const GroupInfo *groupInfo, char **returnGroupInf return HC_SUCCESS; } -static void PostOnGroupCreated(const GroupInfo *groupInfo) +static void PostOnGroupCreated(const TrustedGroupEntry *groupEntry) { - if (groupInfo == NULL) { + if (groupEntry == NULL) { LOGE("The groupEntry is NULL!"); return; } char *messageStr = NULL; - if (GenerateMessage(groupInfo, &messageStr) != HC_SUCCESS) { + if (GenerateMessage(groupEntry, &messageStr) != HC_SUCCESS) { return; } uint32_t index; @@ -78,14 +78,14 @@ static void PostOnGroupCreated(const GroupInfo *groupInfo) g_broadcastMutex->unlock(g_broadcastMutex); } -static void PostOnGroupDeleted(const GroupInfo *groupInfo) +static void PostOnGroupDeleted(const TrustedGroupEntry *groupEntry) { - if (groupInfo == NULL) { + if (groupEntry == NULL) { LOGE("The groupEntry is NULL!"); return; } char *messageStr = NULL; - if (GenerateMessage(groupInfo, &messageStr) != HC_SUCCESS) { + if (GenerateMessage(groupEntry, &messageStr) != HC_SUCCESS) { return; } uint32_t index; @@ -101,14 +101,14 @@ static void PostOnGroupDeleted(const GroupInfo *groupInfo) g_broadcastMutex->unlock(g_broadcastMutex); } -static void PostOnDeviceBound(const char *peerUdid, const GroupInfo *groupInfo) +static void PostOnDeviceBound(const char *peerUdid, const TrustedGroupEntry *groupEntry) { - if ((peerUdid == NULL) || (groupInfo == NULL)) { + if ((peerUdid == NULL) || (groupEntry == NULL)) { LOGE("The peerUdid or groupEntry is NULL!"); return; } char *messageStr = NULL; - if (GenerateMessage(groupInfo, &messageStr) != HC_SUCCESS) { + if (GenerateMessage(groupEntry, &messageStr) != HC_SUCCESS) { return; } uint32_t index; @@ -124,14 +124,14 @@ static void PostOnDeviceBound(const char *peerUdid, const GroupInfo *groupInfo) g_broadcastMutex->unlock(g_broadcastMutex); } -static void PostOnDeviceUnBound(const char *peerUdid, const GroupInfo *groupInfo) +static void PostOnDeviceUnBound(const char *peerUdid, const TrustedGroupEntry *groupEntry) { - if ((peerUdid == NULL) || (groupInfo == NULL)) { + if ((peerUdid == NULL) || (groupEntry == NULL)) { LOGE("The peerUdid or groupEntry is NULL!"); return; } char *messageStr = NULL; - if (GenerateMessage(groupInfo, &messageStr) != HC_SUCCESS) { + if (GenerateMessage(groupEntry, &messageStr) != HC_SUCCESS) { return; } uint32_t index; @@ -284,7 +284,7 @@ int32_t InitBroadcastManager(void) return HC_ERROR; } } - g_listenerEntryVec = CREATE_HC_VECTOR(ListenerEntryVec) + g_listenerEntryVec = CREATE_HC_VECTOR(ListenerEntryVec); LOGI("[Broadcaster]: Init broadcast manager module successfully!"); return HC_SUCCESS; } @@ -300,7 +300,7 @@ void DestroyBroadcastManager(void) HcFree(entry->listener); } } - DESTROY_HC_VECTOR(ListenerEntryVec, &g_listenerEntryVec) + DESTROY_HC_VECTOR(ListenerEntryVec, &g_listenerEntryVec); g_broadcastMutex->unlock(g_broadcastMutex); if (g_broadcastMutex != NULL) { DestroyHcMutex(g_broadcastMutex); diff --git a/services/group_manager/src/callback_manager/callback_manager.c b/services/group_manager/src/callback_manager/callback_manager.c index 4855152..5249b8f 100644 --- a/services/group_manager/src/callback_manager/callback_manager.c +++ b/services/group_manager/src/callback_manager/callback_manager.c @@ -27,7 +27,7 @@ typedef struct { DeviceAuthCallback *callback; } CallbackEntry; -DECLARE_HC_VECTOR(GMCallbackEntryVec, CallbackEntry) +DECLARE_HC_VECTOR(GMCallbackEntryVec, CallbackEntry); IMPLEMENT_HC_VECTOR(GMCallbackEntryVec, CallbackEntry, 1) static GMCallbackEntryVec g_callbackVec; static HcMutex *g_callbackMutex = NULL; diff --git a/services/group_manager/src/channel_manager/soft_bus_channel/soft_bus_channel.c b/services/group_manager/src/channel_manager/soft_bus_channel/soft_bus_channel.c index 4395689..d260de9 100644 --- a/services/group_manager/src/channel_manager/soft_bus_channel/soft_bus_channel.c +++ b/services/group_manager/src/channel_manager/soft_bus_channel/soft_bus_channel.c @@ -37,7 +37,7 @@ typedef struct { int64_t channelId; } ChannelEntry; -DECLARE_HC_VECTOR(ChannelEntryVec, ChannelEntry) +DECLARE_HC_VECTOR(ChannelEntryVec, ChannelEntry); IMPLEMENT_HC_VECTOR(ChannelEntryVec, ChannelEntry, 1) static ChannelEntryVec g_channelVec; static HcMutex *g_channelMutex = NULL; @@ -284,7 +284,7 @@ int32_t InitSoftBusChannelModule(void) return HC_ERR_INIT_FAILED; } } - g_channelVec = CREATE_HC_VECTOR(ChannelEntryVec) + g_channelVec = CREATE_HC_VECTOR(ChannelEntryVec); ISessionListener softBusListener = { .OnSessionOpened = OnChannelOpenedCb, .OnSessionClosed = OnChannelClosedCb, @@ -300,7 +300,7 @@ int32_t InitSoftBusChannelModule(void) void DestroySoftBusChannelModule(void) { g_channelMutex->lock(g_channelMutex); - DESTROY_HC_VECTOR(ChannelEntryVec, &g_channelVec) + DESTROY_HC_VECTOR(ChannelEntryVec, &g_channelVec); g_channelMutex->unlock(g_channelMutex); if (g_channelMutex != NULL) { DestroyHcMutex(g_channelMutex); diff --git a/services/group_manager/src/group_manager.c b/services/group_manager/src/group_manager.c index d5022f6..50aed27 100644 --- a/services/group_manager/src/group_manager.c +++ b/services/group_manager/src/group_manager.c @@ -17,28 +17,32 @@ #include "bind_peer.h" #include "common_defs.h" -#include "database_manager.h" +#include "data_manager.h" #include "group_operation.h" #include "key_agree.h" -int32_t CreateGroupImpl(int64_t requestId, const char *appId, const char *createParams) +int32_t CreateGroupImpl(int32_t osAccountId, int64_t requestId, const char *appId, const char *createParams) { - return IsGroupSupport() ? GetGroupImplInstance()->createGroup(requestId, appId, createParams) : HC_ERR_NOT_SUPPORT; + return IsGroupSupport() ? GetGroupImplInstance()->createGroup(osAccountId, requestId, appId, createParams) + : HC_ERR_NOT_SUPPORT; } -int32_t DeleteGroupImpl(int64_t requestId, const char *appId, const char *disbandParams) +int32_t DeleteGroupImpl(int32_t osAccountId, int64_t requestId, const char *appId, const char *disbandParams) { - return IsGroupSupport() ? GetGroupImplInstance()->deleteGroup(requestId, appId, disbandParams) : HC_ERR_NOT_SUPPORT; + return IsGroupSupport() ? GetGroupImplInstance()->deleteGroup(osAccountId, requestId, appId, disbandParams) + : HC_ERR_NOT_SUPPORT; } -int32_t AddMemberToGroupImpl(int64_t requestId, const char *appId, const char *addParams) +int32_t AddMemberToGroupImpl(int32_t osAccountId, int64_t requestId, const char *appId, const char *addParams) { - return IsGroupSupport() ? GetGroupImplInstance()->addMember(requestId, appId, addParams) : HC_ERR_NOT_SUPPORT; + return IsGroupSupport() ? GetGroupImplInstance()->addMember(osAccountId, requestId, appId, addParams) + : HC_ERR_NOT_SUPPORT; } -int32_t DeleteMemberFromGroupImpl(int64_t requestId, const char *appId, const char *deleteParams) +int32_t DeleteMemberFromGroupImpl(int32_t osAccountId, int64_t requestId, const char *appId, const char *deleteParams) { - return IsGroupSupport() ? GetGroupImplInstance()->deleteMember(requestId, appId, deleteParams) : HC_ERR_NOT_SUPPORT; + return IsGroupSupport() ? GetGroupImplInstance()->deleteMember(osAccountId, requestId, appId, deleteParams) + : HC_ERR_NOT_SUPPORT; } int32_t ProcessBindDataImpl(int64_t requestId, const uint8_t *data, uint32_t dataLen) @@ -46,9 +50,9 @@ int32_t ProcessBindDataImpl(int64_t requestId, const uint8_t *data, uint32_t dat return IsGroupSupport() ? GetGroupImplInstance()->processBindData(requestId, data, dataLen) : HC_ERR_NOT_SUPPORT; } -int32_t ConfirmRequestImpl(int64_t requestId, const char *appId, const char *confirmParams) +int32_t ConfirmRequestImpl(int32_t osAccountId, int64_t requestId, const char *appId, const char *confirmParams) { - return IsGroupSupport() ? GetGroupImplInstance()->confirmRequest(requestId, appId, + return IsGroupSupport() ? GetGroupImplInstance()->confirmRequest(osAccountId, requestId, appId, confirmParams) : HC_ERR_NOT_SUPPORT; } @@ -66,39 +70,41 @@ int32_t SyncAcrossAccountGroupImpl(const char *appId, const char *userIdHash, co sharedUserIdHashList) : HC_ERR_NOT_SUPPORT; } -int32_t AddGroupManagerImpl(const char *appId, const char *groupId, const char *managerAppId) +int32_t AddGroupManagerImpl(int32_t osAccountId, const char *appId, const char *groupId, const char *managerAppId) { - return IsGroupSupport() ? GetGroupImplInstance()->addGroupRole(true, appId, groupId, + return IsGroupSupport() ? GetGroupImplInstance()->addGroupRole(osAccountId, true, appId, groupId, managerAppId) : HC_ERR_NOT_SUPPORT; } -int32_t AddGroupFriendImpl(const char *appId, const char *groupId, const char *friendAppId) +int32_t AddGroupFriendImpl(int32_t osAccountId, const char *appId, const char *groupId, const char *friendAppId) { - return IsGroupSupport() ? GetGroupImplInstance()->addGroupRole(false, appId, groupId, + return IsGroupSupport() ? GetGroupImplInstance()->addGroupRole(osAccountId, false, appId, groupId, friendAppId) : HC_ERR_NOT_SUPPORT; } -int32_t DeleteGroupManagerImpl(const char *appId, const char *groupId, const char *managerAppId) +int32_t DeleteGroupManagerImpl(int32_t osAccountId, const char *appId, const char *groupId, const char *managerAppId) { - return IsGroupSupport() ? GetGroupImplInstance()->deleteGroupRole(true, appId, groupId, + return IsGroupSupport() ? GetGroupImplInstance()->deleteGroupRole(osAccountId, true, appId, groupId, managerAppId) : HC_ERR_NOT_SUPPORT; } -int32_t DeleteGroupFriendImpl(const char *appId, const char *groupId, const char *friendAppId) +int32_t DeleteGroupFriendImpl(int32_t osAccountId, const char *appId, const char *groupId, const char *friendAppId) { - return IsGroupSupport() ? GetGroupImplInstance()->deleteGroupRole(false, appId, groupId, + return IsGroupSupport() ? GetGroupImplInstance()->deleteGroupRole(osAccountId, false, appId, groupId, friendAppId) : HC_ERR_NOT_SUPPORT; } -int32_t GetGroupManagersImpl(const char *appId, const char *groupId, char **returnManagers, uint32_t *returnSize) +int32_t GetGroupManagersImpl(int32_t osAccuntId, const char *appId, const char *groupId, + char **returnManagers, uint32_t *returnSize) { - return IsGroupSupport() ? GetGroupImplInstance()->getGroupRoles(true, appId, groupId, + return IsGroupSupport() ? GetGroupImplInstance()->getGroupRoles(osAccuntId, true, appId, groupId, returnManagers, returnSize) : HC_ERR_NOT_SUPPORT; } -int32_t GetGroupFriendsImpl(const char *appId, const char *groupId, char **returnFriends, uint32_t *returnSize) +int32_t GetGroupFriendsImpl(int32_t osAccuntId, const char *appId, const char *groupId, + char **returnFriends, uint32_t *returnSize) { - return IsGroupSupport() ? GetGroupImplInstance()->getGroupRoles(false, appId, groupId, + return IsGroupSupport() ? GetGroupImplInstance()->getGroupRoles(osAccuntId, false, appId, groupId, returnFriends, returnSize) : HC_ERR_NOT_SUPPORT; } @@ -112,53 +118,66 @@ int32_t UnRegListenerImpl(const char *appId) return IsGroupSupport() ? GetGroupImplInstance()->unRegListener(appId) : HC_ERR_NOT_SUPPORT; } -int32_t CheckAccessToGroupImpl(const char *appId, const char *groupId) +int32_t CheckAccessToGroupImpl(int32_t osAccountId, const char *appId, const char *groupId) { - return IsGroupSupport() ? GetGroupImplInstance()->checkAccessToGroup(appId, groupId) : HC_ERR_NOT_SUPPORT; + return IsGroupSupport() ? GetGroupImplInstance()->checkAccessToGroup(osAccountId, appId, groupId) + : HC_ERR_NOT_SUPPORT; } -int32_t GetGroupInfoByIdImpl(const char *appId, const char *groupId, char **returnGroupInfo) +int32_t GetGroupInfoByIdImpl(int32_t osAccountId, const char *appId, const char *groupId, char **returnGroupInfo) { - return IsGroupSupport() ? GetGroupImplInstance()->getAccessibleGroupInfoById(appId, groupId, + return IsGroupSupport() ? GetGroupImplInstance()->getAccessibleGroupInfoById(osAccountId, appId, groupId, returnGroupInfo) : HC_ERR_NOT_SUPPORT; } -int32_t GetGroupInfoImpl(const char *appId, const char *queryParams, char **returnGroupVec, uint32_t *groupNum) +int32_t GetGroupInfoImpl(int32_t osAccountId, const char *appId, const char *queryParams, + char **returnGroupVec, uint32_t *groupNum) { - return IsGroupSupport() ? GetGroupImplInstance()->getAccessibleGroupInfo(appId, queryParams, returnGroupVec, - groupNum) : HC_ERR_NOT_SUPPORT; -} - -int32_t GetJoinedGroupsImpl(const char *appId, int groupType, char **returnGroupVec, uint32_t *groupNum) -{ - return IsGroupSupport() ? GetGroupImplInstance()->getAccessibleJoinedGroups(appId, groupType, returnGroupVec, - groupNum) : HC_ERR_NOT_SUPPORT; -} - -int32_t GetRelatedGroupsImpl(const char *appId, const char *peerDeviceId, char **returnGroupVec, uint32_t *groupNum) -{ - return IsGroupSupport() ? GetGroupImplInstance()->getAccessibleRelatedGroups(appId, peerDeviceId, false, + return IsGroupSupport() ? GetGroupImplInstance()->getAccessibleGroupInfo(osAccountId, appId, queryParams, returnGroupVec, groupNum) : HC_ERR_NOT_SUPPORT; } -int32_t GetDeviceInfoByIdImpl(const char *appId, const char *deviceId, const char *groupId, char **returnDeviceInfo) +int32_t GetJoinedGroupsImpl(int32_t osAccountId, const char *appId, int groupType, + char **returnGroupVec, uint32_t *groupNum) { - return IsGroupSupport() ? GetGroupImplInstance()->getAccessibleDeviceInfoById(appId, deviceId, false, groupId, - returnDeviceInfo) : HC_ERR_NOT_SUPPORT; + return IsGroupSupport() ? GetGroupImplInstance()->getAccessibleJoinedGroups(osAccountId, appId, groupType, + returnGroupVec, groupNum) : HC_ERR_NOT_SUPPORT; } -int32_t GetTrustedDevicesImpl(const char *appId, const char *groupId, char **returnDevInfoVec, uint32_t *deviceNum) +int32_t GetRelatedGroupsImpl(int32_t osAccountId, const char *appId, const char *peerDeviceId, + char **returnGroupVec, uint32_t *groupNum) { - return IsGroupSupport() ? GetGroupImplInstance()->getAccessibleTrustedDevices(appId, groupId, returnDevInfoVec, - deviceNum) : HC_ERR_NOT_SUPPORT; + return IsGroupSupport() ? GetGroupImplInstance()->getAccessibleRelatedGroups(osAccountId, appId, peerDeviceId, + false, returnGroupVec, groupNum) : HC_ERR_NOT_SUPPORT; } -bool IsDeviceInGroupImpl(const char *appId, const char *groupId, const char *deviceId) +int32_t GetDeviceInfoByIdImpl(int32_t osAccountId, const char *appId, const char *deviceId, const char *groupId, + char **returnDeviceInfo) { - return IsGroupSupport() ? GetGroupImplInstance()->isDeviceInAccessibleGroup(appId, groupId, + return IsGroupSupport() ? GetGroupImplInstance()->getAccessibleDeviceInfoById(osAccountId, appId, deviceId, + false, groupId, returnDeviceInfo) : HC_ERR_NOT_SUPPORT; +} + +int32_t GetTrustedDevicesImpl(int32_t osAccountId, const char *appId, const char *groupId, + char **returnDevInfoVec, uint32_t *deviceNum) +{ + return IsGroupSupport() ? GetGroupImplInstance()->getAccessibleTrustedDevices(osAccountId, appId, groupId, + returnDevInfoVec, deviceNum) : HC_ERR_NOT_SUPPORT; +} + +bool IsDeviceInGroupImpl(int32_t osAccountId, const char *appId, const char *groupId, const char *deviceId) +{ + return IsGroupSupport() ? GetGroupImplInstance()->isDeviceInAccessibleGroup(osAccountId, appId, groupId, deviceId, false) : false; } +int32_t GetPkInfoListImpl(int32_t osAccountId, const char *appId, const char *queryParams, + char **returnInfoList, uint32_t *returnInfoNum) +{ + return IsGroupSupport() ? GetGroupImplInstance()->getPkInfoList(osAccountId, appId, queryParams, + returnInfoList, returnInfoNum) : HC_ERR_NOT_SUPPORT; +} + void DestroyInfoImpl(char **returnInfo) { if (IsGroupSupport()) { diff --git a/services/group_manager/src/group_manager_common.c b/services/group_manager/src/group_manager_common.c index b6e4b40..5571fb9 100644 --- a/services/group_manager/src/group_manager_common.c +++ b/services/group_manager/src/group_manager_common.c @@ -20,14 +20,15 @@ #include "callback_manager.h" #include "task_manager.h" -static int32_t InitGroupManagerTask(GroupManagerTask *task, int32_t opCode, int64_t reqId, CJson *params, TaskFunc func) +static int32_t InitGroupManagerTask(GroupManagerTask *task, GMTaskParams *taskParams, TaskFunc func) { task->base.doAction = func; task->base.destroy = DestroyGroupManagerTask; - task->opCode = opCode; - task->reqId = reqId; - task->params = params; - return BindCallbackToTask(task, params); + task->osAccountId = taskParams->osAccountId; + task->opCode = taskParams->opCode; + task->reqId = taskParams->reqId; + task->params = taskParams->params; + return BindCallbackToTask(task, taskParams->params); } int32_t AddReqInfoToJson(int64_t requestId, const char *appId, CJson *jsonParams) @@ -76,14 +77,19 @@ int32_t AddBindParamsToJson(int operationCode, int64_t requestId, const char *ap return AddReqInfoToJson(requestId, appId, jsonParams); } -int32_t InitAndPushGMTask(int32_t opCode, int64_t reqId, CJson *params, TaskFunc func) +int32_t InitAndPushGMTask(int32_t osAccountId, int32_t opCode, int64_t reqId, CJson *params, TaskFunc func) { GroupManagerTask *task = (GroupManagerTask *)HcMalloc(sizeof(GroupManagerTask), 0); if (task == NULL) { LOGE("Failed to allocate task memory!"); return HC_ERR_ALLOC_MEMORY; } - if (InitGroupManagerTask(task, opCode, reqId, params, func) != HC_SUCCESS) { + GMTaskParams taskParams; + taskParams.osAccountId = osAccountId; + taskParams.opCode = opCode; + taskParams.reqId = reqId; + taskParams.params = params; + if (InitGroupManagerTask(task, &taskParams, func) != HC_SUCCESS) { HcFree(task); return HC_ERR_INIT_TASK_FAIL; } diff --git a/services/group_manager/src/group_operation/group_operation.c b/services/group_manager/src/group_operation/group_operation.c index abd2677..789b072 100644 --- a/services/group_manager/src/group_operation/group_operation.c +++ b/services/group_manager/src/group_operation/group_operation.c @@ -18,11 +18,15 @@ #include "alg_defs.h" #include "broadcast_manager.h" #include "callback_manager.h" -#include "database_manager.h" +#include "common_defs.h" +#include "data_manager.h" #include "dev_auth_module_manager.h" +#include "device_auth_defines.h" #include "group_manager_common.h" #include "group_operation_common.h" +#include "hc_dev_info.h" #include "hc_log.h" +#include "os_account_adapter.h" #include "session_manager.h" #include "task_manager.h" @@ -30,6 +34,7 @@ #include "identical_account_group.h" #include "peer_to_peer_group.h" + static bool IsGroupTypeSupported(int groupType) { if (((groupType == PEER_TO_PEER_GROUP) && (IsPeerToPeerGroupSupported())) || @@ -41,23 +46,24 @@ static bool IsGroupTypeSupported(int groupType) return false; } -static void RemoveNoPermissionGroup(GroupInfoVec *groupInfoVec, const char *appId) +static void RemoveNoPermissionGroup(int32_t osAccountId, GroupEntryVec *groupEntryVec, const char *appId) { uint32_t index = 0; - void **groupInfoPtr = NULL; - while (index < groupInfoVec->size(groupInfoVec)) { - groupInfoPtr = groupInfoVec->getp(groupInfoVec, index); - if ((groupInfoPtr == NULL) || (*groupInfoPtr == NULL)) { + TrustedGroupEntry **groupEntryPtr = NULL; + while (index < groupEntryVec->size(groupEntryVec)) { + groupEntryPtr = groupEntryVec->getp(groupEntryVec, index); + if ((groupEntryPtr == NULL) || (*groupEntryPtr == NULL)) { index++; continue; } - GroupInfo *groupInfo = (GroupInfo *)(*groupInfoPtr); - if (IsGroupAccessible(StringGet(&groupInfo->id), appId)) { + if (IsGroupAccessible(osAccountId, StringGet(&(*groupEntryPtr)->id), appId)) { index++; continue; } - void *tempEntry = NULL; - HC_VECTOR_POPELEMENT(groupInfoVec, &tempEntry, index); + LOGI("Remove a group without permission!"); + TrustedGroupEntry *tempEntry = NULL; + HC_VECTOR_POPELEMENT(groupEntryVec, &tempEntry, index); + DestroyGroupEntry(tempEntry); } } @@ -77,7 +83,7 @@ static int32_t GenerateReturnEmptyArrayStr(char **returnVec) return HC_SUCCESS; } -static int32_t GenerateReturnGroupVec(GroupInfoVec *groupInfoVec, char **returnGroupVec, uint32_t *groupNum) +static int32_t GenerateReturnGroupVec(GroupEntryVec *groupInfoVec, char **returnGroupVec, uint32_t *groupNum) { if (HC_VECTOR_SIZE(groupInfoVec) == 0) { LOGI("No group is found based on the query parameters!"); @@ -92,10 +98,10 @@ static int32_t GenerateReturnGroupVec(GroupInfoVec *groupInfoVec, char **returnG } uint32_t groupCount = 0; uint32_t index; - void **groupInfoPtr = NULL; + TrustedGroupEntry **groupInfoPtr = NULL; FOR_EACH_HC_VECTOR(*groupInfoVec, index, groupInfoPtr) { - if ((groupInfoPtr != NULL) && ((*groupInfoPtr) != NULL)) { - GroupInfo *groupInfo = (GroupInfo*)(*groupInfoPtr); + if (groupInfoPtr != NULL) { + TrustedGroupEntry *groupInfo = *groupInfoPtr; CJson *groupInfoJson = CreateJson(); if (groupInfoJson == NULL) { LOGE("Failed to allocate groupInfoJson memory!"); @@ -127,7 +133,7 @@ static int32_t GenerateReturnGroupVec(GroupInfoVec *groupInfoVec, char **returnG return HC_SUCCESS; } -static int32_t GenerateReturnDeviceVec(DeviceInfoVec *devInfoVec, char **returnDevInfoVec, uint32_t *deviceNum) +static int32_t GenerateReturnDeviceVec(DeviceEntryVec *devInfoVec, char **returnDevInfoVec, uint32_t *deviceNum) { if (HC_VECTOR_SIZE(devInfoVec) == 0) { LOGI("No device is found based on the query parameters!"); @@ -142,10 +148,10 @@ static int32_t GenerateReturnDeviceVec(DeviceInfoVec *devInfoVec, char **returnD } uint32_t devCount = 0; uint32_t index; - void **devInfoPtr = NULL; + TrustedDeviceEntry **devInfoPtr = NULL; FOR_EACH_HC_VECTOR(*devInfoVec, index, devInfoPtr) { if ((devInfoPtr != NULL) && ((*devInfoPtr) != NULL)) { - DeviceInfo *devInfo = (DeviceInfo*)(*devInfoPtr); + TrustedDeviceEntry *devInfo = (TrustedDeviceEntry*)(*devInfoPtr); CJson *devInfoJson = CreateJson(); if (devInfoJson == NULL) { LOGE("Failed to allocate devInfoJson memory!"); @@ -186,6 +192,182 @@ static bool IsQueryParamsValid(int groupType, const char *groupId, const char *g } } +static int32_t QueryRelatedGroupsForGetPk(int32_t osAccountId, const char *udid, GroupEntryVec *returnGroupEntryVec) +{ + DeviceEntryVec deviceEntryVec = CreateDeviceEntryVec(); + QueryDeviceParams params = InitQueryDeviceParams(); + params.udid = udid; + int32_t result = QueryDevices(osAccountId, ¶ms, &deviceEntryVec); + if (result != HC_SUCCESS) { + LOGE("Failed to query trusted devices!"); + ClearDeviceEntryVec(&deviceEntryVec); + return result; + } + uint32_t index; + TrustedDeviceEntry **entry = NULL; + FOR_EACH_HC_VECTOR(deviceEntryVec, index, entry) { + if ((entry == NULL) || (*entry == NULL)) { + continue; + } + TrustedGroupEntry *groupEntry = GetGroupEntryById(osAccountId, StringGet(&(*entry)->groupId)); + if (groupEntry == NULL) { + LOGE("Failed to get group entry by id!"); + ClearDeviceEntryVec(&deviceEntryVec); + return HC_ERR_GROUP_NOT_EXIST; + } + if ((groupEntry->type != PEER_TO_PEER_GROUP) || (groupEntry->visibility != GROUP_VISIBILITY_PUBLIC)) { + DestroyGroupEntry(groupEntry); + continue; + } + if (returnGroupEntryVec->pushBackT(returnGroupEntryVec, groupEntry) == NULL) { + LOGE("Failed to push groupEntry to returnGroupEntryVec!"); + DestroyGroupEntry(groupEntry); + ClearDeviceEntryVec(&deviceEntryVec); + return HC_ERR_MEMORY_COPY; + } + } + ClearDeviceEntryVec(&deviceEntryVec); + return HC_SUCCESS; +} + +static int32_t GetPkByParams(const char *groupId, const TrustedDeviceEntry *deviceEntry, + char *returnPkHexStr, int32_t returnPkHexStrLen) +{ + /* Use the DeviceGroupManager package name. */ + const char *appId = GROUP_MANAGER_PACKAGE_NAME; + int userType = deviceEntry->devType; + const char *authId = StringGet(&deviceEntry->authId); + if (authId == NULL) { + LOGE("Failed to get authId from deviceEntry!"); + return HC_ERR_DB; + } + Uint8Buff authIdBuff = { 0, 0 }; + authIdBuff.length = HcStrlen(authId); + authIdBuff.val = (uint8_t *)HcMalloc(authIdBuff.length, 0); + if (authIdBuff.val == NULL) { + LOGE("Failed to allocate authIdBuff memory!"); + return HC_ERR_ALLOC_MEMORY; + } + if (memcpy_s(authIdBuff.val, authIdBuff.length, authId, authIdBuff.length) != HC_SUCCESS) { + LOGE("Failed to copy authId!"); + HcFree(authIdBuff.val); + return HC_ERR_MEMORY_COPY; + } + uint8_t returnPkBytes[PUBLIC_KEY_MAX_LENGTH] = { 0 }; + Uint8Buff returnPkBuff = { 0, 0 }; + returnPkBuff.length = PUBLIC_KEY_MAX_LENGTH; + returnPkBuff.val = returnPkBytes; + AuthModuleParams authParams = { + .pkgName = appId, + .serviceType = groupId, + .authId = &authIdBuff, + .userType = userType + }; + int32_t res = GetPublicKey(DAS_MODULE, &authParams, &returnPkBuff); + HcFree(authIdBuff.val); + if (res != HC_SUCCESS) { + return res; + } + res = GetHashResult(returnPkBuff.val, returnPkBuff.length, returnPkHexStr, returnPkHexStrLen); + if (res != HC_SUCCESS) { + LOGE("Failed to get hash for pk!"); + return HC_ERR_HASH_FAIL; + } + return HC_SUCCESS; +} + +static int32_t GeneratePkInfo(int32_t osAccountId, const char *queryUdid, const char *groupId, CJson *pkInfo) +{ + TrustedDeviceEntry *deviceEntry = GetTrustedDeviceEntryById(osAccountId, queryUdid, true, groupId); + if (deviceEntry == NULL) { + LOGE("The trusted device is not found!"); + return HC_ERR_DEVICE_NOT_EXIST; + } + char returnPkHexStr[SHA256_LEN * BYTE_TO_HEX_OPER_LENGTH + 1] = { 0 }; + int32_t result = GetPkByParams(groupId, deviceEntry, returnPkHexStr, sizeof(returnPkHexStr)); + DestroyDeviceEntry(deviceEntry); + if (result != HC_SUCCESS) { + return result; + } + if (AddStringToJson(pkInfo, FIELD_GROUP_ID, groupId) != HC_SUCCESS) { + LOGE("Failed to add groupId to pkInfo!"); + return HC_ERR_JSON_ADD; + } + if (AddStringToJson(pkInfo, FIELD_PUBLIC_KEY, returnPkHexStr) != HC_SUCCESS) { + LOGE("Failed to add publicKey to pkInfo!"); + return HC_ERR_JSON_ADD; + } + return HC_SUCCESS; +} + +static void AddAllPkInfoToList(int32_t osAccountId, const char *queryUdid, const GroupEntryVec *groupEntryVec, + CJson *pkInfoList) +{ + uint32_t index; + TrustedGroupEntry **entry = NULL; + FOR_EACH_HC_VECTOR(*groupEntryVec, index, entry) { + if ((entry == NULL) || (*entry == NULL)) { + continue; + } + const char *groupId = StringGet(&((*entry)->id)); + if (groupId == NULL) { + LOGE("Failed to get groupId from groupInfo!"); + continue; + } + CJson *pkInfo = CreateJson(); + if (pkInfo == NULL) { + LOGE("Failed to create json!"); + continue; + } + int32_t res = GeneratePkInfo(osAccountId, queryUdid, groupId, pkInfo); + if (res != HC_SUCCESS) { + FreeJson(pkInfo); + continue; + } + if (AddObjToArray(pkInfoList, pkInfo) != HC_SUCCESS) { + LOGE("Failed to add pkInfo to pkInfoList!"); + FreeJson(pkInfo); + } + } +} + +static int32_t GeneratePkInfoList(int32_t osAccountId, const char *appId, const CJson *params, CJson *pkInfoList) +{ + const char *udid = GetStringFromJson(params, FIELD_UDID); + if (udid == NULL) { + LOGE("Failed to get udid from params!"); + return HC_ERR_JSON_GET; + } + bool isSelfPk = false; + if (GetBoolFromJson(params, FIELD_IS_SELF_PK, &isSelfPk) != HC_SUCCESS) { + LOGE("Failed to get isSelfPk from json!"); + return HC_ERR_JSON_GET; + } + GroupEntryVec groupEntryVec = CreateGroupEntryVec(); + int32_t res = QueryRelatedGroupsForGetPk(osAccountId, udid, &groupEntryVec); + if (res != HC_SUCCESS) { + ClearGroupEntryVec(&groupEntryVec); + return res; + } + RemoveNoPermissionGroup(osAccountId, &groupEntryVec, appId); + const char *queryUdid = NULL; + char selfUdid[INPUT_UDID_LEN] = { 0 }; + if (isSelfPk) { + res = HcGetUdid((uint8_t *)selfUdid, INPUT_UDID_LEN); + if (res != HC_SUCCESS) { + LOGE("Failed to get local udid! res: %d", res); + ClearGroupEntryVec(&groupEntryVec); + return HC_ERR_DB; + } + queryUdid = selfUdid; + } else { + queryUdid = udid; + } + AddAllPkInfoToList(osAccountId, queryUdid, &groupEntryVec, pkInfoList); + ClearGroupEntryVec(&groupEntryVec); + return HC_SUCCESS; +} + static BaseGroup *GetGroupInstance(int32_t groupType) { if (!IsGroupTypeSupported(groupType)) { @@ -202,7 +384,7 @@ static BaseGroup *GetGroupInstance(int32_t groupType) return instance; } -static int32_t CreateGroup(CJson *jsonParams, char **returnJsonStr) +static int32_t CreateGroup(int32_t osAccountId, CJson *jsonParams, char **returnJsonStr) { if ((jsonParams == NULL) || (returnJsonStr == NULL)) { LOGE("The input parameters contains NULL value!"); @@ -218,10 +400,10 @@ static int32_t CreateGroup(CJson *jsonParams, char **returnJsonStr) LOGE("The group instance is NULL or its function ptr is NULL!"); return HC_ERR_NULL_PTR; } - return instance->createGroup(jsonParams, returnJsonStr); + return instance->createGroup(osAccountId, jsonParams, returnJsonStr); } -static int32_t DeleteGroup(CJson *jsonParams, char **returnJsonStr) +static int32_t DeleteGroup(int32_t osAccountId, CJson *jsonParams, char **returnJsonStr) { if ((jsonParams == NULL) || (returnJsonStr == NULL)) { LOGE("The input parameters contains NULL value!"); @@ -233,9 +415,9 @@ static int32_t DeleteGroup(CJson *jsonParams, char **returnJsonStr) int32_t groupType = PEER_TO_PEER_GROUP; if (((result = GetGroupIdFromJson(jsonParams, &groupId)) != HC_SUCCESS) || ((result = GetAppIdFromJson(jsonParams, &appId)) != HC_SUCCESS) || - ((result = CheckGroupExist(groupId)) != HC_SUCCESS) || - ((result = GetGroupTypeFromDb(groupId, &groupType)) != HC_SUCCESS) || - ((result = CheckPermForGroup(GROUP_DISBAND, appId, groupId)) != HC_SUCCESS)) { + ((result = CheckGroupExist(osAccountId, groupId)) != HC_SUCCESS) || + ((result = GetGroupTypeFromDb(osAccountId, groupId, &groupType)) != HC_SUCCESS) || + ((result = CheckPermForGroup(osAccountId, GROUP_DISBAND, appId, groupId)) != HC_SUCCESS)) { return result; } BaseGroup *instance = GetGroupInstance(groupType); @@ -243,10 +425,11 @@ static int32_t DeleteGroup(CJson *jsonParams, char **returnJsonStr) LOGE("The group instance is NULL or its function ptr is NULL!"); return HC_ERR_NULL_PTR; } - return instance->deleteGroup(jsonParams, returnJsonStr); + return instance->deleteGroup(osAccountId, jsonParams, returnJsonStr); } -static int32_t AddMemberToPeerToPeerGroup(int64_t requestId, CJson *jsonParams, const DeviceAuthCallback *callback) +static int32_t AddMemberToPeerToPeerGroup(int32_t osAccountId, int64_t requestId, CJson *jsonParams, + const DeviceAuthCallback *callback) { if ((jsonParams == NULL) || (callback == NULL)) { LOGE("The input parameters contains NULL value!"); @@ -261,10 +444,11 @@ static int32_t AddMemberToPeerToPeerGroup(int64_t requestId, CJson *jsonParams, LOGE("The group instance is NULL or its function ptr is NULL!"); return HC_ERR_NULL_PTR; } - return instance->addMember(requestId, jsonParams, callback); + return instance->addMember(osAccountId, requestId, jsonParams, callback); } -static int32_t DeleteMemberFromPeerToPeerGroup(int64_t requestId, CJson *jsonParams, const DeviceAuthCallback *callback) +static int32_t DeleteMemberFromPeerToPeerGroup(int32_t osAccountId, int64_t requestId, CJson *jsonParams, + const DeviceAuthCallback *callback) { if ((jsonParams == NULL) || (callback == NULL)) { LOGE("The input parameters contains NULL value!"); @@ -279,7 +463,7 @@ static int32_t DeleteMemberFromPeerToPeerGroup(int64_t requestId, CJson *jsonPar LOGE("The group instance is NULL or its function ptr is NULL!"); return HC_ERR_NULL_PTR; } - return instance->deleteMember(requestId, jsonParams, callback); + return instance->deleteMember(osAccountId, requestId, jsonParams, callback); } static int32_t ProcessBindData(int64_t requestId, CJson *jsonParams, const DeviceAuthCallback *callback) @@ -342,7 +526,8 @@ static int32_t SyncAcrossAccountGroup(const char *appId, const char *userIdHash, return instance->syncGroup(appId, userIdHash, deviceId, sharedUserIdHashList); } -static int32_t AddGroupRoleWithCheck(bool isManager, const char *appId, const char *groupId, const char *roleAppId) +static int32_t AddGroupRoleWithCheck(int32_t osAccuntId, bool isManager, const char *appId, const char *groupId, + const char *roleAppId) { if ((appId == NULL) || (groupId == NULL) || (roleAppId == NULL)) { LOGE("The input parameters contains NULL value!"); @@ -357,10 +542,11 @@ static int32_t AddGroupRoleWithCheck(bool isManager, const char *appId, const ch LOGE("The group instance is NULL or its function ptr is NULL!"); return HC_ERR_NULL_PTR; } - return instance->addGroupRole(isManager, appId, groupId, roleAppId); + return instance->addGroupRole(osAccuntId, isManager, appId, groupId, roleAppId); } -static int32_t DeleteGroupRoleWithCheck(bool isManager, const char *appId, const char *groupId, const char *roleAppId) +static int32_t DeleteGroupRoleWithCheck(int32_t osAccuntId, bool isManager, const char *appId, const char *groupId, + const char *roleAppId) { if ((appId == NULL) || (groupId == NULL) || (roleAppId == NULL)) { LOGE("The input parameters contains NULL value!"); @@ -375,11 +561,11 @@ static int32_t DeleteGroupRoleWithCheck(bool isManager, const char *appId, const LOGE("The group instance is NULL or its function ptr is NULL!"); return HC_ERR_NULL_PTR; } - return instance->deleteGroupRole(isManager, appId, groupId, roleAppId); + return instance->deleteGroupRole(osAccuntId, isManager, appId, groupId, roleAppId); } -static int32_t GetGroupRolesWithCheck(bool isManager, const char *appId, const char *groupId, char **returnJsonStr, - uint32_t *returnSize) +static int32_t GetGroupRolesWithCheck(int32_t osAccuntId, bool isManager, const char *appId, const char *groupId, + char **returnJsonStr, uint32_t *returnSize) { if ((appId == NULL) || (groupId == NULL) || (returnJsonStr == NULL) || (returnSize == NULL)) { LOGE("The input parameters contains NULL value!"); @@ -394,7 +580,7 @@ static int32_t GetGroupRolesWithCheck(bool isManager, const char *appId, const c LOGE("The group instance is NULL or its function ptr is NULL!"); return HC_ERR_NULL_PTR; } - return instance->getGroupRoles(isManager, appId, groupId, returnJsonStr, returnSize); + return instance->getGroupRoles(osAccuntId, isManager, appId, groupId, returnJsonStr, returnSize); } static int32_t GetOpCodeWhenAdd(const CJson *jsonParams) @@ -414,7 +600,7 @@ static void DoCreateGroup(HcTaskBase *baseTask) GroupManagerTask *task = (GroupManagerTask *)baseTask; LOGI("[Start]: DoCreateGroup! [ReqId]: %" PRId64, task->reqId); char *returnJsonStr = NULL; - int32_t result = CreateGroup(task->params, &returnJsonStr); + int32_t result = CreateGroup(task->osAccountId, task->params, &returnJsonStr); if (result != HC_SUCCESS) { ProcessErrorCallback(task->reqId, GROUP_CREATE, result, NULL, task->cb); } else { @@ -432,7 +618,7 @@ static void DoDeleteGroup(HcTaskBase *baseTask) GroupManagerTask *task = (GroupManagerTask *)baseTask; LOGI("[Start]: DoDeleteGroup! [ReqId]: %" PRId64, task->reqId); char *returnJsonStr = NULL; - int32_t result = DeleteGroup(task->params, &returnJsonStr); + int32_t result = DeleteGroup(task->osAccountId, task->params, &returnJsonStr); if (result != HC_SUCCESS) { ProcessErrorCallback(task->reqId, GROUP_DISBAND, result, NULL, task->cb); } else { @@ -449,7 +635,7 @@ static void DoAddMember(HcTaskBase *baseTask) } GroupManagerTask *task = (GroupManagerTask *)baseTask; LOGI("[Start]: DoAddMember! [ReqId]: %" PRId64, task->reqId); - (void)AddMemberToPeerToPeerGroup(task->reqId, task->params, task->cb); + (void)AddMemberToPeerToPeerGroup(task->osAccountId, task->reqId, task->params, task->cb); } static void DoDeleteMember(HcTaskBase *baseTask) @@ -460,7 +646,7 @@ static void DoDeleteMember(HcTaskBase *baseTask) } GroupManagerTask *task = (GroupManagerTask *)baseTask; LOGI("[Start]: DoDeleteMember! [ReqId]: %" PRId64, task->reqId); - (void)DeleteMemberFromPeerToPeerGroup(task->reqId, task->params, task->cb); + (void)DeleteMemberFromPeerToPeerGroup(task->osAccountId, task->reqId, task->params, task->cb); } static void DoProcessBindData(HcTaskBase *baseTask) @@ -496,10 +682,11 @@ static void DoConfirmRequest(HcTaskBase *baseTask) OnConfirmed(task->reqId, task->params); } -static int32_t RequestCreateGroup(int64_t requestId, const char *appId, const char *createParams) +static int32_t RequestCreateGroup(int32_t osAccountId, int64_t requestId, const char *appId, const char *createParams) { - if ((appId == NULL) || (createParams == NULL)) { - LOGE("The input parameters contains NULL value!"); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if ((appId == NULL) || (createParams == NULL) || (osAccountId == INVALID_OS_ACCOUNT)) { + LOGE("Invalid input parameters!"); return HC_ERR_INVALID_PARAMS; } LOGI("[Start]: RequestCreateGroup! [AppId]: %s, [RequestId]: %" PRId64, appId, requestId); @@ -513,7 +700,7 @@ static int32_t RequestCreateGroup(int64_t requestId, const char *appId, const ch FreeJson(params); return result; } - if (InitAndPushGMTask(GROUP_CREATE, requestId, params, DoCreateGroup) != HC_SUCCESS) { + if (InitAndPushGMTask(osAccountId, GROUP_CREATE, requestId, params, DoCreateGroup) != HC_SUCCESS) { FreeJson(params); return HC_ERR_INIT_TASK_FAIL; } @@ -521,10 +708,11 @@ static int32_t RequestCreateGroup(int64_t requestId, const char *appId, const ch return HC_SUCCESS; } -static int32_t RequestDeleteGroup(int64_t requestId, const char *appId, const char *disbandParams) +static int32_t RequestDeleteGroup(int32_t osAccountId, int64_t requestId, const char *appId, const char *disbandParams) { - if ((appId == NULL) || (disbandParams == NULL)) { - LOGE("The input parameters contains NULL value!"); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if ((appId == NULL) || (disbandParams == NULL) || (osAccountId == INVALID_OS_ACCOUNT)) { + LOGE("Invalid input parameters!"); return HC_ERR_INVALID_PARAMS; } LOGI("[Start]: RequestDeleteGroup! [AppId]: %s, [RequestId]: %" PRId64, appId, requestId); @@ -538,7 +726,7 @@ static int32_t RequestDeleteGroup(int64_t requestId, const char *appId, const ch FreeJson(params); return result; } - if (InitAndPushGMTask(GROUP_DISBAND, requestId, params, DoDeleteGroup) != HC_SUCCESS) { + if (InitAndPushGMTask(osAccountId, GROUP_DISBAND, requestId, params, DoDeleteGroup) != HC_SUCCESS) { FreeJson(params); return HC_ERR_INIT_TASK_FAIL; } @@ -546,10 +734,11 @@ static int32_t RequestDeleteGroup(int64_t requestId, const char *appId, const ch return HC_SUCCESS; } -static int32_t RequestAddMemberToGroup(int64_t requestId, const char *appId, const char *addParams) +static int32_t RequestAddMemberToGroup(int32_t osAccountId, int64_t requestId, const char *appId, const char *addParams) { - if ((appId == NULL) || (addParams == NULL)) { - LOGE("The input parameters contains NULL value!"); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if ((appId == NULL) || (addParams == NULL) || (osAccountId == INVALID_OS_ACCOUNT)) { + LOGE("Invalid input parameters!"); return HC_ERR_INVALID_PARAMS; } LOGI("[Start]: RequestAddMemberToGroup! [AppId]: %s, [RequestId]: %" PRId64, appId, requestId); @@ -564,7 +753,7 @@ static int32_t RequestAddMemberToGroup(int64_t requestId, const char *appId, con FreeJson(params); return result; } - if (InitAndPushGMTask(opCode, requestId, params, DoAddMember) != HC_SUCCESS) { + if (InitAndPushGMTask(osAccountId, opCode, requestId, params, DoAddMember) != HC_SUCCESS) { FreeJson(params); return HC_ERR_INIT_TASK_FAIL; } @@ -572,10 +761,12 @@ static int32_t RequestAddMemberToGroup(int64_t requestId, const char *appId, con return HC_SUCCESS; } -static int32_t RequestDeleteMemberFromGroup(int64_t requestId, const char *appId, const char *deleteParams) +static int32_t RequestDeleteMemberFromGroup(int32_t osAccountId, int64_t requestId, const char *appId, + const char *deleteParams) { - if ((appId == NULL) || (deleteParams == NULL)) { - LOGE("The input parameters contains NULL value!"); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if ((appId == NULL) || (deleteParams == NULL) || (osAccountId == INVALID_OS_ACCOUNT)) { + LOGE("Invalid input parameters!"); return HC_ERR_INVALID_PARAMS; } LOGI("[Start]: RequestDeleteMemberFromGroup! [AppId]: %s, [RequestId]: %" PRId64, appId, requestId); @@ -589,7 +780,7 @@ static int32_t RequestDeleteMemberFromGroup(int64_t requestId, const char *appId FreeJson(params); return result; } - if (InitAndPushGMTask(MEMBER_DELETE, requestId, params, DoDeleteMember) != HC_SUCCESS) { + if (InitAndPushGMTask(osAccountId, MEMBER_DELETE, requestId, params, DoDeleteMember) != HC_SUCCESS) { FreeJson(params); return HC_ERR_INIT_TASK_FAIL; } @@ -620,7 +811,7 @@ static int32_t RequestProcessBindData(int64_t requestId, const uint8_t *data, ui FreeJson(params); return HC_ERR_INVALID_PARAMS; } - if (InitAndPushGMTask(CODE_NULL, requestId, params, DoProcessBindData) != HC_SUCCESS) { + if (InitAndPushGMTask(INVALID_OS_ACCOUNT, CODE_NULL, requestId, params, DoProcessBindData) != HC_SUCCESS) { FreeJson(params); return HC_ERR_INIT_TASK_FAIL; } @@ -628,10 +819,12 @@ static int32_t RequestProcessBindData(int64_t requestId, const uint8_t *data, ui return HC_SUCCESS; } -static int32_t RequestConfirmRequest(int64_t requestId, const char *appId, const char *confirmParams) +static int32_t RequestConfirmRequest(int32_t osAccountId, int64_t requestId, const char *appId, + const char *confirmParams) { - if ((appId == NULL) || (confirmParams == NULL)) { - LOGE("The input parameters contains NULL value!"); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if ((appId == NULL) || (confirmParams == NULL) || (osAccountId == INVALID_OS_ACCOUNT)) { + LOGE("Invalid input parameters!"); return HC_ERR_INVALID_PARAMS; } LOGI("[Start]: RequestConfirmRequest! [AppId]: %s, [RequestId]: %" PRId64, appId, requestId); @@ -645,7 +838,7 @@ static int32_t RequestConfirmRequest(int64_t requestId, const char *appId, const FreeJson(params); return HC_ERR_JSON_FAIL; } - if (InitAndPushGMTask(CODE_NULL, requestId, params, DoConfirmRequest) != HC_SUCCESS) { + if (InitAndPushGMTask(osAccountId, CODE_NULL, requestId, params, DoConfirmRequest) != HC_SUCCESS) { FreeJson(params); return HC_ERR_INIT_TASK_FAIL; } @@ -679,51 +872,54 @@ static int32_t UnRegListener(const char *appId) return RemoveListener(appId); } -static int32_t CheckAccessToGroup(const char *appId, const char *groupId) +static int32_t CheckAccessToGroup(int32_t osAccountId, const char *appId, const char *groupId) { - if ((appId == NULL) || (groupId == NULL)) { - LOGE("The input parameters contains NULL value!"); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if ((appId == NULL) || (groupId == NULL) || (osAccountId == INVALID_OS_ACCOUNT)) { + LOGE("Invalid input parameters!"); return HC_ERR_INVALID_PARAMS; } - if (!IsGroupAccessible(groupId, appId)) { + if (!IsGroupAccessible(osAccountId, groupId, appId)) { LOGE("You do not have the permission to query the group information!"); return HC_ERR_ACCESS_DENIED; } return HC_SUCCESS; } -static int32_t GetAccessibleGroupInfoById(const char *appId, const char *groupId, char **returnGroupInfo) +static int32_t GetAccessibleGroupInfoById(int32_t osAccountId, const char *appId, const char *groupId, + char **returnGroupInfo) { - if ((appId == NULL) || (groupId == NULL) || (returnGroupInfo == NULL)) { - LOGE("The input parameters contains NULL value!"); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if ((appId == NULL) || (groupId == NULL) || (returnGroupInfo == NULL) || (osAccountId == INVALID_OS_ACCOUNT)) { + LOGE("Invalid input parameters!"); return HC_ERR_INVALID_PARAMS; } - if (!IsGroupExistByGroupId(groupId)) { + if (!IsGroupExistByGroupId(osAccountId, groupId)) { LOGE("No group is found based on the query parameters!"); return HC_ERR_GROUP_NOT_EXIST; } - if (!IsGroupAccessible(groupId, appId)) { + if (!IsGroupAccessible(osAccountId, groupId, appId)) { LOGE("You do not have the permission to query the group information!"); return HC_ERR_ACCESS_DENIED; } - GroupInfo *groupInfo = CreateGroupInfoStruct(); + TrustedGroupEntry *groupInfo = CreateGroupEntry(); if (groupInfo == NULL) { LOGE("Failed to allocate groupInfo memory!"); return HC_ERR_ALLOC_MEMORY; } - if (GetGroupInfoById(groupId, groupInfo) != HC_SUCCESS) { + if (GetGroupInfoById(osAccountId, groupId, groupInfo) != HC_SUCCESS) { LOGE("Failed to obtain the group information from the database!"); - DestroyGroupInfoStruct(groupInfo); + DestroyGroupEntry(groupInfo); return HC_ERR_DB; } CJson *groupInfoJson = CreateJson(); if (groupInfoJson == NULL) { LOGE("Failed to allocate groupInfoJson memory!"); - DestroyGroupInfoStruct(groupInfo); + DestroyGroupEntry(groupInfo); return HC_ERR_JSON_FAIL; } int32_t result = GenerateReturnGroupInfo(groupInfo, groupInfoJson); - DestroyGroupInfoStruct(groupInfo); + DestroyGroupEntry(groupInfo); if (result != HC_SUCCESS) { FreeJson(groupInfoJson); return result; @@ -737,11 +933,13 @@ static int32_t GetAccessibleGroupInfoById(const char *appId, const char *groupId return HC_SUCCESS; } -static int32_t GetAccessibleGroupInfo(const char *appId, const char *queryParams, char **returnGroupVec, - uint32_t *groupNum) +static int32_t GetAccessibleGroupInfo(int32_t osAccountId, const char *appId, const char *queryParams, + char **returnGroupVec, uint32_t *groupNum) { - if ((appId == NULL) || (queryParams == NULL) || (returnGroupVec == NULL) || (groupNum == NULL)) { - LOGE("The input parameters contains NULL value!"); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if ((appId == NULL) || (queryParams == NULL) || (returnGroupVec == NULL) || (groupNum == NULL) || + (osAccountId == INVALID_OS_ACCOUNT)) { + LOGE("Invalid input parameters!"); return HC_ERR_INVALID_PARAMS; } CJson *queryParamsJson = CreateJsonFromString(queryParams); @@ -764,97 +962,100 @@ static int32_t GetAccessibleGroupInfo(const char *appId, const char *queryParams FreeJson(queryParamsJson); return HC_ERR_INVALID_PARAMS; } - GroupInfoVec groupInfoVec; - CreateGroupInfoVecStruct(&groupInfoVec); - int32_t result = GetGroupInfo(groupType, groupId, groupName, groupOwner, &groupInfoVec); + GroupEntryVec groupEntryVec = CreateGroupEntryVec(); + int32_t result = GetGroupInfo(osAccountId, groupType, groupId, groupName, groupOwner, &groupEntryVec); FreeJson(queryParamsJson); if (result != HC_SUCCESS) { - DestroyGroupInfoVecStruct(&groupInfoVec); + ClearGroupEntryVec(&groupEntryVec); return result; } - RemoveNoPermissionGroup(&groupInfoVec, appId); - result = GenerateReturnGroupVec(&groupInfoVec, returnGroupVec, groupNum); - DestroyGroupInfoVecStruct(&groupInfoVec); + RemoveNoPermissionGroup(osAccountId, &groupEntryVec, appId); + result = GenerateReturnGroupVec(&groupEntryVec, returnGroupVec, groupNum); + ClearGroupEntryVec(&groupEntryVec); return result; } -static int32_t GetAccessibleJoinedGroups(const char *appId, int groupType, char **returnGroupVec, uint32_t *groupNum) +static int32_t GetAccessibleJoinedGroups(int32_t osAccountId, const char *appId, int groupType, + char **returnGroupVec, uint32_t *groupNum) { - if ((appId == NULL) || (returnGroupVec == NULL) || (groupNum == NULL)) { - LOGE("The input parameters contains NULL value!"); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if ((appId == NULL) || (returnGroupVec == NULL) || (groupNum == NULL) || (osAccountId == INVALID_OS_ACCOUNT)) { + LOGE("Invalid input parameters!"); return HC_ERR_INVALID_PARAMS; } if (!IsGroupTypeSupported(groupType)) { LOGE("Invalid group type!"); return HC_ERR_INVALID_PARAMS; } - GroupInfoVec groupInfoVec; - CreateGroupInfoVecStruct(&groupInfoVec); - int32_t result = GetJoinedGroups(groupType, &groupInfoVec); + GroupEntryVec groupEntryVec = CreateGroupEntryVec(); + int32_t result = GetJoinedGroups(osAccountId, groupType, &groupEntryVec); if (result != HC_SUCCESS) { - DestroyGroupInfoVecStruct(&groupInfoVec); + ClearGroupEntryVec(&groupEntryVec); return result; } - RemoveNoPermissionGroup(&groupInfoVec, appId); - result = GenerateReturnGroupVec(&groupInfoVec, returnGroupVec, groupNum); - DestroyGroupInfoVecStruct(&groupInfoVec); + RemoveNoPermissionGroup(osAccountId, &groupEntryVec, appId); + result = GenerateReturnGroupVec(&groupEntryVec, returnGroupVec, groupNum); + ClearGroupEntryVec(&groupEntryVec); return result; } -static int32_t GetAccessibleRelatedGroups(const char *appId, const char *peerDeviceId, bool isUdid, +static int32_t GetAccessibleRelatedGroups(int32_t osAccountId, const char *appId, const char *peerDeviceId, bool isUdid, char **returnGroupVec, uint32_t *groupNum) { - if ((appId == NULL) || (peerDeviceId == NULL) || (returnGroupVec == NULL) || (groupNum == NULL)) { - LOGE("The input parameters contains NULL value!"); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if ((appId == NULL) || (peerDeviceId == NULL) || (returnGroupVec == NULL) || (groupNum == NULL) || + (osAccountId == INVALID_OS_ACCOUNT)) { + LOGE("Invalid input parameters!"); return HC_ERR_INVALID_PARAMS; } LOGI("Start to get related groups! [AppId]: %s", appId); - GroupInfoVec groupInfoVec; - CreateGroupInfoVecStruct(&groupInfoVec); - int32_t result = GetRelatedGroups(peerDeviceId, isUdid, &groupInfoVec); + GroupEntryVec groupEntryVec = CreateGroupEntryVec(); + int32_t result = GetRelatedGroups(osAccountId, peerDeviceId, isUdid, &groupEntryVec); if (result != HC_SUCCESS) { - DestroyGroupInfoVecStruct(&groupInfoVec); + ClearGroupEntryVec(&groupEntryVec); return result; } - RemoveNoPermissionGroup(&groupInfoVec, appId); - result = GenerateReturnGroupVec(&groupInfoVec, returnGroupVec, groupNum); - DestroyGroupInfoVecStruct(&groupInfoVec); + RemoveNoPermissionGroup(osAccountId, &groupEntryVec, appId); + result = GenerateReturnGroupVec(&groupEntryVec, returnGroupVec, groupNum); + ClearGroupEntryVec(&groupEntryVec); return result; } -static int32_t GetAccessibleDeviceInfoById(const char *appId, const char *deviceId, bool isUdid, +static int32_t GetAccessibleDeviceInfoById(int32_t osAccountId, const char *appId, const char *deviceId, bool isUdid, const char *groupId, char **returnDeviceInfo) { - if ((appId == NULL) || (deviceId == NULL) || (groupId == NULL) || (returnDeviceInfo == NULL)) { - LOGE("The input parameters contains NULL value!"); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if ((appId == NULL) || (deviceId == NULL) || (groupId == NULL) || (returnDeviceInfo == NULL) || + (osAccountId == INVALID_OS_ACCOUNT)) { + LOGE("Invalid input parameters!"); return HC_ERR_INVALID_PARAMS; } - if (!IsGroupExistByGroupId(groupId)) { + if (!IsGroupExistByGroupId(osAccountId, groupId)) { LOGE("No group is found based on the query parameters!"); return HC_ERR_GROUP_NOT_EXIST; } - if (!IsGroupAccessible(groupId, appId)) { + if (!IsGroupAccessible(osAccountId, groupId, appId)) { LOGE("You do not have the permission to query the group information!"); return HC_ERR_ACCESS_DENIED; } - DeviceInfo *devInfo = CreateDeviceInfoStruct(); - if (devInfo == NULL) { - LOGE("Failed to allocate devInfo memory!"); + TrustedDeviceEntry *deviceEntry = CreateDeviceEntry(); + if (deviceEntry == NULL) { + LOGE("Failed to allocate deviceEntry memory!"); return HC_ERR_ALLOC_MEMORY; } - if (GetTrustedDevInfoById(deviceId, isUdid, groupId, devInfo) != HC_SUCCESS) { + if (GetTrustedDevInfoById(osAccountId, deviceId, isUdid, groupId, deviceEntry) != HC_SUCCESS) { LOGE("No device is found based on the query parameters!"); - DestroyDeviceInfoStruct(devInfo); + DestroyDeviceEntry(deviceEntry); return HC_ERR_DEVICE_NOT_EXIST; } CJson *devInfoJson = CreateJson(); if (devInfoJson == NULL) { LOGE("Failed to allocate devInfoJson memory!"); - DestroyDeviceInfoStruct(devInfo); + DestroyDeviceEntry(deviceEntry); return HC_ERR_JSON_FAIL; } - int32_t result = GenerateReturnDevInfo(devInfo, devInfoJson); - DestroyDeviceInfoStruct(devInfo); + int32_t result = GenerateReturnDevInfo(deviceEntry, devInfoJson); + DestroyDeviceEntry(deviceEntry); if (result != HC_SUCCESS) { FreeJson(devInfoJson); return result; @@ -868,48 +1069,91 @@ static int32_t GetAccessibleDeviceInfoById(const char *appId, const char *device return HC_SUCCESS; } -static int32_t GetAccessibleTrustedDevices(const char *appId, const char *groupId, +static int32_t GetAccessibleTrustedDevices(int32_t osAccountId, const char *appId, const char *groupId, char **returnDevInfoVec, uint32_t *deviceNum) { - if ((appId == NULL) || (groupId == NULL) || (returnDevInfoVec == NULL) || (deviceNum == NULL)) { - LOGE("The input parameters contains NULL value!"); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if ((appId == NULL) || (groupId == NULL) || (returnDevInfoVec == NULL) || (deviceNum == NULL) || + (osAccountId == INVALID_OS_ACCOUNT)) { + LOGE("Invalid input parameters!"); return HC_ERR_INVALID_PARAMS; } - if (!IsGroupExistByGroupId(groupId)) { + if (!IsGroupExistByGroupId(osAccountId, groupId)) { LOGE("No group is found based on the query parameters!"); return HC_ERR_GROUP_NOT_EXIST; } - if (!IsGroupAccessible(groupId, appId)) { + if (!IsGroupAccessible(osAccountId, groupId, appId)) { LOGE("You do not have the permission to query the group information!"); return HC_ERR_ACCESS_DENIED; } - DeviceInfoVec deviceInfoVec; - CreateDeviceInfoVecStruct(&deviceInfoVec); - int32_t result = GetTrustedDevices(groupId, &deviceInfoVec); + DeviceEntryVec deviceEntryVec = CreateDeviceEntryVec(); + int32_t result = GetTrustedDevices(osAccountId, groupId, &deviceEntryVec); if (result != HC_SUCCESS) { - DestroyDeviceInfoVecStruct(&deviceInfoVec); + ClearDeviceEntryVec(&deviceEntryVec); return result; } - result = GenerateReturnDeviceVec(&deviceInfoVec, returnDevInfoVec, deviceNum); - DestroyDeviceInfoVecStruct(&deviceInfoVec); + result = GenerateReturnDeviceVec(&deviceEntryVec, returnDevInfoVec, deviceNum); + ClearDeviceEntryVec(&deviceEntryVec); return result; } -static bool IsDeviceInAccessibleGroup(const char *appId, const char *groupId, const char *deviceId, bool isUdid) +static bool IsDeviceInAccessibleGroup(int32_t osAccountId, const char *appId, const char *groupId, + const char *deviceId, bool isUdid) { - if ((appId == NULL) || (groupId == NULL) || (deviceId == NULL)) { - LOGE("The input parameters contains NULL value!"); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if ((appId == NULL) || (groupId == NULL) || (deviceId == NULL) || (osAccountId == INVALID_OS_ACCOUNT)) { + LOGE("Invalid input parameters!"); return false; } - if (!IsGroupExistByGroupId(groupId)) { + if (!IsGroupExistByGroupId(osAccountId, groupId)) { LOGE("No group is found based on the query parameters!"); return false; } - if (!IsGroupAccessible(groupId, appId)) { + if (!IsGroupAccessible(osAccountId, groupId, appId)) { LOGE("You do not have the permission to query the group information!"); return false; } - return IsTrustedDeviceInGroup(groupId, deviceId, isUdid); + return IsTrustedDeviceInGroup(osAccountId, groupId, deviceId, isUdid); +} + +static int32_t GetPkInfoList(int32_t osAccountId, const char *appId, const char *queryParams, + char **returnInfoList, uint32_t *returnInfoNum) +{ + LOGI("[Start]: start to get pk list!"); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if ((appId == NULL) || (queryParams == NULL) || (returnInfoList == NULL) || + (returnInfoNum == NULL) || (osAccountId == INVALID_OS_ACCOUNT)) { + LOGE("Invalid input parameters!"); + return HC_ERR_INVALID_PARAMS; + } + CJson *params = CreateJsonFromString(queryParams); + if (params == NULL) { + LOGE("Failed to create json from string!"); + return HC_ERR_JSON_CREATE; + } + CJson *pkInfoList = CreateJsonArray(); + if (pkInfoList == NULL) { + LOGE("Failed to create json array!"); + FreeJson(params); + return HC_ERR_JSON_CREATE; + } + int32_t res = GeneratePkInfoList(osAccountId, appId, params, pkInfoList); + FreeJson(params); + if (res != HC_SUCCESS) { + FreeJson(pkInfoList); + return res; + } + int32_t pkInfoNum = GetItemNum(pkInfoList); + char *pkInfoListStr = PackJsonToString(pkInfoList); + FreeJson(pkInfoList); + if (pkInfoListStr == NULL) { + LOGE("Failed to convert json to string!"); + return HC_ERR_PACKAGE_JSON_TO_STRING_FAIL; + } + *returnInfoList = pkInfoListStr; + *returnInfoNum = pkInfoNum; + LOGI("[End]: Get pk list successfully!"); + return HC_SUCCESS; } static void DestroyInfo(char **returnInfo) @@ -943,6 +1187,7 @@ static const GroupImpl g_groupImplInstance = { .getAccessibleDeviceInfoById = GetAccessibleDeviceInfoById, .getAccessibleTrustedDevices = GetAccessibleTrustedDevices, .isDeviceInAccessibleGroup = IsDeviceInAccessibleGroup, + .getPkInfoList = GetPkInfoList, .destroyInfo = DestroyInfo }; @@ -954,15 +1199,11 @@ int32_t InitGroupRelatedModule(void) return HC_ERR_SERVICE_NEED_RESTART; } } - if (IsAcrossAccountGroupSupported()) { - RegGenerateGroupIdFunc(((AcrossAccountGroup *)GetAcrossAccountGroupInstance())->generateGroupId); - } return HC_SUCCESS; } void DestroyGroupRelatedModule(void) { - DeregGenerateGroupIdFunc(); DestroyBroadcastManager(); } diff --git a/services/group_manager/src/group_operation/group_operation_common.c b/services/group_manager/src/group_operation/group_operation_common.c index 29df55a..117f124 100644 --- a/services/group_manager/src/group_operation/group_operation_common.c +++ b/services/group_manager/src/group_operation/group_operation_common.c @@ -17,14 +17,339 @@ #include "alg_loader.h" #include "string_util.h" -#include "database_manager.h" +#include "common_defs.h" +#include "data_manager.h" #include "dev_auth_module_manager.h" +#include "device_auth_defines.h" #include "group_operation.h" #include "hal_error.h" #include "hc_dev_info.h" #include "hc_log.h" -static int32_t AddGroupNameToReturn(const GroupInfo *groupInfo, CJson *json) +static bool IsGroupManager(const char *appId, const TrustedGroupEntry *entry) +{ + uint32_t index; + HcString *manager = NULL; + FOR_EACH_HC_VECTOR(entry->managers, index, manager) { + if (strcmp(StringGet(manager), appId) == 0) { + return true; + } + } + return false; +} + +static bool IsGroupFriend(const char *appId, const TrustedGroupEntry *entry) +{ + uint32_t index; + HcString *trustedFriend = NULL; + FOR_EACH_HC_VECTOR(entry->friends, index, trustedFriend) { + if (strcmp(StringGet(trustedFriend), appId) == 0) { + return true; + } + } + return false; +} + +static int32_t GetGroupNumByOwner(int32_t osAccountId, const char *ownerName) +{ + if (ownerName == NULL) { + LOGE("The input ownerName is NULL!"); + return 0; + } + int count = 0; + QueryGroupParams queryParams = InitQueryGroupParams(); + queryParams.ownerName = ownerName; + GroupEntryVec groupEntryVec = CreateGroupEntryVec(); + int32_t result = QueryGroups(osAccountId, &queryParams, &groupEntryVec); + if (result != HC_SUCCESS) { + LOGE("Failed to query groups!"); + ClearGroupEntryVec(&groupEntryVec); + return count; + } + count = HC_VECTOR_SIZE(&groupEntryVec); + ClearGroupEntryVec(&groupEntryVec); + return count; +} + +TrustedDeviceEntry *GetTrustedDeviceEntryById(int32_t osAccountId, const char *deviceId, bool isUdid, + const char *groupId) +{ + uint32_t index; + TrustedDeviceEntry **deviceEntry = NULL; + DeviceEntryVec deviceEntryVec = CreateDeviceEntryVec(); + QueryDeviceParams params = InitQueryDeviceParams(); + params.groupId = groupId; + if (isUdid) { + params.udid = deviceId; + } else { + params.authId = deviceId; + } + if (QueryDevices(osAccountId, ¶ms, &deviceEntryVec) != HC_SUCCESS) { + LOGE("Failed to query trusted devices!"); + ClearDeviceEntryVec(&deviceEntryVec); + return NULL; + } + FOR_EACH_HC_VECTOR(deviceEntryVec, index, deviceEntry) { + if ((deviceEntry != NULL) && (*deviceEntry != NULL)) { + TrustedDeviceEntry *returnEntry = DeepCopyDeviceEntry(*deviceEntry); + ClearDeviceEntryVec(&deviceEntryVec); + return returnEntry; + } + } + ClearDeviceEntryVec(&deviceEntryVec); + return NULL; +} + +TrustedGroupEntry *GetGroupEntryById(int32_t osAccountId, const char *groupId) +{ + if (groupId == NULL) { + LOGE("The input groupId is NULL!"); + return NULL; + } + uint32_t index; + TrustedGroupEntry **entry = NULL; + GroupEntryVec groupEntryVec = CreateGroupEntryVec(); + QueryGroupParams params = InitQueryGroupParams(); + params.groupId = groupId; + if (QueryGroups(osAccountId, ¶ms, &groupEntryVec) != HC_SUCCESS) { + LOGE("Failed to query groups!"); + ClearGroupEntryVec(&groupEntryVec); + return NULL; + } + FOR_EACH_HC_VECTOR(groupEntryVec, index, entry) { + if ((entry != NULL) && (*entry != NULL)) { + TrustedGroupEntry *returnEntry = DeepCopyGroupEntry(*entry); + ClearGroupEntryVec(&groupEntryVec); + return returnEntry; + } + } + ClearGroupEntryVec(&groupEntryVec); + return NULL; +} + +bool IsTrustedDeviceInGroup(int32_t osAccountId, const char *groupId, const char *deviceId, bool isUdid) +{ + if ((groupId == NULL) || (deviceId == NULL)) { + LOGE("The input groupId or deviceId is NULL!"); + return false; + } + TrustedDeviceEntry *entry = GetTrustedDeviceEntryById(osAccountId, deviceId, isUdid, groupId); + if (entry == NULL) { + return false; + } + DestroyDeviceEntry(entry); + return true; +} + +int32_t GetGroupInfoById(int32_t osAccountId, const char *groupId, TrustedGroupEntry *returnGroupEntry) +{ + if ((groupId == NULL) || (returnGroupEntry == NULL)) { + LOGE("The input groupId or returnGroupEntry is NULL!"); + return HC_ERR_INVALID_PARAMS; + } + int32_t result; + uint32_t index; + TrustedGroupEntry **entry = NULL; + GroupEntryVec groupEntryVec = CreateGroupEntryVec(); + QueryGroupParams params = InitQueryGroupParams(); + params.groupId = groupId; + result = QueryGroups(osAccountId, ¶ms, &groupEntryVec); + if (result != HC_SUCCESS) { + LOGE("Failed to query groups!"); + ClearGroupEntryVec(&groupEntryVec); + return result; + } + FOR_EACH_HC_VECTOR(groupEntryVec, index, entry) { + if ((entry == NULL) || (*entry == NULL)) { + continue; + } + result = GenerateGroupEntryFromEntry(*entry, returnGroupEntry) ? HC_SUCCESS : HC_ERR_MEMORY_COPY; + ClearGroupEntryVec(&groupEntryVec); + return result; + } + ClearGroupEntryVec(&groupEntryVec); + return HC_ERR_GROUP_NOT_EXIST; +} + +bool IsGroupAccessible(int32_t osAccountId, const char *groupId, const char *appId) +{ + if ((groupId == NULL) || (appId == NULL)) { + LOGE("The input groupId or appId is NULL!"); + return false; + } + TrustedGroupEntry *entry = GetGroupEntryById(osAccountId, groupId); + if (entry == NULL) { + LOGE("The group cannot be found!"); + return false; + } + if ((entry->visibility == GROUP_VISIBILITY_PUBLIC) || + (IsGroupManager(appId, entry)) || + (IsGroupFriend(appId, entry))) { + DestroyGroupEntry(entry); + return true; + } + DestroyGroupEntry(entry); + return false; +} + +int32_t CheckGroupNumLimit(int32_t osAccountId, int32_t groupType, const char *appId) +{ + /* Currently, only peer to peer group is supported. */ + (void)groupType; + if (GetGroupNumByOwner(osAccountId, appId) >= HC_TRUST_GROUP_ENTRY_MAX_NUM) { + LOGE("The number of groups created by the service exceeds the maximum!"); + return HC_ERR_BEYOND_LIMIT; + } + return HC_SUCCESS; +} + +bool IsGroupOwner(int32_t osAccountId, const char *groupId, const char *appId) +{ + if ((groupId == NULL) || (appId == NULL)) { + LOGE("The input groupId or appId is NULL!"); + return false; + } + TrustedGroupEntry *entry = GetGroupEntryById(osAccountId, groupId); + if (entry == NULL) { + LOGE("The group cannot be found!"); + return false; + } + if (HC_VECTOR_SIZE(&entry->managers) <= 0) { + LOGE("The group does not have manager and owner!"); + DestroyGroupEntry(entry); + return false; + } + HcString entryManager = HC_VECTOR_GET(&entry->managers, 0); + const char *groupOwner = StringGet(&entryManager); + if ((groupOwner != NULL) && strcmp(groupOwner, appId) == 0) { + DestroyGroupEntry(entry); + return true; + } + DestroyGroupEntry(entry); + return false; +} + +bool IsGroupExistByGroupId(int32_t osAccountId, const char *groupId) +{ + if (groupId == NULL) { + LOGE("The input groupId is NULL!"); + return false; + } + TrustedGroupEntry *entry = GetGroupEntryById(osAccountId, groupId); + if (entry == NULL) { + LOGE("The group cannot be found!"); + return false; + } + DestroyGroupEntry(entry); + return true; +} + +bool IsGroupEditAllowed(int32_t osAccountId, const char *groupId, const char *appId) +{ + if ((groupId == NULL) || (appId == NULL)) { + LOGE("The input groupId or appId is NULL!"); + return false; + } + TrustedGroupEntry *entry = GetGroupEntryById(osAccountId, groupId); + if (entry == NULL) { + LOGE("The group cannot be found!"); + return false; + } + if (IsGroupManager(appId, entry)) { + DestroyGroupEntry(entry); + return true; + } + DestroyGroupEntry(entry); + return false; +} + +int32_t GetGroupInfo(int32_t osAccountId, int groupType, const char *groupId, const char *groupName, + const char *groupOwner, GroupEntryVec *returnGroupEntryVec) +{ + /* Fuzzy query interfaces, so some parameters can be NULL. */ + if (returnGroupEntryVec == NULL) { + LOGE("The input returnGroupEntryVec is NULL!"); + return HC_ERR_INVALID_PARAMS; + } + QueryGroupParams params = InitQueryGroupParams(); + params.groupId = groupId; + params.groupName = groupName; + params.ownerName = groupOwner; + params.groupType = groupType; + return QueryGroups(osAccountId, ¶ms, returnGroupEntryVec); +} + +int32_t GetJoinedGroups(int32_t osAccountId, int groupType, GroupEntryVec *returnGroupEntryVec) +{ + QueryGroupParams params = InitQueryGroupParams(); + params.groupType = groupType; + return QueryGroups(osAccountId, ¶ms, returnGroupEntryVec); +} + +int32_t GetRelatedGroups(int32_t osAccountId, const char *peerDeviceId, bool isUdid, GroupEntryVec *returnGroupEntryVec) +{ + uint32_t index; + TrustedDeviceEntry **entry = NULL; + DeviceEntryVec deviceEntryVec = CreateDeviceEntryVec(); + QueryDeviceParams params = InitQueryDeviceParams(); + params.groupId = NULL; + if (isUdid) { + params.udid = peerDeviceId; + } else { + params.authId = peerDeviceId; + } + int32_t result = QueryDevices(osAccountId, ¶ms, &deviceEntryVec); + if (result != HC_SUCCESS) { + LOGE("Failed to query trusted devices!"); + ClearDeviceEntryVec(&deviceEntryVec); + return result; + } + FOR_EACH_HC_VECTOR(deviceEntryVec, index, entry) { + if ((entry == NULL) || (*entry == NULL)) { + continue; + } + TrustedGroupEntry *groupEntry = GetGroupEntryById(osAccountId, StringGet(&(*entry)->groupId)); + if (groupEntry == NULL) { + LOGE("Failed to get group entry by id!"); + ClearDeviceEntryVec(&deviceEntryVec); + return HC_ERR_GROUP_NOT_EXIST; + } + if (returnGroupEntryVec->pushBackT(returnGroupEntryVec, groupEntry) == NULL) { + DestroyGroupEntry(groupEntry); + ClearDeviceEntryVec(&deviceEntryVec); + return HC_ERR_MEMORY_COPY; + } + } + ClearDeviceEntryVec(&deviceEntryVec); + return HC_SUCCESS; +} + +int32_t GetTrustedDevInfoById(int32_t osAccountId, const char *deviceId, bool isUdid, const char *groupId, + TrustedDeviceEntry *returnDeviceEntry) +{ + if ((deviceId == NULL) || (groupId == NULL) || (returnDeviceEntry == NULL)) { + LOGE("The input parameters contain NULL value!"); + return HC_ERR_INVALID_PARAMS; + } + LOGI("Start to get device information of a specified group!"); + TrustedDeviceEntry *deviceEntry = GetTrustedDeviceEntryById(osAccountId, deviceId, isUdid, groupId); + if (deviceEntry == NULL) { + LOGE("The trusted device is not found!"); + return HC_ERR_DEVICE_NOT_EXIST; + } + int32_t result = GenerateDeviceEntryFromEntry(deviceEntry, returnDeviceEntry) ? HC_SUCCESS : HC_ERR_MEMORY_COPY; + DestroyDeviceEntry(deviceEntry); + return result; +} + +int32_t GetTrustedDevices(int32_t osAccountId, const char *groupId, DeviceEntryVec *returnDeviceEntryVec) +{ + QueryDeviceParams params = InitQueryDeviceParams(); + params.groupId = groupId; + return QueryDevices(osAccountId, ¶ms, returnDeviceEntryVec); +} + +static int32_t AddGroupNameToReturn(const TrustedGroupEntry *groupInfo, CJson *json) { const char *groupName = StringGet(&groupInfo->name); if (groupName == NULL) { @@ -38,7 +363,7 @@ static int32_t AddGroupNameToReturn(const GroupInfo *groupInfo, CJson *json) return HC_SUCCESS; } -static int32_t AddGroupIdToReturn(const GroupInfo *groupInfo, CJson *json) +static int32_t AddGroupIdToReturn(const TrustedGroupEntry *groupInfo, CJson *json) { const char *groupId = StringGet(&groupInfo->id); if (groupId == NULL) { @@ -52,9 +377,10 @@ static int32_t AddGroupIdToReturn(const GroupInfo *groupInfo, CJson *json) return HC_SUCCESS; } -static int32_t AddGroupOwnerToReturn(const GroupInfo *groupInfo, CJson *json) +static int32_t AddGroupOwnerToReturn(const TrustedGroupEntry *groupInfo, CJson *json) { - const char *groupOwner = StringGet(&groupInfo->ownerName); + HcString entryManager = HC_VECTOR_GET(&groupInfo->managers, 0); + const char *groupOwner = StringGet(&entryManager); if (groupOwner == NULL) { LOGE("Failed to get groupOwner from groupInfo!"); return HC_ERR_NULL_PTR; @@ -66,7 +392,7 @@ static int32_t AddGroupOwnerToReturn(const GroupInfo *groupInfo, CJson *json) return HC_SUCCESS; } -static int32_t AddGroupTypeToReturn(const GroupInfo *groupInfo, CJson *json) +static int32_t AddGroupTypeToReturn(const TrustedGroupEntry *groupInfo, CJson *json) { int32_t groupType = groupInfo->type; if (AddIntToJson(json, FIELD_GROUP_TYPE, groupType) != HC_SUCCESS) { @@ -76,7 +402,7 @@ static int32_t AddGroupTypeToReturn(const GroupInfo *groupInfo, CJson *json) return HC_SUCCESS; } -static int32_t AddGroupVisibilityToReturn(const GroupInfo *groupInfo, CJson *json) +static int32_t AddGroupVisibilityToReturn(const TrustedGroupEntry *groupInfo, CJson *json) { int groupVisibility = groupInfo->visibility; if (AddIntToJson(json, FIELD_GROUP_VISIBILITY, groupVisibility) != HC_SUCCESS) { @@ -86,41 +412,7 @@ static int32_t AddGroupVisibilityToReturn(const GroupInfo *groupInfo, CJson *jso return HC_SUCCESS; } -static int32_t AddGroupUserIdHashToReturnIfNeed(const GroupInfo *groupInfo, CJson *json) -{ - if (!IsAccountRelatedGroup(groupInfo->type)) { - return HC_SUCCESS; - } - const char *userIdHash = StringGet(&groupInfo->userIdHash); - if (userIdHash == NULL) { - LOGE("Failed to get userIdHash from groupInfo!"); - return HC_ERR_NULL_PTR; - } - if (AddStringToJson(json, FIELD_USER_ID, userIdHash) != HC_SUCCESS) { - LOGE("Failed to add userIdHash to json!"); - return HC_ERR_JSON_FAIL; - } - return HC_SUCCESS; -} - -static int32_t AddGroupSharedUserIdHashToReturnIfNeed(const GroupInfo *groupInfo, CJson *json) -{ - if (groupInfo->type != ACROSS_ACCOUNT_AUTHORIZE_GROUP) { - return HC_SUCCESS; - } - const char *sharedUserIdHash = StringGet(&groupInfo->sharedUserIdHash); - if (sharedUserIdHash == NULL) { - LOGE("Failed to get sharedUserIdHash from groupInfo!"); - return HC_ERR_NULL_PTR; - } - if (AddStringToJson(json, FIELD_SHARED_USER_ID, sharedUserIdHash) != HC_SUCCESS) { - LOGE("Failed to add sharedUserIdHash to json!"); - return HC_ERR_JSON_FAIL; - } - return HC_SUCCESS; -} - -static int32_t AddAuthIdToReturn(const DeviceInfo *deviceInfo, CJson *json) +static int32_t AddAuthIdToReturn(const TrustedDeviceEntry *deviceInfo, CJson *json) { const char *authId = StringGet(&deviceInfo->authId); if (authId == NULL) { @@ -134,21 +426,7 @@ static int32_t AddAuthIdToReturn(const DeviceInfo *deviceInfo, CJson *json) return HC_SUCCESS; } -static int32_t AddUserIdHashToReturn(const DeviceInfo *deviceInfo, CJson *json) -{ - const char *userIdHash = StringGet(&deviceInfo->userIdHash); - if (userIdHash == NULL) { - LOGE("Failed to get userIdHash from deviceInfo!"); - return HC_ERR_NULL_PTR; - } - if (AddStringToJson(json, FIELD_USER_ID, userIdHash) != HC_SUCCESS) { - LOGE("Failed to add userIdHash to json!"); - return HC_ERR_JSON_FAIL; - } - return HC_SUCCESS; -} - -static int32_t AddCredentialTypeToReturn(const DeviceInfo *deviceInfo, CJson *json) +static int32_t AddCredentialTypeToReturn(const TrustedDeviceEntry *deviceInfo, CJson *json) { int credentialType = deviceInfo->credential; if (AddIntToJson(json, FIELD_CREDENTIAL_TYPE, credentialType) != HC_SUCCESS) { @@ -158,7 +436,7 @@ static int32_t AddCredentialTypeToReturn(const DeviceInfo *deviceInfo, CJson *js return HC_SUCCESS; } -static int32_t AddUserTypeToReturn(const DeviceInfo *deviceInfo, CJson *json) +static int32_t AddUserTypeToReturn(const TrustedDeviceEntry *deviceInfo, CJson *json) { int userType = deviceInfo->devType; if (AddIntToJson(json, FIELD_USER_TYPE, userType) != HC_SUCCESS) { @@ -173,26 +451,23 @@ bool IsAccountRelatedGroup(int groupType) return ((groupType == IDENTICAL_ACCOUNT_GROUP) || (groupType == ACROSS_ACCOUNT_AUTHORIZE_GROUP)); } -int32_t GenerateReturnGroupInfo(const GroupInfo *groupInfo, CJson *returnJson) +int32_t GenerateReturnGroupInfo(const TrustedGroupEntry *groupInfo, CJson *returnJson) { int32_t result; if (((result = AddGroupNameToReturn(groupInfo, returnJson)) != HC_SUCCESS) || ((result = AddGroupIdToReturn(groupInfo, returnJson)) != HC_SUCCESS) || ((result = AddGroupOwnerToReturn(groupInfo, returnJson)) != HC_SUCCESS) || ((result = AddGroupTypeToReturn(groupInfo, returnJson)) != HC_SUCCESS) || - ((result = AddGroupVisibilityToReturn(groupInfo, returnJson)) != HC_SUCCESS) || - ((result = AddGroupUserIdHashToReturnIfNeed(groupInfo, returnJson)) != HC_SUCCESS) || - ((result = AddGroupSharedUserIdHashToReturnIfNeed(groupInfo, returnJson)) != HC_SUCCESS)) { + ((result = AddGroupVisibilityToReturn(groupInfo, returnJson)) != HC_SUCCESS)) { return result; } return HC_SUCCESS; } -int32_t GenerateReturnDevInfo(const DeviceInfo *devInfo, CJson *returnJson) +int32_t GenerateReturnDevInfo(const TrustedDeviceEntry *devInfo, CJson *returnJson) { int32_t result; if (((result = AddAuthIdToReturn(devInfo, returnJson)) != HC_SUCCESS) || - ((result = AddUserIdHashToReturn(devInfo, returnJson)) != HC_SUCCESS) || ((result = AddCredentialTypeToReturn(devInfo, returnJson)) != HC_SUCCESS) || ((result = AddUserTypeToReturn(devInfo, returnJson)) != HC_SUCCESS)) { return result; @@ -242,29 +517,38 @@ int32_t GetHashMessage(const Uint8Buff *first, const Uint8Buff *second, uint8_t return HC_SUCCESS; } -int32_t CheckGroupNumLimit(int32_t groupType, const char *appId) +int32_t GetCurDeviceNumByGroupId(int32_t osAccountId, const char *groupId) { - if ((groupType == IDENTICAL_ACCOUNT_GROUP) && (IsIdenticalGroupExist())) { - LOGE("The identical account group already exists!"); - return HC_ERR_BEYOND_LIMIT; + if (groupId == NULL) { + LOGE("The input groupId is NULL!"); + return 0; } - if (GetGroupNumByOwner(appId) >= HC_TRUST_GROUP_ENTRY_MAX_NUM) { - LOGE("The number of groups created by the service exceeds the maximum!"); - return HC_ERR_BEYOND_LIMIT; + int count = 0; + QueryDeviceParams queryDeviceParams = InitQueryDeviceParams(); + queryDeviceParams.groupId = groupId; + DeviceEntryVec deviceEntryVec = CreateDeviceEntryVec(); + int32_t result = QueryDevices(osAccountId, &queryDeviceParams, &deviceEntryVec); + if (result != HC_SUCCESS) { + LOGE("Failed to query trusted devices!"); + ClearDeviceEntryVec(&deviceEntryVec); + return result; } - return HC_SUCCESS; + count = HC_VECTOR_SIZE(&deviceEntryVec); + ClearDeviceEntryVec(&deviceEntryVec); + return count; } -int32_t CheckDeviceNumLimit(const char *groupId, const char *peerUdid) +int32_t CheckDeviceNumLimit(int32_t osAccountId, const char *groupId, const char *peerUdid) { /* * If the peer device does not exist in the group and needs to be added, * check whether the number of trusted devices exceeds the upper limit. */ - if ((peerUdid != NULL) && (IsTrustedDeviceInGroup(groupId, peerUdid, true))) { + + if ((peerUdid != NULL) && (IsTrustedDeviceInGroup(osAccountId, groupId, peerUdid, true))) { return HC_SUCCESS; } - if (GetCurDeviceNumByGroupId(groupId) >= HC_TRUST_DEV_ENTRY_MAX_NUM) { + if (GetCurDeviceNumByGroupId(osAccountId, groupId) >= HC_TRUST_DEV_ENTRY_MAX_NUM) { LOGE("The number of devices in the group has reached the upper limit!"); return HC_ERR_BEYOND_LIMIT; } @@ -332,7 +616,7 @@ int32_t CheckExpireTimeIfExist(const CJson *jsonParams) return HC_SUCCESS; } -int32_t AddGroupNameToParams(const char *groupName, GroupInfo *groupParams) +int32_t AddGroupNameToParams(const char *groupName, TrustedGroupEntry *groupParams) { if (!StringSetPointer(&groupParams->name, groupName)) { LOGE("Failed to copy groupName!"); @@ -341,7 +625,7 @@ int32_t AddGroupNameToParams(const char *groupName, GroupInfo *groupParams) return HC_SUCCESS; } -int32_t AddGroupIdToParams(const char *groupId, GroupInfo *groupParams) +int32_t AddGroupIdToParams(const char *groupId, TrustedGroupEntry *groupParams) { if (!StringSetPointer(&groupParams->id, groupId)) { LOGE("Failed to copy groupId!"); @@ -350,22 +634,27 @@ int32_t AddGroupIdToParams(const char *groupId, GroupInfo *groupParams) return HC_SUCCESS; } -int32_t AddGroupOwnerToParams(const char *owner, GroupInfo *groupParams) +int32_t AddGroupOwnerToParams(const char *owner, TrustedGroupEntry *groupParams) { - if (!StringSetPointer(&groupParams->ownerName, owner)) { + HcString ownerName = CreateString(); + if (!StringSetPointer(&ownerName, owner)) { LOGE("Failed to copy groupOwner!"); return HC_ERR_MEMORY_COPY; } + if (groupParams->managers.pushBackT(&groupParams->managers, ownerName) == NULL) { + LOGE("Failed to push owner to vec!"); + return HC_ERR_MEMORY_COPY; + } return HC_SUCCESS; } -int32_t AddGroupTypeToParams(int groupType, GroupInfo *groupParams) +int32_t AddGroupTypeToParams(int groupType, TrustedGroupEntry *groupParams) { groupParams->type = groupType; return HC_SUCCESS; } -int32_t AddGroupVisibilityOrDefault(const CJson *jsonParams, GroupInfo *groupParams) +int32_t AddGroupVisibilityOrDefault(const CJson *jsonParams, TrustedGroupEntry *groupParams) { /* Currently, only the public group and private group can be created. */ int32_t groupVisibility = GROUP_VISIBILITY_PUBLIC; @@ -374,7 +663,7 @@ int32_t AddGroupVisibilityOrDefault(const CJson *jsonParams, GroupInfo *groupPar return HC_SUCCESS; } -int32_t AddExpireTimeOrDefault(const CJson *jsonParams, GroupInfo *groupParams) +int32_t AddExpireTimeOrDefault(const CJson *jsonParams, TrustedGroupEntry *groupParams) { int32_t expireTime = DEFAULT_EXPIRE_TIME; (void)GetIntFromJson(jsonParams, FIELD_EXPIRE_TIME, &expireTime); @@ -382,7 +671,7 @@ int32_t AddExpireTimeOrDefault(const CJson *jsonParams, GroupInfo *groupParams) return HC_SUCCESS; } -int32_t AddUserIdHashToGroupParams(const CJson *jsonParams, GroupInfo *groupParams) +int32_t AddUserIdHashToGroupParams(const CJson *jsonParams, TrustedGroupEntry *groupParams) { char *userIdHash = NULL; int32_t result = GetUserIdHashFromJson(jsonParams, &userIdHash); @@ -398,11 +687,12 @@ int32_t AddUserIdHashToGroupParams(const CJson *jsonParams, GroupInfo *groupPara return HC_SUCCESS; } -int32_t AddUdidToParams(DeviceInfo *devParams) +int32_t AddUdidToParams(TrustedDeviceEntry *devParams) { - const char *udid = GetLocalDevUdid(); - if (udid == NULL) { - LOGE("Failed to get local udid!"); + char udid[INPUT_UDID_LEN] = { 0 }; + int32_t res = HcGetUdid((uint8_t *)udid, INPUT_UDID_LEN); + if (res != HC_SUCCESS) { + LOGE("Failed to get local udid! res: %d", res); return HC_ERR_DB; } if (!StringSetPointer(&devParams->udid, udid)) { @@ -412,14 +702,15 @@ int32_t AddUdidToParams(DeviceInfo *devParams) return HC_SUCCESS; } -int32_t AddAuthIdToParamsOrDefault(const CJson *jsonParams, DeviceInfo *devParams) +int32_t AddAuthIdToParamsOrDefault(const CJson *jsonParams, TrustedDeviceEntry *devParams) { const char *authId = GetStringFromJson(jsonParams, FIELD_DEVICE_ID); if (authId == NULL) { LOGD("No authId is found. The default value is udid!"); - const char *udid = GetLocalDevUdid(); - if (udid == NULL) { - LOGE("Failed to get local udid!"); + char udid[INPUT_UDID_LEN] = { 0 }; + int32_t res = HcGetUdid((uint8_t *)udid, INPUT_UDID_LEN); + if (res != HC_SUCCESS) { + LOGE("Failed to get local udid! res: %d", res); return HC_ERR_DB; } authId = udid; @@ -431,7 +722,7 @@ int32_t AddAuthIdToParamsOrDefault(const CJson *jsonParams, DeviceInfo *devParam return HC_SUCCESS; } -int32_t AddUserTypeToParamsOrDefault(const CJson *jsonParams, DeviceInfo *devParams) +int32_t AddUserTypeToParamsOrDefault(const CJson *jsonParams, TrustedDeviceEntry *devParams) { int32_t userType = DEVICE_TYPE_ACCESSORY; (void)GetIntFromJson(jsonParams, FIELD_USER_TYPE, &userType); @@ -439,7 +730,7 @@ int32_t AddUserTypeToParamsOrDefault(const CJson *jsonParams, DeviceInfo *devPar return HC_SUCCESS; } -int32_t AddServiceTypeToParams(const char *groupId, DeviceInfo *devParams) +int32_t AddServiceTypeToParams(const char *groupId, TrustedDeviceEntry *devParams) { if (!StringSetPointer(&devParams->serviceType, groupId)) { LOGE("Failed to copy serviceType!"); @@ -448,7 +739,7 @@ int32_t AddServiceTypeToParams(const char *groupId, DeviceInfo *devParams) return HC_SUCCESS; } -int32_t AddGroupIdToDevParams(const char *groupId, DeviceInfo *devParams) +int32_t AddGroupIdToDevParams(const char *groupId, TrustedDeviceEntry *devParams) { if (!StringSetPointer(&devParams->groupId, groupId)) { LOGE("Failed to copy groupId!"); @@ -457,7 +748,7 @@ int32_t AddGroupIdToDevParams(const char *groupId, DeviceInfo *devParams) return HC_SUCCESS; } -int32_t AddUserIdHashToDevParams(const CJson *jsonParams, DeviceInfo *devParams) +int32_t AddUserIdHashToDevParams(const CJson *jsonParams, TrustedDeviceEntry *devParams) { char *userIdHash = NULL; int32_t result = GetUserIdHashFromJson(jsonParams, &userIdHash); @@ -483,27 +774,27 @@ int32_t AssertUserIdHashExist(const CJson *jsonParams) return HC_SUCCESS; } -int32_t CheckGroupExist(const char *groupId) +int32_t CheckGroupExist(int32_t osAccountId, const char *groupId) { if (groupId == NULL) { LOGE("The input groupId is NULL!"); return HC_ERR_NULL_PTR; } - if (!IsGroupExistByGroupId(groupId)) { + if (!IsGroupExistByGroupId(osAccountId, groupId)) { LOGE("The group does not exist!"); return HC_ERR_GROUP_NOT_EXIST; } return HC_SUCCESS; } -int32_t AddGroupToDatabaseByJson(int32_t (*generateGroupParams)(const CJson*, const char *, GroupInfo*), - const CJson *jsonParams, const char *groupId) +int32_t AddGroupToDatabaseByJson(int32_t osAccountId, int32_t (*generateGroupParams)(const CJson*, const char *, + TrustedGroupEntry*), const CJson *jsonParams, const char *groupId) { if ((generateGroupParams == NULL) || (jsonParams == NULL) || (groupId == NULL)) { LOGE("The input parameters contains NULL value!"); return HC_ERR_INVALID_PARAMS; } - GroupInfo *groupParams = CreateGroupInfoStruct(); + TrustedGroupEntry *groupParams = CreateGroupEntry(); if (groupParams == NULL) { LOGE("Failed to allocate groupParams memory!"); return HC_ERR_ALLOC_MEMORY; @@ -511,26 +802,26 @@ int32_t AddGroupToDatabaseByJson(int32_t (*generateGroupParams)(const CJson*, co int32_t result = (*generateGroupParams)(jsonParams, groupId, groupParams); if (result != HC_SUCCESS) { - DestroyGroupInfoStruct(groupParams); + DestroyGroupEntry(groupParams); return result; } - result = AddGroup(groupParams); - DestroyGroupInfoStruct(groupParams); + result = AddGroup(osAccountId, groupParams); + DestroyGroupEntry(groupParams); if (result != HC_SUCCESS) { LOGE("Failed to add the group to the database!"); } return result; } -int32_t AddDeviceToDatabaseByJson(int32_t (*generateDevParams)(const CJson*, const char*, DeviceInfo*), - const CJson *jsonParams, const char *groupId) +int32_t AddDeviceToDatabaseByJson(int32_t osAccountId, int32_t (*generateDevParams)(const CJson*, const char*, + TrustedDeviceEntry*), const CJson *jsonParams, const char *groupId) { if ((generateDevParams == NULL) || (jsonParams == NULL) || (groupId == NULL)) { LOGE("The input parameters contains NULL value!"); return HC_ERR_INVALID_PARAMS; } - DeviceInfo *devParams = CreateDeviceInfoStruct(); + TrustedDeviceEntry *devParams = CreateDeviceEntry(); if (devParams == NULL) { LOGE("Failed to allocate devParams memory!"); return HC_ERR_ALLOC_MEMORY; @@ -538,26 +829,32 @@ int32_t AddDeviceToDatabaseByJson(int32_t (*generateDevParams)(const CJson*, con int32_t result = (*generateDevParams)(jsonParams, groupId, devParams); if (result != HC_SUCCESS) { - DestroyDeviceInfoStruct(devParams); + DestroyDeviceEntry(devParams); return result; } - result = AddTrustedDevice(devParams, NULL); - DestroyDeviceInfoStruct(devParams); + result = AddTrustedDevice(osAccountId, devParams); + DestroyDeviceEntry(devParams); if (result != HC_SUCCESS) { LOGE("Failed to add the trust device to the database!"); } return result; } -int32_t DelGroupFromDatabase(const char *groupId) +int32_t DelGroupFromDb(int32_t osAccountId, const char *groupId) { if (groupId == NULL) { LOGE("The input groupId is NULL!"); return HC_ERR_NULL_PTR; } - int32_t result = DelGroupByGroupId(groupId); - if (result != HC_SUCCESS) { + int32_t result; + QueryGroupParams queryGroupParams = InitQueryGroupParams(); + queryGroupParams.groupId = groupId; + QueryDeviceParams queryDeviceParams = InitQueryDeviceParams(); + queryDeviceParams.groupId = groupId; + if (((result = DelTrustedDevice(osAccountId, &queryDeviceParams)) != HC_SUCCESS) || + ((result = DelGroup(osAccountId, &queryGroupParams)) != HC_SUCCESS) || + ((result = SaveOsAccountDb(osAccountId)) != HC_SUCCESS)) { LOGE("Failed to delete group from database!"); return result; } @@ -678,14 +975,15 @@ int32_t ProcessKeyPair(int action, const CJson *jsonParams, const char *groupId) /* Use the DeviceGroupManager package name. */ const char *appId = GROUP_MANAGER_PACKAGE_NAME; const char *authId = GetStringFromJson(jsonParams, FIELD_DEVICE_ID); + char udid[INPUT_UDID_LEN] = { 0 }; if (authId == NULL) { LOGD("No authId is found. The default value is udid!"); - const char *udid = GetLocalDevUdid(); - if (udid == NULL) { - LOGE("Failed to get local udid!"); - return HC_ERROR; + int32_t res = HcGetUdid((uint8_t *)udid, INPUT_UDID_LEN); + if (res != HC_SUCCESS) { + LOGE("Failed to get local udid! res: %d", res); + return HC_ERR_DB; } - authId = udid; + authId = (char *)udid; } int32_t userType = DEVICE_TYPE_ACCESSORY; (void)GetIntFromJson(jsonParams, FIELD_USER_TYPE, &userType); @@ -715,24 +1013,24 @@ int32_t ProcessKeyPair(int action, const CJson *jsonParams, const char *groupId) return result; } -int32_t GetGroupTypeFromDb(const char *groupId, int32_t *returnGroupType) +int32_t GetGroupTypeFromDb(int32_t osAccountId, const char *groupId, int32_t *returnGroupType) { if ((groupId == NULL) || (returnGroupType == NULL)) { LOGE("The input parameters contains NULL value!"); return HC_ERR_INVALID_PARAMS; } - GroupInfo *groupInfo = CreateGroupInfoStruct(); - if (groupInfo == NULL) { - LOGE("Failed to allocate groupInfo memory!"); + TrustedGroupEntry *groupEntry = CreateGroupEntry(); + if (groupEntry == NULL) { + LOGE("Failed to allocate groupEntry memory!"); return HC_ERR_ALLOC_MEMORY; } - if (GetGroupInfoById(groupId, groupInfo) != HC_SUCCESS) { - LOGE("Failed to get groupInfo from database!"); - DestroyGroupInfoStruct(groupInfo); + if (GetGroupInfoById(osAccountId, groupId, groupEntry) != HC_SUCCESS) { + LOGE("Failed to get groupEntry from database!"); + DestroyGroupEntry(groupEntry); return HC_ERR_DB; } - *returnGroupType = groupInfo->type; - DestroyGroupInfoStruct(groupInfo); + *returnGroupType = groupEntry->type; + DestroyGroupEntry(groupEntry); return HC_SUCCESS; } @@ -778,11 +1076,11 @@ int32_t GetAppIdFromJson(const CJson *jsonParams, const char **appId) return HC_SUCCESS; } -int32_t CheckPermForGroup(int actionType, const char *callerPkgName, const char *groupId) +int32_t CheckPermForGroup(int32_t osAccountId, int actionType, const char *callerPkgName, const char *groupId) { - if (((actionType == GROUP_DISBAND) && (IsGroupOwner(groupId, callerPkgName))) || - ((actionType == MEMBER_INVITE) && (IsGroupEditAllowed(groupId, callerPkgName))) || - ((actionType == MEMBER_DELETE) && (IsGroupEditAllowed(groupId, callerPkgName)))) { + if (((actionType == GROUP_DISBAND) && (IsGroupOwner(osAccountId, groupId, callerPkgName))) || + ((actionType == MEMBER_INVITE) && (IsGroupEditAllowed(osAccountId, groupId, callerPkgName))) || + ((actionType == MEMBER_DELETE) && (IsGroupEditAllowed(osAccountId, groupId, callerPkgName)))) { return HC_SUCCESS; } LOGE("You do not have the right to execute the command!"); @@ -824,4 +1122,4 @@ int32_t GetHashResult(const uint8_t *info, uint32_t infoLen, char *hash, uint32_ HcFree(infoHash.val); HcFree(message.val); return result; -} +} \ No newline at end of file diff --git a/services/group_manager/src/group_operation/peer_to_peer_group/peer_to_peer_group.c b/services/group_manager/src/group_operation/peer_to_peer_group/peer_to_peer_group.c index 43bde7d..2c91e66 100644 --- a/services/group_manager/src/group_operation/peer_to_peer_group/peer_to_peer_group.c +++ b/services/group_manager/src/group_operation/peer_to_peer_group/peer_to_peer_group.c @@ -18,7 +18,7 @@ #include "alg_defs.h" #include "callback_manager.h" #include "channel_manager.h" -#include "database_manager.h" +#include "data_manager.h" #include "dev_auth_module_manager.h" #include "group_operation_common.h" #include "hc_dev_info.h" @@ -26,7 +26,30 @@ #include "session_manager.h" #include "string_util.h" -static int32_t CheckGroupName(const char *appId, const CJson *jsonParams) +static bool IsSameNameGroupExist(int32_t osAccountId, const char *ownerName, const char *groupName) +{ + if ((ownerName == NULL) || (groupName == NULL)) { + LOGE("The input ownerName or groupName is NULL!"); + return false; + } + QueryGroupParams queryParams = InitQueryGroupParams(); + queryParams.ownerName = ownerName; + queryParams.groupName = groupName; + GroupEntryVec groupEntryVec = CreateGroupEntryVec(); + int32_t result = QueryGroups(osAccountId, &queryParams, &groupEntryVec); + if (result != HC_SUCCESS) { + ClearGroupEntryVec(&groupEntryVec); + return result; + } + if (HC_VECTOR_SIZE(&groupEntryVec) > 0) { + ClearGroupEntryVec(&groupEntryVec); + return true; + } + ClearGroupEntryVec(&groupEntryVec); + return false; +} + +static int32_t CheckGroupName(int32_t osAccountId, const char *appId, const CJson *jsonParams) { const char *groupName = GetStringFromJson(jsonParams, FIELD_GROUP_NAME); if (groupName == NULL) { @@ -34,7 +57,7 @@ static int32_t CheckGroupName(const char *appId, const CJson *jsonParams) return HC_ERR_JSON_GET; } - if (IsSameNameGroupExist(appId, groupName)) { + if (IsSameNameGroupExist(osAccountId, appId, groupName)) { LOGE("A group with the same group name has been created! [AppId]: %s, [GroupName]: %s", appId, groupName); return HC_ERR_INVALID_PARAMS; } @@ -90,7 +113,7 @@ static int32_t GeneratePeerToPeerGroupId(const CJson *jsonParams, char **returnG return HC_SUCCESS; } -static int32_t CheckCreateParams(const CJson *jsonParams) +static int32_t CheckCreateParams(int32_t osAccountId, const CJson *jsonParams) { const char *appId = GetStringFromJson(jsonParams, FIELD_APP_ID); if (appId == NULL) { @@ -98,17 +121,17 @@ static int32_t CheckCreateParams(const CJson *jsonParams) return HC_ERR_JSON_GET; } int32_t result; - if (((result = CheckGroupName(appId, jsonParams)) != HC_SUCCESS) || + if (((result = CheckGroupName(osAccountId, appId, jsonParams)) != HC_SUCCESS) || ((result = CheckUserTypeIfExist(jsonParams)) != HC_SUCCESS) || ((result = CheckGroupVisibilityIfExist(jsonParams)) != HC_SUCCESS) || ((result = CheckExpireTimeIfExist(jsonParams)) != HC_SUCCESS) || - ((result = CheckGroupNumLimit(PEER_TO_PEER_GROUP, appId)) != HC_SUCCESS)) { + ((result = CheckGroupNumLimit(osAccountId, PEER_TO_PEER_GROUP, appId)) != HC_SUCCESS)) { return result; } return HC_SUCCESS; } -static int32_t GenerateGroupParams(const CJson *jsonParams, const char *groupId, GroupInfo *groupParams) +static int32_t GenerateGroupParams(const CJson *jsonParams, const char *groupId, TrustedGroupEntry *groupParams) { const char *groupName = GetStringFromJson(jsonParams, FIELD_GROUP_NAME); if (groupName == NULL) { @@ -132,7 +155,7 @@ static int32_t GenerateGroupParams(const CJson *jsonParams, const char *groupId, return HC_SUCCESS; } -static int32_t GenerateDevParams(const CJson *jsonParams, const char *groupId, DeviceInfo *devParams) +static int32_t GenerateDevParams(const CJson *jsonParams, const char *groupId, TrustedDeviceEntry *devParams) { int32_t result; if (((result = AddUdidToParams(devParams)) != HC_SUCCESS) || @@ -145,15 +168,16 @@ static int32_t GenerateDevParams(const CJson *jsonParams, const char *groupId, D return HC_SUCCESS; } -static int32_t CreateGroupInner(const CJson *jsonParams, char **returnGroupId) +static int32_t CreateGroupInner(int32_t osAccountId, const CJson *jsonParams, char **returnGroupId) { char *groupId = NULL; int32_t result; - if (((result = CheckCreateParams(jsonParams)) != HC_SUCCESS) || + if (((result = CheckCreateParams(osAccountId, jsonParams)) != HC_SUCCESS) || ((result = GeneratePeerToPeerGroupId(jsonParams, &groupId)) != HC_SUCCESS) || ((result = ProcessKeyPair(CREATE_KEY_PAIR, jsonParams, groupId)) != HC_SUCCESS) || - ((result = AddGroupToDatabaseByJson(GenerateGroupParams, jsonParams, groupId)) != HC_SUCCESS) || - ((result = AddDeviceToDatabaseByJson(GenerateDevParams, jsonParams, groupId)) != HC_SUCCESS)) { + ((result = AddGroupToDatabaseByJson(osAccountId, GenerateGroupParams, jsonParams, groupId)) != HC_SUCCESS) || + ((result = AddDeviceToDatabaseByJson(osAccountId, GenerateDevParams, jsonParams, groupId)) != HC_SUCCESS) || + ((result = SaveOsAccountDb(osAccountId)) != HC_SUCCESS)) { HcFree(groupId); return result; } @@ -161,28 +185,31 @@ static int32_t CreateGroupInner(const CJson *jsonParams, char **returnGroupId) return HC_SUCCESS; } -static int32_t GetPeerDevUserTypeFromDb(const char *groupId, const char *peerAuthId) +static int32_t GetPeerDevUserTypeFromDb(int32_t osAccountId, const char *groupId, const char *peerAuthId) { int peerUserType = DEVICE_TYPE_ACCESSORY; - DeviceInfo *devAuthParams = CreateDeviceInfoStruct(); + TrustedDeviceEntry *devAuthParams = CreateDeviceEntry(); if (devAuthParams == NULL) { LOGE("Failed to allocate devEntry memory!"); return peerUserType; } - if (GetTrustedDevInfoById(peerAuthId, false, groupId, devAuthParams) != HC_SUCCESS) { + if (GetTrustedDevInfoById(osAccountId, peerAuthId, false, groupId, devAuthParams) != HC_SUCCESS) { LOGE("Failed to obtain the device information from the database!"); - DestroyDeviceInfoStruct(devAuthParams); + DestroyDeviceEntry(devAuthParams); return peerUserType; } peerUserType = devAuthParams->devType; - DestroyDeviceInfoStruct(devAuthParams); + DestroyDeviceEntry(devAuthParams); return peerUserType; } -static int32_t DelPeerDevAndKeyInfo(const char *groupId, const char *peerAuthId) +static int32_t DelPeerDevAndKeyInfo(int32_t osAccountId, const char *groupId, const char *peerAuthId) { - int32_t peerUserType = GetPeerDevUserTypeFromDb(groupId, peerAuthId); - int32_t result = DelTrustedDevice(peerAuthId, false, groupId); + int32_t peerUserType = GetPeerDevUserTypeFromDb(osAccountId, groupId, peerAuthId); + QueryDeviceParams queryDeviceParams = InitQueryDeviceParams(); + queryDeviceParams.groupId = groupId; + queryDeviceParams.authId = peerAuthId; + int32_t result = DelTrustedDevice(osAccountId, &queryDeviceParams); if (result != HC_SUCCESS) { LOGE("Failed to delete peer device from database!"); return result; @@ -208,77 +235,87 @@ static int32_t DelPeerDevAndKeyInfo(const char *groupId, const char *peerAuthId) static bool IsLocalDevice(const char *udid) { - return (strcmp(GetLocalDevUdid(), udid) == 0); + char localUdid[INPUT_UDID_LEN] = { 0 }; + int32_t res = HcGetUdid((uint8_t *)localUdid, INPUT_UDID_LEN); + if (res != HC_SUCCESS) { + LOGE("Failed to get local udid! res: %d", res); + return HC_ERR_DB; + } + return (strcmp(localUdid, udid) == 0); } -static int32_t DelAllPeerDevAndKeyInfo(const char *groupId) +static int32_t DelAllPeerDevAndKeyInfo(int32_t osAccountId, const char *groupId) { - DeviceInfoVec deviceInfoVec; - CreateDeviceInfoVecStruct(&deviceInfoVec); - int32_t result = GetTrustedDevices(groupId, &deviceInfoVec); + QueryDeviceParams queryParams = InitQueryDeviceParams(); + queryParams.groupId = groupId; + DeviceEntryVec deviceEntryVec = CreateDeviceEntryVec(); + int32_t result = QueryDevices(osAccountId, &queryParams, &deviceEntryVec); if (result != HC_SUCCESS) { - DestroyDeviceInfoVecStruct(&deviceInfoVec); + ClearDeviceEntryVec(&deviceEntryVec); return result; } uint32_t index; - void **devInfoPtr = NULL; - FOR_EACH_HC_VECTOR(deviceInfoVec, index, devInfoPtr) { - if ((devInfoPtr == NULL) || ((*devInfoPtr) == NULL)) { + TrustedDeviceEntry **entryPtr = NULL; + FOR_EACH_HC_VECTOR(deviceEntryVec, index, entryPtr) { + if ((entryPtr == NULL) || (*entryPtr == NULL)) { continue; } - DeviceInfo *devInfo = (DeviceInfo*)(*devInfoPtr); - if (IsLocalDevice(StringGet(&devInfo->udid))) { + TrustedDeviceEntry *entry = (TrustedDeviceEntry *)(*entryPtr); + if (IsLocalDevice(StringGet(&entry->udid))) { continue; } - result = DelPeerDevAndKeyInfo(groupId, StringGet(&devInfo->authId)); + result = DelPeerDevAndKeyInfo(osAccountId, groupId, StringGet(&entry->authId)); if (result != HC_SUCCESS) { - DestroyDeviceInfoVecStruct(&deviceInfoVec); + ClearDeviceEntryVec(&deviceEntryVec); return result; } } - DestroyDeviceInfoVecStruct(&deviceInfoVec); + ClearDeviceEntryVec(&deviceEntryVec); return HC_SUCCESS; } -static int32_t AddAuthIdAndUserTypeToParams(const char *groupId, CJson *jsonParams) +static int32_t AddAuthIdAndUserTypeToParams(int32_t osAccountId, const char *groupId, CJson *jsonParams) { - DeviceInfo *deviceInfo = CreateDeviceInfoStruct(); + TrustedDeviceEntry *deviceInfo = CreateDeviceEntry(); if (deviceInfo == NULL) { LOGE("Failed to allocate deviceInfo memory!"); return HC_ERR_ALLOC_MEMORY; } - const char *udid = GetLocalDevUdid(); - if (udid == NULL) { - LOGE("Failed to get local udid!"); - DestroyDeviceInfoStruct(deviceInfo); - return HC_ERROR; - } - if (GetTrustedDevInfoById(udid, true, groupId, deviceInfo) != HC_SUCCESS) { - LOGE("Failed to obtain the device information from the database!"); - DestroyDeviceInfoStruct(deviceInfo); + + char localUdid[INPUT_UDID_LEN] = { 0 }; + int32_t res = HcGetUdid((uint8_t *)localUdid, INPUT_UDID_LEN); + if (res != HC_SUCCESS) { + LOGE("Failed to get local udid! res: %d", res); return HC_ERR_DB; } + + if (GetTrustedDevInfoById(osAccountId, localUdid, true, groupId, deviceInfo) != HC_SUCCESS) { + LOGE("Failed to obtain the device information from the database!"); + DestroyDeviceEntry(deviceInfo); + return HC_ERR_DB; + } + if (AddStringToJson(jsonParams, FIELD_DEVICE_ID, StringGet(&deviceInfo->authId)) != HC_SUCCESS) { LOGE("Failed to add authId to params!"); - DestroyDeviceInfoStruct(deviceInfo); + DestroyDeviceEntry(deviceInfo); return HC_ERR_JSON_FAIL; } if (AddIntToJson(jsonParams, FIELD_USER_TYPE, deviceInfo->devType) != HC_SUCCESS) { LOGE("Failed to add userType to params!"); - DestroyDeviceInfoStruct(deviceInfo); + DestroyDeviceEntry(deviceInfo); return HC_ERR_JSON_FAIL; } - DestroyDeviceInfoStruct(deviceInfo); + DestroyDeviceEntry(deviceInfo); return HC_SUCCESS; } -static int32_t DelGroupAndSelfKeyInfo(const char *groupId, CJson *jsonParams) +static int32_t DelGroupAndSelfKeyInfo(int32_t osAccountId, const char *groupId, CJson *jsonParams) { - int32_t result = AddAuthIdAndUserTypeToParams(groupId, jsonParams); + int32_t result = AddAuthIdAndUserTypeToParams(osAccountId, groupId, jsonParams); if (result != HC_SUCCESS) { return result; } - result = DelGroupFromDatabase(groupId); + result = DelGroupFromDb(osAccountId, groupId); if (result != HC_SUCCESS) { return result; } @@ -295,7 +332,8 @@ static int32_t DelGroupAndSelfKeyInfo(const char *groupId, CJson *jsonParams) return HC_SUCCESS; } -static int32_t HandleLocalUnbind(int64_t requestId, const CJson *jsonParams, const DeviceAuthCallback *callback) +static int32_t HandleLocalUnbind(int64_t requestId, const CJson *jsonParams, + const DeviceAuthCallback *callback) { const char *peerAuthId = GetStringFromJson(jsonParams, FIELD_DELETE_ID); if (peerAuthId == NULL) { @@ -307,10 +345,20 @@ static int32_t HandleLocalUnbind(int64_t requestId, const CJson *jsonParams, con LOGE("Failed to get groupId from jsonParams!"); return HC_ERR_JSON_GET; } - int32_t result = DelPeerDevAndKeyInfo(groupId, peerAuthId); + int32_t osAccountId; + if (GetIntFromJson(jsonParams, FIELD_OS_ACCOUNT_ID, &osAccountId) != HC_SUCCESS) { + LOGE("Failed to get osAccountId from jsonParams!"); + return HC_ERR_JSON_GET; + } + int result = DelPeerDevAndKeyInfo(osAccountId, groupId, peerAuthId); if (result != HC_SUCCESS) { return result; } + result = SaveOsAccountDb(osAccountId); + if (result != HC_SUCCESS) { + LOGE("Failed to save osAccountDb!"); + return result; + } char *returnDataStr = NULL; result = GenerateUnbindSuccessData(peerAuthId, groupId, &returnDataStr); if (result != HC_SUCCESS) { @@ -346,10 +394,11 @@ static int32_t IsPeerDeviceNotSelf(const char *peerUdid) LOGE("The input peerUdid is NULL!"); return HC_ERR_NULL_PTR; } - const char *udid = GetLocalDevUdid(); - if (udid == NULL) { - LOGE("Failed to get local udid!"); - return HC_ERROR; + char udid[INPUT_UDID_LEN] = { 0 }; + int32_t res = HcGetUdid((uint8_t *)udid, INPUT_UDID_LEN); + if (res != HC_SUCCESS) { + LOGE("Failed to get local udid! res: %d", res); + return HC_ERR_DB; } if (strcmp(peerUdid, udid) == 0) { LOGE("You are not allowed to delete yourself!"); @@ -358,26 +407,26 @@ static int32_t IsPeerDeviceNotSelf(const char *peerUdid) return HC_SUCCESS; } -static int32_t CheckPeerDeviceStatus(const char *groupId, const CJson *jsonParams) +static int32_t CheckPeerDeviceStatus(int32_t osAccountId, const char *groupId, const CJson *jsonParams) { const char *peerAuthId = GetStringFromJson(jsonParams, FIELD_DELETE_ID); if (peerAuthId == NULL) { LOGE("Failed to get peerUdid from jsonParams!"); return HC_ERR_JSON_GET; } - DeviceInfo *deviceInfo = CreateDeviceInfoStruct(); + TrustedDeviceEntry *deviceInfo = CreateDeviceEntry(); if (deviceInfo == NULL) { LOGE("Failed to allocate deviceInfo memory!"); return HC_ERR_ALLOC_MEMORY; } - int32_t result = GetTrustedDevInfoById(peerAuthId, false, groupId, deviceInfo); + int32_t result = GetTrustedDevInfoById(osAccountId, peerAuthId, false, groupId, deviceInfo); if (result != HC_SUCCESS) { LOGE("Failed to obtain the peer device information from the database!"); - DestroyDeviceInfoStruct(deviceInfo); + DestroyDeviceEntry(deviceInfo); return result; } result = IsPeerDeviceNotSelf(StringGet(&deviceInfo->udid)); - DestroyDeviceInfoStruct(deviceInfo); + DestroyDeviceEntry(deviceInfo); return result; } @@ -393,14 +442,19 @@ static int32_t CheckInvitePeer(const CJson *jsonParams) LOGE("Failed to get appId from jsonParams!"); return HC_ERR_JSON_GET; } + int32_t osAccountId; + if (GetIntFromJson(jsonParams, FIELD_OS_ACCOUNT_ID, &osAccountId) != HC_SUCCESS) { + LOGE("Failed to get osAccountId from jsonParams!"); + return HC_ERR_JSON_GET; + } int32_t groupType = PEER_TO_PEER_GROUP; int32_t result; - if (((result = CheckGroupExist(groupId)) != HC_SUCCESS) || - ((result = GetGroupTypeFromDb(groupId, &groupType)) != HC_SUCCESS) || + if (((result = CheckGroupExist(osAccountId, groupId)) != HC_SUCCESS) || + ((result = GetGroupTypeFromDb(osAccountId, groupId, &groupType)) != HC_SUCCESS) || ((result = AssertPeerToPeerGroupType(groupType)) != HC_SUCCESS) || - ((result = CheckPermForGroup(MEMBER_INVITE, appId, groupId)) != HC_SUCCESS) || - ((result = CheckDeviceNumLimit(groupId, NULL)) != HC_SUCCESS)) { + ((result = CheckPermForGroup(osAccountId, MEMBER_INVITE, appId, groupId)) != HC_SUCCESS) || + ((result = CheckDeviceNumLimit(osAccountId, groupId, NULL)) != HC_SUCCESS)) { return result; } return HC_SUCCESS; @@ -423,14 +477,19 @@ static int32_t CheckDeletePeer(const CJson *jsonParams) LOGE("Failed to get appId from jsonParams!"); return HC_ERR_JSON_GET; } + int32_t osAccountId; + if (GetIntFromJson(jsonParams, FIELD_OS_ACCOUNT_ID, &osAccountId) != HC_SUCCESS) { + LOGE("Failed to get osAccountId from jsonParams!"); + return HC_ERR_JSON_GET; + } int32_t groupType = PEER_TO_PEER_GROUP; int32_t result; - if (((result = CheckGroupExist(groupId)) != HC_SUCCESS) || - ((result = GetGroupTypeFromDb(groupId, &groupType)) != HC_SUCCESS) || + if (((result = CheckGroupExist(osAccountId, groupId)) != HC_SUCCESS) || + ((result = GetGroupTypeFromDb(osAccountId, groupId, &groupType)) != HC_SUCCESS) || ((result = AssertPeerToPeerGroupType(groupType)) != HC_SUCCESS) || - ((result = CheckPermForGroup(MEMBER_DELETE, appId, groupId)) != HC_SUCCESS) || - ((result = CheckPeerDeviceStatus(groupId, jsonParams)) != HC_SUCCESS)) { + ((result = CheckPermForGroup(osAccountId, MEMBER_DELETE, appId, groupId)) != HC_SUCCESS) || + ((result = CheckPeerDeviceStatus(osAccountId, groupId, jsonParams)) != HC_SUCCESS)) { return result; } return HC_SUCCESS; @@ -503,49 +562,6 @@ static void InformPeerProcessError(int64_t requestId, const CJson *jsonParams, c FreeJsonString(errorDataStr); } -static int32_t CheckServerStatusIfNotInvite(int operationCode, const CJson *jsonParams) -{ - if (operationCode == MEMBER_INVITE) { - return HC_SUCCESS; - } - const char *groupId = GetStringFromJson(jsonParams, FIELD_GROUP_ID); - if (groupId == NULL) { - LOGE("Failed to get groupId from jsonParams!"); - return HC_ERR_JSON_GET; - } - const char *appId = GetStringFromJson(jsonParams, FIELD_APP_ID); - if (appId == NULL) { - LOGE("Failed to get appId from jsonParams!"); - return HC_ERR_JSON_GET; - } - const char *peerUdid = GetStringFromJson(jsonParams, FIELD_CONN_DEVICE_ID); - if (peerUdid == NULL) { - LOGE("Failed to get peerUdid from jsonParams!"); - return HC_ERR_JSON_GET; - } - int32_t result = CheckGroupExist(groupId); - if (result != HC_SUCCESS) { - return result; - } - if (operationCode == MEMBER_JOIN) { - /* The client sends a join request, which is equivalent to the server performing an invitation operation. */ - result = CheckPermForGroup(MEMBER_INVITE, appId, groupId); - if (result != HC_SUCCESS) { - return result; - } - result = CheckDeviceNumLimit(groupId, peerUdid); - } else if (operationCode == MEMBER_DELETE) { - result = CheckPermForGroup(MEMBER_DELETE, appId, groupId); - if (result != HC_SUCCESS) { - return result; - } - if (!IsTrustedDeviceInGroup(groupId, peerUdid, true)) { - result = HC_ERR_DEVICE_NOT_EXIST; - } - } - return result; -} - static int32_t ShouldForceUnbind(bool isForceDelete, const CJson *jsonParams) { bool isIgnoreChannel = false; @@ -589,7 +605,7 @@ static int32_t CreateServerSession(int64_t requestId, int32_t operationCode, CJs return HC_SUCCESS; } -static int32_t CreateGroup(CJson *jsonParams, char **returnJsonStr) +static int32_t CreateGroup(int32_t osAccountId, CJson *jsonParams, char **returnJsonStr) { LOGI("[Start]: Start to create a peer to peer group!"); if ((jsonParams == NULL) || (returnJsonStr == NULL)) { @@ -597,7 +613,7 @@ static int32_t CreateGroup(CJson *jsonParams, char **returnJsonStr) return HC_ERR_INVALID_PARAMS; } char *groupId = NULL; - int32_t result = CreateGroupInner(jsonParams, &groupId); + int32_t result = CreateGroupInner(osAccountId, jsonParams, &groupId); if (result != HC_SUCCESS) { return result; } @@ -610,7 +626,7 @@ static int32_t CreateGroup(CJson *jsonParams, char **returnJsonStr) return HC_SUCCESS; } -static int32_t DeleteGroup(CJson *jsonParams, char **returnJsonStr) +static int32_t DeleteGroup(int32_t osAccountId, CJson *jsonParams, char **returnJsonStr) { LOGI("[Start]: Start to delete a peer to peer group!"); if ((jsonParams == NULL) || (returnJsonStr == NULL)) { @@ -620,8 +636,8 @@ static int32_t DeleteGroup(CJson *jsonParams, char **returnJsonStr) int32_t result; const char *groupId = NULL; if (((result = GetGroupIdFromJson(jsonParams, &groupId)) != HC_SUCCESS) || - ((result = DelAllPeerDevAndKeyInfo(groupId)) != HC_SUCCESS) || - ((result = DelGroupAndSelfKeyInfo(groupId, jsonParams)) != HC_SUCCESS) || + ((result = DelAllPeerDevAndKeyInfo(osAccountId, groupId)) != HC_SUCCESS) || + ((result = DelGroupAndSelfKeyInfo(osAccountId, groupId, jsonParams)) != HC_SUCCESS) || ((result = ConvertGroupIdToJsonStr(groupId, returnJsonStr)) != HC_SUCCESS)) { return result; } @@ -629,7 +645,8 @@ static int32_t DeleteGroup(CJson *jsonParams, char **returnJsonStr) return HC_SUCCESS; } -static int32_t AddMemberToGroup(int64_t requestId, CJson *jsonParams, const DeviceAuthCallback *callback) +static int32_t AddMemberToGroup(int32_t osAccountId, int64_t requestId, CJson *jsonParams, + const DeviceAuthCallback *callback) { LOGI("[Start]: Start to add member to a peer to peer group!"); if ((jsonParams == NULL) || (callback == NULL)) { @@ -638,6 +655,7 @@ static int32_t AddMemberToGroup(int64_t requestId, CJson *jsonParams, const Devi } int32_t result; int32_t operationCode = MEMBER_INVITE; + AddIntToJson(jsonParams, FIELD_OS_ACCOUNT_ID, osAccountId); (void)GetIntFromJson(jsonParams, FIELD_OPERATION_CODE, &operationCode); result = CheckClientStatus(operationCode, jsonParams); if (result != HC_SUCCESS) { @@ -647,13 +665,15 @@ static int32_t AddMemberToGroup(int64_t requestId, CJson *jsonParams, const Devi return CreateClientSession(requestId, operationCode, GetChannelType(callback, jsonParams), jsonParams, callback); } -static int32_t DeleteMemberFromGroup(int64_t requestId, CJson *jsonParams, const DeviceAuthCallback *callback) +static int32_t DeleteMemberFromGroup(int32_t osAccountId, int64_t requestId, CJson *jsonParams, + const DeviceAuthCallback *callback) { LOGI("[Start]: Start to delete member from a peer to peer group!"); if ((jsonParams == NULL) || (callback == NULL)) { LOGE("The input parameters contains NULL value!"); return HC_ERR_INVALID_PARAMS; } + AddIntToJson(jsonParams, FIELD_OS_ACCOUNT_ID, osAccountId); int32_t result = CheckClientStatus(MEMBER_DELETE, jsonParams); if (result != HC_SUCCESS) { ProcessErrorCallback(requestId, MEMBER_DELETE, result, NULL, callback); @@ -680,118 +700,95 @@ static int32_t ProcessData(int64_t requestId, CJson *jsonParams, const DeviceAut } int32_t operationCode = MEMBER_INVITE; (void)(GetIntFromJson(jsonParams, FIELD_GROUP_OP, &operationCode)); - int32_t result = CheckServerStatusIfNotInvite(operationCode, jsonParams); - if (result != HC_SUCCESS) { - InformPeerProcessError(requestId, jsonParams, callback, result); - ProcessErrorCallback(requestId, operationCode, result, NULL, callback); - return result; - } return CreateServerSession(requestId, operationCode, jsonParams, callback); } -static int32_t AddManagerWithCheck(const char *appId, const char *groupId, const char *managerAppId) +static int32_t AddManagerWithCheck(int32_t osAccountId, const char *appId, const char *groupId, const char *managerAppId) { int32_t groupType = PEER_TO_PEER_GROUP; - if (GetGroupTypeFromDb(groupId, &groupType) != HC_SUCCESS) { + if (GetGroupTypeFromDb(osAccountId, groupId, &groupType) != HC_SUCCESS) { LOGE("No group is found based on the query parameters!"); return HC_ERR_GROUP_NOT_EXIST; } if (AssertPeerToPeerGroupType(groupType) != HC_SUCCESS) { return HC_ERR_NOT_SUPPORT; } - if (!IsGroupOwner(groupId, appId)) { + if (!IsGroupOwner(osAccountId, groupId, appId)) { LOGE("You do not have the permission to add a manager to the group!"); return HC_ERR_ACCESS_DENIED; } - if (AddGroupRole(groupId, GROUP_MANAGER, managerAppId) != HC_SUCCESS) { - LOGE("Failed to add manager!"); - return HC_ERR_DB; - } + (void)managerAppId; return HC_SUCCESS; } -static int32_t AddFriendWithCheck(const char *appId, const char *groupId, const char *friendAppId) +static int32_t AddFriendWithCheck(int32_t osAccountId, const char *appId, const char *groupId, const char *friendAppId) { int32_t groupType = PEER_TO_PEER_GROUP; - if (GetGroupTypeFromDb(groupId, &groupType) != HC_SUCCESS) { + if (GetGroupTypeFromDb(osAccountId, groupId, &groupType) != HC_SUCCESS) { LOGE("No group is found based on the query parameters!"); return HC_ERR_GROUP_NOT_EXIST; } if (AssertPeerToPeerGroupType(groupType) != HC_SUCCESS) { return HC_ERR_NOT_SUPPORT; } - if (!IsGroupEditAllowed(groupId, appId)) { + if (!IsGroupEditAllowed(osAccountId, groupId, appId)) { LOGE("You do not have the permission to add a friend to the group!"); return HC_ERR_ACCESS_DENIED; } - if (CompareVisibility(groupId, GROUP_VISIBILITY_ALLOW_LIST) != HC_SUCCESS) { - LOGE("The group dose not support the allow list protection!"); - return HC_ERR_NOT_SUPPORT; - } - if (AddGroupRole(groupId, GROUP_FRIEND, friendAppId) != HC_SUCCESS) { - LOGE("Failed to add friend!"); - return HC_ERR_DB; - } + (void)friendAppId; return HC_SUCCESS; } -static int32_t DeleteManagerWithCheck(const char *appId, const char *groupId, const char *managerAppId) +static int32_t DeleteManagerWithCheck(int32_t osAccountId, const char *appId, const char *groupId, + const char *managerAppId) { int32_t groupType = PEER_TO_PEER_GROUP; - if (GetGroupTypeFromDb(groupId, &groupType) != HC_SUCCESS) { + if (GetGroupTypeFromDb(osAccountId, groupId, &groupType) != HC_SUCCESS) { LOGE("No group is found based on the query parameters!"); return HC_ERR_GROUP_NOT_EXIST; } if (AssertPeerToPeerGroupType(groupType) != HC_SUCCESS) { return HC_ERR_NOT_SUPPORT; } - if (!IsGroupOwner(groupId, appId)) { + if (!IsGroupOwner(osAccountId, groupId, appId)) { LOGE("You do not have the permission to delete a manager from the group!"); return HC_ERR_ACCESS_DENIED; } - if (RemoveGroupRole(groupId, GROUP_MANAGER, managerAppId) != HC_SUCCESS) { - LOGE("Failed to delete manager!"); - return HC_ERR_DB; - } + (void)managerAppId; return HC_SUCCESS; } -static int32_t DeleteFriendWithCheck(const char *appId, const char *groupId, const char *friendAppId) +static int32_t DeleteFriendWithCheck(int32_t osAccountId, const char *appId, const char *groupId, + const char *friendAppId) { int32_t groupType = PEER_TO_PEER_GROUP; - if (GetGroupTypeFromDb(groupId, &groupType) != HC_SUCCESS) { + if (GetGroupTypeFromDb(osAccountId, groupId, &groupType) != HC_SUCCESS) { LOGE("No group is found based on the query parameters!"); return HC_ERR_GROUP_NOT_EXIST; } if (AssertPeerToPeerGroupType(groupType) != HC_SUCCESS) { return HC_ERR_NOT_SUPPORT; } - if (!IsGroupEditAllowed(groupId, appId)) { + if (!IsGroupEditAllowed(osAccountId, groupId, appId)) { LOGE("You do not have the permission to add a friend to the group!"); return HC_ERR_ACCESS_DENIED; } - if (CompareVisibility(groupId, GROUP_VISIBILITY_ALLOW_LIST) != HC_SUCCESS) { - LOGE("The group dose not support the allow list protection!"); - return HC_ERR_NOT_SUPPORT; - } - if (RemoveGroupRole(groupId, GROUP_FRIEND, friendAppId) != HC_SUCCESS) { - LOGE("Failed to delete friend!"); - return HC_ERR_DB; - } + (void)friendAppId; return HC_SUCCESS; } -static int32_t GetManagersWithCheck(const char *appId, const char *groupId, char **returnManagers, uint32_t *returnSize) +static int32_t GetManagersWithCheck(int32_t osAccountId, const char *appId, const char *groupId, char **returnManagers, + uint32_t *returnSize) { int32_t groupType = PEER_TO_PEER_GROUP; - if (GetGroupTypeFromDb(groupId, &groupType) != HC_SUCCESS) { + if (GetGroupTypeFromDb(osAccountId, groupId, &groupType) != HC_SUCCESS) { LOGE("No group is found based on the query parameters!"); return HC_ERR_GROUP_NOT_EXIST; } if (AssertPeerToPeerGroupType(groupType) != HC_SUCCESS) { return HC_ERR_NOT_SUPPORT; } - if (!IsGroupOwner(groupId, appId)) { + if (!IsGroupOwner(osAccountId, groupId, appId)) { LOGE("You do not have the permission to query the group managers information!"); return HC_ERR_ACCESS_DENIED; } @@ -800,82 +797,56 @@ static int32_t GetManagersWithCheck(const char *appId, const char *groupId, char LOGE("Failed to allocate managers memory!"); return HC_ERR_JSON_FAIL; } - int32_t result = GetGroupRoles(groupId, GROUP_MANAGER, managers); - if (result != HC_SUCCESS) { - LOGE("Failed to get managers!"); - FreeJson(managers); - return result; - } - *returnManagers = PackJsonToString(managers); - if (*returnManagers == NULL) { - LOGE("Failed to convert json to string!"); - FreeJson(managers); - return HC_ERR_JSON_FAIL; - } - *returnSize = GetItemNum(managers); - FreeJson(managers); + (void)returnManagers; + (void)returnSize; return HC_SUCCESS; } -static int32_t GetFriendsWithCheck(const char *appId, const char *groupId, char **returnFriends, uint32_t *returnSize) +static int32_t GetFriendsWithCheck(int32_t osAccountId, const char *appId, const char *groupId, char **returnFriends, + uint32_t *returnSize) { int32_t groupType = PEER_TO_PEER_GROUP; - if (GetGroupTypeFromDb(groupId, &groupType) != HC_SUCCESS) { + if (GetGroupTypeFromDb(osAccountId, groupId, &groupType) != HC_SUCCESS) { LOGE("No group is found based on the query parameters!"); return HC_ERR_GROUP_NOT_EXIST; } if (AssertPeerToPeerGroupType(groupType) != HC_SUCCESS) { return HC_ERR_NOT_SUPPORT; } - if (!IsGroupEditAllowed(groupId, appId)) { + if (!IsGroupEditAllowed(osAccountId, groupId, appId)) { LOGE("You do not have the permission to query the group friends information!"); return HC_ERR_ACCESS_DENIED; } - CJson *friends = CreateJsonArray(); - if (friends == NULL) { - LOGE("Failed to allocate friends memory!"); - return HC_ERR_JSON_FAIL; - } - int32_t result = GetGroupRoles(groupId, GROUP_FRIEND, friends); - if (result != HC_SUCCESS) { - LOGE("Failed to get friends!"); - FreeJson(friends); - return result; - } - *returnFriends = PackJsonToString(friends); - if (*returnFriends == NULL) { - LOGE("Failed to convert json to string!"); - FreeJson(friends); - return HC_ERR_JSON_FAIL; - } - *returnSize = GetItemNum(friends); - FreeJson(friends); + (void)returnFriends; + (void)returnSize; return HC_SUCCESS; } -static int32_t AddGroupRoleWithCheck(bool isManager, const char *appId, const char *groupId, const char *roleAppId) +static int32_t AddGroupRoleWithCheck(int32_t osAccountId, bool isManager, const char *appId, const char *groupId, + const char *roleAppId) { if (isManager) { - return AddManagerWithCheck(appId, groupId, roleAppId); + return AddManagerWithCheck(osAccountId, appId, groupId, roleAppId); } - return AddFriendWithCheck(appId, groupId, roleAppId); + return AddFriendWithCheck(osAccountId, appId, groupId, roleAppId); } -static int32_t DeleteGroupRoleWithCheck(bool isManager, const char *appId, const char *groupId, const char *roleAppId) +static int32_t DeleteGroupRoleWithCheck(int32_t osAccountId, bool isManager, const char *appId, const char *groupId, + const char *roleAppId) { if (isManager) { - return DeleteManagerWithCheck(appId, groupId, roleAppId); + return DeleteManagerWithCheck(osAccountId, appId, groupId, roleAppId); } - return DeleteFriendWithCheck(appId, groupId, roleAppId); + return DeleteFriendWithCheck(osAccountId, appId, groupId, roleAppId); } -static int32_t GetGroupRolesWithCheck(bool isManager, const char *appId, const char *groupId, char **returnJsonStr, - uint32_t *returnSize) +static int32_t GetGroupRolesWithCheck(int32_t osAccountId, bool isManager, const char *appId, const char *groupId, + char **returnJsonStr, uint32_t *returnSize) { if (isManager) { - return GetManagersWithCheck(appId, groupId, returnJsonStr, returnSize); + return GetManagersWithCheck(osAccountId, appId, groupId, returnJsonStr, returnSize); } - return GetFriendsWithCheck(appId, groupId, returnJsonStr, returnSize); + return GetFriendsWithCheck(osAccountId, appId, groupId, returnJsonStr, returnSize); } static PeerToPeerGroup g_peerToPeerGroup = { diff --git a/services/group_manager/src/group_operation/peer_to_peer_group_mock/peer_to_peer_group_mock.c b/services/group_manager/src/group_operation/peer_to_peer_group_mock/peer_to_peer_group_mock.c index aab06b4..4715025 100644 --- a/services/group_manager/src/group_operation/peer_to_peer_group_mock/peer_to_peer_group_mock.c +++ b/services/group_manager/src/group_operation/peer_to_peer_group_mock/peer_to_peer_group_mock.c @@ -24,5 +24,5 @@ BaseGroup *GetPeerToPeerGroupInstance(void) bool IsPeerToPeerGroupSupported(void) { - return false; + return true; } diff --git a/services/group_manager/src/session/bind_session/bind_session_client.c b/services/group_manager/src/session/bind_session/bind_session_client.c index 6de2d38..256ad3e 100644 --- a/services/group_manager/src/session/bind_session/bind_session_client.c +++ b/services/group_manager/src/session/bind_session/bind_session_client.c @@ -136,7 +136,7 @@ static void OnBindChannelOpened(Session *session, int64_t channelId, int64_t req static int32_t PrepareClient(const CJson *jsonParams, BindSession *session) { - int32_t result = GenerateBindParams(CLIENT, jsonParams, session); + int32_t result = GenerateBindParams(session->osAccountId, CLIENT, jsonParams, session); if (result != HC_SUCCESS) { return result; } diff --git a/services/group_manager/src/session/bind_session/bind_session_common.c b/services/group_manager/src/session/bind_session/bind_session_common.c index 844e209..2e52a03 100644 --- a/services/group_manager/src/session/bind_session/bind_session_common.c +++ b/services/group_manager/src/session/bind_session/bind_session_common.c @@ -17,7 +17,7 @@ #include "bind_session_common_util.h" #include "callback_manager.h" #include "channel_manager.h" -#include "database_manager.h" +#include "data_manager.h" #include "dev_auth_module_manager.h" #include "group_operation_common.h" #include "hc_dev_info.h" @@ -98,8 +98,10 @@ static int32_t AddRequestInfoToSendData(const BindSession *session, CJson *data) static int32_t GenerateCompatibleInfo(CJson *groupInfo) { - const char *udid = GetLocalDevUdid(); - if (udid == NULL) { + char udid[INPUT_UDID_LEN] = { 0 }; + int32_t res = HcGetUdid((uint8_t *)udid, INPUT_UDID_LEN); + if (res != HC_SUCCESS) { + LOGE("Failed to get local udid! res: %d", res); return HC_ERR_DB; } if (AddStringToJson(groupInfo, FIELD_DEVICE_ID, udid) != HC_SUCCESS) { @@ -279,7 +281,7 @@ static int32_t TryAddPeerUserTypeToParams(const CJson *jsonParams, BindSession * return HC_SUCCESS; } -static int32_t AddGroupInfoToParams(const GroupInfo *entry, CJson *params) +static int32_t AddGroupInfoToParams(const TrustedGroupEntry *entry, CJson *params) { if (AddStringToJson(params, FIELD_GROUP_ID, StringGet(&entry->id)) != HC_SUCCESS) { LOGE("Failed to add groupId to json!"); @@ -296,7 +298,7 @@ static int32_t AddGroupInfoToParams(const GroupInfo *entry, CJson *params) return HC_SUCCESS; } -static int32_t AddDevInfoToParams(const DeviceInfo *devAuthParams, CJson *params) +static int32_t AddDevInfoToParams(const TrustedDeviceEntry *devAuthParams, CJson *params) { if (AddStringToJson(params, FIELD_AUTH_ID, StringGet(&devAuthParams->authId)) != HC_SUCCESS) { LOGE("Failed to add authId to params!"); @@ -313,47 +315,49 @@ static int32_t AddDevInfoToParams(const DeviceInfo *devAuthParams, CJson *params return HC_SUCCESS; } -static int32_t AddGroupInfoByDatabase(const char *groupId, CJson *params) +static int32_t AddGroupInfoByDatabase(int32_t osAccountId, const char *groupId, CJson *params) { - GroupInfo *entry = CreateGroupInfoStruct(); + TrustedGroupEntry *entry = CreateGroupEntry(); if (entry == NULL) { LOGE("Failed to allocate groupEntry memory!"); return HC_ERR_ALLOC_MEMORY; } - if (GetGroupInfoById(groupId, entry) != HC_SUCCESS) { + if (GetGroupInfoById(osAccountId, groupId, entry) != HC_SUCCESS) { LOGE("Failed to obtain the group information from the database!"); - DestroyGroupInfoStruct(entry); + DestroyGroupEntry(entry); return HC_ERR_DB; } if (AddGroupInfoToParams(entry, params) != HC_SUCCESS) { - DestroyGroupInfoStruct(entry); + DestroyGroupEntry(entry); return HC_ERR_JSON_FAIL; } - DestroyGroupInfoStruct(entry); + DestroyGroupEntry(entry); return HC_SUCCESS; } -static int32_t AddDevInfoByDatabase(const char *groupId, CJson *params) +static int32_t AddDevInfoByDatabase(int32_t osAccountId, const char *groupId, CJson *params) { - const char *udid = GetLocalDevUdid(); - if (udid == NULL) { + char udid[INPUT_UDID_LEN] = { 0 }; + int32_t res = HcGetUdid((uint8_t *)udid, INPUT_UDID_LEN); + if (res != HC_SUCCESS) { + LOGE("Failed to get local udid! res: %d", res); return HC_ERR_DB; } - DeviceInfo *devAuthParams = CreateDeviceInfoStruct(); + TrustedDeviceEntry *devAuthParams = CreateDeviceEntry(); if (devAuthParams == NULL) { LOGE("Failed to allocate devEntry memory!"); return HC_ERR_ALLOC_MEMORY; } - if (GetTrustedDevInfoById(udid, true, groupId, devAuthParams) != HC_SUCCESS) { + if (GetTrustedDevInfoById(osAccountId, udid, true, groupId, devAuthParams) != HC_SUCCESS) { LOGE("Failed to obtain the device information from the database!"); - DestroyDeviceInfoStruct(devAuthParams); + DestroyDeviceEntry(devAuthParams); return HC_ERR_DB; } if (AddDevInfoToParams(devAuthParams, params) != HC_SUCCESS) { - DestroyDeviceInfoStruct(devAuthParams); + DestroyDeviceEntry(devAuthParams); return HC_ERR_JSON_FAIL; } - DestroyDeviceInfoStruct(devAuthParams); + DestroyDeviceEntry(devAuthParams); return HC_SUCCESS; } @@ -440,37 +444,40 @@ static int32_t AddExpireTimeIfValidOrDefault(const CJson *jsonParams, CJson *par return HC_SUCCESS; } -static int32_t CheckAuthIdAndUserTypeValid(int userType, const char *groupId, const char *authId) +static int32_t CheckAuthIdAndUserTypeValid(int32_t osAccountId, int userType, const char *groupId, const char *authId) { - if (!IsGroupExistByGroupId(groupId)) { + if (!IsGroupExistByGroupId(osAccountId, groupId)) { return HC_SUCCESS; } - const char *udid = GetLocalDevUdid(); - if (udid == NULL) { + char udid[INPUT_UDID_LEN] = { 0 }; + int32_t res = HcGetUdid((uint8_t *)udid, INPUT_UDID_LEN); + if (res != HC_SUCCESS) { + LOGE("Failed to get local udid! res: %d", res); return HC_ERR_DB; } - DeviceInfo *deviceInfo = CreateDeviceInfoStruct(); + TrustedDeviceEntry *deviceInfo = CreateDeviceEntry(); if (deviceInfo == NULL) { LOGE("Failed to allocate deviceInfo memory!"); return HC_ERR_ALLOC_MEMORY; } - int32_t result = GetTrustedDevInfoById(udid, true, groupId, deviceInfo); + int32_t result = GetTrustedDevInfoById(osAccountId, udid, true, groupId, deviceInfo); if (result != HC_SUCCESS) { LOGE("Failed to obtain the local device information from the database!"); - DestroyDeviceInfoStruct(deviceInfo); + DestroyDeviceEntry(deviceInfo); return result; } const char *oriAuthId = StringGet(&deviceInfo->authId); if ((deviceInfo->devType != userType) || ((oriAuthId != NULL) && (strcmp(oriAuthId, authId) != 0))) { LOGE("Once a group is created, the service cannot change the local authId and userType used in the group!"); - DestroyDeviceInfoStruct(deviceInfo); + DestroyDeviceEntry(deviceInfo); return HC_ERR_INVALID_PARAMS; } - DestroyDeviceInfoStruct(deviceInfo); + DestroyDeviceEntry(deviceInfo); return HC_SUCCESS; } -static int32_t AddAuthIdAndUserTypeIfValidOrDefault(const char *groupId, const CJson *jsonParams, CJson *params) +static int32_t AddAuthIdAndUserTypeIfValidOrDefault(int32_t osAccountId, const char *groupId, const CJson *jsonParams, + CJson *params) { int32_t userType = DEVICE_TYPE_ACCESSORY; (void)GetIntFromJson(jsonParams, FIELD_USER_TYPE, &userType); @@ -481,12 +488,18 @@ static int32_t AddAuthIdAndUserTypeIfValidOrDefault(const char *groupId, const C const char *authId = GetStringFromJson(jsonParams, FIELD_DEVICE_ID); if (authId == NULL) { LOGD("No authId is found. The default value is udid!"); - authId = GetLocalDevUdid(); + char udid[INPUT_UDID_LEN] = { 0 }; + int32_t res = HcGetUdid((uint8_t *)udid, INPUT_UDID_LEN); + if (res != HC_SUCCESS) { + LOGE("Failed to get local udid! res: %d", res); + return HC_ERR_DB; + } + authId = udid; if (authId == NULL) { return HC_ERR_DB; } } - int32_t result = CheckAuthIdAndUserTypeValid(userType, groupId, authId); + int32_t result = CheckAuthIdAndUserTypeValid(osAccountId, userType, groupId, authId); if (result != HC_SUCCESS) { return result; } @@ -503,8 +516,10 @@ static int32_t AddAuthIdAndUserTypeIfValidOrDefault(const char *groupId, const C static int32_t AddUdid(CJson *params) { - const char *udid = GetLocalDevUdid(); - if (udid == NULL) { + char udid[INPUT_UDID_LEN] = { 0 }; + int32_t res = HcGetUdid((uint8_t *)udid, INPUT_UDID_LEN); + if (res != HC_SUCCESS) { + LOGE("Failed to get local udid! res: %d", res); return HC_ERR_DB; } if (AddStringToJson(params, FIELD_CONN_DEVICE_ID, udid) != HC_SUCCESS) { @@ -543,10 +558,11 @@ static int32_t AddGroupInfoToSessionParams(const char *groupId, const CJson *jso return HC_SUCCESS; } -static int32_t AddDevInfoToSessionParams(const char *groupId, const CJson *jsonParams, CJson *params) +static int32_t AddDevInfoToSessionParams(int32_t osAccountId, const char *groupId, const CJson *jsonParams, + CJson *params) { int32_t result; - if (((result = AddAuthIdAndUserTypeIfValidOrDefault(groupId, jsonParams, params)) != HC_SUCCESS) || + if (((result = AddAuthIdAndUserTypeIfValidOrDefault(osAccountId, groupId, jsonParams, params)) != HC_SUCCESS) || ((result = AddUdid(params)) != HC_SUCCESS) || ((result = AddUserTypeIfValidOrDefault(jsonParams, params)) != HC_SUCCESS)) { return result; @@ -554,22 +570,22 @@ static int32_t AddDevInfoToSessionParams(const char *groupId, const CJson *jsonP return HC_SUCCESS; } -static int32_t GenerateParamsByInput(const char *groupId, const CJson *jsonParams, CJson *params) +static int32_t GenerateParamsByInput(int32_t osAccountId, const char *groupId, const CJson *jsonParams, CJson *params) { int32_t result = AddGroupInfoToSessionParams(groupId, jsonParams, params); if (result != HC_SUCCESS) { return result; } - return AddDevInfoToSessionParams(groupId, jsonParams, params); + return AddDevInfoToSessionParams(osAccountId, groupId, jsonParams, params); } -static int32_t GenerateParamsByDatabase(const char *groupId, CJson *params) +static int32_t GenerateParamsByDatabase(int32_t osAccountId, const char *groupId, CJson *params) { - int32_t result = AddGroupInfoByDatabase(groupId, params); + int32_t result = AddGroupInfoByDatabase(osAccountId, groupId, params); if (result != HC_SUCCESS) { return result; } - return AddDevInfoByDatabase(groupId, params); + return AddDevInfoByDatabase(osAccountId, groupId, params); } static int32_t AddIsForceDeleteIfNeed(int isClient, const CJson *jsonParams, BindSession *session) @@ -664,21 +680,21 @@ static int32_t AddPeerUserTypeIfDelete(BindSession *session) LOGE("Failed to get groupId from params!"); return HC_ERR_JSON_GET; } - DeviceInfo *devAuthParams = CreateDeviceInfoStruct(); + TrustedDeviceEntry *devAuthParams = CreateDeviceEntry(); if (devAuthParams == NULL) { LOGE("Failed to allocate devEntry memory!"); return HC_ERR_ALLOC_MEMORY; } - if (GetTrustedDevInfoById(peerAuthId, false, groupId, devAuthParams) != HC_SUCCESS) { + if (GetTrustedDevInfoById(session->osAccountId, peerAuthId, false, groupId, devAuthParams) != HC_SUCCESS) { LOGE("Failed to obtain the device information from the database!"); - DestroyDeviceInfoStruct(devAuthParams); + DestroyDeviceEntry(devAuthParams); return HC_ERR_DB; } if (AddIntToJson(session->params, FIELD_PEER_USER_TYPE, devAuthParams->devType) != HC_SUCCESS) { - DestroyDeviceInfoStruct(devAuthParams); + DestroyDeviceEntry(devAuthParams); return HC_ERR_JSON_FAIL; } - DestroyDeviceInfoStruct(devAuthParams); + DestroyDeviceEntry(devAuthParams); return HC_SUCCESS; } @@ -694,7 +710,7 @@ static int32_t AddPeerDevInfoIfNeed(bool isClient, const CJson *jsonParams, Bind return AddPeerAuthIdAndUdidIfExist(jsonParams, session); } -static int32_t AddGroupAndDevInfo(int isClient, const CJson *jsonParams, BindSession *session) +static int32_t AddGroupAndDevInfo(int32_t osAccountId, int isClient, const CJson *jsonParams, BindSession *session) { const char *groupId = GetStringFromJson(jsonParams, FIELD_GROUP_ID); if (groupId == NULL) { @@ -702,9 +718,9 @@ static int32_t AddGroupAndDevInfo(int isClient, const CJson *jsonParams, BindSes return HC_ERR_JSON_GET; } if (NeedCreateGroup(isClient, session->opCode)) { - return GenerateParamsByInput(groupId, jsonParams, session->params); + return GenerateParamsByInput(osAccountId, groupId, jsonParams, session->params); } else { - return GenerateParamsByDatabase(groupId, session->params); + return GenerateParamsByDatabase(session->osAccountId, groupId, session->params); } } @@ -752,7 +768,7 @@ static int32_t InformSelfUnbindSuccess(const char *peerAuthId, const char *group return HC_SUCCESS; } -static int32_t SetGroupId(const CJson *params, GroupInfo *groupParams) +static int32_t SetGroupId(const CJson *params, TrustedGroupEntry *groupParams) { const char *groupId = GetStringFromJson(params, FIELD_GROUP_ID); if (groupId == NULL) { @@ -766,7 +782,7 @@ static int32_t SetGroupId(const CJson *params, GroupInfo *groupParams) return HC_SUCCESS; } -static int32_t SetGroupName(const CJson *params, GroupInfo *groupParams) +static int32_t SetGroupName(const CJson *params, TrustedGroupEntry *groupParams) { const char *groupName = GetStringFromJson(params, FIELD_GROUP_NAME); if (groupName == NULL) { @@ -780,27 +796,29 @@ static int32_t SetGroupName(const CJson *params, GroupInfo *groupParams) return HC_SUCCESS; } -static int32_t SetGroupOwner(const char *ownerAppId, GroupInfo *groupParams) +static int32_t SetGroupOwner(const char *ownerAppId, TrustedGroupEntry *groupParams) { - if (!StringSetPointer(&groupParams->ownerName, ownerAppId)) { + HcString ownerName = CreateString(); + if (!StringSetPointer(&ownerName, ownerAppId)) { LOGE("Failed to copy groupOwner!"); return HC_ERR_MEMORY_COPY; } + if (groupParams->managers.pushBackT(&groupParams->managers, ownerName) == NULL) { + LOGE("Failed to push owner to vec!"); + return HC_ERR_MEMORY_COPY; + } return HC_SUCCESS; } -static int32_t SetGroupType(const CJson *params, GroupInfo *groupParams) +static int32_t SetGroupType(const CJson *params, TrustedGroupEntry *groupParams) { - int32_t groupType = PEER_TO_PEER_GROUP; - if (GetIntFromJson(params, FIELD_GROUP_TYPE, &groupType) != HC_SUCCESS) { - LOGE("Failed to get groupType from params!"); - return HC_ERR_JSON_GET; - } - groupParams->type = groupType; + /* Currently, only peer to peer group is supported. */ + (void)params; + groupParams->type = PEER_TO_PEER_GROUP; return HC_SUCCESS; } -static int32_t SetGroupVisibility(const CJson *params, GroupInfo *groupParams) +static int32_t SetGroupVisibility(const CJson *params, TrustedGroupEntry *groupParams) { int32_t groupVisibility = GROUP_VISIBILITY_PUBLIC; (void)GetIntFromJson(params, FIELD_GROUP_VISIBILITY, &groupVisibility); @@ -808,7 +826,7 @@ static int32_t SetGroupVisibility(const CJson *params, GroupInfo *groupParams) return HC_SUCCESS; } -static int32_t SetGroupExpireTime(const CJson *params, GroupInfo *groupParams) +static int32_t SetGroupExpireTime(const CJson *params, TrustedGroupEntry *groupParams) { int32_t expireTime = DEFAULT_EXPIRE_TIME; (void)GetIntFromJson(params, FIELD_EXPIRE_TIME, &expireTime); @@ -839,7 +857,7 @@ static int32_t ForceDeletePeerKey(CJson *params) return DeletePeerAuthInfo(appId, groupId, &peerAuthIdBuff, peerUserType, DAS_MODULE); } -static int32_t GenerateGroupParams(const BindSession *session, GroupInfo *groupParams) +static int32_t GenerateGroupParams(const BindSession *session, TrustedGroupEntry *groupParams) { int32_t result; if (((result = SetGroupId(session->params, groupParams)) != HC_SUCCESS) || @@ -855,7 +873,7 @@ static int32_t GenerateGroupParams(const BindSession *session, GroupInfo *groupP static int32_t AddGroupToDatabase(const BindSession *session) { - GroupInfo *groupParams = CreateGroupInfoStruct(); + TrustedGroupEntry *groupParams = CreateGroupEntry(); if (groupParams == NULL) { LOGE("Failed to allocate groupParams memory!"); return HC_ERR_ALLOC_MEMORY; @@ -863,11 +881,11 @@ static int32_t AddGroupToDatabase(const BindSession *session) int32_t result = GenerateGroupParams(session, groupParams); if (result != HC_SUCCESS) { LOGE("Failed to generate groupParams!"); - DestroyGroupInfoStruct(groupParams); + DestroyGroupEntry(groupParams); return HC_ERR_DB; } - result = AddGroup(groupParams); - DestroyGroupInfoStruct(groupParams); + result = AddGroup(session->osAccountId, groupParams); + DestroyGroupEntry(groupParams); if (result != HC_SUCCESS) { LOGE("Failed to add the group to the database!"); return HC_ERR_DB; @@ -876,7 +894,7 @@ static int32_t AddGroupToDatabase(const BindSession *session) } static int32_t GenerateDevAuthParams(const char *authId, const char *udid, const char *groupId, - int userType, DeviceInfo *devAuthParams) + int userType, TrustedDeviceEntry *devAuthParams) { devAuthParams->devType = userType; StringSetPointer(&(devAuthParams->authId), authId); @@ -886,9 +904,10 @@ static int32_t GenerateDevAuthParams(const char *authId, const char *udid, const return HC_SUCCESS; } -static int32_t AddTrustDevToDatabase(const char *authId, const char *udid, const char *groupId, int userType) +static int32_t AddTrustDevToDatabase(int32_t osAccountId, const char *authId, const char *udid, const char *groupId, + int userType) { - DeviceInfo *devAuthParams = CreateDeviceInfoStruct(); + TrustedDeviceEntry *devAuthParams = CreateDeviceEntry(); if (devAuthParams == NULL) { LOGE("Failed to allocate devAuthParams memory!"); return HC_ERR_ALLOC_MEMORY; @@ -896,11 +915,11 @@ static int32_t AddTrustDevToDatabase(const char *authId, const char *udid, const int32_t result = GenerateDevAuthParams(authId, udid, groupId, userType, devAuthParams); if (result != HC_SUCCESS) { LOGE("Failed to generate devAuthParams!"); - DestroyDeviceInfoStruct(devAuthParams); + DestroyDeviceEntry(devAuthParams); return result; } - result = AddTrustedDevice(devAuthParams, NULL); - DestroyDeviceInfoStruct(devAuthParams); + result = AddTrustedDevice(osAccountId, devAuthParams); + DestroyDeviceEntry(devAuthParams); if (result != HC_SUCCESS) { LOGE("Failed to add the trusted devices to the database!"); return HC_ERR_DB; @@ -910,34 +929,39 @@ static int32_t AddTrustDevToDatabase(const char *authId, const char *udid, const static int32_t AddGroupAndLocalDevIfNotExist(const char *groupId, const BindSession *session) { - int32_t result = HC_SUCCESS; - if (!IsGroupExistByGroupId(groupId)) { - const char *udid = GetLocalDevUdid(); - if (udid == NULL) { - return HC_ERR_DB; - } - result = AddGroupToDatabase(session); - if (result != HC_SUCCESS) { - return result; - } - const char *authId = GetStringFromJson(session->params, FIELD_AUTH_ID); - if (authId == NULL) { - LOGI("No authId is found. The default value is udid!"); - authId = udid; - } - int32_t userType = DEVICE_TYPE_ACCESSORY; - (void)GetIntFromJson(session->params, FIELD_USER_TYPE, &userType); - return AddTrustDevToDatabase(authId, udid, groupId, userType); + if (IsGroupExistByGroupId(session->osAccountId, groupId)) { + return HC_SUCCESS; } - return result; + int32_t result = HC_SUCCESS; + char udid[INPUT_UDID_LEN] = { 0 }; + result = HcGetUdid((uint8_t *)udid, INPUT_UDID_LEN); + if (result != HC_SUCCESS) { + LOGE("Failed to get local udid! res: %d", result); + return HC_ERR_DB; + } + result = AddGroupToDatabase(session); + if (result != HC_SUCCESS) { + return result; + } + const char *authId = GetStringFromJson(session->params, FIELD_AUTH_ID); + if (authId == NULL) { + LOGI("No authId is found. The default value is udid!"); + authId = udid; + } + int32_t userType = DEVICE_TYPE_ACCESSORY; + (void)GetIntFromJson(session->params, FIELD_USER_TYPE, &userType); + return AddTrustDevToDatabase(session->osAccountId, authId, udid, groupId, userType); } static int32_t AddPeerDevToGroup(const char *peerAuthId, const char *peerUdid, const char *groupId, const BindSession *session) { - if (IsTrustedDeviceInGroup(groupId, peerAuthId, false)) { + if (IsTrustedDeviceInGroup(session->osAccountId, groupId, peerUdid, true)) { LOGI("The peer device already exists in the group! RequestId: %" PRId64, session->reqId); - if (DelTrustedDevice(peerAuthId, false, groupId) != HC_SUCCESS) { + QueryDeviceParams params = InitQueryDeviceParams(); + params.groupId = groupId; + params.udid = peerUdid; + if (DelTrustedDevice(session->osAccountId, ¶ms) != HC_SUCCESS) { LOGE("Failed to delete the original data! RequestId: %" PRId64, session->reqId); return HC_ERR_DB; } @@ -945,7 +969,7 @@ static int32_t AddPeerDevToGroup(const char *peerAuthId, const char *peerUdid, } int32_t peerUserType = DEVICE_TYPE_ACCESSORY; (void)GetIntFromJson(session->params, FIELD_PEER_USER_TYPE, &peerUserType); - int32_t result = AddTrustDevToDatabase(peerAuthId, peerUdid, groupId, peerUserType); + int32_t result = AddTrustDevToDatabase(session->osAccountId, peerAuthId, peerUdid, groupId, peerUserType); if (result != HC_SUCCESS) { LOGE("Failed to update the peer trusted device information! RequestId: %" PRId64, session->reqId); return result; @@ -961,7 +985,11 @@ static int32_t AddGroupAndDev(const char *peerAuthId, const char *peerUdid, if (result != HC_SUCCESS) { return result; } - return AddPeerDevToGroup(peerAuthId, peerUdid, groupId, session); + result = AddPeerDevToGroup(peerAuthId, peerUdid, groupId, session); + if (result != HC_SUCCESS) { + return result; + } + return SaveOsAccountDb(session->osAccountId); } static int32_t HandleBindSuccess(const char *peerAuthId, const char *peerUdid, @@ -976,8 +1004,12 @@ static int32_t HandleBindSuccess(const char *peerAuthId, const char *peerUdid, static int32_t HandleUnbindSuccess(const char *peerAuthId, const char *groupId, const BindSession *session) { - if (IsGroupExistByGroupId(groupId)) { - if (DelTrustedDevice(peerAuthId, false, groupId) != HC_SUCCESS) { + if (IsGroupExistByGroupId(session->osAccountId, groupId)) { + QueryDeviceParams params = InitQueryDeviceParams(); + params.groupId = groupId; + params.authId = peerAuthId; + if (DelTrustedDevice(session->osAccountId, ¶ms) != HC_SUCCESS || + SaveOsAccountDb(session->osAccountId) != HC_SUCCESS) { LOGE("Failed to unbind device from database!"); return HC_ERR_DB; } @@ -1136,16 +1168,19 @@ int32_t ForceUnbindDevice(const BindSession *session) LOGE("Failed to get groupId from jsonParams!"); return HC_ERR_JSON_GET; } - int32_t result = DelTrustedDevice(peerAuthId, false, groupId); - if (result != HC_SUCCESS) { + QueryDeviceParams queryDeviceParams = InitQueryDeviceParams(); + queryDeviceParams.groupId = groupId; + queryDeviceParams.authId = peerAuthId; + if (DelTrustedDevice(session->osAccountId, &queryDeviceParams) != HC_SUCCESS || + SaveOsAccountDb(session->osAccountId) != HC_SUCCESS) { LOGE("Failed to delete trust device from database!"); - return result; + return HC_ERR_DB; } /* * If the trusted device has been deleted from the database but the peer key fails to be deleted, * the forcible unbinding is still considered successful. Only logs need to be printed. */ - result = ForceDeletePeerKey(session->params); + int32_t result = ForceDeletePeerKey(session->params); if (result != HC_SUCCESS) { LOGE("Failed to delete peer key!"); } @@ -1160,7 +1195,7 @@ int32_t ForceUnbindDevice(const BindSession *session) return HC_SUCCESS; } -int32_t GenerateBindParams(int isClient, const CJson *jsonParams, BindSession *session) +int32_t GenerateBindParams(int32_t osAccountId, int isClient, const CJson *jsonParams, BindSession *session) { if (session->params == NULL) { session->params = CreateJson(); @@ -1174,7 +1209,7 @@ int32_t GenerateBindParams(int isClient, const CJson *jsonParams, BindSession *s if (((result = AddIsForceDeleteIfNeed(isClient, jsonParams, session)) != HC_SUCCESS) || ((result = AddChannelIdIfNeed(isClient, jsonParams, session)) != HC_SUCCESS) || ((result = AddPinCodeIfNeed(jsonParams, session)) != HC_SUCCESS) || - ((result = AddGroupAndDevInfo(isClient, jsonParams, session)) != HC_SUCCESS) || + ((result = AddGroupAndDevInfo(osAccountId, isClient, jsonParams, session)) != HC_SUCCESS) || ((result = AddPeerDevInfoIfNeed(isClient, jsonParams, session)) != HC_SUCCESS)) { return result; } diff --git a/services/group_manager/src/session/bind_session/bind_session_server.c b/services/group_manager/src/session/bind_session/bind_session_server.c index b61a539..828dced 100644 --- a/services/group_manager/src/session/bind_session/bind_session_server.c +++ b/services/group_manager/src/session/bind_session/bind_session_server.c @@ -20,6 +20,7 @@ #include "das_module_defines.h" #include "group_operation_common.h" #include "hc_log.h" +#include "os_account_adapter.h" #include "session_manager.h" static int32_t AddRecvModuleDataToParams(CJson *jsonParams, CJson *moduleParams) @@ -311,6 +312,49 @@ static int32_t CombineInputData(int operationCode, const CJson *returnData, CJso } } +static int32_t CheckServerStatusIfNotInvite(int32_t osAccountId, int operationCode, const CJson *jsonParams) +{ + if (operationCode == MEMBER_INVITE) { + return HC_SUCCESS; + } + const char *groupId = GetStringFromJson(jsonParams, FIELD_GROUP_ID); + if (groupId == NULL) { + LOGE("Failed to get groupId from jsonParams!"); + return HC_ERR_JSON_GET; + } + const char *appId = GetStringFromJson(jsonParams, FIELD_APP_ID); + if (appId == NULL) { + LOGE("Failed to get appId from jsonParams!"); + return HC_ERR_JSON_GET; + } + const char *peerUdid = GetStringFromJson(jsonParams, FIELD_CONN_DEVICE_ID); + if (peerUdid == NULL) { + LOGE("Failed to get peerUdid from jsonParams!"); + return HC_ERR_JSON_GET; + } + int32_t result = CheckGroupExist(osAccountId, groupId); + if (result != HC_SUCCESS) { + return result; + } + if (operationCode == MEMBER_JOIN) { + /* The client sends a join request, which is equivalent to the server performing an invitation operation. */ + result = CheckPermForGroup(osAccountId, MEMBER_INVITE, appId, groupId); + if (result != HC_SUCCESS) { + return result; + } + result = CheckDeviceNumLimit(osAccountId, groupId, peerUdid); + } else if (operationCode == MEMBER_DELETE) { + result = CheckPermForGroup(osAccountId, MEMBER_DELETE, appId, groupId); + if (result != HC_SUCCESS) { + return result; + } + if (!IsTrustedDeviceInGroup(osAccountId, groupId, peerUdid, true)) { + result = HC_ERR_DEVICE_NOT_EXIST; + } + } + return result; +} + static int32_t PrepareServer(BindSession *session, CJson *returnData, bool *isNeedInform) { if ((session->isWaiting) && (!IsAcceptRequest(returnData))) { @@ -322,7 +366,20 @@ static int32_t PrepareServer(BindSession *session, CJson *returnData, bool *isNe LOGE("Received data before request confirmation are lost!"); return HC_ERR_LOST_DATA; } - int32_t result = CombineInputData(session->opCode, returnData, jsonParams); + int32_t osAccountId = ANY_OS_ACCOUNT; + (void)GetIntFromJson(returnData, FIELD_OS_ACCOUNT_ID, &osAccountId); + osAccountId = DevAuthGetRealOsAccountLocalId(osAccountId); + if (osAccountId == INVALID_OS_ACCOUNT) { + FreeJson(jsonParams); + return HC_ERR_INVALID_PARAMS; + } + int32_t result = CheckServerStatusIfNotInvite(osAccountId, session->opCode, jsonParams); + if (result != HC_SUCCESS) { + FreeJson(jsonParams); + return result; + } + session->osAccountId = osAccountId; + result = CombineInputData(session->opCode, returnData, jsonParams); /* Release the memory in advance to reduce the memory usage. */ DeleteAllItem(returnData); session->isWaiting = false; @@ -330,7 +387,7 @@ static int32_t PrepareServer(BindSession *session, CJson *returnData, bool *isNe FreeJson(jsonParams); return result; } - result = GenerateBindParams(SERVER, jsonParams, session); + result = GenerateBindParams(osAccountId, SERVER, jsonParams, session); if (result != HC_SUCCESS) { FreeJson(jsonParams); return result; diff --git a/services/group_manager/src/session/bind_session_common_util.c b/services/group_manager/src/session/bind_session_common_util.c index 0f0d9e3..9132d97 100644 --- a/services/group_manager/src/session/bind_session_common_util.c +++ b/services/group_manager/src/session/bind_session_common_util.c @@ -82,10 +82,13 @@ BindSession *CreateBaseBindSession(int32_t sessionType, int32_t opCode, const CJ HcFree(session); return NULL; } + int32_t osAccountId = 0; + (void)GetIntFromJson(params, FIELD_OS_ACCOUNT_ID, &osAccountId); session->base.type = sessionType; session->base.process = func; session->base.destroy = DestroyBindSession; session->base.callback = callback; + session->osAccountId = osAccountId; session->curTaskId = 0; session->opCode = opCode; session->moduleType = DAS_MODULE; diff --git a/test/unittest/deviceauth/BUILD.gn b/test/unittest/deviceauth/BUILD.gn index 19e03e4..3819e95 100644 --- a/test/unittest/deviceauth/BUILD.gn +++ b/test/unittest/deviceauth/BUILD.gn @@ -19,21 +19,25 @@ module_output_path = "deviceauth_standard/deviceauth_test" ohos_unittest("deviceauth_llt") { module_out_path = module_output_path - include_dirs = [ + + include_dirs = inc_path + include_dirs += hals_inc_path + + include_dirs += [ "./include", "//third_party/json/include", "//utils/native/base/include", "//foundation/communication/dsoftbus/interfaces/kits/common", "//foundation/communication/dsoftbus/interfaces/kits/transport", "//foundation/communication/dsoftbus/interfaces/inner_kits/transport", + "//base/account/os_account/interfaces/innerkits/osaccount/native/include", ] - include_dirs += inc_path - include_dirs += hals_inc_path sources = [ "${common_lib_path}/impl/src/clib_types.c", "${common_lib_path}/impl/src/hc_parcel.c", "${common_lib_path}/impl/src/hc_string.c", + "${common_lib_path}/impl/src/hc_string_vector.c", "${common_lib_path}/impl/src/hc_tlv_parser.c", "${common_lib_path}/impl/src/json_utils.c", "${common_lib_path}/impl/src/string_util.c", @@ -67,5 +71,6 @@ ohos_unittest("deviceauth_llt") { external_deps = [ "dsoftbus_standard:softbus_client", "hiviewdfx_hilog_native:libhilog", + "os_account_standard:os_account_innerkits", ] } diff --git a/test/unittest/deviceauth/include/deviceauth_standard_test.h b/test/unittest/deviceauth/include/deviceauth_standard_test.h index f995428..d068644 100644 --- a/test/unittest/deviceauth/include/deviceauth_standard_test.h +++ b/test/unittest/deviceauth/include/deviceauth_standard_test.h @@ -16,93 +16,5 @@ #ifndef DEVICEAUTH_STANDARD_TEST_H #define DEVICEAUTH_STANDARD_TEST_H -#include -#include "gtest/gtest.h" -#include "gmock/gmock.h" - -extern "C" { -#include "device_auth.h" -} - -namespace { - const char *TEST_APP_NAME = "TestApp"; - const int32_t TEMP_REQUEST_ID = 123; - const int32_t BUFFER_SIZE = 2048; - const char *CLIENT_AUTH_ID = "3C58C27533D8"; - const char *SERVER_AUTH_ID = "CAF34E13190CBA510AA8DABB70CDFF8E9F623656DED400EF0D4CFD9E88FD6202"; - const char *PIN_CODE = "123456"; - const int32_t CLIENT_REQUEST_ID = 123; - const int32_t SERVER_REQUEST_ID = 345; - const int32_t STR_BUFF_SZ_MIN = 32; - const int32_t STR_BUFF_SZ_NORMAL = 128; - const int32_t MAX_GROUP_NUMBER = 101; -} - -typedef enum { - ON_REQUEST = 1, - ON_ERROR = 2, - ON_FINISH = 3, - ON_SESSION_KEY_RETURNED = 4, - ON_TRANSMIT = 5 -} CallbackType; - -class GET_INSTANCE : public testing::Test { -public: - static void SetUpTestCase(); - static void TearDownTestCase(); - void SetUp() override {} - void TearDown() override {} -}; - -class REGISTER_CALLBACK : public testing::Test { -public: - static void SetUpTestCase() {} - static void TearDownTestCase() {} - virtual void SetUp() override; - virtual void TearDown() override; - - const DeviceGroupManager *gm = nullptr; - const GroupAuthManager *ga = nullptr; -}; - -class CREATE_GROUP_P2P : public testing::Test { -public: - static void SetUpTestCase(); - static void TearDownTestCase(); - void SetUp() override; - void TearDown() override; -}; - -class AUTHENTICATE_GA : public testing::Test { -public: - static void SetUpTestCase(); - static void TearDownTestCase(); - void SetUp() override {} - void TearDown() override {} -}; - -class ADD_MEMBER_TO_GROUP : public testing::Test { -public: - static void SetUpTestCase() {}; - static void TearDownTestCase() {}; - void SetUp() override; - void TearDown() override; -}; - -class REGISTER_LISTENER : public testing::Test { -public: - static void SetUpTestCase(); - static void TearDownTestCase(); - void SetUp() override; - void TearDown() override; -}; - -class QUERY_INTERFACE : public testing::Test { -public: - static void SetUpTestCase(); - static void TearDownTestCase(); - void SetUp() override; - void TearDown() override; -}; #endif diff --git a/test/unittest/deviceauth/include/deviceauth_test_mock.h b/test/unittest/deviceauth/include/deviceauth_test_mock.h index e8c7efe..8fa96f9 100644 --- a/test/unittest/deviceauth/include/deviceauth_test_mock.h +++ b/test/unittest/deviceauth/include/deviceauth_test_mock.h @@ -23,4 +23,6 @@ void SetClient(bool tag); bool GetClient(); +const char *GetStorageDirPath(void); + #endif diff --git a/test/unittest/deviceauth/source/deviceauth_standard_test.cpp b/test/unittest/deviceauth/source/deviceauth_standard_test.cpp index 90c1931..46bbe4a 100644 --- a/test/unittest/deviceauth/source/deviceauth_standard_test.cpp +++ b/test/unittest/deviceauth/source/deviceauth_standard_test.cpp @@ -14,431 +14,44 @@ */ #include "deviceauth_standard_test.h" -#include "deviceauth_test_mock.h" #include -extern "C" { +#include #include "common_defs.h" -#include "json_utils.h" +#include "deviceauth_test_mock.h" #include "device_auth.h" #include "device_auth_defines.h" -#include "database_manager.h" -#include "hc_condition.h" -#include "hc_mutex.h" -#include "hc_types.h" -} +#include "gtest/gtest.h" +#include "gmock/gmock.h" +#include "json_utils.h" using namespace std; using namespace testing::ext; -static bool g_isNeedContinue = false; -static int64_t g_requestId = 0L; -static int g_operationCode = -1; -static int g_errorCode = 1; -static char *g_tempStr = nullptr; -static int g_messageCode = -1; -static char g_dataBuffer[BUFFER_SIZE] = { 0 }; -static HcCondition g_testCondition; -static const DeviceGroupManager *g_testGm = nullptr; -static const GroupAuthManager *g_testGa = nullptr; -static DeviceAuthCallback g_gaCallback; - -static void DelayWithMSec(int32_t mSecs) -{ - struct timeval out; - out.tv_sec = 0; - out.tv_usec = mSecs * 1000; - (void)select(1, NULL, NULL, NULL, &out); - return; -} - -void ClearTempValue() -{ - g_isNeedContinue = false; - g_requestId = 0L; - g_operationCode = -1; - g_errorCode = 1; - g_tempStr = nullptr; - g_messageCode = -1; -} - -/* delete file path success */ -static int32_t RemoveDir(const char *path) -{ - char strBuf[BUFFER_SIZE] = {0}; - if (path == nullptr) { - return -1; +/* test suit - GET_INSTANCE */ +class GET_INSTANCE : public testing::Test { +public: + static void SetUpTestCase() {}; + static void TearDownTestCase() {}; + virtual void SetUp() + { + int32_t ret = InitDeviceAuthService(); + EXPECT_EQ(ret == HC_SUCCESS, true); } - sprintf_s(strBuf, sizeof(strBuf) - 1, "rm -rf %s", path); - cout << strBuf << endl; - system(strBuf); - return 0; -} - -static void RemoveHuks(void) -{ - int ret; - ret = RemoveDir("/data/data/maindata"); - cout << "[Clear] clear huks:maindata done: " << ret << endl; - ret = RemoveDir("/data/data/bakdata"); - cout << "[Clear] clear huks:bakdata done: " << ret << endl; -} - -static int DeleteDatabase() -{ - const char *groupPath = "/data/data/deviceauth/hcgroup.dat"; - int ret; - ret = RemoveDir(groupPath); - cout << "[Clear] clear db: done: " << ret << endl; - RemoveHuks(); - /* wait for delete data */ - DelayWithMSec(500); - return 0; -} - -#define CHECK_GROUP_ID(groupInfo) const char *groupId = GetStringFromJson(groupInfo, FIELD_GROUP_ID); \ -ret = strcmp(groupId, "BC680ED1137A5731F4A5A90B1AACC4A0A3663F6FC2387B7273EFBCC66A54DC0B"); \ -EXPECT_EQ(ret == HC_SUCCESS, true); - -#define PRINT_COST_TIME(costTime) cout << "[ TIME ] used time: " << costTime << "(ms)" << endl; - -#define CHECK_EXPIRE_TIME(groupInfo, tmpExpireTime) int expireTime = 0; \ -GetIntFromJson(groupInfo, FIELD_EXPIRE_TIME, &expireTime); \ -EXPECT_EQ(expireTime, tmpExpireTime); - -static char *OnRequestNormal(int64_t requestId, int operationCode, const char *reqParams) -{ - g_messageCode = ON_REQUEST; - g_requestId = requestId; - g_operationCode = operationCode; - CJson *json = CreateJson(); - AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED); - AddStringToJson(json, FIELD_PIN_CODE, "123456"); - AddStringToJson(json, FIELD_DEVICE_ID, SERVER_AUTH_ID); - AddIntToJson(json, FIELD_USER_TYPE, DEVICE_TYPE_ACCESSORY); - AddIntToJson(json, FIELD_GROUP_VISIBILITY, GROUP_VISIBILITY_PUBLIC); - AddIntToJson(json, FIELD_EXPIRE_TIME, 90); - char *returnDataStr = PackJsonToString(json); - FreeJson(json); - return returnDataStr; -} - -static void OnError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn) -{ - (void)errorReturn; - g_messageCode = ON_ERROR; - g_requestId = requestId; - g_operationCode = operationCode; - g_errorCode = errorCode; - g_testCondition.notify(&g_testCondition); -} - -static void OnError2(int64_t requestId, int operationCode, int errorCode, const char *errorReturn) -{ - (void)errorReturn; - g_messageCode = ON_ERROR; - g_requestId = requestId; - g_operationCode = operationCode; - g_errorCode = errorCode; -} - -static void OnFinish(int64_t requestId, int operationCode, const char *returnData) -{ - g_messageCode = ON_FINISH; - g_requestId = requestId; - g_operationCode = operationCode; - if (operationCode == GROUP_CREATE) { - CJson *json = CreateJsonFromString(returnData); - const char *groupId = GetStringFromJson(json, FIELD_GROUP_ID); - (void)memcpy_s(g_dataBuffer, BUFFER_SIZE, groupId, strlen(groupId)); - FreeJson(json); + virtual void TearDown() + { + DestroyDeviceAuthService(); } - g_testCondition.notify(&g_testCondition); -} - -static void OnFinish2(int64_t requestId, int operationCode, const char *returnData) -{ - g_messageCode = ON_FINISH; - g_requestId = requestId; - g_operationCode = operationCode; -} - -static void OnSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen) -{ - g_messageCode = ON_SESSION_KEY_RETURNED; - g_requestId = requestId; -} - -static bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen) -{ - g_messageCode = ON_TRANSMIT; - g_requestId = requestId; - g_isNeedContinue = true; - memset_s(g_dataBuffer, BUFFER_SIZE, 0, BUFFER_SIZE); - memcpy_s(g_dataBuffer, BUFFER_SIZE, data, dataLen); - return true; -} - -static char *GaOnRequest(int64_t requestId, int operationCode, const char *reqParams) -{ - g_messageCode = ON_REQUEST; - g_requestId = requestId; - g_operationCode = operationCode; - CJson *json = CreateJson(); - AddIntToJson(json, FIELD_CONFIRMATION, REQUEST_ACCEPTED); - AddStringToJson(json, FIELD_SERVICE_PKG_NAME, TEST_APP_NAME); - AddStringToJson(json, FIELD_PEER_CONN_DEVICE_ID, "udid1"); - char *returnDataStr = PackJsonToString(json); - FreeJson(json); - return returnDataStr; -} - -enum { - GROUP_CREATED = 0, - GROUP_DELETED, - DEVICE_BOUND, - DEVICE_UNBOUND, - DEVICE_NOT_TRUSTED, - LAST_GROUP_DELETED, - TRUSTED_DEVICE_NUM_CHANGED }; -static int g_receivedMessageNum[7] = {0}; - -void OnGroupCreated(const char *groupInfo) -{ - g_receivedMessageNum[GROUP_CREATED]++; -} - -void OnGroupDeleted(const char *groupInfo) -{ - g_receivedMessageNum[GROUP_DELETED]++; -} - -void OnDeviceBound(const char *peerUdid, const char *groupInfo) -{ - g_receivedMessageNum[DEVICE_BOUND]++; -} - -void OnDeviceUnBound(const char *peerUdid, const char *groupInfo) -{ - g_receivedMessageNum[DEVICE_UNBOUND]++; -} - -void OnDeviceNotTrusted(const char *peerUdid) -{ - g_receivedMessageNum[DEVICE_NOT_TRUSTED]++; -} - -void OnLastGroupDeleted(const char *peerUdid, int groupType) -{ - g_receivedMessageNum[LAST_GROUP_DELETED]++; -} - -void OnTrustedDeviceNumChanged(int curTrustedDeviceNum) -{ - g_receivedMessageNum[TRUSTED_DEVICE_NUM_CHANGED]++; -} - -static void InitCaseResource(void) -{ - int32_t ret; - const DeviceGroupManager *gmTmp = nullptr; - ret = InitDeviceAuthService(); - EXPECT_EQ(ret == HC_SUCCESS, true); - gmTmp = GetGmInstance(); - EXPECT_NE(gmTmp, nullptr); - g_testGm = gmTmp; - g_gaCallback.onRequest = OnRequestNormal; - g_gaCallback.onTransmit = OnTransmit; - g_gaCallback.onFinish = OnFinish; - g_gaCallback.onError = OnError; - g_gaCallback.onSessionKeyReturned = OnSessionKeyReturned; - g_testGm->regCallback(TEST_APP_NAME, &g_gaCallback); - DelayWithMSec(500); -} - -static void DeInitCaseResource(void) -{ - DestroyDeviceAuthService(); - ClearTempValue(); - g_testGm = nullptr; -} - -/* test suit - GET_INSTANCE */ -void GET_INSTANCE::SetUpTestCase() -{ - int32_t ret; - ret = InitDeviceAuthService(); - EXPECT_EQ(ret == HC_SUCCESS, true); -} - -void GET_INSTANCE::TearDownTestCase() -{ - DestroyDeviceAuthService(); - ClearTempValue(); -} - -/* test suit - REGISTER_CALLBACK */ -void REGISTER_CALLBACK::SetUp() -{ - int32_t ret; - ret = InitDeviceAuthService(); - EXPECT_EQ(ret == HC_SUCCESS, true); - gm = GetGmInstance(); - EXPECT_NE(gm, nullptr); -} - -void REGISTER_CALLBACK::TearDown() -{ - DestroyDeviceAuthService(); - ClearTempValue(); - gm = nullptr; -} - -/* test suit - CREATE_GROUP_P2P */ -void CREATE_GROUP_P2P::SetUpTestCase() -{ - InitHcCond(&g_testCondition, nullptr); -} - -void CREATE_GROUP_P2P::TearDownTestCase() -{ - DestroyHcCond(&g_testCondition); -} -void CREATE_GROUP_P2P::SetUp() -{ - SetClient(false); - DeleteDatabase(); - InitCaseResource(); -} - -void CREATE_GROUP_P2P::TearDown() -{ - DeInitCaseResource(); -} - -/* test suit - AUTHENTICATE_GA */ -void AUTHENTICATE_GA::SetUpTestCase() -{ - int32_t ret; - ret = InitDeviceAuthService(); - EXPECT_EQ(ret == HC_SUCCESS, true); - g_gaCallback = { - OnTransmit, - OnSessionKeyReturned, - OnFinish, - OnError, - GaOnRequest - }; - g_testGa = GetGaInstance(); - EXPECT_NE(g_testGa, nullptr); - SetClient(false); -} - -void AUTHENTICATE_GA::TearDownTestCase() -{ - DestroyDeviceAuthService(); - DeleteDatabase(); - ClearTempValue(); - g_testGa = nullptr; -} - -/* test suit - ADD_MEMBER_TO_GROUP */ -void ADD_MEMBER_TO_GROUP::SetUp() -{ - int32_t ret; - const DeviceGroupManager *gmTmp = nullptr; - - DeleteDatabase(); - ret = InitDeviceAuthService(); - EXPECT_EQ(ret == HC_SUCCESS, true); - g_gaCallback = { - OnTransmit, - OnSessionKeyReturned, - OnFinish2, - OnError2, - OnRequestNormal - }; - gmTmp = GetGmInstance(); - EXPECT_NE(gmTmp, nullptr); - g_testGm = gmTmp; - ret = g_testGm->regCallback(TEST_APP_NAME, &g_gaCallback); - EXPECT_EQ(ret == HC_SUCCESS, true); - SetClient(false); -} - -void ADD_MEMBER_TO_GROUP::TearDown() -{ - DestroyDeviceAuthService(); - DeleteDatabase(); - ClearTempValue(); - g_testGm = nullptr; -} - -/* test suit - REGISTER_LISTENER */ -void REGISTER_LISTENER::SetUpTestCase() -{ - DeleteDatabase(); - InitHcCond(&g_testCondition, nullptr); -} - -void REGISTER_LISTENER::TearDownTestCase() -{ - DestroyHcCond(&g_testCondition); -} - -void REGISTER_LISTENER::SetUp() -{ - InitDeviceAuthService(); - g_gaCallback = { - OnTransmit, - OnSessionKeyReturned, - OnFinish, - OnError, - OnRequestNormal - }; - g_testGm = GetGmInstance(); - g_testGm->regCallback(TEST_APP_NAME, &g_gaCallback); - DelayWithMSec(500); -} -void REGISTER_LISTENER::TearDown() -{ - DestroyDeviceAuthService(); - DeleteDatabase(); - ClearTempValue(); -} - -void QUERY_INTERFACE::SetUpTestCase() -{ - DeleteDatabase(); -} - -void QUERY_INTERFACE::TearDownTestCase() {} - -void QUERY_INTERFACE::SetUp() -{ - InitDeviceAuthService(); - g_gaCallback = { - OnTransmit, - OnSessionKeyReturned, - OnFinish2, - OnError2, - OnRequestNormal - }; - g_testGm = GetGmInstance(); - g_testGm->regCallback(TEST_APP_NAME, &g_gaCallback); -} -void QUERY_INTERFACE::TearDown() -{ - DestroyDeviceAuthService(); - DeleteDatabase(); - ClearTempValue(); -} - /* start cases */ -HWTEST_F(GET_INSTANCE, TC_GET_GM_INSTANCE, TestSize.Level0) +TEST_F(GET_INSTANCE, TC_GET_GM_INSTANCE) { const DeviceGroupManager *gm = GetGmInstance(); EXPECT_NE(gm, nullptr); } +TEST_F(GET_INSTANCE, TC_GET_GA_INSTANCE) +{ + const GroupAuthManager *ga = GetGaInstance(); + EXPECT_NE(ga, nullptr); +} diff --git a/test/unittest/deviceauth/source/deviceauth_test_mock.cpp b/test/unittest/deviceauth/source/deviceauth_test_mock.cpp index d9135cb..b5e42b6 100644 --- a/test/unittest/deviceauth/source/deviceauth_test_mock.cpp +++ b/test/unittest/deviceauth/source/deviceauth_test_mock.cpp @@ -14,9 +14,12 @@ */ #include "deviceauth_test_mock.h" +#include "iostream" #include #include "securec.h" +using namespace std; + static bool g_testForClient = false; void SetClient(bool tag) @@ -41,7 +44,17 @@ int32_t HcGetUdid(uint8_t *udid, int32_t udidLen) return 0; } -const char *GetStoragePath() +const char *GetStoragePath(void) { return "/data/data/deviceauth/hcgroup.dat"; } + +const char *GetStorageDirPath(void) +{ +#ifndef LITE_DEVICE + const char *storageFile = "/data/data/deviceauth"; +#else + const char *storageFile = "/storage/deviceauth"; +#endif + return storageFile; +} \ No newline at end of file