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_state_full_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->hapPolicyParameter.apl));
31 RETURN_IF_FALSE(out.WriteString(this->hapPolicyParameter.domain));
32
33 const std::vector<PermissionDef>& permList = this->hapPolicyParameter.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 out.WriteParcelable(&permDefParcel);
41 }
42
43 const std::vector<PermissionStateFull>& permStateList = this->hapPolicyParameter.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 PermissionStateFullParcel permStateParcel;
49 permStateParcel.permStatFull = permStateList[i];
50 out.WriteParcelable(&permStateParcel);
51 }
52
53 const std::vector<std::string>& aclRequestedList = this->hapPolicyParameter.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->hapPolicyParameter.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 true;
70 }
71
Unmarshalling(Parcel & in)72 HapPolicyParcel* HapPolicyParcel::Unmarshalling(Parcel& in)
73 {
74 auto* hapPolicyParcel = new (std::nothrow) HapPolicyParcel();
75 if (hapPolicyParcel == nullptr) {
76 return nullptr;
77 }
78
79 int32_t apl;
80 RELEASE_IF_FALSE(in.ReadInt32(apl), hapPolicyParcel);
81 hapPolicyParcel->hapPolicyParameter.apl = ATokenAplEnum(apl);
82
83 hapPolicyParcel->hapPolicyParameter.domain = in.ReadString();
84
85 uint32_t permListSize;
86 RELEASE_IF_FALSE(in.ReadUint32(permListSize), hapPolicyParcel);
87 RELEASE_IF_FALSE((permListSize <= MAX_PERMLIST_SIZE), hapPolicyParcel);
88
89 for (uint32_t i = 0; i < permListSize; i++) {
90 sptr<PermissionDefParcel> permDefParcel = in.ReadParcelable<PermissionDefParcel>();
91 RELEASE_IF_FALSE(permDefParcel != nullptr, hapPolicyParcel);
92 hapPolicyParcel->hapPolicyParameter.permList.emplace_back(permDefParcel->permissionDef);
93 }
94
95 uint32_t permStateListSize;
96 RELEASE_IF_FALSE(in.ReadUint32(permStateListSize), hapPolicyParcel);
97 RELEASE_IF_FALSE((permStateListSize <= MAX_PERMLIST_SIZE), hapPolicyParcel);
98 for (uint32_t i = 0; i < permStateListSize; i++) {
99 sptr<PermissionStateFullParcel> permissionStateParcel = in.ReadParcelable<PermissionStateFullParcel>();
100 RELEASE_IF_FALSE(permissionStateParcel != nullptr, hapPolicyParcel);
101 hapPolicyParcel->hapPolicyParameter.permStateList.emplace_back(permissionStateParcel->permStatFull);
102 }
103 uint32_t aclRequestedListSize;
104 RELEASE_IF_FALSE(in.ReadUint32(aclRequestedListSize), hapPolicyParcel);
105 RELEASE_IF_FALSE((aclRequestedListSize <= MAX_PERMLIST_SIZE), hapPolicyParcel);
106 for (uint32_t i = 0; i < aclRequestedListSize; i++) {
107 std::string acl;
108 RELEASE_IF_FALSE(in.ReadString(acl), hapPolicyParcel);
109 hapPolicyParcel->hapPolicyParameter.aclRequestedList.emplace_back(acl);
110 }
111 uint32_t infoSize;
112 RELEASE_IF_FALSE(in.ReadUint32(infoSize), hapPolicyParcel);
113 RELEASE_IF_FALSE((infoSize <= MAX_PERMLIST_SIZE), hapPolicyParcel);
114 for (uint32_t i = 0; i < infoSize; i++) {
115 PreAuthorizationInfo info;
116 RELEASE_IF_FALSE(in.ReadString(info.permissionName), hapPolicyParcel);
117 RELEASE_IF_FALSE(in.ReadBool(info.userCancelable), hapPolicyParcel);
118 hapPolicyParcel->hapPolicyParameter.preAuthorizationInfo.emplace_back(info);
119 }
120 return hapPolicyParcel;
121 }
122 } // namespace AccessToken
123 } // namespace Security
124 } // namespace OHOS
125