1 /*
2 * Copyright (c) 2021-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 "accesstoken_manager_proxy.h"
17
18 #include "accesstoken_log.h"
19 #include "accesstoken_common_log.h"
20 #include "access_token_error.h"
21
22 #include "parcel.h"
23 #include "string_ex.h"
24
25 namespace OHOS {
26 namespace Security {
27 namespace AccessToken {
28 namespace {
29 static constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, SECURITY_DOMAIN_ACCESSTOKEN, "ATMProxy"};
30 static const int MAX_PERMISSION_SIZE = 1000;
31 static const int32_t MAX_USER_POLICY_SIZE = 1024;
32 static const int32_t MAX_EXTENDED_VALUE_LIST_SIZE = 512;
33 }
34
AccessTokenManagerProxy(const sptr<IRemoteObject> & impl)35 AccessTokenManagerProxy::AccessTokenManagerProxy(const sptr<IRemoteObject>& impl)
36 : IRemoteProxy<IAccessTokenManager>(impl) {
37 }
38
~AccessTokenManagerProxy()39 AccessTokenManagerProxy::~AccessTokenManagerProxy()
40 {}
41
SendRequest(AccessTokenInterfaceCode code,MessageParcel & data,MessageParcel & reply)42 bool AccessTokenManagerProxy::SendRequest(
43 AccessTokenInterfaceCode code, MessageParcel& data, MessageParcel& reply)
44 {
45 MessageOption option(MessageOption::TF_SYNC);
46
47 sptr<IRemoteObject> remote = Remote();
48 if (remote == nullptr) {
49 LOGE(ATM_DOMAIN, ATM_TAG, "Code: %{public}d remote service null.", code);
50 return false;
51 }
52 int32_t requestResult = remote->SendRequest(
53 static_cast<uint32_t>(code), data, reply, option);
54 if (requestResult != NO_ERROR) {
55 LOGE(ATM_DOMAIN, ATM_TAG, "Code: %{public}d request fail, result: %{public}d", code, requestResult);
56 return false;
57 }
58 return true;
59 }
60
GetPermissionUsedType(AccessTokenID tokenID,const std::string & permissionName)61 PermUsedTypeEnum AccessTokenManagerProxy::GetPermissionUsedType(
62 AccessTokenID tokenID, const std::string &permissionName)
63 {
64 MessageParcel data;
65 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
66 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
67 return PermUsedTypeEnum::INVALID_USED_TYPE;
68 }
69 if (!data.WriteUint32(tokenID)) {
70 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
71 return PermUsedTypeEnum::INVALID_USED_TYPE;
72 }
73 if (!data.WriteString(permissionName)) {
74 LOGE(ATM_DOMAIN, ATM_TAG, "WriteString failed.");
75 return PermUsedTypeEnum::INVALID_USED_TYPE;
76 }
77
78 MessageParcel reply;
79 if (!SendRequest(AccessTokenInterfaceCode::GET_USER_GRANTED_PERMISSION_USED_TYPE, data, reply)) {
80 return PermUsedTypeEnum::INVALID_USED_TYPE;
81 }
82
83 int32_t ret;
84 if (!reply.ReadInt32(ret)) {
85 LOGE(ATM_DOMAIN, ATM_TAG, "ReadInt32t failed.");
86 return PermUsedTypeEnum::INVALID_USED_TYPE;
87 }
88 PermUsedTypeEnum result = static_cast<PermUsedTypeEnum>(ret);
89 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (type=%{public}d).", result);
90 return result;
91 }
92
VerifyAccessToken(AccessTokenID tokenID,const std::string & permissionName)93 int AccessTokenManagerProxy::VerifyAccessToken(AccessTokenID tokenID, const std::string& permissionName)
94 {
95 MessageParcel data;
96 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
97 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
98 return PERMISSION_DENIED;
99 }
100 if (!data.WriteUint32(tokenID)) {
101 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
102 return PERMISSION_DENIED;
103 }
104 if (!data.WriteString(permissionName)) {
105 LOGE(ATM_DOMAIN, ATM_TAG, "WriteString failed.");
106 return PERMISSION_DENIED;
107 }
108
109 MessageParcel reply;
110 if (!SendRequest(AccessTokenInterfaceCode::VERIFY_ACCESSTOKEN, data, reply)) {
111 return PERMISSION_DENIED;
112 }
113
114 int32_t result = reply.ReadInt32();
115 LOGD(ATM_DOMAIN, ATM_TAG, "Result from server (status=%{public}d).", result);
116 return result;
117 }
118
VerifyAccessToken(AccessTokenID tokenID,const std::vector<std::string> & permissionList,std::vector<int32_t> & permStateList)119 int AccessTokenManagerProxy::VerifyAccessToken(AccessTokenID tokenID,
120 const std::vector<std::string>& permissionList, std::vector<int32_t>& permStateList)
121 {
122 MessageParcel data;
123 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
124 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
125 return ERR_WRITE_PARCEL_FAILED;
126 }
127 if (!data.WriteUint32(tokenID)) {
128 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
129 return ERR_WRITE_PARCEL_FAILED;
130 }
131 if (!data.WriteStringVector(permissionList)) {
132 LOGE(ATM_DOMAIN, ATM_TAG, "WriteStringVector failed.");
133 return ERR_WRITE_PARCEL_FAILED;
134 }
135
136 MessageParcel reply;
137 if (!SendRequest(AccessTokenInterfaceCode::VERIFY_ACCESSTOKEN_WITH_LIST, data, reply)) {
138 return ERR_SERVICE_ABNORMAL;
139 }
140
141 if (!reply.ReadInt32Vector(&permStateList)) {
142 LOGE(ATM_DOMAIN, ATM_TAG, "ReadInt32Vector failed.");
143 return ERR_READ_PARCEL_FAILED;
144 }
145
146 return ERR_OK;
147 }
148
GetDefPermission(const std::string & permissionName,PermissionDefParcel & permissionDefResult)149 int AccessTokenManagerProxy::GetDefPermission(
150 const std::string& permissionName, PermissionDefParcel& permissionDefResult)
151 {
152 MessageParcel data;
153 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
154 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
155 return ERR_WRITE_PARCEL_FAILED;
156 }
157 if (!data.WriteString(permissionName)) {
158 LOGE(ATM_DOMAIN, ATM_TAG, "WriteString failed.");
159 return ERR_WRITE_PARCEL_FAILED;
160 }
161
162 MessageParcel reply;
163 if (!SendRequest(AccessTokenInterfaceCode::GET_DEF_PERMISSION, data, reply)) {
164 return ERR_SERVICE_ABNORMAL;
165 }
166
167 int32_t result = reply.ReadInt32();
168 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
169 if (result != RET_SUCCESS) {
170 return result;
171 }
172 sptr<PermissionDefParcel> resultSptr = reply.ReadParcelable<PermissionDefParcel>();
173 if (resultSptr == nullptr) {
174 LOGE(ATM_DOMAIN, ATM_TAG, "ReadParcelable failed.");
175 return ERR_READ_PARCEL_FAILED;
176 }
177 permissionDefResult = *resultSptr;
178 return result;
179 }
180
GetReqPermissions(AccessTokenID tokenID,std::vector<PermissionStatusParcel> & reqPermList,bool isSystemGrant)181 int AccessTokenManagerProxy::GetReqPermissions(
182 AccessTokenID tokenID, std::vector<PermissionStatusParcel>& reqPermList, bool isSystemGrant)
183 {
184 MessageParcel data;
185 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
186 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
187 return ERR_WRITE_PARCEL_FAILED;
188 }
189 if (!data.WriteUint32(tokenID)) {
190 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
191 return ERR_WRITE_PARCEL_FAILED;
192 }
193 if (!data.WriteInt32(isSystemGrant)) {
194 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInt32 failed.");
195 return ERR_WRITE_PARCEL_FAILED;
196 }
197
198 MessageParcel reply;
199 if (!SendRequest(AccessTokenInterfaceCode::GET_REQ_PERMISSIONS, data, reply)) {
200 return ERR_SERVICE_ABNORMAL;
201 }
202
203 int32_t result = reply.ReadInt32();
204 LOGD(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
205 if (result != RET_SUCCESS) {
206 return result;
207 }
208 uint32_t reqPermSize = reply.ReadUint32();
209 if (reqPermSize > MAX_PERMISSION_SIZE) {
210 LOGE(ATM_DOMAIN, ATM_TAG, "Size(%{public}u) is oversize.", reqPermSize);
211 return ERR_OVERSIZE;
212 }
213 for (uint32_t i = 0; i < reqPermSize; i++) {
214 sptr<PermissionStatusParcel> permissionReq = reply.ReadParcelable<PermissionStatusParcel>();
215 if (permissionReq != nullptr) {
216 reqPermList.emplace_back(*permissionReq);
217 }
218 }
219 return result;
220 }
221
SetPermissionRequestToggleStatus(const std::string & permissionName,uint32_t status,int32_t userID=0)222 int32_t AccessTokenManagerProxy::SetPermissionRequestToggleStatus(const std::string& permissionName, uint32_t status,
223 int32_t userID = 0)
224 {
225 MessageParcel sendData;
226 if (!sendData.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
227 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
228 return ERR_WRITE_PARCEL_FAILED;
229 }
230 if (!sendData.WriteString(permissionName)) {
231 LOGE(ATM_DOMAIN, ATM_TAG, "WriteString failed.");
232 return ERR_WRITE_PARCEL_FAILED;
233 }
234 if (!sendData.WriteUint32(status)) {
235 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
236 return ERR_WRITE_PARCEL_FAILED;
237 }
238 if (!sendData.WriteInt32(userID)) {
239 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInt32 failed.");
240 return ERR_WRITE_PARCEL_FAILED;
241 }
242
243 MessageParcel reply;
244 if (!SendRequest(AccessTokenInterfaceCode::SET_PERMISSION_REQUEST_TOGGLE_STATUS, sendData, reply)) {
245 return ERR_SERVICE_ABNORMAL;
246 }
247
248 int32_t result = reply.ReadInt32();
249 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
250 return result;
251 }
252
GetPermissionRequestToggleStatus(const std::string & permissionName,uint32_t & status,int32_t userID=0)253 int32_t AccessTokenManagerProxy::GetPermissionRequestToggleStatus(const std::string& permissionName, uint32_t& status,
254 int32_t userID = 0)
255 {
256 MessageParcel sendData;
257 if (!sendData.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
258 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
259 return ERR_WRITE_PARCEL_FAILED;
260 }
261 if (!sendData.WriteString(permissionName)) {
262 LOGE(ATM_DOMAIN, ATM_TAG, "WriteString failed.");
263 return ERR_WRITE_PARCEL_FAILED;
264 }
265 if (!sendData.WriteInt32(userID)) {
266 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInt32 failed.");
267 return ERR_WRITE_PARCEL_FAILED;
268 }
269
270 MessageParcel reply;
271 if (!SendRequest(AccessTokenInterfaceCode::GET_PERMISSION_REQUEST_TOGGLE_STATUS, sendData, reply)) {
272 return ERR_SERVICE_ABNORMAL;
273 }
274
275 int32_t result = reply.ReadInt32();
276 if (result == RET_SUCCESS) {
277 status = reply.ReadUint32();
278 }
279 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d, status=%{public}d).", result, status);
280 return result;
281 }
282
RequestAppPermOnSetting(AccessTokenID tokenID)283 int32_t AccessTokenManagerProxy::RequestAppPermOnSetting(AccessTokenID tokenID)
284 {
285 MessageParcel data;
286 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
287 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
288 return ERR_WRITE_PARCEL_FAILED;
289 }
290 if (!data.WriteUint32(tokenID)) {
291 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInt32 failed.");
292 return ERR_WRITE_PARCEL_FAILED;
293 }
294
295 MessageParcel reply;
296 if (!SendRequest(AccessTokenInterfaceCode::REQUEST_APP_PERM_ON_SETTING, data, reply)) {
297 return ERR_SERVICE_ABNORMAL;
298 }
299
300 int32_t result;
301 if (!reply.ReadInt32(result)) {
302 LOGE(ATM_DOMAIN, ATM_TAG, "ReadInt32 failed.");
303 return ERR_READ_PARCEL_FAILED;
304 }
305 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (result=%{public}d).", result);
306 return result;
307 }
308
GetPermissionFlag(AccessTokenID tokenID,const std::string & permissionName,uint32_t & flag)309 int AccessTokenManagerProxy::GetPermissionFlag(AccessTokenID tokenID, const std::string& permissionName, uint32_t& flag)
310 {
311 MessageParcel sendData;
312 if (!sendData.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
313 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
314 return ERR_WRITE_PARCEL_FAILED;
315 }
316 if (!sendData.WriteUint32(tokenID)) {
317 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
318 return ERR_WRITE_PARCEL_FAILED;
319 }
320 if (!sendData.WriteString(permissionName)) {
321 LOGE(ATM_DOMAIN, ATM_TAG, "WriteString failed.");
322 return ERR_WRITE_PARCEL_FAILED;
323 }
324
325 MessageParcel reply;
326 if (!SendRequest(AccessTokenInterfaceCode::GET_PERMISSION_FLAG, sendData, reply)) {
327 return ERR_SERVICE_ABNORMAL;
328 }
329
330 int32_t result = reply.ReadInt32();
331 if (result == RET_SUCCESS) {
332 flag = reply.ReadUint32();
333 }
334 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d, flag=%{public}d).", result, flag);
335 return result;
336 }
337
GetSelfPermissionsState(std::vector<PermissionListStateParcel> & permListParcel,PermissionGrantInfoParcel & infoParcel)338 PermissionOper AccessTokenManagerProxy::GetSelfPermissionsState(std::vector<PermissionListStateParcel>& permListParcel,
339 PermissionGrantInfoParcel& infoParcel)
340 {
341 MessageParcel data;
342 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
343 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
344 return INVALID_OPER;
345 }
346 if (!data.WriteUint32(permListParcel.size())) {
347 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
348 return INVALID_OPER;
349 }
350 for (const auto& permission : permListParcel) {
351 if (!data.WriteParcelable(&permission)) {
352 LOGE(ATM_DOMAIN, ATM_TAG, "WriteParcelable failed.");
353 return INVALID_OPER;
354 }
355 }
356
357 MessageParcel reply;
358 if (!SendRequest(AccessTokenInterfaceCode::GET_PERMISSION_OPER_STATE, data, reply)) {
359 return INVALID_OPER;
360 }
361
362 PermissionOper result = static_cast<PermissionOper>(reply.ReadInt32());
363 size_t size = reply.ReadUint32();
364 if (size != permListParcel.size()) {
365 LOGE(ATM_DOMAIN, ATM_TAG, "Size(%{public}zu) from server is not equal inputSize(%{public}zu)!",
366 size, permListParcel.size());
367 return INVALID_OPER;
368 }
369 if (size > MAX_PERMISSION_SIZE) {
370 LOGE(ATM_DOMAIN, ATM_TAG, "Size(%{public}zu) is oversize.", size);
371 return INVALID_OPER;
372 }
373 for (uint32_t i = 0; i < size; i++) {
374 sptr<PermissionListStateParcel> permissionReq = reply.ReadParcelable<PermissionListStateParcel>();
375 if (permissionReq != nullptr) {
376 permListParcel[i].permsState.state = permissionReq->permsState.state;
377 permListParcel[i].permsState.errorReason = permissionReq->permsState.errorReason;
378 }
379 }
380
381 sptr<PermissionGrantInfoParcel> resultSptr = reply.ReadParcelable<PermissionGrantInfoParcel>();
382 if (resultSptr == nullptr) {
383 LOGE(ATM_DOMAIN, ATM_TAG, "ReadParcelable failed.");
384 return INVALID_OPER;
385 }
386 infoParcel = *resultSptr;
387
388 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (status=%{public}d).", result);
389 return result;
390 }
391
GetPermissionsStatus(AccessTokenID tokenID,std::vector<PermissionListStateParcel> & permListParcel)392 int32_t AccessTokenManagerProxy::GetPermissionsStatus(AccessTokenID tokenID,
393 std::vector<PermissionListStateParcel>& permListParcel)
394 {
395 MessageParcel data;
396 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
397 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
398 return ERR_WRITE_PARCEL_FAILED;
399 }
400 if (!data.WriteUint32(tokenID)) {
401 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed");
402 return ERR_WRITE_PARCEL_FAILED;
403 }
404 if (!data.WriteUint32(permListParcel.size())) {
405 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
406 return ERR_WRITE_PARCEL_FAILED;
407 }
408 for (const auto& permission : permListParcel) {
409 if (!data.WriteParcelable(&permission)) {
410 LOGE(ATM_DOMAIN, ATM_TAG, "WriteParcelable failed.");
411 return ERR_WRITE_PARCEL_FAILED;
412 }
413 }
414
415 MessageParcel reply;
416 if (!SendRequest(AccessTokenInterfaceCode::GET_PERMISSIONS_STATUS, data, reply)) {
417 return ERR_SERVICE_ABNORMAL;
418 }
419
420 int32_t result = reply.ReadInt32();
421 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
422 if (result != RET_SUCCESS) {
423 return result;
424 }
425 size_t size = reply.ReadUint32();
426 if (size != permListParcel.size()) {
427 LOGE(ATM_DOMAIN, ATM_TAG, "Size(%{public}zu) from server is not equal inputSize(%{public}zu)!",
428 size, permListParcel.size());
429 return ERR_SIZE_NOT_EQUAL;
430 }
431 for (uint32_t i = 0; i < size; i++) {
432 sptr<PermissionListStateParcel> permissionReq = reply.ReadParcelable<PermissionListStateParcel>();
433 if (permissionReq != nullptr) {
434 permListParcel[i].permsState.state = permissionReq->permsState.state;
435 }
436 }
437 return result;
438 }
439
GrantPermission(AccessTokenID tokenID,const std::string & permissionName,uint32_t flag)440 int AccessTokenManagerProxy::GrantPermission(AccessTokenID tokenID, const std::string& permissionName, uint32_t flag)
441 {
442 MessageParcel inData;
443 if (!inData.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
444 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
445 return ERR_WRITE_PARCEL_FAILED;
446 }
447 if (!inData.WriteUint32(tokenID)) {
448 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
449 return ERR_WRITE_PARCEL_FAILED;
450 }
451 if (!inData.WriteString(permissionName)) {
452 LOGE(ATM_DOMAIN, ATM_TAG, "WriteString failed.");
453 return ERR_WRITE_PARCEL_FAILED;
454 }
455 if (!inData.WriteUint32(flag)) {
456 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
457 return ERR_WRITE_PARCEL_FAILED;
458 }
459
460 MessageParcel reply;
461 if (!SendRequest(AccessTokenInterfaceCode::GRANT_PERMISSION, inData, reply)) {
462 return ERR_SERVICE_ABNORMAL;
463 }
464
465 int32_t result = reply.ReadInt32();
466 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
467 return result;
468 }
469
RevokePermission(AccessTokenID tokenID,const std::string & permissionName,uint32_t flag)470 int AccessTokenManagerProxy::RevokePermission(AccessTokenID tokenID, const std::string& permissionName, uint32_t flag)
471 {
472 MessageParcel data;
473 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
474 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
475 return ERR_WRITE_PARCEL_FAILED;
476 }
477 if (!data.WriteUint32(tokenID)) {
478 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
479 return ERR_WRITE_PARCEL_FAILED;
480 }
481 if (!data.WriteString(permissionName)) {
482 LOGE(ATM_DOMAIN, ATM_TAG, "WriteString failed.");
483 return ERR_WRITE_PARCEL_FAILED;
484 }
485 if (!data.WriteUint32(flag)) {
486 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
487 return ERR_WRITE_PARCEL_FAILED;
488 }
489
490 MessageParcel reply;
491 if (!SendRequest(AccessTokenInterfaceCode::REVOKE_PERMISSION, data, reply)) {
492 return ERR_SERVICE_ABNORMAL;
493 }
494
495 int32_t result = reply.ReadInt32();
496 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
497 return result;
498 }
499
GrantPermissionForSpecifiedTime(AccessTokenID tokenID,const std::string & permissionName,uint32_t onceTime)500 int AccessTokenManagerProxy::GrantPermissionForSpecifiedTime(
501 AccessTokenID tokenID, const std::string& permissionName, uint32_t onceTime)
502 {
503 MessageParcel data;
504 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
505 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
506 return ERR_WRITE_PARCEL_FAILED;
507 }
508 if (!data.WriteUint32(tokenID)) {
509 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
510 return ERR_WRITE_PARCEL_FAILED;
511 }
512 if (!data.WriteString(permissionName)) {
513 LOGE(ATM_DOMAIN, ATM_TAG, "WriteString failed.");
514 return ERR_WRITE_PARCEL_FAILED;
515 }
516 if (!data.WriteUint32(onceTime)) {
517 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
518 return ERR_WRITE_PARCEL_FAILED;
519 }
520
521 MessageParcel reply;
522 if (!SendRequest(AccessTokenInterfaceCode::GRANT_PERMISSION_FOR_SPECIFIEDTIME, data, reply)) {
523 return ERR_SERVICE_ABNORMAL;
524 }
525
526 int32_t result;
527 if (!reply.ReadInt32(result)) {
528 LOGE(ATM_DOMAIN, ATM_TAG, "ReadInt32 failed.");
529 return ERR_READ_PARCEL_FAILED;
530 }
531 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (result=%{public}d).", result);
532 return result;
533 }
534
ClearUserGrantedPermissionState(AccessTokenID tokenID)535 int AccessTokenManagerProxy::ClearUserGrantedPermissionState(AccessTokenID tokenID)
536 {
537 MessageParcel data;
538 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
539 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
540 return ERR_WRITE_PARCEL_FAILED;
541 }
542 if (!data.WriteUint32(tokenID)) {
543 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
544 return ERR_WRITE_PARCEL_FAILED;
545 }
546
547 MessageParcel reply;
548 if (!SendRequest(AccessTokenInterfaceCode::CLEAR_USER_GRANT_PERMISSION, data, reply)) {
549 return ERR_SERVICE_ABNORMAL;
550 }
551
552 int32_t result = reply.ReadInt32();
553 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
554 return result;
555 }
556
RegisterPermStateChangeCallback(const PermStateChangeScopeParcel & scope,const sptr<IRemoteObject> & callback)557 int32_t AccessTokenManagerProxy::RegisterPermStateChangeCallback(
558 const PermStateChangeScopeParcel& scope, const sptr<IRemoteObject>& callback)
559 {
560 MessageParcel data;
561 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
562 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
563 return ERR_WRITE_PARCEL_FAILED;
564 }
565 if (!data.WriteParcelable(&scope)) {
566 LOGE(ATM_DOMAIN, ATM_TAG, "WriteParcelable failed.");
567 return ERR_WRITE_PARCEL_FAILED;
568 }
569 if (!data.WriteRemoteObject(callback)) {
570 LOGE(ATM_DOMAIN, ATM_TAG, "WriteRemoteObject failed.");
571 return ERR_WRITE_PARCEL_FAILED;
572 }
573 MessageParcel reply;
574 if (!SendRequest(AccessTokenInterfaceCode::REGISTER_PERM_STATE_CHANGE_CALLBACK, data, reply)) {
575 return ERR_SERVICE_ABNORMAL;
576 }
577
578 int32_t ret;
579 if (!reply.ReadInt32(ret)) {
580 LOGE(ATM_DOMAIN, ATM_TAG, "ReadInt32 failed.");
581 return ERR_READ_PARCEL_FAILED;
582 }
583 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", ret);
584 return ret;
585 }
586
UnRegisterPermStateChangeCallback(const sptr<IRemoteObject> & callback)587 int32_t AccessTokenManagerProxy::UnRegisterPermStateChangeCallback(const sptr<IRemoteObject>& callback)
588 {
589 MessageParcel data;
590 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
591 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
592 return ERR_WRITE_PARCEL_FAILED;
593 }
594 if (!data.WriteRemoteObject(callback)) {
595 LOGE(ATM_DOMAIN, ATM_TAG, "WriteRemoteObject failed.");
596 return ERR_WRITE_PARCEL_FAILED;
597 }
598
599 MessageParcel reply;
600 if (!SendRequest(
601 AccessTokenInterfaceCode::UNREGISTER_PERM_STATE_CHANGE_CALLBACK, data, reply)) {
602 return ERR_SERVICE_ABNORMAL;
603 }
604
605 int32_t result;
606 if (!reply.ReadInt32(result)) {
607 LOGE(ATM_DOMAIN, ATM_TAG, "ReadInt32 failed.");
608 return ERR_READ_PARCEL_FAILED;
609 }
610 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
611 return result;
612 }
613
RegisterSelfPermStateChangeCallback(const PermStateChangeScopeParcel & scope,const sptr<IRemoteObject> & callback)614 int32_t AccessTokenManagerProxy::RegisterSelfPermStateChangeCallback(
615 const PermStateChangeScopeParcel& scope, const sptr<IRemoteObject>& callback)
616 {
617 MessageParcel data;
618 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
619 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
620 return ERR_WRITE_PARCEL_FAILED;
621 }
622 if (!data.WriteParcelable(&scope)) {
623 LOGE(ATM_DOMAIN, ATM_TAG, "WriteParcelable failed.");
624 return ERR_WRITE_PARCEL_FAILED;
625 }
626 if (!data.WriteRemoteObject(callback)) {
627 LOGE(ATM_DOMAIN, ATM_TAG, "WriteRemoteObject failed.");
628 return ERR_WRITE_PARCEL_FAILED;
629 }
630 MessageParcel reply;
631 if (!SendRequest(AccessTokenInterfaceCode::REGISTER_SELF_PERM_STATE_CHANGE_CALLBACK, data, reply)) {
632 return ERR_SERVICE_ABNORMAL;
633 }
634
635 int32_t ret;
636 if (!reply.ReadInt32(ret)) {
637 LOGE(ATM_DOMAIN, ATM_TAG, "ReadInt32 failed.");
638 return ERR_READ_PARCEL_FAILED;
639 }
640 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", ret);
641 return ret;
642 }
643
UnRegisterSelfPermStateChangeCallback(const sptr<IRemoteObject> & callback)644 int32_t AccessTokenManagerProxy::UnRegisterSelfPermStateChangeCallback(const sptr<IRemoteObject>& callback)
645 {
646 MessageParcel data;
647 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
648 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
649 return ERR_WRITE_PARCEL_FAILED;
650 }
651 if (!data.WriteRemoteObject(callback)) {
652 LOGE(ATM_DOMAIN, ATM_TAG, "WriteRemoteObject failed.");
653 return ERR_WRITE_PARCEL_FAILED;
654 }
655
656 MessageParcel reply;
657 if (!SendRequest(
658 AccessTokenInterfaceCode::UNREGISTER_SELF_PERM_STATE_CHANGE_CALLBACK, data, reply)) {
659 return ERR_SERVICE_ABNORMAL;
660 }
661
662 int32_t result;
663 if (!reply.ReadInt32(result)) {
664 LOGE(ATM_DOMAIN, ATM_TAG, "ReadInt32 failed.");
665 return ERR_READ_PARCEL_FAILED;
666 }
667 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
668 return result;
669 }
670
AllocHapToken(const HapInfoParcel & hapInfo,const HapPolicyParcel & policyParcel)671 AccessTokenIDEx AccessTokenManagerProxy::AllocHapToken(
672 const HapInfoParcel& hapInfo, const HapPolicyParcel& policyParcel)
673 {
674 MessageParcel data;
675 AccessTokenIDEx res = { 0 };
676 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
677 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
678 return res;
679 }
680
681 if (!data.WriteParcelable(&hapInfo)) {
682 LOGE(ATM_DOMAIN, ATM_TAG, "WriteParcelable failed.");
683 return res;
684 }
685 if (!data.WriteParcelable(&policyParcel)) {
686 LOGE(ATM_DOMAIN, ATM_TAG, "WriteParcelable failed.");
687 return res;
688 }
689
690 MessageParcel reply;
691 if (!SendRequest(AccessTokenInterfaceCode::ALLOC_TOKEN_HAP, data, reply)) {
692 return res;
693 }
694
695 unsigned long long result = reply.ReadUint64();
696 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (id=%{public}llu).", result);
697 res.tokenIDEx = result;
698 return res;
699 }
700
InitHapToken(const HapInfoParcel & hapInfoParcel,HapPolicyParcel & policyParcel,AccessTokenIDEx & fullTokenId,HapInfoCheckResult & resultInfo)701 int32_t AccessTokenManagerProxy::InitHapToken(const HapInfoParcel& hapInfoParcel, HapPolicyParcel& policyParcel,
702 AccessTokenIDEx& fullTokenId, HapInfoCheckResult& resultInfo)
703 {
704 MessageParcel data;
705 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
706 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
707 return ERR_WRITE_PARCEL_FAILED;
708 }
709
710 if (!data.WriteParcelable(&hapInfoParcel)) {
711 LOGE(ATM_DOMAIN, ATM_TAG, "WriteParcelable failed.");
712 return ERR_WRITE_PARCEL_FAILED;
713 }
714 if (!data.WriteParcelable(&policyParcel)) {
715 LOGE(ATM_DOMAIN, ATM_TAG, "WriteParcelable failed.");
716 return ERR_WRITE_PARCEL_FAILED;
717 }
718
719 MessageParcel reply;
720 if (!SendRequest(AccessTokenInterfaceCode::INIT_TOKEN_HAP, data, reply)) {
721 return ERR_SERVICE_ABNORMAL;
722 }
723 int32_t result = 0;
724 if (!reply.ReadInt32(result)) {
725 LOGE(ATM_DOMAIN, ATM_TAG, "ReadInt32 failed.");
726 return ERR_READ_PARCEL_FAILED;
727 }
728 if (result == RET_SUCCESS) {
729 uint64_t tokenId = 0;
730 if (!reply.ReadUint64(tokenId)) {
731 LOGE(ATM_DOMAIN, ATM_TAG, "ReadUint64 faild.");
732 return ERR_READ_PARCEL_FAILED;
733 }
734 fullTokenId.tokenIDEx = tokenId;
735 } else {
736 if (reply.GetDataSize() > reply.GetReadPosition()) {
737 IF_FALSE_RETURN_VALUE_LOG(LABEL, reply.ReadString(resultInfo.permCheckResult.permissionName),
738 ERR_READ_PARCEL_FAILED, "ReadString faild.");
739
740 int32_t rule;
741 IF_FALSE_RETURN_VALUE_LOG(LABEL, reply.ReadInt32(rule),
742 ERR_READ_PARCEL_FAILED, "ReadString faild.");
743 resultInfo.permCheckResult.rule = static_cast<PermissionRulesEnum>(rule);
744 }
745 }
746 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d, id=%{public}llu).",
747 result, fullTokenId.tokenIDEx);
748 return result;
749 }
750
DeleteToken(AccessTokenID tokenID)751 int AccessTokenManagerProxy::DeleteToken(AccessTokenID tokenID)
752 {
753 MessageParcel data;
754 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
755 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
756 return ERR_WRITE_PARCEL_FAILED;
757 }
758
759 if (!data.WriteUint32(tokenID)) {
760 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
761 return ERR_WRITE_PARCEL_FAILED;
762 }
763
764 MessageParcel reply;
765 if (!SendRequest(AccessTokenInterfaceCode::TOKEN_DELETE, data, reply)) {
766 return ERR_SERVICE_ABNORMAL;
767 }
768
769 int result = reply.ReadInt32();
770 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d, id=%{public}u).", result, tokenID);
771 return result;
772 }
773
GetTokenType(AccessTokenID tokenID)774 int AccessTokenManagerProxy::GetTokenType(AccessTokenID tokenID)
775 {
776 MessageParcel data;
777 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
778 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
779 return ERR_WRITE_PARCEL_FAILED;
780 }
781
782 if (!data.WriteUint32(tokenID)) {
783 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write tokenID");
784 return ERR_WRITE_PARCEL_FAILED;
785 }
786
787 MessageParcel reply;
788 if (!SendRequest(AccessTokenInterfaceCode::GET_TOKEN_TYPE, data, reply)) {
789 return ERR_SERVICE_ABNORMAL;
790 }
791
792 int result = reply.ReadInt32();
793 LOGD(ATM_DOMAIN, ATM_TAG, "Result from server (type=%{public}d).", result);
794 return result;
795 }
796
GetHapTokenID(int32_t userID,const std::string & bundleName,int32_t instIndex)797 AccessTokenIDEx AccessTokenManagerProxy::GetHapTokenID(int32_t userID, const std::string& bundleName, int32_t instIndex)
798 {
799 AccessTokenIDEx tokenIdEx = {0};
800 MessageParcel data;
801 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
802 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
803 return tokenIdEx;
804 }
805
806 if (!data.WriteInt32(userID)) {
807 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write tokenID");
808 return tokenIdEx;
809 }
810 if (!data.WriteString(bundleName)) {
811 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write dcap");
812 return tokenIdEx;
813 }
814 if (!data.WriteInt32(instIndex)) {
815 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write dcap");
816 return tokenIdEx;
817 }
818 MessageParcel reply;
819 if (!SendRequest(AccessTokenInterfaceCode::GET_HAP_TOKEN_ID, data, reply)) {
820 return tokenIdEx;
821 }
822
823 tokenIdEx.tokenIDEx = reply.ReadUint64();
824 LOGD(ATM_DOMAIN, ATM_TAG, "Result from server (id=%{public}llu).", tokenIdEx.tokenIDEx);
825 return tokenIdEx;
826 }
827
AllocLocalTokenID(const std::string & remoteDeviceID,AccessTokenID remoteTokenID)828 AccessTokenID AccessTokenManagerProxy::AllocLocalTokenID(
829 const std::string& remoteDeviceID, AccessTokenID remoteTokenID)
830 {
831 MessageParcel data;
832 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
833 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
834 return 0;
835 }
836
837 if (!data.WriteString(remoteDeviceID)) {
838 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write dcap");
839 return 0;
840 }
841 if (!data.WriteUint32(remoteTokenID)) {
842 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write dcap");
843 return 0;
844 }
845 MessageParcel reply;
846 if (!SendRequest(AccessTokenInterfaceCode::ALLOC_LOCAL_TOKEN_ID, data, reply)) {
847 return 0;
848 }
849
850 AccessTokenID result = reply.ReadUint32();
851 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (id=%{public}d).", result);
852 return result;
853 }
854
GetNativeTokenInfo(AccessTokenID tokenID,NativeTokenInfoParcel & nativeTokenInfoRes)855 int AccessTokenManagerProxy::GetNativeTokenInfo(AccessTokenID tokenID, NativeTokenInfoParcel& nativeTokenInfoRes)
856 {
857 MessageParcel data;
858 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
859 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
860 return ERR_WRITE_PARCEL_FAILED;
861 }
862 if (!data.WriteUint32(tokenID)) {
863 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
864 return ERR_WRITE_PARCEL_FAILED;
865 }
866
867 MessageParcel reply;
868 if (!SendRequest(AccessTokenInterfaceCode::GET_NATIVE_TOKENINFO, data, reply)) {
869 return ERR_SERVICE_ABNORMAL;
870 }
871
872 int32_t result = reply.ReadInt32();
873 LOGD(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
874 if (result != RET_SUCCESS) {
875 return result;
876 }
877 sptr<NativeTokenInfoParcel> resultSptr = reply.ReadParcelable<NativeTokenInfoParcel>();
878 if (resultSptr == nullptr) {
879 LOGE(ATM_DOMAIN, ATM_TAG, "ReadParcelable fail");
880 return ERR_READ_PARCEL_FAILED;
881 }
882 nativeTokenInfoRes = *resultSptr;
883 return result;
884 }
885
GetTokenIDByUserID(int32_t userID,std::unordered_set<AccessTokenID> & tokenIdList)886 int32_t AccessTokenManagerProxy::GetTokenIDByUserID(int32_t userID, std::unordered_set<AccessTokenID>& tokenIdList)
887 {
888 MessageParcel data;
889 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
890 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
891 return ERR_WRITE_PARCEL_FAILED;
892 }
893 if (!data.WriteInt32(userID)) {
894 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInt32 failed.");
895 return ERR_WRITE_PARCEL_FAILED;
896 }
897
898 MessageParcel reply;
899 if (!SendRequest(AccessTokenInterfaceCode::GET_TOKEN_ID_BY_USER_ID, data, reply)) {
900 return ERR_SERVICE_ABNORMAL;
901 }
902
903 int32_t result = 0;
904 if (!reply.ReadInt32(result)) {
905 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
906 return ERR_READ_PARCEL_FAILED;
907 }
908 if (result != RET_SUCCESS) {
909 return result;
910 }
911
912 uint32_t tokenIDListSize = 0;
913 if (!reply.ReadUint32(tokenIDListSize)) {
914 LOGE(ATM_DOMAIN, ATM_TAG, "ReadUint32 failed.");
915 return ERR_READ_PARCEL_FAILED;
916 }
917 for (uint32_t i = 0; i < tokenIDListSize; i++) {
918 AccessTokenID tokenId = 0;
919 if (!reply.ReadUint32(tokenId)) {
920 LOGE(ATM_DOMAIN, ATM_TAG, "ReadUint32 failed.");
921 return ERR_READ_PARCEL_FAILED;
922 }
923 tokenIdList.emplace(tokenId);
924 }
925 return result;
926 }
927
GetHapTokenInfo(AccessTokenID tokenID,HapTokenInfoParcel & hapTokenInfoRes)928 int AccessTokenManagerProxy::GetHapTokenInfo(AccessTokenID tokenID, HapTokenInfoParcel& hapTokenInfoRes)
929 {
930 MessageParcel data;
931 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
932 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
933 return ERR_WRITE_PARCEL_FAILED;
934 }
935 if (!data.WriteUint32(tokenID)) {
936 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 failed.");
937 return ERR_WRITE_PARCEL_FAILED;
938 }
939
940 MessageParcel reply;
941 if (!SendRequest(AccessTokenInterfaceCode::GET_HAP_TOKENINFO, data, reply)) {
942 return ERR_SERVICE_ABNORMAL;
943 }
944
945 int32_t result = reply.ReadInt32();
946 LOGD(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
947 if (result != RET_SUCCESS) {
948 return result;
949 }
950 sptr<HapTokenInfoParcel> resultSptr = reply.ReadParcelable<HapTokenInfoParcel>();
951 if (resultSptr == nullptr) {
952 LOGE(ATM_DOMAIN, ATM_TAG, "ReadParcelable failed.");
953 return ERR_READ_PARCEL_FAILED;
954 }
955 hapTokenInfoRes = *resultSptr;
956 return result;
957 }
958
UpdateHapToken(AccessTokenIDEx & tokenIdEx,const UpdateHapInfoParams & info,const HapPolicyParcel & policyParcel,HapInfoCheckResult & resultInfo)959 int32_t AccessTokenManagerProxy::UpdateHapToken(AccessTokenIDEx& tokenIdEx, const UpdateHapInfoParams& info,
960 const HapPolicyParcel& policyParcel, HapInfoCheckResult& resultInfo)
961 {
962 AccessTokenID tokenID = tokenIdEx.tokenIdExStruct.tokenID;
963 MessageParcel data;
964 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
965 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
966 return ERR_WRITE_PARCEL_FAILED;
967 }
968 if (!data.WriteUint32(tokenID)) {
969 LOGE(ATM_DOMAIN, ATM_TAG, "Write tokenID failed.");
970 return ERR_WRITE_PARCEL_FAILED;
971 }
972 if (!data.WriteBool(info.isSystemApp)) {
973 LOGE(ATM_DOMAIN, ATM_TAG, "Write isSystemApp failed.");
974 return ERR_WRITE_PARCEL_FAILED;
975 }
976 if (!data.WriteString(info.appIDDesc)) {
977 LOGE(ATM_DOMAIN, ATM_TAG, "Write appIDDesc failed.");
978 return ERR_WRITE_PARCEL_FAILED;
979 }
980 if (!data.WriteInt32(info.apiVersion)) {
981 LOGE(ATM_DOMAIN, ATM_TAG, "Write apiVersion failed.");
982 return ERR_WRITE_PARCEL_FAILED;
983 }
984 if (!data.WriteString(info.appDistributionType)) {
985 LOGE(ATM_DOMAIN, ATM_TAG, "Write appDistributionType failed.");
986 return ERR_WRITE_PARCEL_FAILED;
987 }
988 if (!data.WriteParcelable(&policyParcel)) {
989 LOGE(ATM_DOMAIN, ATM_TAG, "Write policyParcel failed.");
990 return ERR_WRITE_PARCEL_FAILED;
991 }
992
993 MessageParcel reply;
994 if (!SendRequest(AccessTokenInterfaceCode::UPDATE_HAP_TOKEN, data, reply)) {
995 return ERR_SERVICE_ABNORMAL;
996 }
997 int32_t result = reply.ReadInt32();
998 tokenIdEx.tokenIdExStruct.tokenAttr = reply.ReadUint32();
999 if (result != RET_SUCCESS && reply.GetDataSize() > reply.GetReadPosition()) {
1000 IF_FALSE_RETURN_VALUE_LOG(LABEL, reply.ReadString(resultInfo.permCheckResult.permissionName),
1001 ERR_READ_PARCEL_FAILED, "ReadString faild.");
1002
1003 int32_t rule;
1004 IF_FALSE_RETURN_VALUE_LOG(LABEL, reply.ReadInt32(rule),
1005 ERR_READ_PARCEL_FAILED, "ReadString faild.");
1006 resultInfo.permCheckResult.rule = static_cast<PermissionRulesEnum>(rule);
1007 }
1008 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
1009 return result;
1010 }
1011
1012 #ifndef ATM_BUILD_VARIANT_USER_ENABLE
ReloadNativeTokenInfo()1013 int32_t AccessTokenManagerProxy::ReloadNativeTokenInfo()
1014 {
1015 MessageParcel data;
1016 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1017 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
1018 return ERR_WRITE_PARCEL_FAILED;
1019 }
1020 MessageParcel reply;
1021 if (!SendRequest(AccessTokenInterfaceCode::RELOAD_NATIVE_TOKEN_INFO, data, reply)) {
1022 return ERR_SERVICE_ABNORMAL;
1023 }
1024
1025 int32_t result = reply.ReadInt32();
1026 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
1027 return result;
1028 }
1029
1030 #endif
1031
GetHapTokenInfoExtension(AccessTokenID tokenID,HapTokenInfoParcel & hapTokenInfoRes,std::string & appID)1032 int AccessTokenManagerProxy::GetHapTokenInfoExtension(AccessTokenID tokenID,
1033 HapTokenInfoParcel& hapTokenInfoRes, std::string& appID)
1034 {
1035 MessageParcel data;
1036 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1037 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
1038 return ERR_WRITE_PARCEL_FAILED;
1039 }
1040 if (!data.WriteUint32(tokenID)) {
1041 LOGE(ATM_DOMAIN, ATM_TAG, "WriteUint32 fail");
1042 return ERR_WRITE_PARCEL_FAILED;
1043 }
1044
1045 MessageParcel reply;
1046 if (!SendRequest(AccessTokenInterfaceCode::GET_HAP_TOKENINFO_EXT, data, reply)) {
1047 return ERR_SERVICE_ABNORMAL;
1048 }
1049
1050 int32_t result = reply.ReadInt32();
1051 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
1052 if (result != RET_SUCCESS) {
1053 return result;
1054 }
1055 sptr<HapTokenInfoParcel> hapResult = reply.ReadParcelable<HapTokenInfoParcel>();
1056 if (hapResult == nullptr) {
1057 LOGE(ATM_DOMAIN, ATM_TAG, "ReadParcelable fail.");
1058 return ERR_READ_PARCEL_FAILED;
1059 }
1060 hapTokenInfoRes = *hapResult;
1061 if (!reply.ReadString(appID)) {
1062 LOGE(ATM_DOMAIN, ATM_TAG, "ReadString fail.");
1063 return ERR_READ_PARCEL_FAILED;
1064 }
1065
1066 return result;
1067 }
1068
GetNativeTokenId(const std::string & processName)1069 AccessTokenID AccessTokenManagerProxy::GetNativeTokenId(const std::string& processName)
1070 {
1071 MessageParcel data;
1072 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1073 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
1074 return INVALID_TOKENID;
1075 }
1076
1077 if (!data.WriteString(processName)) {
1078 LOGE(ATM_DOMAIN, ATM_TAG, "WriteString failed.");
1079 return INVALID_TOKENID;
1080 }
1081 MessageParcel reply;
1082 if (!SendRequest(AccessTokenInterfaceCode::GET_NATIVE_TOKEN_ID, data, reply)) {
1083 return INVALID_TOKENID;
1084 }
1085 AccessTokenID id;
1086 if (!reply.ReadUint32(id)) {
1087 LOGI(ATM_DOMAIN, ATM_TAG, "ReadInt32 failed.");
1088 return INVALID_TOKENID;
1089 }
1090 LOGD(ATM_DOMAIN, ATM_TAG, "Result from server (process=%{public}s, id=%{public}d).", processName.c_str(), id);
1091 return id;
1092 }
1093
1094 #ifdef TOKEN_SYNC_ENABLE
GetHapTokenInfoFromRemote(AccessTokenID tokenID,HapTokenInfoForSyncParcel & hapSyncParcel)1095 int AccessTokenManagerProxy::GetHapTokenInfoFromRemote(AccessTokenID tokenID,
1096 HapTokenInfoForSyncParcel& hapSyncParcel)
1097 {
1098 MessageParcel data;
1099 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1100 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
1101 return ERR_WRITE_PARCEL_FAILED;
1102 }
1103 if (!data.WriteUint32(tokenID)) {
1104 return ERR_WRITE_PARCEL_FAILED;
1105 }
1106
1107 MessageParcel reply;
1108 if (!SendRequest(AccessTokenInterfaceCode::GET_HAP_TOKEN_FROM_REMOTE, data, reply)) {
1109 return ERR_SERVICE_ABNORMAL;
1110 }
1111
1112 int32_t result = reply.ReadInt32();
1113 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
1114 if (result != RET_SUCCESS) {
1115 return result;
1116 }
1117 sptr<HapTokenInfoForSyncParcel> hapResult = reply.ReadParcelable<HapTokenInfoForSyncParcel>();
1118 if (hapResult == nullptr) {
1119 LOGE(ATM_DOMAIN, ATM_TAG, "ReadParcelable fail");
1120 return ERR_READ_PARCEL_FAILED;
1121 }
1122 hapSyncParcel = *hapResult;
1123 return result;
1124 }
1125
SetRemoteHapTokenInfo(const std::string & deviceID,HapTokenInfoForSyncParcel & hapSyncParcel)1126 int AccessTokenManagerProxy::SetRemoteHapTokenInfo(const std::string& deviceID,
1127 HapTokenInfoForSyncParcel& hapSyncParcel)
1128 {
1129 MessageParcel data;
1130 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1131 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
1132 return ERR_WRITE_PARCEL_FAILED;
1133 }
1134 if (!data.WriteString(deviceID)) {
1135 return ERR_WRITE_PARCEL_FAILED;
1136 }
1137 if (!data.WriteParcelable(&hapSyncParcel)) {
1138 return ERR_WRITE_PARCEL_FAILED;
1139 }
1140
1141 MessageParcel reply;
1142 if (!SendRequest(AccessTokenInterfaceCode::SET_REMOTE_HAP_TOKEN_INFO, data, reply)) {
1143 return ERR_SERVICE_ABNORMAL;
1144 }
1145
1146 int32_t result = reply.ReadInt32();
1147 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
1148 return result;
1149 }
1150
DeleteRemoteToken(const std::string & deviceID,AccessTokenID tokenID)1151 int AccessTokenManagerProxy::DeleteRemoteToken(const std::string& deviceID, AccessTokenID tokenID)
1152 {
1153 MessageParcel data;
1154 data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor());
1155 if (!data.WriteString(deviceID)) {
1156 return ERR_WRITE_PARCEL_FAILED;
1157 }
1158
1159 if (!data.WriteUint32(tokenID)) {
1160 return ERR_WRITE_PARCEL_FAILED;
1161 }
1162
1163 MessageParcel reply;
1164 if (!SendRequest(AccessTokenInterfaceCode::DELETE_REMOTE_TOKEN_INFO, data, reply)) {
1165 return ERR_SERVICE_ABNORMAL;
1166 }
1167
1168 int32_t result = reply.ReadInt32();
1169 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
1170 return result;
1171 }
1172
GetRemoteNativeTokenID(const std::string & deviceID,AccessTokenID tokenID)1173 AccessTokenID AccessTokenManagerProxy::GetRemoteNativeTokenID(const std::string& deviceID, AccessTokenID tokenID)
1174 {
1175 MessageParcel data;
1176 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1177 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
1178 return 0;
1179 }
1180 if (!data.WriteString(deviceID)) {
1181 return 0;
1182 }
1183
1184 if (!data.WriteUint32(tokenID)) {
1185 return 0;
1186 }
1187
1188 MessageParcel reply;
1189 if (!SendRequest(AccessTokenInterfaceCode::GET_NATIVE_REMOTE_TOKEN, data, reply)) {
1190 return 0;
1191 }
1192
1193 AccessTokenID id = reply.ReadUint32();
1194 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (id=%{public}d).", id);
1195 return id;
1196 }
1197
DeleteRemoteDeviceTokens(const std::string & deviceID)1198 int AccessTokenManagerProxy::DeleteRemoteDeviceTokens(const std::string& deviceID)
1199 {
1200 MessageParcel data;
1201 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1202 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
1203 return ERR_WRITE_PARCEL_FAILED;
1204 }
1205 if (!data.WriteString(deviceID)) {
1206 return ERR_WRITE_PARCEL_FAILED;
1207 }
1208
1209 MessageParcel reply;
1210 if (!SendRequest(AccessTokenInterfaceCode::DELETE_REMOTE_DEVICE_TOKEN, data, reply)) {
1211 return ERR_SERVICE_ABNORMAL;
1212 }
1213
1214 int32_t result = reply.ReadInt32();
1215 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
1216 return result;
1217 }
1218
RegisterTokenSyncCallback(const sptr<IRemoteObject> & callback)1219 int32_t AccessTokenManagerProxy::RegisterTokenSyncCallback(const sptr<IRemoteObject>& callback)
1220 {
1221 MessageParcel data;
1222 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1223 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
1224 return ERR_WRITE_PARCEL_FAILED;
1225 }
1226 if (!data.WriteRemoteObject(callback)) {
1227 LOGE(ATM_DOMAIN, ATM_TAG, "WriteRemoteObject failed.");
1228 return ERR_WRITE_PARCEL_FAILED;
1229 }
1230
1231 MessageParcel reply;
1232 if (!SendRequest(
1233 AccessTokenInterfaceCode::REGISTER_TOKEN_SYNC_CALLBACK, data, reply)) {
1234 return ERR_SERVICE_ABNORMAL;
1235 }
1236
1237 int32_t result;
1238 if (!reply.ReadInt32(result)) {
1239 LOGE(ATM_DOMAIN, ATM_TAG, "ReadInt32 failed.");
1240 return ERR_READ_PARCEL_FAILED;
1241 }
1242 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
1243 return result;
1244 }
1245
UnRegisterTokenSyncCallback()1246 int32_t AccessTokenManagerProxy::UnRegisterTokenSyncCallback()
1247 {
1248 MessageParcel data;
1249 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1250 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
1251 return ERR_WRITE_PARCEL_FAILED;
1252 }
1253
1254 MessageParcel reply;
1255 if (!SendRequest(
1256 AccessTokenInterfaceCode::UNREGISTER_TOKEN_SYNC_CALLBACK, data, reply)) {
1257 return ERR_SERVICE_ABNORMAL;
1258 }
1259
1260 int32_t result;
1261 if (!reply.ReadInt32(result)) {
1262 LOGE(ATM_DOMAIN, ATM_TAG, "ReadInt32 failed.");
1263 return ERR_READ_PARCEL_FAILED;
1264 }
1265 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
1266 return result;
1267 }
1268 #endif
1269
DumpTokenInfo(const AtmToolsParamInfoParcel & infoParcel,std::string & dumpInfo)1270 void AccessTokenManagerProxy::DumpTokenInfo(const AtmToolsParamInfoParcel& infoParcel, std::string& dumpInfo)
1271 {
1272 MessageParcel data;
1273 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1274 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
1275 return;
1276 }
1277
1278 if (!data.WriteParcelable(&infoParcel)) {
1279 LOGE(ATM_DOMAIN, ATM_TAG, "Write infoParcel failed.");
1280 return;
1281 }
1282 MessageParcel reply;
1283 if (!SendRequest(AccessTokenInterfaceCode::DUMP_TOKENINFO, data, reply)) {
1284 return;
1285 }
1286 if (!reply.ReadString(dumpInfo)) {
1287 LOGE(ATM_DOMAIN, ATM_TAG, "ReadString failed.");
1288 }
1289 }
1290
GetVersion(uint32_t & version)1291 int32_t AccessTokenManagerProxy::GetVersion(uint32_t& version)
1292 {
1293 MessageParcel data;
1294 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1295 LOGE(ATM_DOMAIN, ATM_TAG, "Write interface token failed.");
1296 return ERR_WRITE_PARCEL_FAILED;
1297 }
1298
1299 MessageParcel reply;
1300 if (!SendRequest(AccessTokenInterfaceCode::GET_VERSION, data, reply)) {
1301 return ERR_SERVICE_ABNORMAL;
1302 }
1303 int32_t result = reply.ReadInt32();
1304 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server (error=%{public}d).", result);
1305 if (result != RET_SUCCESS) {
1306 return result;
1307 }
1308 if (!reply.ReadUint32(version)) {
1309 LOGE(ATM_DOMAIN, ATM_TAG, "ReadUint32 failed.");
1310 return ERR_READ_PARCEL_FAILED;
1311 }
1312 return result;
1313 }
1314
SetPermDialogCap(const HapBaseInfoParcel & hapBaseInfo,bool enable)1315 int32_t AccessTokenManagerProxy::SetPermDialogCap(const HapBaseInfoParcel& hapBaseInfo, bool enable)
1316 {
1317 MessageParcel data;
1318 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1319 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
1320 return ERR_WRITE_PARCEL_FAILED;
1321 }
1322
1323 if (!data.WriteParcelable(&hapBaseInfo)) {
1324 LOGE(ATM_DOMAIN, ATM_TAG, "WriteParcelable failed.");
1325 return ERR_WRITE_PARCEL_FAILED;
1326 }
1327 if (!data.WriteBool(enable)) {
1328 LOGE(ATM_DOMAIN, ATM_TAG, "WriteBool failed.");
1329 return ERR_WRITE_PARCEL_FAILED;
1330 }
1331
1332 MessageParcel reply;
1333 if (!SendRequest(AccessTokenInterfaceCode::SET_PERM_DIALOG_CAPABILITY, data, reply)) {
1334 return ERR_SERVICE_ABNORMAL;
1335 }
1336 return reply.ReadInt32();
1337 }
1338
GetPermissionManagerInfo(PermissionGrantInfoParcel & infoParcel)1339 void AccessTokenManagerProxy::GetPermissionManagerInfo(PermissionGrantInfoParcel& infoParcel)
1340 {
1341 MessageParcel data;
1342 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1343 LOGE(ATM_DOMAIN, ATM_TAG, "WriteInterfaceToken failed.");
1344 return;
1345 }
1346
1347 MessageParcel reply;
1348 if (!SendRequest(AccessTokenInterfaceCode::GET_PERMISSION_MANAGER_INFO, data, reply)) {
1349 return;
1350 }
1351
1352 sptr<PermissionGrantInfoParcel> parcel = reply.ReadParcelable<PermissionGrantInfoParcel>();
1353 if (parcel == nullptr) {
1354 LOGE(ATM_DOMAIN, ATM_TAG, "ReadParcelable failed.");
1355 return;
1356 }
1357 infoParcel = *parcel;
1358 }
1359
InitUserPolicy(const std::vector<UserState> & userList,const std::vector<std::string> & permList)1360 int32_t AccessTokenManagerProxy::InitUserPolicy(
1361 const std::vector<UserState>& userList, const std::vector<std::string>& permList)
1362 {
1363 MessageParcel data;
1364 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1365 LOGE(ATM_DOMAIN, ATM_TAG, "Write interface token failed.");
1366 return ERR_WRITE_PARCEL_FAILED;
1367 }
1368
1369 size_t userLen = userList.size();
1370 size_t permLen = permList.size();
1371 if ((userLen == 0) || (userLen > MAX_USER_POLICY_SIZE) || (permLen == 0) || (permLen > MAX_USER_POLICY_SIZE)) {
1372 LOGE(ATM_DOMAIN, ATM_TAG, "UserLen %{public}zu or permLen %{public}zu is invalid", userLen, permLen);
1373 return ERR_PARAM_INVALID;
1374 }
1375
1376 if (!data.WriteUint32(userLen)) {
1377 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write userLen size.");
1378 return ERR_WRITE_PARCEL_FAILED;
1379 }
1380 if (!data.WriteUint32(permLen)) {
1381 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write permLen size.");
1382 return ERR_WRITE_PARCEL_FAILED;
1383 }
1384 for (const auto& userInfo : userList) {
1385 if (!data.WriteInt32(userInfo.userId)) {
1386 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write userId.");
1387 return ERR_WRITE_PARCEL_FAILED;
1388 }
1389 if (!data.WriteBool(userInfo.isActive)) {
1390 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write isActive.");
1391 return ERR_WRITE_PARCEL_FAILED;
1392 }
1393 }
1394 for (const auto& permission : permList) {
1395 if (!data.WriteString(permission)) {
1396 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write permission.");
1397 return ERR_WRITE_PARCEL_FAILED;
1398 }
1399 }
1400
1401 MessageParcel reply;
1402 if (!SendRequest(AccessTokenInterfaceCode::INIT_USER_POLICY, data, reply)) {
1403 LOGE(ATM_DOMAIN, ATM_TAG, "Read replay failed");
1404 return ERR_SERVICE_ABNORMAL;
1405 }
1406 int32_t result;
1407 if (!reply.ReadInt32(result)) {
1408 LOGE(ATM_DOMAIN, ATM_TAG, "Read Int32 failed");
1409 return AccessTokenError::ERR_READ_PARCEL_FAILED;
1410 }
1411 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server data = %{public}d", result);
1412 return result;
1413 }
1414
ClearUserPolicy()1415 int32_t AccessTokenManagerProxy::ClearUserPolicy()
1416 {
1417 MessageParcel data;
1418 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1419 LOGE(ATM_DOMAIN, ATM_TAG, "Write interface token failed.");
1420 return ERR_WRITE_PARCEL_FAILED;
1421 }
1422
1423 MessageParcel reply;
1424 if (!SendRequest(AccessTokenInterfaceCode::CLEAR_USER_POLICY, data, reply)) {
1425 LOGE(ATM_DOMAIN, ATM_TAG, "Read replay failed");
1426 return ERR_SERVICE_ABNORMAL;
1427 }
1428 int32_t result;
1429 if (!reply.ReadInt32(result)) {
1430 LOGE(ATM_DOMAIN, ATM_TAG, "Read Int32 failed");
1431 return AccessTokenError::ERR_READ_PARCEL_FAILED;
1432 }
1433 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server data = %{public}d", result);
1434 return result;
1435 }
1436
UpdateUserPolicy(const std::vector<UserState> & userList)1437 int32_t AccessTokenManagerProxy::UpdateUserPolicy(const std::vector<UserState>& userList)
1438 {
1439 MessageParcel data;
1440 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1441 LOGE(ATM_DOMAIN, ATM_TAG, "Write interface token failed.");
1442 return ERR_WRITE_PARCEL_FAILED;
1443 }
1444
1445 size_t userLen = userList.size();
1446 if ((userLen == 0) || (userLen > MAX_USER_POLICY_SIZE)) {
1447 LOGE(ATM_DOMAIN, ATM_TAG, "UserLen %{public}zu is invalid.", userLen);
1448 return ERR_PARAM_INVALID;
1449 }
1450
1451 if (!data.WriteUint32(userLen)) {
1452 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write userLen size.");
1453 return ERR_WRITE_PARCEL_FAILED;
1454 }
1455
1456 for (const auto& userInfo : userList) {
1457 if (!data.WriteInt32(userInfo.userId)) {
1458 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write userId.");
1459 return ERR_WRITE_PARCEL_FAILED;
1460 }
1461 if (!data.WriteBool(userInfo.isActive)) {
1462 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write isActive.");
1463 return ERR_WRITE_PARCEL_FAILED;
1464 }
1465 }
1466
1467 MessageParcel reply;
1468 if (!SendRequest(AccessTokenInterfaceCode::UPDATE_USER_POLICY, data, reply)) {
1469 LOGE(ATM_DOMAIN, ATM_TAG, "Read replay failed");
1470 return ERR_SERVICE_ABNORMAL;
1471 }
1472 int32_t result;
1473 if (!reply.ReadInt32(result)) {
1474 LOGE(ATM_DOMAIN, ATM_TAG, "Read Int32 failed");
1475 return AccessTokenError::ERR_READ_PARCEL_FAILED;
1476 }
1477 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server data = %{public}d", result);
1478 return result;
1479 }
1480
GetKernelPermissions(AccessTokenID tokenID,std::vector<PermissionWithValue> & kernelPermList)1481 int32_t AccessTokenManagerProxy::GetKernelPermissions(
1482 AccessTokenID tokenID, std::vector<PermissionWithValue>& kernelPermList)
1483 {
1484 MessageParcel data;
1485 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1486 LOGE(ATM_DOMAIN, ATM_TAG, "Write interface token failed.");
1487 return ERR_WRITE_PARCEL_FAILED;
1488 }
1489
1490 if (!data.WriteUint32(tokenID)) {
1491 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write tokenID.");
1492 return ERR_WRITE_PARCEL_FAILED;
1493 }
1494
1495 MessageParcel reply;
1496 if (!SendRequest(AccessTokenInterfaceCode::GET_KERNEL_PERMISSIONS, data, reply)) {
1497 LOGE(ATM_DOMAIN, ATM_TAG, "Read replay failed");
1498 return ERR_SERVICE_ABNORMAL;
1499 }
1500 int32_t result;
1501 if (!reply.ReadInt32(result)) {
1502 LOGE(ATM_DOMAIN, ATM_TAG, "Read result failed");
1503 return AccessTokenError::ERR_READ_PARCEL_FAILED;
1504 }
1505 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server data = %{public}d", result);
1506 if (result != RET_SUCCESS) {
1507 return result;
1508 }
1509 uint32_t size;
1510 if (!reply.ReadUint32(size)) {
1511 LOGE(ATM_DOMAIN, ATM_TAG, "Read size failed");
1512 return AccessTokenError::ERR_READ_PARCEL_FAILED;
1513 }
1514 if (size > MAX_EXTENDED_VALUE_LIST_SIZE) {
1515 return AccessTokenError::ERR_OVERSIZE;
1516 }
1517 for (uint32_t i = 0; i < size; ++i) {
1518 PermissionWithValue perm;
1519 if (!reply.ReadString(perm.permissionName)) {
1520 LOGE(ATM_DOMAIN, ATM_TAG, "Read permission name failed.");
1521 return AccessTokenError::ERR_READ_PARCEL_FAILED;
1522 }
1523 if (!reply.ReadString(perm.value)) {
1524 LOGE(ATM_DOMAIN, ATM_TAG, "Read value failed.");
1525 return AccessTokenError::ERR_READ_PARCEL_FAILED;
1526 }
1527 if (perm.value == "true") {
1528 perm.value.clear();
1529 }
1530 kernelPermList.emplace_back(perm);
1531 }
1532 return RET_SUCCESS;
1533 }
1534
GetReqPermissionByName(AccessTokenID tokenID,const std::string & permissionName,std::string & value)1535 int32_t AccessTokenManagerProxy::GetReqPermissionByName(
1536 AccessTokenID tokenID, const std::string& permissionName, std::string& value)
1537 {
1538 MessageParcel data;
1539 if (!data.WriteInterfaceToken(IAccessTokenManager::GetDescriptor())) {
1540 LOGE(ATM_DOMAIN, ATM_TAG, "Write interface token failed.");
1541 return ERR_WRITE_PARCEL_FAILED;
1542 }
1543
1544 if (!data.WriteUint32(tokenID)) {
1545 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write tokenID.");
1546 return ERR_WRITE_PARCEL_FAILED;
1547 }
1548
1549 if (!data.WriteString(permissionName)) {
1550 LOGE(ATM_DOMAIN, ATM_TAG, "Failed to write tokenID.");
1551 return ERR_WRITE_PARCEL_FAILED;
1552 }
1553
1554 MessageParcel reply;
1555 if (!SendRequest(AccessTokenInterfaceCode::GET_PERMISSION_BY_NAME, data, reply)) {
1556 LOGE(ATM_DOMAIN, ATM_TAG, "Read replay failed");
1557 return ERR_SERVICE_ABNORMAL;
1558 }
1559 int32_t result;
1560 if (!reply.ReadInt32(result)) {
1561 LOGE(ATM_DOMAIN, ATM_TAG, "Read result failed");
1562 return AccessTokenError::ERR_READ_PARCEL_FAILED;
1563 }
1564 LOGI(ATM_DOMAIN, ATM_TAG, "Result from server data = %{public}d", result);
1565 if (result != RET_SUCCESS) {
1566 return result;
1567 }
1568 if (!reply.ReadString(value)) {
1569 LOGE(ATM_DOMAIN, ATM_TAG, "Read value failed");
1570 return AccessTokenError::ERR_READ_PARCEL_FAILED;
1571 }
1572
1573 return RET_SUCCESS;
1574 }
1575
1576 } // namespace AccessToken
1577 } // namespace Security
1578 } // namespace OHOS
1579