1 /*
2  * Copyright (C) 2021-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 "i_wifi_supplicant_iface.h"
17 #include <stddef.h>
18 #include <sys/un.h>
19 #include "client.h"
20 #include "context.h"
21 #include "i_wifi_public_func.h"
22 #include "serial.h"
23 #include "wifi_idl_inner_interface.h"
24 #include "wifi_log.h"
25 #include "wifi_native_define.h"
26 
27 #undef LOG_TAG
28 #define LOG_TAG "WifiIdlSupplicantIface"
29 static ISupplicantEventCallback g_wifiSupplicantEventCallback = {0};
SetSupplicantEventCallback(ISupplicantEventCallback callback)30 void SetSupplicantEventCallback(ISupplicantEventCallback callback)
31 {
32     g_wifiSupplicantEventCallback = callback;
33 }
34 
GetSupplicantEventCallback(void)35 ISupplicantEventCallback *GetSupplicantEventCallback(void)
36 {
37     return &g_wifiSupplicantEventCallback;
38 }
39 
StartSupplicant(void)40 WifiErrorNo StartSupplicant(void)
41 {
42     RpcClient *client = GetSupplicantRpcClient();
43     LockRpcClient(client);
44     Context *context = client->context;
45     WriteBegin(context, 0);
46     WriteFunc(context, "StartSupplicant");
47     WriteEnd(context);
48     if (RpcClientCall(client, "StartSupplicant") != WIFI_HAL_OPT_OK) {
49         return WIFI_HAL_OPT_FAILED;
50     }
51     int result = WIFI_HAL_OPT_FAILED;
52     ReadInt(context, &result);
53     ReadClientEnd(client);
54     UnlockRpcClient(client);
55     return result;
56 }
57 
StopSupplicant(void)58 WifiErrorNo StopSupplicant(void)
59 {
60     RpcClient *client = GetSupplicantRpcClient();
61     LockRpcClient(client);
62     Context *context = client->context;
63     WriteBegin(context, 0);
64     WriteFunc(context, "StopSupplicant");
65     WriteEnd(context);
66     if (RpcClientCall(client, "StopSupplicant") != WIFI_HAL_OPT_OK) {
67         return WIFI_HAL_OPT_FAILED;
68     }
69     int result = WIFI_HAL_OPT_FAILED;
70     ReadInt(context, &result);
71     ReadClientEnd(client);
72     UnlockRpcClient(client);
73     return result;
74 }
75 
ConnectSupplicant(void)76 WifiErrorNo ConnectSupplicant(void)
77 {
78     RpcClient *client = GetSupplicantRpcClient();
79     LockRpcClient(client);
80     Context *context = client->context;
81     WriteBegin(context, 0);
82     WriteFunc(context, "ConnectSupplicant");
83     WriteEnd(context);
84     if (RpcClientCall(client, "ConnectSupplicant") != WIFI_HAL_OPT_OK) {
85         return WIFI_HAL_OPT_FAILED;
86     }
87     int result = WIFI_HAL_OPT_FAILED;
88     ReadInt(context, &result);
89     ReadClientEnd(client);
90     UnlockRpcClient(client);
91     return result;
92 }
93 
DisconnectSupplicant(void)94 WifiErrorNo DisconnectSupplicant(void)
95 {
96     RpcClient *client = GetSupplicantRpcClient();
97     LockRpcClient(client);
98     Context *context = client->context;
99     WriteBegin(context, 0);
100     WriteFunc(context, "DisconnectSupplicant");
101     WriteEnd(context);
102     if (RpcClientCall(client, "DisconnectSupplicant") != WIFI_HAL_OPT_OK) {
103         return WIFI_HAL_OPT_FAILED;
104     }
105     int result = WIFI_HAL_OPT_FAILED;
106     ReadInt(context, &result);
107     ReadClientEnd(client);
108     UnlockRpcClient(client);
109     return result;
110 }
111 
RequestToSupplicant(unsigned char * buf,int32_t bufSize)112 WifiErrorNo RequestToSupplicant(unsigned char *buf, int32_t bufSize)
113 {
114     RpcClient *client = GetSupplicantRpcClient();
115     LockRpcClient(client);
116     Context *context = client->context;
117     WriteBegin(context, 0);
118     WriteFunc(context, "RequestToSupplicant");
119     WriteInt(context, bufSize);
120     WriteUStr(context, buf, bufSize);
121     WriteEnd(context);
122     if (RpcClientCall(client, "RequestToSupplicant") != WIFI_HAL_OPT_OK) {
123         return WIFI_HAL_OPT_FAILED;
124     }
125     int result = WIFI_HAL_OPT_FAILED;
126     ReadInt(context, &result);
127     ReadClientEnd(client);
128     UnlockRpcClient(client);
129     return result;
130 }
131 
RegisterSupplicantEventCallback(ISupplicantEventCallback callback)132 WifiErrorNo RegisterSupplicantEventCallback(ISupplicantEventCallback callback)
133 {
134     int num = 0;
135     if (callback.onScanNotify != NULL) {
136         num += 1;
137     }
138     RpcClient *client = GetSupplicantRpcClient();
139     LockRpcClient(client);
140     Context *context = client->context;
141     WriteBegin(context, 0);
142     if (num == 0) { /* UnRegisterEventCallback */
143         WriteFunc(context, "UnRegisterEventCallback");
144         WriteInt(context, 1); /* ISupplicantEventCallback event num */
145         WriteInt(context, HAL_CBK_CMD_SCAN_INFO_NOTIFY);
146     } else {
147         WriteFunc(context, "RegisterEventCallback");
148         WriteInt(context, num);
149         if (callback.onScanNotify != NULL) {
150             WriteInt(context, HAL_CBK_CMD_SCAN_INFO_NOTIFY);
151         }
152     }
153     WriteEnd(context);
154     if (RpcClientCall(client, "RegisterSupplicantEventCallback") != WIFI_HAL_OPT_OK) {
155         if (num == 0) {
156             SetSupplicantEventCallback(callback);
157         }
158         return WIFI_HAL_OPT_FAILED;
159     }
160     int result = WIFI_HAL_OPT_FAILED;
161     ReadInt(context, &result);
162     if (result == WIFI_HAL_OPT_OK || num == 0) {
163         SetSupplicantEventCallback(callback);
164     }
165     ReadClientEnd(client);
166     UnlockRpcClient(client);
167     return result;
168 }
169 
Connect(int networkId)170 WifiErrorNo Connect(int networkId)
171 {
172     RpcClient *client = GetStaRpcClient();
173     LockRpcClient(client);
174     Context *context = client->context;
175     WriteBegin(context, 0);
176     WriteFunc(context, "Connect");
177     WriteInt(context, networkId);
178     WriteEnd(context);
179     if (RpcClientCall(client, "Connect") != WIFI_HAL_OPT_OK) {
180         return WIFI_HAL_OPT_FAILED;
181     }
182     int result = WIFI_HAL_OPT_FAILED;
183     ReadInt(context, &result);
184     ReadClientEnd(client);
185     UnlockRpcClient(client);
186     return result;
187 }
188 
Reconnect(void)189 WifiErrorNo Reconnect(void)
190 {
191     RpcClient *client = GetStaRpcClient();
192     LockRpcClient(client);
193     Context *context = client->context;
194     WriteBegin(context, 0);
195     WriteFunc(context, "Reconnect");
196     WriteEnd(context);
197     if (RpcClientCall(client, "Reconnect") != WIFI_HAL_OPT_OK) {
198         return WIFI_HAL_OPT_FAILED;
199     }
200     int result = WIFI_HAL_OPT_FAILED;
201     ReadInt(context, &result);
202     ReadClientEnd(client);
203     UnlockRpcClient(client);
204     return result;
205 }
206 
Reassociate(void)207 WifiErrorNo Reassociate(void)
208 {
209     RpcClient *client = GetStaRpcClient();
210     LockRpcClient(client);
211     Context *context = client->context;
212     WriteBegin(context, 0);
213     WriteFunc(context, "Reassociate");
214     WriteEnd(context);
215     if (RpcClientCall(client, "Reassociate") != WIFI_HAL_OPT_OK) {
216         return WIFI_HAL_OPT_FAILED;
217     }
218     int result = WIFI_HAL_OPT_FAILED;
219     ReadInt(context, &result);
220     ReadClientEnd(client);
221     UnlockRpcClient(client);
222     return result;
223 }
224 
Disconnect(void)225 WifiErrorNo Disconnect(void)
226 {
227     RpcClient *client = GetStaRpcClient();
228     LockRpcClient(client);
229     Context *context = client->context;
230     WriteBegin(context, 0);
231     WriteFunc(context, "Disconnect");
232     WriteEnd(context);
233     if (RpcClientCall(client, "Disconnect") != WIFI_HAL_OPT_OK) {
234         return WIFI_HAL_OPT_FAILED;
235     }
236     int result = WIFI_HAL_OPT_FAILED;
237     ReadInt(context, &result);
238     ReadClientEnd(client);
239     UnlockRpcClient(client);
240     return result;
241 }
242 
SetPowerSave(int enable)243 WifiErrorNo SetPowerSave(int enable)
244 {
245     RpcClient *client = GetSupplicantRpcClient();
246     LockRpcClient(client);
247     Context *context = client->context;
248     WriteBegin(context, 0);
249     WriteFunc(context, "SetPowerSave");
250     WriteInt(context, (int)enable);
251     WriteEnd(context);
252     if (RpcClientCall(client, "SetPowerSave") != WIFI_HAL_OPT_OK) {
253         return WIFI_HAL_OPT_FAILED;
254     }
255     int result = WIFI_HAL_OPT_FAILED;
256     ReadInt(context, &result);
257     ReadClientEnd(client);
258     UnlockRpcClient(client);
259     return result;
260 }
261 
WpaSetCountryCode(const char * countryCode)262 WifiErrorNo WpaSetCountryCode(const char *countryCode)
263 {
264     RpcClient *client = GetSupplicantRpcClient();
265     LockRpcClient(client);
266     Context *context = client->context;
267     WriteBegin(context, 0);
268     WriteFunc(context, "WpaSetCountryCode");
269     WriteStr(context, countryCode);
270     WriteEnd(context);
271     if (RpcClientCall(client, "WpaSetCountryCode") != WIFI_HAL_OPT_OK) {
272         return WIFI_HAL_OPT_FAILED;
273     }
274     int result = WIFI_HAL_OPT_FAILED;
275     ReadInt(context, &result);
276     ReadClientEnd(client);
277     UnlockRpcClient(client);
278     return result;
279 }
280 
WpaGetCountryCode(char * countryCode,int codeSize)281 WifiErrorNo WpaGetCountryCode(char *countryCode, int codeSize)
282 {
283     RpcClient *client = GetSupplicantRpcClient();
284     LockRpcClient(client);
285     Context *context = client->context;
286     WriteBegin(context, 0);
287     WriteFunc(context, "WpaGetCountryCode");
288     WriteEnd(context);
289     if (RpcClientCall(client, "WpaGetCountryCode") != WIFI_HAL_OPT_OK) {
290         return WIFI_HAL_OPT_FAILED;
291     }
292     int result = WIFI_HAL_OPT_FAILED;
293     ReadInt(context, &result);
294     if (result == WIFI_HAL_OPT_OK) {
295         ReadStr(context, countryCode, codeSize);
296     }
297     ReadClientEnd(client);
298     UnlockRpcClient(client);
299     if (strlen(countryCode) <= 0) {
300         return WIFI_HAL_OPT_FAILED;
301     }
302     return result;
303 }
304