1 /*
2  * Copyright (c) 2022-2024 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 "uri_permission_manager_stub.h"
17 
18 #include "ability_manager_errors.h"
19 #include "hilog_tag_wrapper.h"
20 
21 namespace OHOS {
22 namespace AAFwk {
23 namespace {
24 const int MAX_URI_COUNT = 500;
25 }
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)26 int UriPermissionManagerStub::OnRemoteRequest(
27     uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
28 {
29     if (data.ReadInterfaceToken() != IUriPermissionManager::GetDescriptor()) {
30         TAG_LOGE(AAFwkTag::URIPERMMGR, "InterfaceToken not equal IUriPermissionManager's descriptor.");
31         return ERR_INVALID_VALUE;
32     }
33     ErrCode errCode = ERR_OK;
34     switch (code) {
35         case UriPermMgrCmd::ON_GRANT_URI_PERMISSION : {
36             return HandleGrantUriPermission(data, reply);
37         }
38         case UriPermMgrCmd::ON_BATCH_GRANT_URI_PERMISSION : {
39             return HandleBatchGrantUriPermission(data, reply);
40         }
41         case UriPermMgrCmd::ON_GRANT_URI_PERMISSION_PRIVILEGED : {
42             return HandleGrantUriPermissionPrivileged(data, reply);
43         }
44         case UriPermMgrCmd::ON_REVOKE_URI_PERMISSION : {
45             return HandleRevokeUriPermission(data, reply);
46         }
47         case UriPermMgrCmd::ON_REVOKE_ALL_URI_PERMISSION : {
48             return HandleRevokeAllUriPermission(data, reply);
49         }
50         case UriPermMgrCmd::ON_REVOKE_URI_PERMISSION_MANUALLY : {
51             return HandleRevokeUriPermissionManually(data, reply);
52         }
53         case UriPermMgrCmd::ON_VERIFY_URI_PERMISSION : {
54             return HandleVerifyUriPermission(data, reply);
55         }
56         case UriPermMgrCmd::ON_CHECK_URI_AUTHORIZATION : {
57             return HandleCheckUriAuthorization(data, reply);
58         }
59         case UriPermMgrCmd::ON_CLEAR_PERMISSION_TOKEN_BY_MAP : {
60             return HandleClearPermissionTokenByMap(data, reply);
61         }
62 #ifdef ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
63         case UriPermMgrCmd::ON_ACTIVE : {
64             return HandleActive(data, reply);
65         }
66 #endif // ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
67         default:
68             return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
69     }
70     return errCode;
71 }
72 
HandleRevokeUriPermission(MessageParcel & data,MessageParcel & reply)73 int UriPermissionManagerStub::HandleRevokeUriPermission(MessageParcel &data, MessageParcel &reply)
74 {
75     auto tokenId = data.ReadUint32();
76     auto abilityId = data.ReadInt32();
77     RevokeUriPermission(tokenId, abilityId);
78     return ERR_OK;
79 }
80 
HandleRevokeAllUriPermission(MessageParcel & data,MessageParcel & reply)81 int UriPermissionManagerStub::HandleRevokeAllUriPermission(MessageParcel &data, MessageParcel &reply)
82 {
83     auto tokenId = data.ReadUint32();
84     int result = RevokeAllUriPermissions(tokenId);
85     reply.WriteInt32(result);
86     return ERR_OK;
87 }
88 
HandleGrantUriPermission(MessageParcel & data,MessageParcel & reply)89 int UriPermissionManagerStub::HandleGrantUriPermission(MessageParcel &data, MessageParcel &reply)
90 {
91     std::unique_ptr<Uri> uri(data.ReadParcelable<Uri>());
92     if (!uri) {
93         TAG_LOGE(AAFwkTag::URIPERMMGR, "To read uri failed.");
94         return ERR_DEAD_OBJECT;
95     }
96     auto flag = data.ReadUint32();
97     auto targetBundleName = data.ReadString();
98     auto appIndex = data.ReadInt32();
99     auto initiatorTokenId = data.ReadUint32();
100     auto abilityId = data.ReadInt32();
101     int result = GrantUriPermission(*uri, flag, targetBundleName, appIndex, initiatorTokenId, abilityId);
102     reply.WriteInt32(result);
103     return ERR_OK;
104 }
105 
HandleBatchGrantUriPermission(MessageParcel & data,MessageParcel & reply)106 int UriPermissionManagerStub::HandleBatchGrantUriPermission(MessageParcel &data, MessageParcel &reply)
107 {
108     auto size = data.ReadUint32();
109     if (size == 0 || size > MAX_URI_COUNT) {
110         TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec is empty or exceed maximum size %{public}d.", MAX_URI_COUNT);
111         return ERR_URI_LIST_OUT_OF_RANGE;
112     }
113     std::vector<Uri> uriVec;
114     for (uint32_t i = 0; i < size; i++) {
115         std::unique_ptr<Uri> uri(data.ReadParcelable<Uri>());
116         if (!uri) {
117             TAG_LOGE(AAFwkTag::URIPERMMGR, "To read uri failed.");
118             return ERR_DEAD_OBJECT;
119         }
120         uriVec.emplace_back(*uri);
121     }
122     auto flag = data.ReadUint32();
123     auto targetBundleName = data.ReadString();
124     auto appIndex = data.ReadInt32();
125     auto initiatorTokenId = data.ReadUint32();
126     auto abilityId = data.ReadInt32();
127     int result = GrantUriPermission(uriVec, flag, targetBundleName, appIndex, initiatorTokenId, abilityId);
128     reply.WriteInt32(result);
129     return ERR_OK;
130 }
131 
HandleGrantUriPermissionPrivileged(MessageParcel & data,MessageParcel & reply)132 int32_t UriPermissionManagerStub::HandleGrantUriPermissionPrivileged(MessageParcel &data, MessageParcel &reply)
133 {
134     auto size = data.ReadUint32();
135     if (size == 0 || size > MAX_URI_COUNT) {
136         TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec is empty or exceed maximum size %{public}d.", MAX_URI_COUNT);
137         return ERR_URI_LIST_OUT_OF_RANGE;
138     }
139     std::vector<Uri> uriVec;
140     for (uint32_t i = 0; i < size; i++) {
141         std::unique_ptr<Uri> uri(data.ReadParcelable<Uri>());
142         if (!uri) {
143             TAG_LOGE(AAFwkTag::URIPERMMGR, "To read uri failed.");
144             return ERR_DEAD_OBJECT;
145         }
146         uriVec.emplace_back(*uri);
147     }
148     auto flag = data.ReadUint32();
149     auto targetBundleName = data.ReadString();
150     auto appIndex = data.ReadInt32();
151     auto initiatorTokenId = data.ReadUint32();
152     auto abilityId = data.ReadInt32();
153     int result = GrantUriPermissionPrivileged(uriVec, flag, targetBundleName, appIndex, initiatorTokenId, abilityId);
154     reply.WriteInt32(result);
155     return ERR_OK;
156 }
157 
HandleRevokeUriPermissionManually(MessageParcel & data,MessageParcel & reply)158 int UriPermissionManagerStub::HandleRevokeUriPermissionManually(MessageParcel &data, MessageParcel &reply)
159 {
160     std::unique_ptr<Uri> uri(data.ReadParcelable<Uri>());
161     if (!uri) {
162         TAG_LOGE(AAFwkTag::URIPERMMGR, "To read uri failed.");
163         return ERR_DEAD_OBJECT;
164     }
165     auto bundleName = data.ReadString();
166     auto appIndex = data.ReadInt32();
167     int result = RevokeUriPermissionManually(*uri, bundleName, appIndex);
168     reply.WriteInt32(result);
169     return ERR_OK;
170 }
171 
HandleVerifyUriPermission(MessageParcel & data,MessageParcel & reply)172 int UriPermissionManagerStub::HandleVerifyUriPermission(MessageParcel &data, MessageParcel &reply)
173 {
174     std::unique_ptr<Uri> uri(data.ReadParcelable<Uri>());
175     if (!uri) {
176         TAG_LOGE(AAFwkTag::URIPERMMGR, "To read uri failed.");
177         return ERR_DEAD_OBJECT;
178     }
179     auto flag = data.ReadUint32();
180     auto tokenId = data.ReadUint32();
181     bool result = VerifyUriPermission(*uri, flag, tokenId);
182     reply.WriteBool(result);
183     return ERR_OK;
184 }
185 
HandleCheckUriAuthorization(MessageParcel & data,MessageParcel & reply)186 int32_t UriPermissionManagerStub::HandleCheckUriAuthorization(MessageParcel &data, MessageParcel &reply)
187 {
188     auto size = data.ReadUint32();
189     if (size == 0 || size > MAX_URI_COUNT) {
190         TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec is empty or exceed maximum size %{public}d.", MAX_URI_COUNT);
191         return ERR_URI_LIST_OUT_OF_RANGE;
192     }
193     std::vector<std::string> uriVec;
194     for (uint32_t i = 0; i < size; i++) {
195         auto uri = data.ReadString();
196         uriVec.emplace_back(uri);
197     }
198     auto flag = data.ReadUint32();
199     auto tokenId = data.ReadUint32();
200     auto result = CheckUriAuthorization(uriVec, flag, tokenId);
201     if (!reply.WriteUint32(result.size())) {
202         TAG_LOGE(AAFwkTag::URIPERMMGR, "Write size of uriVec failed.");
203         return ERR_DEAD_OBJECT;
204     }
205     for (auto res: result) {
206         if (!reply.WriteBool(res)) {
207             TAG_LOGE(AAFwkTag::URIPERMMGR, "Write res failed.");
208             return ERR_DEAD_OBJECT;
209         }
210     }
211     return ERR_OK;
212 }
213 
HandleClearPermissionTokenByMap(MessageParcel & data,MessageParcel & reply)214 int UriPermissionManagerStub::HandleClearPermissionTokenByMap(MessageParcel &data, MessageParcel &reply)
215 {
216     auto tokenId = data.ReadUint32();
217     int result = ClearPermissionTokenByMap(tokenId);
218     reply.WriteInt32(result);
219     return ERR_OK;
220 }
221 
222 #ifdef ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
HandleActive(MessageParcel & data,MessageParcel & reply)223 int UriPermissionManagerStub::HandleActive(MessageParcel &data, MessageParcel &reply)
224 {
225     auto policySize = data.ReadUint32();
226     if (policySize == 0 || policySize > MAX_URI_COUNT) {
227         TAG_LOGE(AAFwkTag::URIPERMMGR, "policy empty or exceed maxSize %{public}d", MAX_URI_COUNT);
228         return ERR_URI_LIST_OUT_OF_RANGE;
229     }
230     std::vector<PolicyInfo> policy;
231     for (uint32_t i = 0; i < policySize; i++) {
232         PolicyInfo info = {data.ReadString(), data.ReadUint64()};
233         policy.emplace_back(info);
234     }
235     std::vector<uint32_t> result;
236     int res = Active(policy, result);
237     if (!reply.WriteUInt32Vector(result)) {
238         TAG_LOGE(AAFwkTag::URIPERMMGR, "Write res failed");
239         return ERR_DEAD_OBJECT;
240     }
241     return res;
242 }
243 #endif // ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
244 }  // namespace AAFwk
245 }  // namespace OHOS
246