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_proxy.h"
17
18 #include "ability_manager_errors.h"
19 #include "hilog_tag_wrapper.h"
20 #include "parcel.h"
21
22 namespace OHOS {
23 namespace AAFwk {
24 namespace {
25 const int MAX_URI_COUNT = 500;
26 }
UriPermissionManagerProxy(const sptr<IRemoteObject> & impl)27 UriPermissionManagerProxy::UriPermissionManagerProxy(const sptr<IRemoteObject> &impl)
28 : IRemoteProxy<IUriPermissionManager>(impl) {}
29
GrantUriPermission(const Uri & uri,unsigned int flag,const std::string targetBundleName,int32_t appIndex,uint32_t initiatorTokenId,int32_t abilityId)30 int UriPermissionManagerProxy::GrantUriPermission(const Uri &uri, unsigned int flag,
31 const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId, int32_t abilityId)
32 {
33 TAG_LOGD(AAFwkTag::URIPERMMGR, "called");
34 MessageParcel data;
35 if (!data.WriteInterfaceToken(IUriPermissionManager::GetDescriptor())) {
36 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write interface token failed.");
37 return INNER_ERR;
38 }
39 if (!data.WriteParcelable(&uri)) {
40 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write uri failed.");
41 return INNER_ERR;
42 }
43 if (!data.WriteUint32(flag)) {
44 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write flag failed.");
45 return INNER_ERR;
46 }
47 if (!data.WriteString(targetBundleName)) {
48 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write targetBundleName failed.");
49 return INNER_ERR;
50 }
51 if (!data.WriteInt32(appIndex)) {
52 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write appIndex failed.");
53 return INNER_ERR;
54 }
55 if (!data.WriteUint32(initiatorTokenId)) {
56 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write initiatorTokenId failed.");
57 return INNER_ERR;
58 }
59 if (!data.WriteInt32(abilityId)) {
60 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write abilityId failed.");
61 return INNER_ERR;
62 }
63 MessageParcel reply;
64 MessageOption option;
65 int error = SendTransactCmd(UriPermMgrCmd::ON_GRANT_URI_PERMISSION, data, reply, option);
66 if (error != ERR_OK) {
67 TAG_LOGE(AAFwkTag::URIPERMMGR, "SendRequest fial, error: %{public}d", error);
68 return INNER_ERR;
69 }
70 return reply.ReadInt32();
71 }
72
GrantUriPermission(const std::vector<Uri> & uriVec,unsigned int flag,const std::string targetBundleName,int32_t appIndex,uint32_t initiatorTokenId,int32_t abilityId)73 int UriPermissionManagerProxy::GrantUriPermission(const std::vector<Uri> &uriVec, unsigned int flag,
74 const std::string targetBundleName, int32_t appIndex, uint32_t initiatorTokenId, int32_t abilityId)
75 {
76 TAG_LOGD(AAFwkTag::URIPERMMGR, "called");
77 if (uriVec.empty() || uriVec.size() > MAX_URI_COUNT) {
78 TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec is empty or exceed maximum size %{public}d.", MAX_URI_COUNT);
79 return ERR_URI_LIST_OUT_OF_RANGE;
80 }
81 MessageParcel data;
82 if (!data.WriteInterfaceToken(IUriPermissionManager::GetDescriptor())) {
83 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write interface token failed.");
84 return INNER_ERR;
85 }
86 if (!data.WriteUint32(uriVec.size())) {
87 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write size of uriVec failed.");
88 return INNER_ERR;
89 }
90 for (const auto &uri : uriVec) {
91 if (!data.WriteParcelable(&uri)) {
92 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write uri failed.");
93 return INNER_ERR;
94 }
95 }
96 if (!data.WriteUint32(flag)) {
97 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write flag failed.");
98 return INNER_ERR;
99 }
100 if (!data.WriteString(targetBundleName)) {
101 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write targetBundleName failed.");
102 return INNER_ERR;
103 }
104 if (!data.WriteInt32(appIndex)) {
105 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write appIndex failed.");
106 return INNER_ERR;
107 }
108 if (!data.WriteUint32(initiatorTokenId)) {
109 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write initiatorTokenId failed.");
110 return INNER_ERR;
111 }
112 if (!data.WriteInt32(abilityId)) {
113 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write abilityId failed.");
114 return INNER_ERR;
115 }
116 MessageParcel reply;
117 MessageOption option;
118 int error = SendTransactCmd(UriPermMgrCmd::ON_BATCH_GRANT_URI_PERMISSION, data, reply, option);
119 if (error != ERR_OK) {
120 TAG_LOGE(AAFwkTag::URIPERMMGR, "SendRequest fial, error: %{public}d", error);
121 return INNER_ERR;
122 }
123 return reply.ReadInt32();
124 }
125
GrantUriPermissionPrivileged(const std::vector<Uri> & uriVec,uint32_t flag,const std::string & targetBundleName,int32_t appIndex,uint32_t initiatorTokenId,int32_t abilityId)126 int32_t UriPermissionManagerProxy::GrantUriPermissionPrivileged(const std::vector<Uri> &uriVec, uint32_t flag,
127 const std::string &targetBundleName, int32_t appIndex, uint32_t initiatorTokenId, int32_t abilityId)
128 {
129 TAG_LOGD(AAFwkTag::URIPERMMGR, "called");
130 if (uriVec.empty() || uriVec.size() > MAX_URI_COUNT) {
131 TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec is empty or exceed maximum size %{public}d.", MAX_URI_COUNT);
132 return ERR_URI_LIST_OUT_OF_RANGE;
133 }
134 MessageParcel data;
135 if (!data.WriteInterfaceToken(IUriPermissionManager::GetDescriptor())) {
136 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write interface token failed.");
137 return INNER_ERR;
138 }
139 if (!data.WriteUint32(uriVec.size())) {
140 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write size of uriVec failed.");
141 return INNER_ERR;
142 }
143 for (const auto &uri : uriVec) {
144 if (!data.WriteParcelable(&uri)) {
145 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write uri failed.");
146 return INNER_ERR;
147 }
148 }
149 if (!data.WriteUint32(flag)) {
150 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write flag failed.");
151 return INNER_ERR;
152 }
153 if (!data.WriteString(targetBundleName)) {
154 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write targetBundleName failed.");
155 return INNER_ERR;
156 }
157 if (!data.WriteInt32(appIndex)) {
158 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write appIndex failed.");
159 return INNER_ERR;
160 }
161 if (!data.WriteUint32(initiatorTokenId)) {
162 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write initiatorTokenId failed");
163 return INNER_ERR;
164 }
165 if (!data.WriteInt32(abilityId)) {
166 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write abilityId failed");
167 return INNER_ERR;
168 }
169 MessageParcel reply;
170 MessageOption option;
171 int error = SendTransactCmd(UriPermMgrCmd::ON_GRANT_URI_PERMISSION_PRIVILEGED, data, reply, option);
172 if (error != ERR_OK) {
173 TAG_LOGE(AAFwkTag::URIPERMMGR, "SendRequest fial, error: %{public}d", error);
174 return INNER_ERR;
175 }
176 return reply.ReadInt32();
177 }
178
RevokeUriPermission(const uint32_t tokenId,int32_t abilityId)179 void UriPermissionManagerProxy::RevokeUriPermission(const uint32_t tokenId, int32_t abilityId)
180 {
181 TAG_LOGD(AAFwkTag::URIPERMMGR, "called");
182 MessageParcel data;
183 if (!data.WriteInterfaceToken(IUriPermissionManager::GetDescriptor())) {
184 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write interface token failed.");
185 return;
186 }
187 if (!data.WriteUint32(tokenId)) {
188 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write AccessTokenID failed.");
189 return;
190 }
191 if (!data.WriteInt32(abilityId)) {
192 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write AccessTokenID failed.");
193 return;
194 }
195 MessageParcel reply;
196 MessageOption option;
197 int error = SendTransactCmd(UriPermMgrCmd::ON_REVOKE_URI_PERMISSION, data, reply, option);
198 if (error != ERR_OK) {
199 TAG_LOGE(AAFwkTag::URIPERMMGR, "SendRequest fail, error: %{public}d", error);
200 }
201 }
202
RevokeAllUriPermissions(const uint32_t tokenId)203 int UriPermissionManagerProxy::RevokeAllUriPermissions(const uint32_t tokenId)
204 {
205 TAG_LOGD(AAFwkTag::URIPERMMGR, "called");
206 MessageParcel data;
207 if (!data.WriteInterfaceToken(IUriPermissionManager::GetDescriptor())) {
208 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write interface token failed.");
209 return INNER_ERR;
210 }
211 if (!data.WriteUint32(tokenId)) {
212 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write AccessTokenID failed.");
213 return INNER_ERR;
214 }
215 MessageParcel reply;
216 MessageOption option;
217 int error = SendTransactCmd(UriPermMgrCmd::ON_REVOKE_ALL_URI_PERMISSION, data, reply, option);
218 if (error != ERR_OK) {
219 TAG_LOGE(AAFwkTag::URIPERMMGR, "SendRequest fail, error: %{public}d", error);
220 return INNER_ERR;
221 }
222 return reply.ReadInt32();
223 }
224
RevokeUriPermissionManually(const Uri & uri,const std::string bundleName,int32_t appIndex)225 int UriPermissionManagerProxy::RevokeUriPermissionManually(const Uri &uri, const std::string bundleName,
226 int32_t appIndex)
227 {
228 TAG_LOGD(AAFwkTag::URIPERMMGR, "called");
229 MessageParcel data;
230 if (!data.WriteInterfaceToken(IUriPermissionManager::GetDescriptor())) {
231 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write interface token failed.");
232 return INNER_ERR;
233 }
234 if (!data.WriteParcelable(&uri)) {
235 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write uri failed.");
236 return INNER_ERR;
237 }
238 if (!data.WriteString(bundleName)) {
239 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write bundleName failed.");
240 return INNER_ERR;
241 }
242 if (!data.WriteInt32(appIndex)) {
243 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write appIndex failed.");
244 return INNER_ERR;
245 }
246 MessageParcel reply;
247 MessageOption option;
248 int error = SendTransactCmd(UriPermMgrCmd::ON_REVOKE_URI_PERMISSION_MANUALLY, data, reply, option);
249 if (error != ERR_OK) {
250 TAG_LOGE(AAFwkTag::URIPERMMGR, "SendRequest fail, error: %{public}d", error);
251 return INNER_ERR;
252 }
253 return reply.ReadInt32();
254 }
255
VerifyUriPermission(const Uri & uri,uint32_t flag,uint32_t tokenId)256 bool UriPermissionManagerProxy::VerifyUriPermission(const Uri& uri, uint32_t flag, uint32_t tokenId)
257 {
258 TAG_LOGD(AAFwkTag::URIPERMMGR, "called");
259 MessageParcel data;
260 if (!data.WriteInterfaceToken(IUriPermissionManager::GetDescriptor())) {
261 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write interface token failed.");
262 return false;
263 }
264 if (!data.WriteParcelable(&uri)) {
265 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write uri failed.");
266 return false;
267 }
268 if (!data.WriteUint32(flag)) {
269 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write flag failed.");
270 return false;
271 }
272 if (!data.WriteUint32(tokenId)) {
273 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write tokenId failed.");
274 return false;
275 }
276 MessageParcel reply;
277 MessageOption option;
278 int error = SendTransactCmd(UriPermMgrCmd::ON_VERIFY_URI_PERMISSION, data, reply, option);
279 if (error != ERR_OK) {
280 TAG_LOGE(AAFwkTag::URIPERMMGR, "SendRequest fail, error: %{public}d", error);
281 return false;
282 }
283 return reply.ReadBool();
284 }
285
CheckUriAuthorization(const std::vector<std::string> & uriVec,uint32_t flag,uint32_t tokenId)286 std::vector<bool> UriPermissionManagerProxy::CheckUriAuthorization(const std::vector<std::string> &uriVec,
287 uint32_t flag, uint32_t tokenId)
288 {
289 TAG_LOGD(AAFwkTag::URIPERMMGR, "UriPermissionManagerProxy::CheckUriAuthorization is called");
290 std::vector<bool> result(uriVec.size(), false);
291 if (uriVec.empty() || uriVec.size() > MAX_URI_COUNT) {
292 TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec is empty or exceed maximum size %{public}d.", MAX_URI_COUNT);
293 return result;
294 }
295 MessageParcel data;
296 if (!data.WriteInterfaceToken(IUriPermissionManager::GetDescriptor())) {
297 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write interface token failed.");
298 return result;
299 }
300 if (!data.WriteUint32(uriVec.size())) {
301 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write size of uriVec failed.");
302 return result;
303 }
304 for (const auto &uri : uriVec) {
305 if (!data.WriteString(uri)) {
306 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write uri failed.");
307 return result;
308 }
309 }
310 if (!data.WriteUint32(flag)) {
311 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write flag failed.");
312 return result;
313 }
314 if (!data.WriteUint32(tokenId)) {
315 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write tokenId failed.");
316 return result;
317 }
318 MessageParcel reply;
319 MessageOption option;
320 int error = SendTransactCmd(UriPermMgrCmd::ON_CHECK_URI_AUTHORIZATION, data, reply, option);
321 if (error != ERR_OK) {
322 TAG_LOGE(AAFwkTag::URIPERMMGR, "SendRequest fial, error: %{public}d", error);
323 return result;
324 }
325 auto size = reply.ReadUint32();
326 for (auto i = 0; i < static_cast<int32_t>(size); i++) {
327 result[i] = reply.ReadBool();
328 }
329 return result;
330 }
331
SendTransactCmd(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)332 int32_t UriPermissionManagerProxy::SendTransactCmd(uint32_t code, MessageParcel &data,
333 MessageParcel &reply, MessageOption &option)
334 {
335 sptr<IRemoteObject> remote = Remote();
336 if (remote == nullptr) {
337 TAG_LOGE(AAFwkTag::URIPERMMGR, "remote object is nullptr.");
338 return ERR_NULL_OBJECT;
339 }
340
341 int32_t ret = remote->SendRequest(code, data, reply, option);
342 if (ret != NO_ERROR) {
343 TAG_LOGE(AAFwkTag::URIPERMMGR, "SendRequest failed. code is %{public}d, ret is %{public}d.", code, ret);
344 return ret;
345 }
346 return NO_ERROR;
347 }
348
ClearPermissionTokenByMap(const uint32_t tokenId)349 int UriPermissionManagerProxy::ClearPermissionTokenByMap(const uint32_t tokenId)
350 {
351 TAG_LOGD(AAFwkTag::URIPERMMGR, "call");
352 MessageParcel data;
353 if (!data.WriteInterfaceToken(IUriPermissionManager::GetDescriptor())) {
354 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write interfaceToken failed");
355 return INNER_ERR;
356 }
357 if (!data.WriteUint32(tokenId)) {
358 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write AccessTokenID failed");
359 return INNER_ERR;
360 }
361 MessageParcel reply;
362 MessageOption option;
363 int error = SendTransactCmd(UriPermMgrCmd::ON_CLEAR_PERMISSION_TOKEN_BY_MAP, data, reply, option);
364 if (error != ERR_OK) {
365 TAG_LOGE(AAFwkTag::URIPERMMGR, "SendRequest fail, error:%{public}d", error);
366 return INNER_ERR;
367 }
368 return reply.ReadInt32();
369 }
370
371 #ifdef ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
Active(const std::vector<PolicyInfo> & policy,std::vector<uint32_t> & result)372 int UriPermissionManagerProxy::Active(const std::vector<PolicyInfo> &policy, std::vector<uint32_t> &result)
373 {
374 TAG_LOGD(AAFwkTag::URIPERMMGR, "call");
375 if (policy.empty() || policy.size() > MAX_URI_COUNT) {
376 TAG_LOGE(AAFwkTag::URIPERMMGR, "uriVec empty or exceed maxSize %{public}d", MAX_URI_COUNT);
377 return ERR_URI_LIST_OUT_OF_RANGE;
378 }
379 MessageParcel data;
380 if (!data.WriteInterfaceToken(IUriPermissionManager::GetDescriptor())) {
381 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write interfaceToken failed");
382 return INNER_ERR;
383 }
384 if (!data.WriteUint32(policy.size())) {
385 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write size of policy failed");
386 return INNER_ERR;
387 }
388 for (const auto &policyInfo : policy) {
389 if (!data.WriteString(policyInfo.path)) {
390 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write policy path failed");
391 return INNER_ERR;
392 }
393 if (!data.WriteUint64(policyInfo.mode)) {
394 TAG_LOGE(AAFwkTag::URIPERMMGR, "Write policy mode failed");
395 return INNER_ERR;
396 }
397 }
398 MessageParcel reply;
399 MessageOption option;
400 int error = SendTransactCmd(UriPermMgrCmd::ON_ACTIVE, data, reply, option);
401 if (error != ERR_OK) {
402 TAG_LOGE(AAFwkTag::URIPERMMGR, "SendRequest fail, error:%{public}d", error);
403 return INNER_ERR;
404 }
405 auto res = reply.ReadUInt32Vector(&result);
406 if (res) {
407 return ERR_OK;
408 }
409 return INNER_ERR;
410 }
411 #endif // ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
412 } // namespace AAFwk
413 } // namespace OHOS
414