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_hotspot_iface.h"
17 #include <stddef.h>
18 #include "client.h"
19 #include "context.h"
20 #include "i_wifi_public_func.h"
21 #include "serial.h"
22 #include "wifi_idl_inner_interface.h"
23 #include "wifi_log.h"
24 #include "wifi_native_define.h"
25 
26 #undef LOG_TAG
27 #define LOG_TAG "WifiIdlHotspotIface"
28 
29 #define AP_EVENT_MAX_NUM 8
30 
31 static IWifiApEventCallback g_wifiApEventCallback[AP_INSTANCE_MAX_NUM];
SetWifiApEventCallback(IWifiApEventCallback callback,int id)32 void SetWifiApEventCallback(IWifiApEventCallback callback, int id)
33 {
34     if ((id >= AP_INSTANCE_MAX_NUM) || (id < 0)) {
35         LOGE("SetWifiApEventCallback error");
36         return;
37     }
38     g_wifiApEventCallback[id] = callback;
39 }
40 
GetWifiApEventCallback(int id)41 IWifiApEventCallback *GetWifiApEventCallback(int id)
42 {
43     if ((id >= AP_INSTANCE_MAX_NUM) || (id < 0)) {
44         LOGE("GetWifiApEventCallback error");
45         return NULL;
46     }
47     return &g_wifiApEventCallback[id];
48 }
49 
StartSoftAp(int id,const char * ifaceName)50 WifiErrorNo StartSoftAp(int id, const char *ifaceName)
51 {
52     RpcClient *client = GetApRpcClient();
53     LockRpcClient(client);
54     Context *context = client->context;
55     WriteBegin(context, 0);
56     WriteFunc(context, "StartSoftAp");
57     WriteInt(context, id);
58     WriteStr(context, ifaceName);
59     WriteEnd(context);
60 
61     if (RpcClientCall(client, "StartSoftAp") != WIFI_HAL_OPT_OK) {
62         return WIFI_HAL_OPT_FAILED;
63     }
64 
65     int result = WIFI_HAL_OPT_FAILED;
66     ReadInt(context, &result);
67     ReadClientEnd(client);
68     UnlockRpcClient(client);
69     return result;
70 }
71 
StopSoftAp(int id)72 WifiErrorNo StopSoftAp(int id)
73 {
74     RpcClient *client = GetApRpcClient();
75     LockRpcClient(client);
76     Context *context = client->context;
77     WriteBegin(context, 0);
78     WriteFunc(context, "StopSoftAp");
79     WriteInt(context, id);
80     WriteEnd(context);
81 
82     if (RpcClientCall(client, "StopSoftAp") != WIFI_HAL_OPT_OK) {
83         return WIFI_HAL_OPT_FAILED;
84     }
85 
86     int result = WIFI_HAL_OPT_FAILED;
87     ReadInt(context, &result);
88     ReadClientEnd(client);
89     UnlockRpcClient(client);
90     return result;
91 }
92 
SetHostapdConfig(HostapdConfig * config,int id)93 WifiErrorNo SetHostapdConfig(HostapdConfig *config, int id)
94 {
95     RpcClient *client = GetApRpcClient();
96     LockRpcClient(client);
97     Context *context = client->context;
98     WriteBegin(context, 0);
99     WriteFunc(context, "SetHostapdConfig");
100     WriteStr(context, config->ssid);
101     WriteInt(context, config->ssidLen);
102     WriteStr(context, config->preSharedKey);
103     WriteInt(context, config->preSharedKeyLen);
104     WriteInt(context, config->securityType);
105     WriteInt(context, config->band);
106     WriteInt(context, config->channel);
107     WriteInt(context, config->maxConn);
108     WriteInt(context, id);
109     WriteEnd(context);
110     if (RpcClientCall(client, "SetHostapdConfig") != WIFI_HAL_OPT_OK) {
111         return WIFI_HAL_OPT_FAILED;
112     }
113     int result = WIFI_HAL_OPT_FAILED;
114     ReadInt(context, &result);
115     ReadClientEnd(client);
116     UnlockRpcClient(client);
117     return result;
118 }
119 
GetStaInfos(char * infos,int32_t * size,int id)120 WifiErrorNo GetStaInfos(char *infos, int32_t *size, int id)
121 {
122     RpcClient *client = GetApRpcClient();
123     LockRpcClient(client);
124     Context *context = client->context;
125     WriteBegin(context, 0);
126     WriteFunc(context, "GetStaInfos");
127     WriteInt(context, *size);
128     WriteInt(context, id);
129     WriteEnd(context);
130     if (RpcClientCall(client, "GetStaInfos") != WIFI_HAL_OPT_OK) {
131         return WIFI_HAL_OPT_FAILED;
132     }
133     int result = WIFI_HAL_OPT_FAILED;
134     ReadInt(context, &result);
135     if (result != WIFI_HAL_OPT_OK) {
136         LOGE("server GetStaInfos deal failed!");
137     } else {
138         ReadInt(context, size);
139         ReadStr(context, infos, *size);
140     }
141     ReadClientEnd(client);
142     UnlockRpcClient(client);
143     return result;
144 }
145 
SetMacFilter(unsigned char * mac,int lenMac,int id)146 WifiErrorNo SetMacFilter(unsigned char *mac, int lenMac, int id)
147 {
148     RpcClient *client = GetApRpcClient();
149     LockRpcClient(client);
150     Context *context = client->context;
151     WriteBegin(context, 0);
152     WriteFunc(context, "SetMacFilter");
153     WriteInt(context, lenMac);
154     WriteUStr(context, mac, lenMac);
155     WriteInt(context, id);
156     WriteEnd(context);
157     if (RpcClientCall(client, "SetMacFilter") != WIFI_HAL_OPT_OK) {
158         return WIFI_HAL_OPT_FAILED;
159     }
160     int result = WIFI_HAL_OPT_FAILED;
161     ReadInt(context, &result);
162     ReadClientEnd(client);
163     UnlockRpcClient(client);
164     return result;
165 }
166 
DelMacFilter(unsigned char * mac,int lenMac,int id)167 WifiErrorNo DelMacFilter(unsigned char *mac, int lenMac, int id)
168 {
169     RpcClient *client = GetApRpcClient();
170     LockRpcClient(client);
171     Context *context = client->context;
172     WriteBegin(context, 0);
173     WriteFunc(context, "DelMacFilter");
174     WriteInt(context, lenMac);
175     WriteUStr(context, mac, lenMac);
176     WriteInt(context, id);
177     WriteEnd(context);
178     if (RpcClientCall(client, "DelMacFilter") != WIFI_HAL_OPT_OK) {
179         return WIFI_HAL_OPT_FAILED;
180     }
181     int result = WIFI_HAL_OPT_FAILED;
182     ReadInt(context, &result);
183     ReadClientEnd(client);
184     UnlockRpcClient(client);
185     return result;
186 }
187 
DisassociateSta(unsigned char * mac,int lenMac,int id)188 WifiErrorNo DisassociateSta(unsigned char *mac, int lenMac, int id)
189 {
190     RpcClient *client = GetApRpcClient();
191     LockRpcClient(client);
192     Context *context = client->context;
193     WriteBegin(context, 0);
194     WriteFunc(context, "DisassociateSta");
195     WriteInt(context, lenMac);
196     WriteUStr(context, mac, lenMac);
197     WriteInt(context, id);
198     WriteEnd(context);
199     if (RpcClientCall(client, "DisassociateSta") != WIFI_HAL_OPT_OK) {
200         return WIFI_HAL_OPT_FAILED;
201     }
202     int result = WIFI_HAL_OPT_FAILED;
203     ReadInt(context, &result);
204     ReadClientEnd(client);
205     UnlockRpcClient(client);
206     return result;
207 }
208 
GetValidFrequenciesForBand(int32_t band,int * frequencies,int32_t * size,int id)209 WifiErrorNo GetValidFrequenciesForBand(int32_t band, int *frequencies, int32_t *size, int id)
210 {
211     RpcClient *client = GetApRpcClient();
212     LockRpcClient(client);
213     Context *context = client->context;
214     WriteBegin(context, 0);
215     WriteFunc(context, "GetValidFrequenciesForBand");
216     WriteInt(context, band);
217     WriteInt(context, *size);
218     WriteInt(context, id);
219     WriteEnd(context);
220     if (RpcClientCall(client, "GetValidFrequenciesForBand") != WIFI_HAL_OPT_OK) {
221         return WIFI_HAL_OPT_FAILED;
222     }
223     int result = WIFI_HAL_OPT_FAILED;
224     ReadInt(context, &result);
225     if (result != WIFI_HAL_OPT_OK) {
226         LOGE("server GetValidFrequenciesForBand deal failed!");
227     } else {
228         ReadInt(context, size);
229         for (int i = 0; i < *size; ++i) {
230             ReadInt(context, frequencies + i);
231         }
232     }
233     ReadClientEnd(client);
234     UnlockRpcClient(client);
235     return result;
236 }
237 
SetCountryCode(const char * code,int id)238 WifiErrorNo SetCountryCode(const char *code, int id)
239 {
240     RpcClient *client = GetApRpcClient();
241     LockRpcClient(client);
242     Context *context = client->context;
243     WriteBegin(context, 0);
244     WriteFunc(context, "SetCountryCode");
245     WriteStr(context, code);
246     WriteInt(context, id);
247     WriteEnd(context);
248     if (RpcClientCall(client, "SetCountryCode") != WIFI_HAL_OPT_OK) {
249         return WIFI_HAL_OPT_FAILED;
250     }
251     int result = WIFI_HAL_OPT_FAILED;
252     ReadInt(context, &result);
253     ReadClientEnd(client);
254     UnlockRpcClient(client);
255     return result;
256 }
257 
GetApCallbackEvents(int * events,int size)258 static int GetApCallbackEvents(int *events, int size)
259 {
260     int apEvents[] = {
261         HAL_CBK_CMD_STA_JOIN,
262         HAL_CBK_CMD_STA_LEAVE,
263         HAL_CBK_CMD_AP_ENABLE,
264         HAL_CBK_CMD_AP_DISABLE,
265         HAL_CBK_CMD_AP_STA_PSK_MISMATCH_EVENT
266     };
267     int max = sizeof(apEvents) / sizeof(apEvents[0]);
268     int num = 0;
269     for (; num < max && num < size; ++num) {
270         events[num] = apEvents[num];
271     }
272     return num;
273 }
274 
RegisterAsscociatedEvent(IWifiApEventCallback callback,int id)275 WifiErrorNo RegisterAsscociatedEvent(IWifiApEventCallback callback, int id)
276 {
277     int events[AP_EVENT_MAX_NUM];
278     int num = GetApCallbackEvents(events, AP_EVENT_MAX_NUM);
279     RpcClient *client = GetApRpcClient();
280     LockRpcClient(client);
281     Context *context = client->context;
282     WriteBegin(context, 0);
283     if (callback.onStaJoinOrLeave == NULL) {
284         WriteFunc(context, "UnRegisterEventCallback");
285     } else {
286         WriteFunc(context, "RegisterEventCallback");
287     }
288     WriteInt(context, num);
289     for (int i = 0; i < num; ++i) {
290         WriteInt(context, events[i]);
291     }
292     WriteEnd(context);
293     if (RpcClientCall(client, "RegisterAsscociatedEvent") != WIFI_HAL_OPT_OK) {
294         if (callback.onStaJoinOrLeave == NULL) {
295             SetWifiApEventCallback(callback, id);
296         }
297         return WIFI_HAL_OPT_FAILED;
298     }
299     int result = WIFI_HAL_OPT_FAILED;
300     ReadInt(context, &result);
301     if (result == WIFI_HAL_OPT_OK || callback.onStaJoinOrLeave == NULL) {
302         SetWifiApEventCallback(callback, id);
303     }
304     ReadClientEnd(client);
305     UnlockRpcClient(client);
306     return result;
307 }
308 
WpaSetPowerModel(const int model,int id)309 WifiErrorNo WpaSetPowerModel(const int model, int id)
310 {
311     RpcClient *client = GetSupplicantRpcClient();
312     LockRpcClient(client);
313     Context *context = client->context;
314     WriteBegin(context, 0);
315     WriteFunc(context, "WpaSetPowerModel");
316     WriteInt(context, model);
317     WriteInt(context, id);
318     WriteEnd(context);
319     if (RpcClientCall(client, "WpaSetPowerModel") != WIFI_HAL_OPT_OK) {
320         return WIFI_HAL_OPT_FAILED;
321     }
322     int result = WIFI_HAL_OPT_FAILED;
323     ReadInt(context, &result);
324     ReadClientEnd(client);
325     UnlockRpcClient(client);
326     return result;
327 }
328 
WpaGetPowerModel(int * model,int id)329 WifiErrorNo WpaGetPowerModel(int* model, int id)
330 {
331     RpcClient *client = GetSupplicantRpcClient();
332     LockRpcClient(client);
333     Context *context = client->context;
334     WriteBegin(context, 0);
335     WriteFunc(context, "WpaGetPowerModel");
336     WriteInt(context, id);
337     WriteEnd(context);
338     if (RpcClientCall(client, "WpaGetPowerModel") != WIFI_HAL_OPT_OK) {
339         return WIFI_HAL_OPT_FAILED;
340     }
341     int result = WIFI_HAL_OPT_FAILED;
342     ReadInt(context, &result);
343     if (result == WIFI_HAL_OPT_OK) {
344         ReadInt(context, model);
345     }
346     ReadClientEnd(client);
347     UnlockRpcClient(client);
348     return result;
349 }
350