1 /*
2 * Copyright (c) 2021-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 "hap_policy_parcel.h"
17 #include "refbase.h"
18 #include "access_token.h"
19 #include "parcel_utils.h"
20 #include "permission_def.h"
21 #include "permission_def_parcel.h"
22 #include "permission_state_full.h"
23 #include "permission_status_parcel.h"
24
25 namespace OHOS {
26 namespace Security {
27 namespace AccessToken {
Marshalling(Parcel & out) const28 bool HapPolicyParcel::Marshalling(Parcel& out) const
29 {
30 RETURN_IF_FALSE(out.WriteInt32(this->hapPolicy.apl));
31 RETURN_IF_FALSE(out.WriteString(this->hapPolicy.domain));
32
33 const std::vector<PermissionDef>& permList = this->hapPolicy.permList;
34 uint32_t permListSize = permList.size();
35 RETURN_IF_FALSE(out.WriteUint32(permListSize));
36
37 for (uint32_t i = 0; i < permListSize; i++) {
38 PermissionDefParcel permDefParcel;
39 permDefParcel.permissionDef = permList[i];
40 RETURN_IF_FALSE(out.WriteParcelable(&permDefParcel));
41 }
42
43 const std::vector<PermissionStatus>& permStateList = this->hapPolicy.permStateList;
44 uint32_t permStateListSize = permStateList.size();
45 RETURN_IF_FALSE(out.WriteUint32(permStateListSize));
46
47 for (uint32_t i = 0; i < permStateListSize; i++) {
48 PermissionStatusParcel permStateParcel;
49 permStateParcel.permState = permStateList[i];
50 RETURN_IF_FALSE(out.WriteParcelable(&permStateParcel));
51 }
52
53 const std::vector<std::string>& aclRequestedList = this->hapPolicy.aclRequestedList;
54 uint32_t aclRequestedListSize = aclRequestedList.size();
55 RETURN_IF_FALSE(out.WriteUint32(aclRequestedListSize));
56
57 for (uint32_t i = 0; i < aclRequestedListSize; i++) {
58 RETURN_IF_FALSE(out.WriteString(aclRequestedList[i]));
59 }
60
61 const std::vector<PreAuthorizationInfo>& info = this->hapPolicy.preAuthorizationInfo;
62 uint32_t infoSize = info.size();
63 RETURN_IF_FALSE(out.WriteUint32(infoSize));
64
65 for (uint32_t i = 0; i < infoSize; i++) {
66 RETURN_IF_FALSE(out.WriteString(info[i].permissionName));
67 RETURN_IF_FALSE(out.WriteBool(info[i].userCancelable));
68 }
69 RETURN_IF_FALSE(out.WriteInt32(this->hapPolicy.checkIgnore));
70 RETURN_IF_FALSE(out.WriteUint32(this->hapPolicy.aclExtendedMap.size()));
71 for (const auto& iter : this->hapPolicy.aclExtendedMap) {
72 RETURN_IF_FALSE(out.WriteString(iter.first));
73 RETURN_IF_FALSE(out.WriteString(iter.second));
74 }
75 return true;
76 }
77
ReadLeftHapPolicyParcel(Parcel & in,HapPolicyParcel * hapPolicyParcel)78 static bool ReadLeftHapPolicyParcel(Parcel& in, HapPolicyParcel* hapPolicyParcel)
79 {
80 uint32_t infoSize;
81 RETURN_IF_FALSE(in.ReadUint32(infoSize));
82 RETURN_IF_FALSE((infoSize <= MAX_PERMLIST_SIZE));
83 for (uint32_t i = 0; i < infoSize; i++) {
84 PreAuthorizationInfo info;
85 RETURN_IF_FALSE(in.ReadString(info.permissionName));
86 RETURN_IF_FALSE(in.ReadBool(info.userCancelable));
87 hapPolicyParcel->hapPolicy.preAuthorizationInfo.emplace_back(info);
88 }
89 int32_t checkIgnore;
90 RETURN_IF_FALSE(in.ReadInt32(checkIgnore));
91 hapPolicyParcel->hapPolicy.checkIgnore = HapPolicyCheckIgnore(checkIgnore);
92
93 uint32_t extSize;
94 RETURN_IF_FALSE(in.ReadUint32(extSize));
95 RETURN_IF_FALSE((extSize <= MAX_ACL_MAP_SIZE));
96 for (uint32_t i = 0; i < extSize; i++) {
97 std::string perm;
98 std::string value;
99 RETURN_IF_FALSE(in.ReadString(perm));
100 RETURN_IF_FALSE(in.ReadString(value));
101 hapPolicyParcel->hapPolicy.aclExtendedMap[perm] = value;
102 }
103
104 return true;
105 }
106
Unmarshalling(Parcel & in)107 HapPolicyParcel* HapPolicyParcel::Unmarshalling(Parcel& in)
108 {
109 auto* hapPolicyParcel = new (std::nothrow) HapPolicyParcel();
110 if (hapPolicyParcel == nullptr) {
111 return nullptr;
112 }
113
114 int32_t apl;
115 RELEASE_IF_FALSE(in.ReadInt32(apl), hapPolicyParcel);
116 hapPolicyParcel->hapPolicy.apl = ATokenAplEnum(apl);
117
118 hapPolicyParcel->hapPolicy.domain = in.ReadString();
119
120 uint32_t permListSize;
121 RELEASE_IF_FALSE(in.ReadUint32(permListSize), hapPolicyParcel);
122 RELEASE_IF_FALSE((permListSize <= MAX_PERMLIST_SIZE), hapPolicyParcel);
123
124 for (uint32_t i = 0; i < permListSize; i++) {
125 sptr<PermissionDefParcel> permDefParcel = in.ReadParcelable<PermissionDefParcel>();
126 RELEASE_IF_FALSE(permDefParcel != nullptr, hapPolicyParcel);
127 hapPolicyParcel->hapPolicy.permList.emplace_back(permDefParcel->permissionDef);
128 }
129
130 uint32_t permStateListSize;
131 RELEASE_IF_FALSE(in.ReadUint32(permStateListSize), hapPolicyParcel);
132 RELEASE_IF_FALSE((permStateListSize <= MAX_PERMLIST_SIZE), hapPolicyParcel);
133 for (uint32_t i = 0; i < permStateListSize; i++) {
134 sptr<PermissionStatusParcel> permissionStateParcel = in.ReadParcelable<PermissionStatusParcel>();
135 RELEASE_IF_FALSE(permissionStateParcel != nullptr, hapPolicyParcel);
136 hapPolicyParcel->hapPolicy.permStateList.emplace_back(permissionStateParcel->permState);
137 }
138 uint32_t aclRequestedListSize;
139 RELEASE_IF_FALSE(in.ReadUint32(aclRequestedListSize), hapPolicyParcel);
140 RELEASE_IF_FALSE((aclRequestedListSize <= MAX_PERMLIST_SIZE), hapPolicyParcel);
141 for (uint32_t i = 0; i < aclRequestedListSize; i++) {
142 std::string acl;
143 RELEASE_IF_FALSE(in.ReadString(acl), hapPolicyParcel);
144 hapPolicyParcel->hapPolicy.aclRequestedList.emplace_back(acl);
145 }
146 RELEASE_IF_FALSE(ReadLeftHapPolicyParcel(in, hapPolicyParcel), hapPolicyParcel);
147 return hapPolicyParcel;
148 }
149 } // namespace AccessToken
150 } // namespace Security
151 } // namespace OHOS
152