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
Unmarshalling(Parcel & in)78 HapPolicyParcel* HapPolicyParcel::Unmarshalling(Parcel& in)
79 {
80 auto* hapPolicyParcel = new (std::nothrow) HapPolicyParcel();
81 if (hapPolicyParcel == nullptr) {
82 return nullptr;
83 }
84
85 int32_t apl;
86 RELEASE_IF_FALSE(in.ReadInt32(apl), hapPolicyParcel);
87 hapPolicyParcel->hapPolicy.apl = ATokenAplEnum(apl);
88
89 hapPolicyParcel->hapPolicy.domain = in.ReadString();
90
91 uint32_t permListSize;
92 RELEASE_IF_FALSE(in.ReadUint32(permListSize), hapPolicyParcel);
93 RELEASE_IF_FALSE((permListSize <= MAX_PERMLIST_SIZE), hapPolicyParcel);
94
95 for (uint32_t i = 0; i < permListSize; i++) {
96 sptr<PermissionDefParcel> permDefParcel = in.ReadParcelable<PermissionDefParcel>();
97 RELEASE_IF_FALSE(permDefParcel != nullptr, hapPolicyParcel);
98 hapPolicyParcel->hapPolicy.permList.emplace_back(permDefParcel->permissionDef);
99 }
100
101 uint32_t permStateListSize;
102 RELEASE_IF_FALSE(in.ReadUint32(permStateListSize), hapPolicyParcel);
103 RELEASE_IF_FALSE((permStateListSize <= MAX_PERMLIST_SIZE), hapPolicyParcel);
104 for (uint32_t i = 0; i < permStateListSize; i++) {
105 sptr<PermissionStatusParcel> permissionStateParcel = in.ReadParcelable<PermissionStatusParcel>();
106 RELEASE_IF_FALSE(permissionStateParcel != nullptr, hapPolicyParcel);
107 hapPolicyParcel->hapPolicy.permStateList.emplace_back(permissionStateParcel->permState);
108 }
109 uint32_t aclRequestedListSize;
110 RELEASE_IF_FALSE(in.ReadUint32(aclRequestedListSize), hapPolicyParcel);
111 RELEASE_IF_FALSE((aclRequestedListSize <= MAX_PERMLIST_SIZE), hapPolicyParcel);
112 for (uint32_t i = 0; i < aclRequestedListSize; i++) {
113 std::string acl;
114 RELEASE_IF_FALSE(in.ReadString(acl), hapPolicyParcel);
115 hapPolicyParcel->hapPolicy.aclRequestedList.emplace_back(acl);
116 }
117 uint32_t infoSize;
118 RELEASE_IF_FALSE(in.ReadUint32(infoSize), hapPolicyParcel);
119 RELEASE_IF_FALSE((infoSize <= MAX_PERMLIST_SIZE), hapPolicyParcel);
120 for (uint32_t i = 0; i < infoSize; i++) {
121 PreAuthorizationInfo info;
122 RELEASE_IF_FALSE(in.ReadString(info.permissionName), hapPolicyParcel);
123 RELEASE_IF_FALSE(in.ReadBool(info.userCancelable), hapPolicyParcel);
124 hapPolicyParcel->hapPolicy.preAuthorizationInfo.emplace_back(info);
125 }
126 int32_t checkIgnore;
127 RELEASE_IF_FALSE(in.ReadInt32(checkIgnore), hapPolicyParcel);
128 hapPolicyParcel->hapPolicy.checkIgnore = HapPolicyCheckIgnore(checkIgnore);
129
130 uint32_t extSize;
131 RELEASE_IF_FALSE(in.ReadUint32(extSize), hapPolicyParcel);
132 RELEASE_IF_FALSE((extSize <= MAX_ACL_MAP_SIZE), hapPolicyParcel);
133 for (uint32_t i = 0; i < extSize; i++) {
134 std::string perm;
135 std::string value;
136 RELEASE_IF_FALSE(in.ReadString(perm), hapPolicyParcel);
137 RELEASE_IF_FALSE(in.ReadString(value), hapPolicyParcel);
138 hapPolicyParcel->hapPolicy.aclExtendedMap[perm] = value;
139 }
140 return hapPolicyParcel;
141 }
142 } // namespace AccessToken
143 } // namespace Security
144 } // namespace OHOS
145