diff --git a/BUILD.gn b/BUILD.gn index f334150b7b10a5f69643740bf143b0ba266f705d..2a2972062c7ddc5e3605cb9d14747b17d5a10094 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -19,6 +19,7 @@ group("accesstoken_build_module_test") { deps = [] if (is_standard_system) { deps += [ + "//base/security/access_token/frameworks/accesstoken/test:unittest", "//base/security/access_token/interfaces/innerkits/accesstoken/test:unittest", "//base/security/access_token/interfaces/innerkits/nativetoken/test:unittest", "//base/security/access_token/interfaces/innerkits/privacy/test:unittest", diff --git a/frameworks/accesstoken/include/i_accesstoken_manager.h b/frameworks/accesstoken/include/i_accesstoken_manager.h index c06b98b6abc43841fce2cd48d4cbaf15a02d2e9e..53609ef7bb02e8fc5eab41455b0f529802a4b91d 100644 --- a/frameworks/accesstoken/include/i_accesstoken_manager.h +++ b/frameworks/accesstoken/include/i_accesstoken_manager.h @@ -67,6 +67,7 @@ public: const PermStateChangeScopeParcel& scope, const sptr& callback) = 0; virtual int32_t UnRegisterPermStateChangeCallback(const sptr& callback) = 0; virtual int32_t ReloadNativeTokenInfo() = 0; + virtual AccessTokenID GetNativeTokenId(const std::string& processName) = 0; #ifdef TOKEN_SYNC_ENABLE virtual int GetHapTokenInfoFromRemote(AccessTokenID tokenID, @@ -116,6 +117,7 @@ public: REGISTER_PERM_STATE_CHANGE_CALLBACK, UNREGISTER_PERM_STATE_CHANGE_CALLBACK, RELOAD_NATIVE_TOKEN_INFO, + GET_NATIVE_TOKEN_ID, }; }; } // namespace AccessToken diff --git a/frameworks/accesstoken/test/BUILD.gn b/frameworks/accesstoken/test/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..f4fc1de58af4a6d1688acc3ffbf3732dc4848a77 --- /dev/null +++ b/frameworks/accesstoken/test/BUILD.gn @@ -0,0 +1,140 @@ +# 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. + +import("//base/security/access_token/access_token.gni") +import("//build/test.gni") + +config("accesstoken_test_config") { + include_dirs = [ + "//commonlibrary/c_utils/base/include", + "//third_party/googletest/include", + "//base/security/access_token/frameworks/accesstoken/include", + "//base/security/access_token/frameworks/common/include", + ] +} +ohos_unittest("libpermission_state_change_info_parcel_test") { + subsystem_name = "security" + part_name = "access_token" + module_out_path = part_name + "/" + part_name + + sources = [ "unittest/src/permission_state_change_info_parcel_test.cpp" ] + + cflags_cc = [ "-DHILOG_ENABLE" ] + + configs = [ + ":accesstoken_test_config", + "//base/security/access_token/config:coverage_flags", + ] + + deps = [ "//base/security/access_token/frameworks/accesstoken:accesstoken_communication_adapter_cxx" ] + + external_deps = [ + "c_utils:utils", + "dsoftbus:softbus_client", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_single", + ] + if (token_sync_enable == true) { + cflags_cc += [ "-DTOKEN_SYNC_ENABLE" ] + } +} + +ohos_unittest("libpermission_state_change_scope_parcel_test") { + subsystem_name = "security" + part_name = "access_token" + module_out_path = part_name + "/" + part_name + + sources = [ "unittest/src/permission_state_change_scope_parcel_test.cpp" ] + + cflags_cc = [ "-DHILOG_ENABLE" ] + + configs = [ + ":accesstoken_test_config", + "//base/security/access_token/config:coverage_flags", + ] + + deps = [ "//base/security/access_token/frameworks/accesstoken:accesstoken_communication_adapter_cxx" ] + + external_deps = [ + "c_utils:utils", + "dsoftbus:softbus_client", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_single", + ] + if (token_sync_enable == true) { + cflags_cc += [ "-DTOKEN_SYNC_ENABLE" ] + } +} + +ohos_unittest("libhap_info_parcel_test") { + subsystem_name = "security" + part_name = "access_token" + module_out_path = part_name + "/" + part_name + + sources = [ "unittest/src/hap_info_parcel_test.cpp" ] + + cflags_cc = [ "-DHILOG_ENABLE" ] + + configs = [ + ":accesstoken_test_config", + "//base/security/access_token/config:coverage_flags", + ] + + deps = [ "//base/security/access_token/frameworks/accesstoken:accesstoken_communication_adapter_cxx" ] + + external_deps = [ + "c_utils:utils", + "dsoftbus:softbus_client", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_single", + ] + if (token_sync_enable == true) { + cflags_cc += [ "-DTOKEN_SYNC_ENABLE" ] + } +} + +ohos_unittest("libhap_policy_parcel_test") { + subsystem_name = "security" + part_name = "access_token" + module_out_path = part_name + "/" + part_name + + sources = [ "unittest/src/hap_policy_parcel_test.cpp" ] + + cflags_cc = [ "-DHILOG_ENABLE" ] + + configs = [ + ":accesstoken_test_config", + "//base/security/access_token/config:coverage_flags", + ] + + deps = [ "//base/security/access_token/frameworks/accesstoken:accesstoken_communication_adapter_cxx" ] + + external_deps = [ + "c_utils:utils", + "dsoftbus:softbus_client", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_single", + ] + if (token_sync_enable == true) { + cflags_cc += [ "-DTOKEN_SYNC_ENABLE" ] + } +} +group("unittest") { + testonly = true + deps = [ + ":libhap_info_parcel_test", + ":libhap_policy_parcel_test", + ":libpermission_state_change_info_parcel_test", + ":libpermission_state_change_scope_parcel_test", + ] +} diff --git a/frameworks/accesstoken/test/unittest/src/hap_info_parcel_test.cpp b/frameworks/accesstoken/test/unittest/src/hap_info_parcel_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5c230b98853aafb7b25ad7b1ad9c2c2100358e15 --- /dev/null +++ b/frameworks/accesstoken/test/unittest/src/hap_info_parcel_test.cpp @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2021-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 +#include +#include +#include "accesstoken_log.h" +#include "hap_info_parcel.h" +#include "parcel.h" +#include "access_token.h" +#include "hap_token_info.h" + +using namespace testing::ext; + +namespace OHOS { +namespace Security { +namespace AccessToken { +namespace { +static constexpr int32_t DEFAULT_API_VERSION = 8; +} +class HapInfoParcelTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void HapInfoParcelTest::SetUpTestCase(void) {} +void HapInfoParcelTest::TearDownTestCase(void) {} +void HapInfoParcelTest::SetUp(void) {} +void HapInfoParcelTest::TearDown(void) {} + +/** + * @tc.name: HapInfoParcel001 + * @tc.desc: Verify the CreateHapTokenInfo add one hap token function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(HapInfoParcelTest, HapInfoParcel001, TestSize.Level1) +{ + HapInfoParcel hapinfoParcel; + hapinfoParcel.hapInfoParameter = { + .userID = 1, + .bundleName = "accesstoken_test", + .instIndex = 0, + .appIDDesc = "testtesttesttest", + .apiVersion = DEFAULT_API_VERSION, + }; + + Parcel parcel; + EXPECT_TRUE(hapinfoParcel.Marshalling(parcel)); + + std::shared_ptr readedData(HapInfoParcel::Unmarshalling(parcel)); + EXPECT_TRUE(readedData); + + EXPECT_EQ(hapinfoParcel.hapInfoParameter.userID, readedData->hapInfoParameter.userID); + EXPECT_EQ(true, hapinfoParcel.hapInfoParameter.bundleName == readedData->hapInfoParameter.bundleName); + EXPECT_EQ(hapinfoParcel.hapInfoParameter.instIndex, readedData->hapInfoParameter.instIndex); + EXPECT_EQ(true, hapinfoParcel.hapInfoParameter.appIDDesc == readedData->hapInfoParameter.appIDDesc); + EXPECT_EQ(hapinfoParcel.hapInfoParameter.apiVersion, readedData->hapInfoParameter.apiVersion); +} +} +} +} \ No newline at end of file diff --git a/frameworks/accesstoken/test/unittest/src/hap_policy_parcel_test.cpp b/frameworks/accesstoken/test/unittest/src/hap_policy_parcel_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b680cb718f7cc5765e2962446dd257c42fa50c5b --- /dev/null +++ b/frameworks/accesstoken/test/unittest/src/hap_policy_parcel_test.cpp @@ -0,0 +1,94 @@ +/* + * Copyright (c) 2021-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 +#include +#include +#include "accesstoken_log.h" +#include "hap_policy_parcel.h" +#include "parcel.h" +#include "access_token.h" +#include "hap_token_info.h" +#include "permission_state_full.h" + +using namespace testing::ext; + +namespace OHOS { +namespace Security { +namespace AccessToken { +namespace { +static const std::string TEST_PERMISSION_NAME_ALPHA = "ohos.permission.ALPHA"; +static const std::string TEST_PERMISSION_NAME_BETA = "ohos.permission.BETA"; +} +class HapPolicyParcelTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void HapPolicyParcelTest::SetUpTestCase(void) {} +void HapPolicyParcelTest::TearDownTestCase(void) {} +void HapPolicyParcelTest::SetUp(void) {} +void HapPolicyParcelTest::TearDown(void) {} + +/** + * @tc.name: HapPolicyParcel001 + * @tc.desc: Verify the CreateHapTokenInfo add one hap token function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(HapPolicyParcelTest, HapPolicyParcel001, TestSize.Level1) +{ + PermissionStateFull permStatAlpha = { + .permissionName = TEST_PERMISSION_NAME_ALPHA, + .isGeneral = true, + .resDeviceID = {"device"}, + .grantStatus = {PermissionState::PERMISSION_DENIED}, + .grantFlags = {PermissionFlag::PERMISSION_USER_SET} + }; + PermissionStateFull permStatBeta = { + .permissionName = TEST_PERMISSION_NAME_BETA, + .isGeneral = true, + .resDeviceID = {"device"}, + .grantStatus = {PermissionState::PERMISSION_GRANTED}, + .grantFlags = {PermissionFlag::PERMISSION_SYSTEM_FIXED} + }; + HapPolicyParcel hapPolicyParcel; + hapPolicyParcel.hapPolicyParameter.apl = ATokenAplEnum::APL_NORMAL; + hapPolicyParcel.hapPolicyParameter.domain = "test.domain"; + hapPolicyParcel.hapPolicyParameter.permStateList.emplace_back(permStatAlpha); + hapPolicyParcel.hapPolicyParameter.permStateList.emplace_back(permStatBeta); + + Parcel parcel; + EXPECT_TRUE(hapPolicyParcel.Marshalling(parcel)); + + std::shared_ptr readedData(HapPolicyParcel::Unmarshalling(parcel)); + EXPECT_TRUE(readedData); + + EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.apl, readedData->hapPolicyParameter.apl); + EXPECT_EQ(true, hapPolicyParcel.hapPolicyParameter.domain == readedData->hapPolicyParameter.domain); + for(int32_t i=0;ihapPolicyParameter.permStateList[i].permissionName); + EXPECT_EQ(hapPolicyParcel.hapPolicyParameter.permStateList[i].isGeneral, readedData->hapPolicyParameter.permStateList[i].isGeneral); + EXPECT_EQ(true, hapPolicyParcel.hapPolicyParameter.permStateList[i].resDeviceID == readedData->hapPolicyParameter.permStateList[i].resDeviceID); + EXPECT_EQ(true, hapPolicyParcel.hapPolicyParameter.permStateList[i].grantStatus == readedData->hapPolicyParameter.permStateList[i].grantStatus); + EXPECT_EQ(true, hapPolicyParcel.hapPolicyParameter.permStateList[i].grantFlags == readedData->hapPolicyParameter.permStateList[i].grantFlags); + } +} +} +} +} diff --git a/frameworks/accesstoken/test/unittest/src/permission_state_change_info_parcel_test.cpp b/frameworks/accesstoken/test/unittest/src/permission_state_change_info_parcel_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..1b14698a47587fffde26aa3dc3f2a529c7df5182 --- /dev/null +++ b/frameworks/accesstoken/test/unittest/src/permission_state_change_info_parcel_test.cpp @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2021-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 +#include +#include +#include "accesstoken_log.h" +#include "permission_state_change_info_parcel.h" +#include "parcel.h" +#include "permission_state_change_info.h" + +using namespace testing::ext; + +namespace OHOS { +namespace Security { +namespace AccessToken { +namespace { +static constexpr int32_t TEST_PERMSTATE_CHANGE_TYPE = 10001; +static constexpr AccessTokenID TEST_TOKEN_ID = 10002; +static const std::string TEST_PERMISSION_NAME = "ohos.permission.PERMISSION_STATE_CHANGE_INFO"; + +class PermissionStateChangeInfoParcelTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void PermissionStateChangeInfoParcelTest::SetUpTestCase(void) {} +void PermissionStateChangeInfoParcelTest::TearDownTestCase(void) {} +void PermissionStateChangeInfoParcelTest::SetUp(void) {} +void PermissionStateChangeInfoParcelTest::TearDown(void) {} + +/** + * @tc.name: PermissionStateChangeInfoParcel001 + * @tc.desc: Verify the CreateHapTokenInfo add one hap token function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(PermissionStateChangeInfoParcelTest, PermissionStateChangeInfoParcel001, TestSize.Level1) +{ + PermissionStateChangeInfoParcel permissionStateParcel; + permissionStateParcel.changeInfo.PermStateChangeType = TEST_PERMSTATE_CHANGE_TYPE; + permissionStateParcel.changeInfo.tokenID = TEST_TOKEN_ID; + permissionStateParcel.changeInfo.permissionName = TEST_PERMISSION_NAME; + + Parcel parcel; + EXPECT_TRUE(permissionStateParcel.Marshalling(parcel)); + + std::shared_ptr readedData(PermissionStateChangeInfoParcel::Unmarshalling(parcel)); + EXPECT_TRUE(readedData); + + EXPECT_EQ(permissionStateParcel.changeInfo.PermStateChangeType, readedData->changeInfo.PermStateChangeType); + EXPECT_EQ(permissionStateParcel.changeInfo.tokenID, readedData->changeInfo.tokenID); + EXPECT_EQ(permissionStateParcel.changeInfo.permissionName, readedData->changeInfo.permissionName); + +} +} +} +} +} \ No newline at end of file diff --git a/frameworks/accesstoken/test/unittest/src/permission_state_change_scope_parcel_test.cpp b/frameworks/accesstoken/test/unittest/src/permission_state_change_scope_parcel_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5f093d47bf2ef0840967176cf7817503e6e99030 --- /dev/null +++ b/frameworks/accesstoken/test/unittest/src/permission_state_change_scope_parcel_test.cpp @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2021-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 +#include +#include +#include "accesstoken_log.h" +#include "permission_state_change_scope_parcel.h" +#include "parcel.h" + +using namespace testing::ext; + +namespace OHOS { +namespace Security { +namespace AccessToken { +namespace { +static constexpr AccessTokenID TEST_TOKEN_ID = 10002; +static const std::string TEST_PERMISSION_NAME = "ohos.permission.PERMISSION_STATE_CHANGE_INFO"; + +class PermStateChangeScopeParcelTest : public testing::Test { +public: + static void SetUpTestCase(void); + static void TearDownTestCase(void); + void SetUp(); + void TearDown(); +}; + +void PermStateChangeScopeParcelTest::SetUpTestCase(void) {} +void PermStateChangeScopeParcelTest::TearDownTestCase(void) {} +void PermStateChangeScopeParcelTest::SetUp(void) {} +void PermStateChangeScopeParcelTest::TearDown(void) {} + +/** + * @tc.name: PermStateChangeScopeParcel001 + * @tc.desc: Verify the CreateHapTokenInfo add one hap token function. + * @tc.type: FUNC + * @tc.require: Issue Number + */ +HWTEST_F(PermStateChangeScopeParcelTest, PermStateChangeScopeParcel001, TestSize.Level1) +{ + PermStateChangeScopeParcel permStateChangeScopeParcel; + permStateChangeScopeParcel.scope.tokenIDs.emplace_back(TEST_TOKEN_ID); + permStateChangeScopeParcel.scope.permList.emplace_back(TEST_PERMISSION_NAME); + + Parcel parcel; + EXPECT_TRUE(permStateChangeScopeParcel.Marshalling(parcel)); + + std::shared_ptr readedData(PermStateChangeScopeParcel::Unmarshalling(parcel)); + EXPECT_TRUE(readedData); + + for(int32_t i=0;iscope.tokenIDs.size();i++) { + EXPECT_EQ(permStateChangeScopeParcel.scope.tokenIDs[i], readedData->scope.tokenIDs[i]); + } + for(int32_t i=0;iscope.permList.size();i++) { + EXPECT_EQ(true, permStateChangeScopeParcel.scope.permList[i] == readedData->scope.permList[i]); + } +} +} +} +} +} \ No newline at end of file diff --git a/interfaces/innerkits/accesstoken/include/accesstoken_kit.h b/interfaces/innerkits/accesstoken/include/accesstoken_kit.h index b5fef3e72b8141949d8c49ad01958e84dead64c3..ff0632e343c386ce412caddbbc78c2a8fb30a7a9 100644 --- a/interfaces/innerkits/accesstoken/include/accesstoken_kit.h +++ b/interfaces/innerkits/accesstoken/include/accesstoken_kit.h @@ -63,6 +63,7 @@ public: static int32_t UnRegisterPermStateChangeCallback(const std::shared_ptr& callback); static int32_t GetHapDlpFlag(AccessTokenID tokenID); static int32_t ReloadNativeTokenInfo(); + static AccessTokenID GetNativeTokenId(const std::string& processName); #ifdef TOKEN_SYNC_ENABLE static int GetHapTokenInfoFromRemote(AccessTokenID tokenID, HapTokenInfoForSync& hapSync); diff --git a/interfaces/innerkits/accesstoken/src/accesstoken_kit.cpp b/interfaces/innerkits/accesstoken/src/accesstoken_kit.cpp index f18c0837b660a77166ae88ee33d86f00c7e03cc8..6736123e156c460e76ed69c6110d0ba1541c73f0 100644 --- a/interfaces/innerkits/accesstoken/src/accesstoken_kit.cpp +++ b/interfaces/innerkits/accesstoken/src/accesstoken_kit.cpp @@ -317,6 +317,15 @@ int32_t AccessTokenKit::ReloadNativeTokenInfo() return AccessTokenManagerClient::GetInstance().ReloadNativeTokenInfo(); } +AccessTokenID AccessTokenKit::GetNativeTokenId(const std::string& processName) +{ + if (!DataValidator::IsProcessNameValid(processName)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "processName is invalid"); + return INVALID_TOKENID; + } + return AccessTokenManagerClient::GetInstance().GetNativeTokenId(processName); +} + #ifdef TOKEN_SYNC_ENABLE int AccessTokenKit::GetHapTokenInfoFromRemote(AccessTokenID tokenID, HapTokenInfoForSync& hapSync) { diff --git a/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.cpp b/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.cpp index 5b4d29a637b3179a4623b779adb4fa9b99796071..4b2bbb3e49d17c9ca27847faf0f592beaede8fc0 100644 --- a/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.cpp +++ b/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.cpp @@ -370,6 +370,16 @@ int32_t AccessTokenManagerClient::ReloadNativeTokenInfo() return proxy->ReloadNativeTokenInfo(); } +AccessTokenID AccessTokenManagerClient::GetNativeTokenId(const std::string& processName) +{ + auto proxy = GetProxy(); + if (proxy == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "proxy is null"); + return INVALID_TOKENID; + } + return proxy->GetNativeTokenId(processName); +} + #ifdef TOKEN_SYNC_ENABLE int AccessTokenManagerClient::GetHapTokenInfoFromRemote(AccessTokenID tokenID, HapTokenInfoForSync& hapSync) { diff --git a/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.h b/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.h index 442d0c8b646fa26db6ef6fddcfb185b79303d621..7d5a2d44f0067ca075a58ce6add0312f53e1d897 100644 --- a/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.h +++ b/interfaces/innerkits/accesstoken/src/accesstoken_manager_client.h @@ -64,6 +64,7 @@ public: int GetHapTokenInfo(AccessTokenID tokenID, HapTokenInfo& hapTokenInfoRes); int GetNativeTokenInfo(AccessTokenID tokenID, NativeTokenInfo& nativeTokenInfoRes); int32_t ReloadNativeTokenInfo(); + AccessTokenID GetNativeTokenId(const std::string& processName); int32_t RegisterPermStateChangeCallback( const std::shared_ptr& customizedCallback); int32_t UnRegisterPermStateChangeCallback( diff --git a/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.cpp b/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.cpp index ab6abd8577ec01742eda9044902fd248d10285a8..2ae0493b6dffcc1ec268a32b7100de326ca4fe67 100644 --- a/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.cpp +++ b/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.cpp @@ -768,6 +768,40 @@ int32_t AccessTokenManagerProxy::ReloadNativeTokenInfo() return result; } +AccessTokenID AccessTokenManagerProxy::GetNativeTokenId(const std::string& processName) +{ + MessageParcel data; + if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to write WriteInterfaceToken."); + return INVALID_TOKENID; + } + + if (!data.WriteString(processName)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Failed to write processName"); + return INVALID_TOKENID; + } + MessageParcel reply; + MessageOption option(MessageOption::TF_SYNC); + sptr remote = Remote(); + if (remote == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "remote service null."); + return INVALID_TOKENID; + } + int32_t requestResult = remote->SendRequest( + static_cast(IAccessTokenManager::InterfaceCode::GET_NATIVE_TOKEN_ID), data, reply, option); + if (requestResult != NO_ERROR) { + ACCESSTOKEN_LOG_ERROR(LABEL, "request fail, result: %{public}d", requestResult); + return INVALID_TOKENID; + } + AccessTokenID result; + if (!reply.ReadUint32(result)) { + ACCESSTOKEN_LOG_INFO(LABEL, "readInt32 failed, result: %{public}d", result); + return INVALID_TOKENID; + } + ACCESSTOKEN_LOG_INFO(LABEL, "result from server data = %{public}d", result); + return result; +} + #ifdef TOKEN_SYNC_ENABLE int AccessTokenManagerProxy::GetHapTokenInfoFromRemote(AccessTokenID tokenID, HapTokenInfoForSyncParcel& hapSyncParcel) diff --git a/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.h b/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.h index 55dc477fbb0ec4a6b10fccd4910b8a379f7d535d..c14d48bb92689893242e8256b6785dfd5425fcdf 100644 --- a/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.h +++ b/interfaces/innerkits/accesstoken/src/accesstoken_manager_proxy.h @@ -61,6 +61,7 @@ public: int GetHapTokenInfo(AccessTokenID tokenID, HapTokenInfoParcel& hapTokenInfoRes) override; int GetNativeTokenInfo(AccessTokenID tokenID, NativeTokenInfoParcel& nativeTokenInfoRes) override; int32_t ReloadNativeTokenInfo() override; + AccessTokenID GetNativeTokenId(const std::string& processName) override; int32_t RegisterPermStateChangeCallback( const PermStateChangeScopeParcel& scope, const sptr& callback) override; int32_t UnRegisterPermStateChangeCallback(const sptr& callback) override; diff --git a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_test.cpp b/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_test.cpp index d6c419f10ef58a65d2cd2b666afeebd548f84f7d..2b6c47c8c2d178787009989ce7da4960f200a81f 100644 --- a/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_test.cpp +++ b/interfaces/innerkits/accesstoken/test/unittest/src/accesstoken_kit_test.cpp @@ -1340,6 +1340,34 @@ HWTEST_F(AccessTokenKitTest, ReloadNativeTokenInfo001, TestSize.Level1) int32_t ret = AccessTokenKit::ReloadNativeTokenInfo(); ASSERT_EQ(RET_SUCCESS, ret); } +/** + * @tc.name: GetNativeTokenId001 + * @tc.desc: cannot get native tokenid with invalid processName. + * @tc.type: FUNC + * @tc.require:AR000GK6TH + */ +HWTEST_F(AccessTokenKitTest, GetNativeTokenId001, TestSize.Level1) +{ + std::string processName = "invalid processName"; + AccessTokenID tokenID = AccessTokenKit::GetNativeTokenId(processName); + ASSERT_EQ(0, tokenID); +} + +/** + * @tc.name: GetNativeTokenId002 + * @tc.desc: get native tokenid with processName. + * @tc.type: FUNC + * @tc.require:AR000GK6TH + */ +HWTEST_F(AccessTokenKitTest, GetNativeTokenId002, TestSize.Level1) +{ + std::string processName = "hdcd"; + AccessTokenID tokenID = AccessTokenKit::GetNativeTokenId(processName); + NativeTokenInfo tokenInfo; + int ret = AccessTokenKit::GetNativeTokenInfo(tokenID, tokenInfo); + ASSERT_EQ(RET_SUCCESS, ret); + ASSERT_EQ(true, tokenInfo.processName == processName); +} /** * @tc.name: AllocHapToken001 diff --git a/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_service.h b/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_service.h index 927cad74748dcdf47bb8b83762094447ec616004..9220707882866419ea34488ce1d85a2f5ce9efa2 100644 --- a/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_service.h +++ b/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_service.h @@ -65,7 +65,8 @@ public: const PermStateChangeScopeParcel& scope, const sptr& callback) override; int32_t UnRegisterPermStateChangeCallback(const sptr& callback) override; int32_t ReloadNativeTokenInfo() override; - + AccessTokenID GetNativeTokenId(const std::string& processName) override; + #ifdef TOKEN_SYNC_ENABLE int GetHapTokenInfoFromRemote(AccessTokenID tokenID, HapTokenInfoForSyncParcel& hapSyncParcel) override; int GetAllNativeTokenInfo(std::vector& nativeTokenInfosRes) override; diff --git a/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_stub.h b/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_stub.h index 5ed1dfffcdeb21a412996e2fe853bcf98914d5f3..6fb115250644bf122d75fb13971fc53f09643fb6 100644 --- a/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_stub.h +++ b/services/accesstokenmanager/main/cpp/include/service/accesstoken_manager_stub.h @@ -56,7 +56,8 @@ private: void RegisterPermStateChangeCallbackInner(MessageParcel& data, MessageParcel& reply); void UnRegisterPermStateChangeCallbackInner(MessageParcel& data, MessageParcel& reply); void ReloadNativeTokenInfoInner(MessageParcel& data, MessageParcel& reply); - + void GetNativeTokenIdInner(MessageParcel& data, MessageParcel& reply); + #ifdef TOKEN_SYNC_ENABLE void GetHapTokenInfoFromRemoteInner(MessageParcel& data, MessageParcel& reply); void GetAllNativeTokenInfoInner(MessageParcel& data, MessageParcel& reply); diff --git a/services/accesstokenmanager/main/cpp/include/token/accesstoken_info_manager.h b/services/accesstokenmanager/main/cpp/include/token/accesstoken_info_manager.h index e48ec35a50a2f3ad84d285f0901c24a115bb92dd..33619ef878458beb91b2b5f209ad001f6b5c9fb5 100644 --- a/services/accesstokenmanager/main/cpp/include/token/accesstoken_info_manager.h +++ b/services/accesstokenmanager/main/cpp/include/token/accesstoken_info_manager.h @@ -58,7 +58,7 @@ public: void DumpTokenInfo(AccessTokenID tokenID, std::string& dumpInfo); void RefreshTokenInfoIfNeeded(); bool IsTokenIdExist(AccessTokenID id); - + AccessTokenID GetNativeTokenId(const std::string& processName); #ifdef TOKEN_SYNC_ENABLE /* tokensync needed */ int GetHapTokenSync(AccessTokenID tokenID, HapTokenInfoForSync& hapSync); diff --git a/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_service.cpp b/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_service.cpp index 192c9de550e18b8effc18d71ffa50f5d08fc9eb6..f51a99ec35d5e88824281d30cae5d457816f3095 100644 --- a/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_service.cpp +++ b/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_service.cpp @@ -327,6 +327,11 @@ int32_t AccessTokenManagerService::ReloadNativeTokenInfo() return NativeTokenReceptor::GetInstance().Init(); } +AccessTokenID AccessTokenManagerService::GetNativeTokenId(const std::string& processName) +{ + return AccessTokenInfoManager::GetInstance().GetNativeTokenId(processName); +} + #ifdef TOKEN_SYNC_ENABLE int AccessTokenManagerService::GetHapTokenInfoFromRemote(AccessTokenID tokenID, HapTokenInfoForSyncParcel& hapSyncParcel) diff --git a/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_stub.cpp b/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_stub.cpp index c86358030c1aa5664458f203f65a3e027ae83617..b1085b915e8ffa2b4f6a6388da02f798ef17e4af 100644 --- a/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_stub.cpp +++ b/services/accesstokenmanager/main/cpp/src/service/accesstoken_manager_stub.cpp @@ -371,6 +371,23 @@ void AccessTokenManagerStub::ReloadNativeTokenInfoInner(MessageParcel& data, Mes reply.WriteInt32(result); } +void AccessTokenManagerStub::GetNativeTokenIdInner(MessageParcel& data, MessageParcel& reply) +{ + if (!IsNativeProcessCalling()) { + ACCESSTOKEN_LOG_ERROR(LABEL, "%{public}s called, permission denied", __func__); + reply.WriteInt32(RET_FAILED); + return; + } + std::string processName; + if (!data.ReadString(processName)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "readString fail, processName=%{public}s", processName.c_str()); + return; + } + AccessTokenID result = this->GetNativeTokenId(processName); + reply.WriteUint32(result); +} + + #ifdef TOKEN_SYNC_ENABLE void AccessTokenManagerStub::GetHapTokenInfoFromRemoteInner(MessageParcel& data, MessageParcel& reply) { @@ -568,6 +585,8 @@ AccessTokenManagerStub::AccessTokenManagerStub() &AccessTokenManagerStub::UpdateHapTokenInner; requestFuncMap_[static_cast(IAccessTokenManager::InterfaceCode::RELOAD_NATIVE_TOKEN_INFO)] = &AccessTokenManagerStub::ReloadNativeTokenInfoInner; + requestFuncMap_[static_cast(IAccessTokenManager::InterfaceCode::GET_NATIVE_TOKEN_ID)] = + &AccessTokenManagerStub::GetNativeTokenIdInner; #ifdef TOKEN_SYNC_ENABLE requestFuncMap_[static_cast(IAccessTokenManager::InterfaceCode::GET_HAP_TOKEN_FROM_REMOTE)] = &AccessTokenManagerStub::GetHapTokenInfoFromRemoteInner; diff --git a/services/accesstokenmanager/main/cpp/src/token/accesstoken_info_manager.cpp b/services/accesstokenmanager/main/cpp/src/token/accesstoken_info_manager.cpp index 6ead354274811c337c6e749d93fe62dae93224cb..9a4c9bb54db951db4a65e18f72cb1081c9f22faa 100644 --- a/services/accesstokenmanager/main/cpp/src/token/accesstoken_info_manager.cpp +++ b/services/accesstokenmanager/main/cpp/src/token/accesstoken_info_manager.cpp @@ -1007,6 +1007,17 @@ void AccessTokenInfoManager::RefreshTokenInfoIfNeeded() }); } +AccessTokenID AccessTokenInfoManager::GetNativeTokenId(const std::string& processName) +{ + AccessTokenID tokenID = INVALID_TOKENID; + for (auto iter = nativeTokenInfoMap_.begin(); iter != nativeTokenInfoMap_.end(); iter++) { + if (iter->second != nullptr && iter->second->GetProcessName() == processName) { + tokenID = iter->first; + } + } + return tokenID; +} + void AccessTokenInfoManager::DumpTokenInfo(AccessTokenID tokenID, std::string& dumpInfo) { ACCESSTOKEN_LOG_INFO(LABEL, "get hapTokenInfo");