1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "sync_remote_hap_token_command.h"
17
18 #include "accesstoken_kit.h"
19 #include "accesstoken_log.h"
20 #include "constant_common.h"
21 #include "base_remote_command.h"
22
23 namespace OHOS {
24 namespace Security {
25 namespace AccessToken {
26 namespace {
27 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {
28 LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "SyncRemoteHapTokenCommand"};
29 }
30
SyncRemoteHapTokenCommand(const std::string & srcDeviceId,const std::string & dstDeviceId,AccessTokenID id)31 SyncRemoteHapTokenCommand::SyncRemoteHapTokenCommand(
32 const std::string &srcDeviceId, const std::string &dstDeviceId, AccessTokenID id) : requestTokenId_(id)
33 {
34 remoteProtocol_.commandName = COMMAND_NAME;
35 remoteProtocol_.uniqueId = COMMAND_NAME;
36 remoteProtocol_.srcDeviceId = srcDeviceId;
37 remoteProtocol_.dstDeviceId = dstDeviceId;
38 remoteProtocol_.responseVersion = Constant::DISTRIBUTED_ACCESS_TOKEN_SERVICE_VERSION;
39 remoteProtocol_.requestVersion = Constant::DISTRIBUTED_ACCESS_TOKEN_SERVICE_VERSION;
40 hapTokenInfo_.baseInfo.apl = APL_NORMAL;
41 hapTokenInfo_.baseInfo.appID = "";
42 hapTokenInfo_.baseInfo.bundleName = "";
43 hapTokenInfo_.baseInfo.deviceID = "";
44 hapTokenInfo_.baseInfo.instIndex = 0;
45 hapTokenInfo_.baseInfo.dlpType = 0;
46 hapTokenInfo_.baseInfo.tokenAttr = 0;
47 hapTokenInfo_.baseInfo.tokenID = 0;
48 hapTokenInfo_.baseInfo.userID = 0;
49 hapTokenInfo_.baseInfo.ver = DEFAULT_TOKEN_VERSION;
50 }
51
SyncRemoteHapTokenCommand(const std::string & json)52 SyncRemoteHapTokenCommand::SyncRemoteHapTokenCommand(const std::string &json)
53 {
54 requestTokenId_ = 0;
55 hapTokenInfo_.baseInfo.apl = APL_INVALID;
56 hapTokenInfo_.baseInfo.appID = "";
57 hapTokenInfo_.baseInfo.bundleName = "";
58 hapTokenInfo_.baseInfo.deviceID = "";
59 hapTokenInfo_.baseInfo.instIndex = 0;
60 hapTokenInfo_.baseInfo.dlpType = 0;
61 hapTokenInfo_.baseInfo.tokenAttr = 0;
62 hapTokenInfo_.baseInfo.tokenID = 0;
63 hapTokenInfo_.baseInfo.userID = 0;
64 hapTokenInfo_.baseInfo.ver = DEFAULT_TOKEN_VERSION;
65
66 nlohmann::json jsonObject = nlohmann::json::parse(json, nullptr, false);
67 BaseRemoteCommand::FromRemoteProtocolJson(jsonObject);
68 if (jsonObject.find("requestTokenId") != jsonObject.end() && jsonObject.at("requestTokenId").is_number()) {
69 jsonObject.at("requestTokenId").get_to(requestTokenId_);
70 }
71
72 if (jsonObject.find("HapTokenInfo") != jsonObject.end()) {
73 nlohmann::json hapTokenJson = jsonObject.at("HapTokenInfo").get<nlohmann::json>();
74 BaseRemoteCommand::FromHapTokenInfoJson(hapTokenJson, hapTokenInfo_);
75 }
76 }
77
ToJsonPayload()78 std::string SyncRemoteHapTokenCommand::ToJsonPayload()
79 {
80 nlohmann::json j = BaseRemoteCommand::ToRemoteProtocolJson();
81 j["requestTokenId"] = requestTokenId_;
82 j["HapTokenInfo"] = BaseRemoteCommand::ToHapTokenInfosJson(hapTokenInfo_);
83 return j.dump();
84 }
85
Prepare()86 void SyncRemoteHapTokenCommand::Prepare()
87 {
88 remoteProtocol_.statusCode = Constant::SUCCESS;
89 remoteProtocol_.message = Constant::COMMAND_RESULT_SUCCESS;
90 ACCESSTOKEN_LOG_DEBUG(LABEL, " end as: SyncRemoteHapTokenCommand");
91 }
92
Execute()93 void SyncRemoteHapTokenCommand::Execute()
94 {
95 ACCESSTOKEN_LOG_INFO(LABEL, "execute: start as: SyncRemoteHapTokenCommand");
96 remoteProtocol_.responseDeviceId = ConstantCommon::GetLocalDeviceId();
97 remoteProtocol_.responseVersion = Constant::DISTRIBUTED_ACCESS_TOKEN_SERVICE_VERSION;
98
99 int ret = AccessTokenKit::GetHapTokenInfoFromRemote(requestTokenId_, hapTokenInfo_);
100 if (ret != RET_SUCCESS) {
101 remoteProtocol_.statusCode = Constant::FAILURE_BUT_CAN_RETRY;
102 remoteProtocol_.message = Constant::COMMAND_RESULT_FAILED;
103 } else {
104 remoteProtocol_.statusCode = Constant::SUCCESS;
105 remoteProtocol_.message = Constant::COMMAND_RESULT_SUCCESS;
106 }
107
108 ACCESSTOKEN_LOG_INFO(LABEL, "execute: end as: SyncRemoteHapTokenCommand");
109 }
110
Finish()111 void SyncRemoteHapTokenCommand::Finish()
112 {
113 if (remoteProtocol_.statusCode != Constant::SUCCESS) {
114 ACCESSTOKEN_LOG_ERROR(LABEL, "Finish: end as: SyncRemoteHapTokenCommand get remote result error.");
115 return;
116 }
117 AccessTokenKit::SetRemoteHapTokenInfo(remoteProtocol_.dstDeviceId, hapTokenInfo_);
118 remoteProtocol_.statusCode = Constant::SUCCESS;
119 ACCESSTOKEN_LOG_INFO(LABEL, "Finish: end as: SyncRemoteHapTokenCommand");
120 }
121 } // namespace AccessToken
122 } // namespace Security
123 } // namespace OHOS
124