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