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 "access_token_error.h"
21 #include "constant_common.h"
22 #include "base_remote_command.h"
23
24 namespace OHOS {
25 namespace Security {
26 namespace AccessToken {
27 namespace {
28 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {
29 LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "SyncRemoteHapTokenCommand"};
30 }
31
SyncRemoteHapTokenCommand(const std::string & srcDeviceId,const std::string & dstDeviceId,AccessTokenID id)32 SyncRemoteHapTokenCommand::SyncRemoteHapTokenCommand(
33 const std::string &srcDeviceId, const std::string &dstDeviceId, AccessTokenID id) : requestTokenId_(id)
34 {
35 remoteProtocol_.commandName = COMMAND_NAME;
36 remoteProtocol_.uniqueId = COMMAND_NAME;
37 remoteProtocol_.srcDeviceId = srcDeviceId;
38 remoteProtocol_.dstDeviceId = dstDeviceId;
39 remoteProtocol_.responseVersion = Constant::DISTRIBUTED_ACCESS_TOKEN_SERVICE_VERSION;
40 remoteProtocol_.requestVersion = Constant::DISTRIBUTED_ACCESS_TOKEN_SERVICE_VERSION;
41 hapTokenInfo_.baseInfo.apl = APL_NORMAL;
42 hapTokenInfo_.baseInfo.appID = "";
43 hapTokenInfo_.baseInfo.bundleName = "";
44 hapTokenInfo_.baseInfo.deviceID = "";
45 hapTokenInfo_.baseInfo.instIndex = 0;
46 hapTokenInfo_.baseInfo.dlpType = 0;
47 hapTokenInfo_.baseInfo.tokenAttr = 0;
48 hapTokenInfo_.baseInfo.tokenID = 0;
49 hapTokenInfo_.baseInfo.userID = 0;
50 hapTokenInfo_.baseInfo.ver = DEFAULT_TOKEN_VERSION;
51 }
52
SyncRemoteHapTokenCommand(const std::string & json)53 SyncRemoteHapTokenCommand::SyncRemoteHapTokenCommand(const std::string &json)
54 {
55 requestTokenId_ = 0;
56 hapTokenInfo_.baseInfo.apl = APL_INVALID;
57 hapTokenInfo_.baseInfo.appID = "";
58 hapTokenInfo_.baseInfo.bundleName = "";
59 hapTokenInfo_.baseInfo.deviceID = "";
60 hapTokenInfo_.baseInfo.instIndex = 0;
61 hapTokenInfo_.baseInfo.dlpType = 0;
62 hapTokenInfo_.baseInfo.tokenAttr = 0;
63 hapTokenInfo_.baseInfo.tokenID = 0;
64 hapTokenInfo_.baseInfo.userID = 0;
65 hapTokenInfo_.baseInfo.ver = DEFAULT_TOKEN_VERSION;
66
67 nlohmann::json jsonObject = nlohmann::json::parse(json, nullptr, false);
68 if (jsonObject.is_discarded()) {
69 ACCESSTOKEN_LOG_ERROR(LABEL, "JsonObject is invalid.");
70 return;
71 }
72 BaseRemoteCommand::FromRemoteProtocolJson(jsonObject);
73 if ((jsonObject.find("requestTokenId") != jsonObject.end()) && (jsonObject.at("requestTokenId").is_number())) {
74 jsonObject.at("requestTokenId").get_to(requestTokenId_);
75 }
76
77 if ((jsonObject.find("HapTokenInfo") != jsonObject.end()) && (jsonObject.at("HapTokenInfo").is_object())) {
78 nlohmann::json hapTokenJson = jsonObject.at("HapTokenInfo").get<nlohmann::json>();
79 BaseRemoteCommand::FromHapTokenInfoJson(hapTokenJson, hapTokenInfo_);
80 }
81 }
82
ToJsonPayload()83 std::string SyncRemoteHapTokenCommand::ToJsonPayload()
84 {
85 nlohmann::json j = BaseRemoteCommand::ToRemoteProtocolJson();
86 j["requestTokenId"] = requestTokenId_;
87 j["HapTokenInfo"] = BaseRemoteCommand::ToHapTokenInfosJson(hapTokenInfo_);
88 return j.dump();
89 }
90
Prepare()91 void SyncRemoteHapTokenCommand::Prepare()
92 {
93 remoteProtocol_.statusCode = Constant::SUCCESS;
94 remoteProtocol_.message = Constant::COMMAND_RESULT_SUCCESS;
95 ACCESSTOKEN_LOG_DEBUG(LABEL, " end as: SyncRemoteHapTokenCommand");
96 }
97
Execute()98 void SyncRemoteHapTokenCommand::Execute()
99 {
100 ACCESSTOKEN_LOG_INFO(LABEL, "Execute: start as: SyncRemoteHapTokenCommand");
101 remoteProtocol_.responseDeviceId = ConstantCommon::GetLocalDeviceId();
102 remoteProtocol_.responseVersion = Constant::DISTRIBUTED_ACCESS_TOKEN_SERVICE_VERSION;
103
104 int ret = AccessTokenKit::GetHapTokenInfoFromRemote(requestTokenId_, hapTokenInfo_);
105 if (ret != RET_SUCCESS) {
106 remoteProtocol_.statusCode = Constant::FAILURE_BUT_CAN_RETRY;
107 remoteProtocol_.message = Constant::COMMAND_RESULT_FAILED;
108 } else {
109 remoteProtocol_.statusCode = Constant::SUCCESS;
110 remoteProtocol_.message = Constant::COMMAND_RESULT_SUCCESS;
111 }
112
113 ACCESSTOKEN_LOG_INFO(LABEL, "Execute: end as: SyncRemoteHapTokenCommand");
114 }
115
Finish()116 void SyncRemoteHapTokenCommand::Finish()
117 {
118 if (remoteProtocol_.statusCode != Constant::SUCCESS) {
119 ACCESSTOKEN_LOG_ERROR(LABEL, "Finish: end as: SyncRemoteHapTokenCommand get remote result error.");
120 return;
121 }
122 AccessTokenKit::SetRemoteHapTokenInfo(remoteProtocol_.dstDeviceId, hapTokenInfo_);
123 remoteProtocol_.statusCode = Constant::SUCCESS;
124 ACCESSTOKEN_LOG_INFO(LABEL, "Finish: end as: SyncRemoteHapTokenCommand");
125 }
126 } // namespace AccessToken
127 } // namespace Security
128 } // namespace OHOS
129