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