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 BaseRemoteCommand::FromRemoteProtocolJson(jsonObject);
69 if ((jsonObject.find("requestTokenId") != jsonObject.end()) && (jsonObject.at("requestTokenId").is_number())) {
70 jsonObject.at("requestTokenId").get_to(requestTokenId_);
71 }
72
73 if ((jsonObject.find("HapTokenInfo") != jsonObject.end()) && (jsonObject.at("HapTokenInfo").is_object())) {
74 nlohmann::json hapTokenJson = jsonObject.at("HapTokenInfo").get<nlohmann::json>();
75 BaseRemoteCommand::FromHapTokenInfoJson(hapTokenJson, hapTokenInfo_);
76 }
77 }
78
ToJsonPayload()79 std::string SyncRemoteHapTokenCommand::ToJsonPayload()
80 {
81 nlohmann::json j = BaseRemoteCommand::ToRemoteProtocolJson();
82 j["requestTokenId"] = requestTokenId_;
83 j["HapTokenInfo"] = BaseRemoteCommand::ToHapTokenInfosJson(hapTokenInfo_);
84 return j.dump();
85 }
86
Prepare()87 void SyncRemoteHapTokenCommand::Prepare()
88 {
89 remoteProtocol_.statusCode = Constant::SUCCESS;
90 remoteProtocol_.message = Constant::COMMAND_RESULT_SUCCESS;
91 ACCESSTOKEN_LOG_DEBUG(LABEL, " end as: SyncRemoteHapTokenCommand");
92 }
93
Execute()94 void SyncRemoteHapTokenCommand::Execute()
95 {
96 ACCESSTOKEN_LOG_INFO(LABEL, "execute: start as: SyncRemoteHapTokenCommand");
97 remoteProtocol_.responseDeviceId = ConstantCommon::GetLocalDeviceId();
98 remoteProtocol_.responseVersion = Constant::DISTRIBUTED_ACCESS_TOKEN_SERVICE_VERSION;
99
100 int ret = AccessTokenKit::GetHapTokenInfoFromRemote(requestTokenId_, hapTokenInfo_);
101 if (ret != RET_SUCCESS) {
102 remoteProtocol_.statusCode = Constant::FAILURE_BUT_CAN_RETRY;
103 remoteProtocol_.message = Constant::COMMAND_RESULT_FAILED;
104 } else {
105 remoteProtocol_.statusCode = Constant::SUCCESS;
106 remoteProtocol_.message = Constant::COMMAND_RESULT_SUCCESS;
107 }
108
109 ACCESSTOKEN_LOG_INFO(LABEL, "execute: end as: SyncRemoteHapTokenCommand");
110 }
111
Finish()112 void SyncRemoteHapTokenCommand::Finish()
113 {
114 if (remoteProtocol_.statusCode != Constant::SUCCESS) {
115 ACCESSTOKEN_LOG_ERROR(LABEL, "Finish: end as: SyncRemoteHapTokenCommand get remote result error.");
116 return;
117 }
118 AccessTokenKit::SetRemoteHapTokenInfo(remoteProtocol_.dstDeviceId, hapTokenInfo_);
119 remoteProtocol_.statusCode = Constant::SUCCESS;
120 ACCESSTOKEN_LOG_INFO(LABEL, "Finish: end as: SyncRemoteHapTokenCommand");
121 }
122 } // namespace AccessToken
123 } // namespace Security
124 } // namespace OHOS
125