1 /*
2 * Copyright (c) 2023 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 #include "bundle_verify_status_info.h"
16 #include "app_domain_verify_hilog.h"
17 #include "app_domain_verify_parcel_util.h"
18 #include "inner_verify_status.h"
19 #include <tuple>
20 namespace OHOS {
21 namespace AppDomainVerify {
Marshalling(Parcel & parcel) const22 bool VerifyResultInfo::Marshalling(Parcel& parcel) const
23 {
24 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, appIdentifier);
25 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, hostVerifyStatusMap.size());
26 for (auto& it : hostVerifyStatusMap) {
27 std::string domain = it.first;
28 auto [status, verifyTime, cnt] = it.second;
29 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, domain);
30 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, status);
31 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, verifyTime);
32 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, cnt);
33 }
34 return true;
35 }
36
Unmarshalling(Parcel & parcel)37 VerifyResultInfo* VerifyResultInfo::Unmarshalling(Parcel& parcel)
38 {
39 VerifyResultInfo* verifyResultInfo = new (std::nothrow) VerifyResultInfo();
40 if ((verifyResultInfo != nullptr) && (!verifyResultInfo->ReadFromParcel(parcel))) {
41 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "failed to read from parcel");
42 delete verifyResultInfo;
43 verifyResultInfo = nullptr;
44 }
45 return verifyResultInfo;
46 }
47
ReadFromParcel(Parcel & parcel)48 bool VerifyResultInfo::ReadFromParcel(Parcel& parcel)
49 {
50 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, appIdentifier);
51 uint32_t size = 0;
52 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, size);
53 if (IsInvalidParcelArraySize(size)) {
54 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
55 return false;
56 }
57 hostVerifyStatusMap.clear();
58 for (uint32_t index = 0; index < size; ++index) {
59 std::string url;
60 int verifyStatus = 0;
61 std::string verifyTs;
62 int count = 0;
63 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, url);
64 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, verifyStatus);
65 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, verifyTs);
66 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, count);
67 hostVerifyStatusMap.insert(std::make_pair(
68 url, std::make_tuple(static_cast<InnerVerifyStatus>(verifyStatus), verifyTs, count)));
69 }
70 return true;
71 }
72
Dump() const73 std::string VerifyResultInfo::Dump() const
74 {
75 std::string dumpStr = "appIdentifier:" + appIdentifier + "\n";
76 for (const auto& hostVerifyStatus : hostVerifyStatusMap) {
77 InnerVerifyStatus status;
78 std::string verifyTime;
79 int count = 0;
80 std::tie(status, verifyTime, count) = hostVerifyStatus.second;
81 dumpStr = dumpStr + " " + "domain:" + hostVerifyStatus.first +
82 " status:" + std::to_string(status) + " verifyTime:" + verifyTime + ";\n";
83 }
84 return dumpStr;
85 }
86
Marshalling(Parcel & parcel) const87 bool BundleVerifyStatusInfo::Marshalling(Parcel& parcel) const
88 {
89 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, bundleVerifyStatusInfoMap_.size());
90 for (auto& it : bundleVerifyStatusInfoMap_) {
91 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, it.first);
92 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, it.second.appIdentifier);
93 if (!WriteHostVerifyStatusMap(it.second.hostVerifyStatusMap, parcel)) {
94 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "failed to WriteHostVerifyStatusMap");
95 return false;
96 }
97 }
98 return true;
99 }
100
WriteHostVerifyStatusMap(const HostVerifyStatusMap & hostVerifyStatusMap,Parcel & parcel) const101 bool BundleVerifyStatusInfo::WriteHostVerifyStatusMap(
102 const HostVerifyStatusMap& hostVerifyStatusMap, Parcel& parcel) const
103 {
104 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, hostVerifyStatusMap.size());
105 for (auto& it : hostVerifyStatusMap) {
106 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, it.first);
107 auto [status, verifyTime, cnt] = it.second;
108 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, status);
109 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, verifyTime);
110 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, cnt);
111 }
112 return true;
113 }
114
ReadHostVerifyStatusMap(HostVerifyStatusMap & hostVerifyStatusMap,Parcel & parcel)115 bool BundleVerifyStatusInfo::ReadHostVerifyStatusMap(
116 HostVerifyStatusMap& hostVerifyStatusMap, Parcel& parcel)
117 {
118 uint32_t size = 0;
119 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, size);
120 if (IsInvalidParcelArraySize(size)) {
121 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
122 return false;
123 }
124 hostVerifyStatusMap.clear();
125 for (uint32_t index = 0; index < size; ++index) {
126 std::string url;
127 int verifyStatus = 0;
128 std::string verifyTs;
129 int verifyCnt = 0;
130 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, url);
131 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, verifyStatus);
132 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, verifyTs);
133 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, verifyCnt);
134 hostVerifyStatusMap.insert(
135 std::make_pair(url, std::make_tuple(static_cast<InnerVerifyStatus>(verifyStatus), verifyTs, verifyCnt)));
136 }
137 return true;
138 }
139
Unmarshalling(Parcel & parcel)140 BundleVerifyStatusInfo* BundleVerifyStatusInfo::Unmarshalling(Parcel& parcel)
141 {
142 BundleVerifyStatusInfo* bundleVerifyStatusInfo = new (std::nothrow) BundleVerifyStatusInfo();
143 if ((bundleVerifyStatusInfo != nullptr) && (!bundleVerifyStatusInfo->ReadFromParcel(parcel))) {
144 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "failed to read from parcel");
145 delete bundleVerifyStatusInfo;
146 bundleVerifyStatusInfo = nullptr;
147 }
148 return bundleVerifyStatusInfo;
149 }
150
ReadFromParcel(Parcel & parcel)151 bool BundleVerifyStatusInfo::ReadFromParcel(Parcel& parcel)
152 {
153 uint32_t size = 0;
154 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, size);
155 if (IsInvalidParcelArraySize(size)) {
156 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
157 return false;
158 }
159 bundleVerifyStatusInfoMap_.clear();
160 for (uint32_t index = 0; index < size; ++index) {
161 std::string bundleName;
162 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, bundleName);
163 VerifyResultInfo verifyResultInfo;
164 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, parcel, verifyResultInfo.appIdentifier);
165 if (!ReadHostVerifyStatusMap(verifyResultInfo.hostVerifyStatusMap, parcel)) {
166 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "failed to ReadHostVerifyStatusMap");
167 return false;
168 }
169 bundleVerifyStatusInfoMap_.insert(std::make_pair(bundleName, verifyResultInfo));
170 }
171 return true;
172 }
173 }
174 }
175