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_common_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
SyncRemoteHapTokenCommand(const std::string & srcDeviceId,const std::string & dstDeviceId,AccessTokenID id)28 SyncRemoteHapTokenCommand::SyncRemoteHapTokenCommand(
29 const std::string &srcDeviceId, const std::string &dstDeviceId, AccessTokenID id) : requestTokenId_(id)
30 {
31 remoteProtocol_.commandName = COMMAND_NAME;
32 remoteProtocol_.uniqueId = COMMAND_NAME;
33 remoteProtocol_.srcDeviceId = srcDeviceId;
34 remoteProtocol_.dstDeviceId = dstDeviceId;
35 remoteProtocol_.responseVersion = Constant::DISTRIBUTED_ACCESS_TOKEN_SERVICE_VERSION;
36 remoteProtocol_.requestVersion = Constant::DISTRIBUTED_ACCESS_TOKEN_SERVICE_VERSION;
37 hapTokenInfo_.baseInfo.bundleName = "";
38 hapTokenInfo_.baseInfo.instIndex = 0;
39 hapTokenInfo_.baseInfo.dlpType = 0;
40 hapTokenInfo_.baseInfo.tokenAttr = 0;
41 hapTokenInfo_.baseInfo.tokenID = 0;
42 hapTokenInfo_.baseInfo.userID = 0;
43 hapTokenInfo_.baseInfo.ver = DEFAULT_TOKEN_VERSION;
44 }
45
SyncRemoteHapTokenCommand(const std::string & json)46 SyncRemoteHapTokenCommand::SyncRemoteHapTokenCommand(const std::string &json)
47 {
48 requestTokenId_ = 0;
49 hapTokenInfo_.baseInfo.bundleName = "";
50 hapTokenInfo_.baseInfo.instIndex = 0;
51 hapTokenInfo_.baseInfo.dlpType = 0;
52 hapTokenInfo_.baseInfo.tokenAttr = 0;
53 hapTokenInfo_.baseInfo.tokenID = 0;
54 hapTokenInfo_.baseInfo.userID = 0;
55 hapTokenInfo_.baseInfo.ver = DEFAULT_TOKEN_VERSION;
56
57 CJsonUnique jsonObject = CreateJsonFromString(json);
58 if (jsonObject == nullptr) {
59 LOGE(ATM_DOMAIN, ATM_TAG, "JsonObject is invalid.");
60 return;
61 }
62 BaseRemoteCommand::FromRemoteProtocolJson(jsonObject.get());
63 GetUnsignedIntFromJson(jsonObject, "requestTokenId", requestTokenId_);
64
65 CJson *hapTokenJson = GetObjFromJson(jsonObject, "HapTokenInfo");
66 if (hapTokenJson != nullptr) {
67 BaseRemoteCommand::FromHapTokenInfoJson(hapTokenJson, hapTokenInfo_);
68 }
69 }
70
ToJsonPayload()71 std::string SyncRemoteHapTokenCommand::ToJsonPayload()
72 {
73 CJsonUnique j = BaseRemoteCommand::ToRemoteProtocolJson();
74 AddUnsignedIntToJson(j, "requestTokenId", requestTokenId_);
75 CJsonUnique HapTokenInfo = BaseRemoteCommand::ToHapTokenInfosJson(hapTokenInfo_);
76 AddObjToJson(j, "HapTokenInfo", HapTokenInfo);
77 return PackJsonToString(j);
78 }
79
Prepare()80 void SyncRemoteHapTokenCommand::Prepare()
81 {
82 remoteProtocol_.statusCode = Constant::SUCCESS;
83 remoteProtocol_.message = Constant::COMMAND_RESULT_SUCCESS;
84 LOGD(ATM_DOMAIN, ATM_TAG, " end as: SyncRemoteHapTokenCommand");
85 }
86
Execute()87 void SyncRemoteHapTokenCommand::Execute()
88 {
89 LOGI(ATM_DOMAIN, ATM_TAG, "Execute: start as: SyncRemoteHapTokenCommand");
90 remoteProtocol_.responseDeviceId = ConstantCommon::GetLocalDeviceId();
91 remoteProtocol_.responseVersion = Constant::DISTRIBUTED_ACCESS_TOKEN_SERVICE_VERSION;
92
93 int ret = AccessTokenKit::GetHapTokenInfoFromRemote(requestTokenId_, hapTokenInfo_);
94 if (ret != RET_SUCCESS) {
95 remoteProtocol_.statusCode = Constant::FAILURE_BUT_CAN_RETRY;
96 remoteProtocol_.message = Constant::COMMAND_RESULT_FAILED;
97 } else {
98 remoteProtocol_.statusCode = Constant::SUCCESS;
99 remoteProtocol_.message = Constant::COMMAND_RESULT_SUCCESS;
100 }
101
102 LOGI(ATM_DOMAIN, ATM_TAG, "Execute: end as: SyncRemoteHapTokenCommand");
103 }
104
Finish()105 void SyncRemoteHapTokenCommand::Finish()
106 {
107 if (remoteProtocol_.statusCode != Constant::SUCCESS) {
108 LOGE(ATM_DOMAIN, ATM_TAG, "Finish: end as: SyncRemoteHapTokenCommand get remote result error.");
109 return;
110 }
111 AccessTokenKit::SetRemoteHapTokenInfo(remoteProtocol_.dstDeviceId, hapTokenInfo_);
112 remoteProtocol_.statusCode = Constant::SUCCESS;
113 LOGI(ATM_DOMAIN, ATM_TAG, "Finish: end as: SyncRemoteHapTokenCommand");
114 }
115 } // namespace AccessToken
116 } // namespace Security
117 } // namespace OHOS
118