1 /*
2 * Copyright (c) 2022 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 "userauth_proxy.h"
17 #include <cinttypes>
18 #include <message_parcel.h>
19 #include "userauth_hilog_wrapper.h"
20
21 namespace OHOS {
22 namespace UserIAM {
23 namespace UserAuth {
UserAuthProxy(const sptr<IRemoteObject> & object)24 UserAuthProxy::UserAuthProxy(const sptr<IRemoteObject> &object) : IRemoteProxy<IUserAuth>(object)
25 {
26 }
27
GetAvailableStatus(const AuthType authType,const AuthTurstLevel authTurstLevel)28 int32_t UserAuthProxy::GetAvailableStatus(const AuthType authType, const AuthTurstLevel authTurstLevel)
29 {
30 USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthProxy GetAvailableStatus start");
31 int32_t result = SUCCESS;
32 MessageParcel data;
33 MessageParcel reply;
34 MessageOption option(MessageOption::TF_SYNC);
35
36 if (!data.WriteInterfaceToken(UserAuthProxy::GetDescriptor())) {
37 USERAUTH_HILOGE(MODULE_INNERKIT, "write descriptor failed");
38 return GENERAL_ERROR;
39 }
40 if (!data.WriteUint32(static_cast<uint32_t>(authType))) {
41 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write authType");
42 return GENERAL_ERROR;
43 }
44 if (!data.WriteUint32(static_cast<uint32_t>(authTurstLevel))) {
45 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write authTurstLevel");
46 return GENERAL_ERROR;
47 }
48 bool ret = SendRequest(static_cast<int32_t>(IUserAuth::USER_AUTH_GET_AVAILABLE_STATUS), data, reply, option);
49 if (!ret) {
50 USERAUTH_HILOGE(MODULE_INNERKIT, "SendRequest failed");
51 return GENERAL_ERROR;
52 }
53 if (!reply.ReadInt32(result)) {
54 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to read result");
55 return GENERAL_ERROR;
56 }
57
58 return result;
59 }
60
GetProperty(const GetPropertyRequest request,sptr<IUserAuthCallback> & callback)61 void UserAuthProxy::GetProperty(const GetPropertyRequest request, sptr<IUserAuthCallback> &callback)
62 {
63 USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthProxy GetProperty start");
64 MessageParcel data;
65 MessageParcel reply;
66 MessageOption option(MessageOption::TF_ASYNC);
67
68 if (!data.WriteInterfaceToken(UserAuthProxy::GetDescriptor())) {
69 USERAUTH_HILOGE(MODULE_INNERKIT, "write descriptor failed!");
70 return;
71 }
72 if (!data.WriteUint32(static_cast<uint32_t>(request.authType))) {
73 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write request.authType");
74 return;
75 }
76 if (!data.WriteUInt32Vector(request.keys)) {
77 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write request.keys");
78 return;
79 }
80 if (!data.WriteRemoteObject(callback->AsObject())) {
81 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write callback");
82 return;
83 }
84 bool ret = SendRequest(static_cast<int32_t>(IUserAuth::USER_AUTH_GET_PROPERTY), data, reply, option);
85 if (!ret) {
86 USERAUTH_HILOGE(MODULE_INNERKIT, "SendRequest failed");
87 ExecutorProperty result = {};
88 result.result = IPC_ERROR;
89 callback->onExecutorPropertyInfo(result);
90 }
91 }
SetProperty(const SetPropertyRequest request,sptr<IUserAuthCallback> & callback)92 void UserAuthProxy::SetProperty(const SetPropertyRequest request, sptr<IUserAuthCallback> &callback)
93 {
94 USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthProxy SetProperty start");
95 MessageParcel data;
96 MessageParcel reply;
97 MessageOption option(MessageOption::TF_ASYNC);
98
99 if (!data.WriteInterfaceToken(UserAuthProxy::GetDescriptor())) {
100 USERAUTH_HILOGE(MODULE_INNERKIT, "write descriptor failed");
101 return;
102 }
103 if (!data.WriteUint32(static_cast<uint32_t>(request.authType))) {
104 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write request.authType");
105 return;
106 }
107 if (!data.WriteUint32(static_cast<uint32_t>(request.key))) {
108 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write request.key");
109 return;
110 }
111 if (!data.WriteUInt8Vector(request.setInfo)) {
112 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write request.setInfo");
113 return;
114 }
115 if (!data.WriteRemoteObject(callback->AsObject())) {
116 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write callback");
117 return;
118 }
119 bool ret = SendRequest(IUserAuth::USER_AUTH_SET_PROPERTY, data, reply, option);
120 if (!ret) {
121 int32_t result = IPC_ERROR;
122 callback->onSetExecutorProperty(result);
123 USERAUTH_HILOGE(MODULE_INNERKIT, "SendRequest failed");
124 return;
125 }
126 }
127
Auth(const uint64_t challenge,const AuthType authType,const AuthTurstLevel authTurstLevel,sptr<IUserAuthCallback> & callback)128 uint64_t UserAuthProxy::Auth(const uint64_t challenge, const AuthType authType, const AuthTurstLevel authTurstLevel,
129 sptr<IUserAuthCallback> &callback)
130 {
131 USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthProxy Auth start");
132 const uint64_t invalidContextID = 0;
133 uint64_t result = invalidContextID;
134 MessageParcel data;
135 MessageParcel reply;
136 MessageOption option(MessageOption::TF_SYNC);
137
138 if (!data.WriteInterfaceToken(UserAuthProxy::GetDescriptor())) {
139 USERAUTH_HILOGE(MODULE_INNERKIT, "write descriptor failed");
140 return invalidContextID;
141 }
142 USERAUTH_HILOGE(MODULE_SERVICE, "UserAuthProxy::Auth challenge = %{public}04" PRIx64 "", challenge);
143 if (!data.WriteUint64(challenge)) {
144 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write challenge");
145 return invalidContextID;
146 }
147 if (!data.WriteUint32(static_cast<uint32_t>(authType))) {
148 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write authType");
149 return invalidContextID;
150 }
151 if (!data.WriteUint32(static_cast<uint32_t>(authTurstLevel))) {
152 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write authTurstLevel");
153 return invalidContextID;
154 }
155 if (!data.WriteRemoteObject(callback->AsObject())) {
156 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write callback");
157 return invalidContextID;
158 }
159 bool ret = SendRequest(IUserAuth::USER_AUTH_AUTH, data, reply, option);
160 if (!ret) {
161 USERAUTH_HILOGE(MODULE_INNERKIT, "SendRequest failed");
162 return invalidContextID;
163 }
164 if (!reply.ReadUint64(result)) {
165 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to read result");
166 }
167
168 return result;
169 }
170
AuthUser(const int32_t userId,const uint64_t challenge,const AuthType authType,const AuthTurstLevel authTurstLevel,sptr<IUserAuthCallback> & callback)171 uint64_t UserAuthProxy::AuthUser(const int32_t userId, const uint64_t challenge, const AuthType authType,
172 const AuthTurstLevel authTurstLevel, sptr<IUserAuthCallback> &callback)
173 {
174 USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthProxy AuthUser start");
175 const uint64_t invalidContextID = 0;
176 uint64_t result = invalidContextID;
177 MessageParcel data;
178 MessageParcel reply;
179 MessageOption option(MessageOption::TF_SYNC);
180
181 if (!data.WriteInterfaceToken(UserAuthProxy::GetDescriptor())) {
182 USERAUTH_HILOGE(MODULE_INNERKIT, "write descriptor failed");
183 return invalidContextID;
184 }
185 if (!data.WriteInt32(userId)) {
186 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write userId");
187 return invalidContextID;
188 }
189 if (!data.WriteUint64(challenge)) {
190 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write challenge");
191 return invalidContextID;
192 }
193 if (!data.WriteUint32(static_cast<uint32_t>(authType))) {
194 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write authType");
195 return invalidContextID;
196 }
197 if (!data.WriteUint32(static_cast<uint32_t>(authTurstLevel))) {
198 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write authTurstLevel");
199 return invalidContextID;
200 }
201 if (!data.WriteRemoteObject(callback->AsObject())) {
202 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write callback");
203 return invalidContextID;
204 }
205 bool ret = SendRequest(IUserAuth::USER_AUTH_AUTH_USER, data, reply, option);
206 if (!ret) {
207 USERAUTH_HILOGE(MODULE_INNERKIT, "SendRequest failed");
208 return invalidContextID;
209 }
210 if (!reply.ReadUint64(result)) {
211 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to read result");
212 }
213
214 return result;
215 }
216
CancelAuth(const uint64_t contextId)217 int32_t UserAuthProxy::CancelAuth(const uint64_t contextId)
218 {
219 USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthProxy CancelAuth start");
220 int32_t result = GENERAL_ERROR;
221 MessageParcel data;
222 MessageParcel reply;
223 MessageOption option(MessageOption::TF_SYNC);
224
225 if (!data.WriteInterfaceToken(UserAuthProxy::GetDescriptor())) {
226 USERAUTH_HILOGE(MODULE_INNERKIT, "write descriptor failed");
227 return E_WRITE_PARCEL_ERROR;
228 }
229 if (!data.WriteUint64(contextId)) {
230 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to write contextId");
231 return E_WRITE_PARCEL_ERROR;
232 }
233 bool ret = SendRequest(IUserAuth::USER_AUTH_CANCEL_AUTH, data, reply, option);
234 if (!ret) {
235 USERAUTH_HILOGE(MODULE_INNERKIT, "SendRequest failed");
236 return IPC_ERROR;
237 }
238 if (!reply.ReadInt32(result)) {
239 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to read result");
240 }
241
242 return result;
243 }
244
GetVersion()245 int32_t UserAuthProxy::GetVersion()
246 {
247 USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthProxy GetVersion start");
248 int32_t result = GENERAL_ERROR;
249 MessageParcel data;
250 MessageParcel reply;
251 MessageOption option(MessageOption::TF_SYNC);
252
253 if (!data.WriteInterfaceToken(UserAuthProxy::GetDescriptor())) {
254 USERAUTH_HILOGE(MODULE_INNERKIT, "write descriptor failed");
255 return result;
256 }
257
258 bool ret = SendRequest(IUserAuth::USER_AUTH_GET_VERSION, data, reply, option);
259 if (!ret) {
260 USERAUTH_HILOGE(MODULE_INNERKIT, "SendRequest failed");
261 return IPC_ERROR;
262 }
263 if (!reply.ReadInt32(result)) {
264 USERAUTH_HILOGE(MODULE_INNERKIT, "failed to read result");
265 }
266
267 return result;
268 }
269
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption option)270 bool UserAuthProxy::SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption option)
271 {
272 USERAUTH_HILOGD(MODULE_INNERKIT, "UserAuthProxy SendRequest start");
273 sptr<IRemoteObject> remote = Remote();
274 if (remote == nullptr) {
275 return false;
276 }
277
278 int32_t result = remote->SendRequest(code, data, reply, option);
279 if (result != OHOS::UserIAM::UserAuth::SUCCESS) {
280 USERAUTH_HILOGE(MODULE_INNERKIT, "UserAuthProxy SendRequest failed");
281 return false;
282 }
283 return true;
284 }
285 } // namespace UserAuth
286 } // namespace UserIAM
287 } // namespace OHOS
288