1 /*
2 * Copyright (c) 2023 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 #include "wpa_common_cmd.h"
16 #include "wpa_p2p_cmd.h"
17 #include <securec.h>
18 #include <hdf_base.h>
19 #include <hdf_log.h>
20 #include <osal_time.h>
21 #include <osal_mem.h>
22 #include <arpa/inet.h>
23 #include "utils/common.h"
24 #include "wpa_supplicant_i.h"
25 #include "main.h"
26 #include "wps_supplicant.h"
27 #include "p2p_supplicant.h"
28 #include "ctrl_iface.h"
29 #include "wpa_magiclink.h"
30 #include "wifi_display.h"
31 #include "bssid_ignore.h"
32 #include "config.h"
33
34 #include "v1_0/iwpa_callback.h"
35 #include "v1_0/iwpa_interface.h"
36
37 #define HEX_TO_DEC_MOVING 4
38 #define DEC_MAX_SCOPE 10
39
40 struct HdiWpaKeyValue {
41 char key[CMD_SIZE];
42 char value[CMD_SIZE];
43 };
44
IsNull(const char * ifName,const struct wpa_supplicant * wpaSupp)45 int32_t IsNull(const char *ifName, const struct wpa_supplicant *wpaSupp)
46 {
47 if (ifName == NULL) {
48 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
49 return HDF_ERR_INVALID_PARAM;
50 }
51
52 if (!wpaSupp) {
53 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
54 return HDF_FAILURE;
55 }
56 return 0;
57 }
58
Hex2Dec(const char * str)59 int Hex2Dec(const char *str)
60 {
61 if (str == NULL || strncasecmp(str, "0x", strlen("0x")) != 0) {
62 return 0;
63 }
64 uint32_t result = 0;
65 const char *tmp = str + strlen("0x");
66 while (*tmp != '\0') {
67 result <<= HEX_TO_DEC_MOVING;
68 if (*tmp >= '0' && *tmp <= '9') {
69 result += *tmp - '0';
70 } else if (*tmp >= 'A' && *tmp <= 'F') {
71 result += *tmp - 'A' + DEC_MAX_SCOPE;
72 } else if (*tmp >= 'a' && *tmp <= 'f') {
73 result += *tmp - 'a' + DEC_MAX_SCOPE;
74 } else {
75 result = 0;
76 break;
77 }
78 ++tmp;
79 }
80 return result;
81 }
82
GetStrKeyVal(char * src,const char * split,struct HdiWpaKeyValue * out)83 void GetStrKeyVal(char *src, const char *split, struct HdiWpaKeyValue *out)
84 {
85 if (src == NULL || split == NULL || out == NULL) {
86 return;
87 }
88 char *p = strstr(src, split);
89 if (p == NULL) {
90 StrSafeCopy(out->key, sizeof(out->key), src);
91 return;
92 }
93 *p = '\0';
94 StrSafeCopy(out->key, sizeof(out->key), src);
95 p += strlen(split);
96 StrSafeCopy(out->value, sizeof(out->value), p);
97 return;
98 }
99
GetHalNetworkInfos(char * buf,struct HdiP2pNetworkInfo * info)100 void GetHalNetworkInfos(char *buf, struct HdiP2pNetworkInfo *info)
101 {
102 if (buf == NULL || info == NULL) {
103 return;
104 }
105 int len = strlen(buf);
106 int start = 0;
107 int end = 0;
108 int i = 0;
109 const int count = 2;
110 while (end < len) {
111 if (buf[end] != '\t') {
112 ++end;
113 continue;
114 }
115 buf[end] = '\0';
116 if (i == 0) {
117 info->id = atoi(buf);
118 } else if (i == 1) {
119 if (strcpy_s((char *)info->ssid, WIFI_SSID_LENGTH + 1, buf + start) != EOK) {
120 break;
121 }
122 printf_decode((u8 *)info->ssid, WIFI_SSID_LENGTH + 1, (char *)info->ssid);
123 } else if (i == count) {
124 uint8_t tmpBssid[ETH_ADDR_LEN] = {0};
125 hwaddr_aton(buf + start, tmpBssid);
126 if (strcpy_s((char *)info->bssid, ETH_ADDR_LEN + 1, (char *)tmpBssid) != EOK) {
127 break;
128 }
129 start = end + 1;
130 if (strcpy_s((char *)info->flags, WIFI_NETWORK_FLAGS_LENGTH + 1, buf + start) != EOK) {
131 break;
132 }
133 break;
134 }
135 ++i;
136 end++;
137 start = end;
138 }
139 return;
140 }
141
WpaInterfaceP2pSetSsidPostfixName(struct IWpaInterface * self,const char * ifName,const char * name)142 int32_t WpaInterfaceP2pSetSsidPostfixName(struct IWpaInterface *self, const char *ifName, const char *name)
143 {
144 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
145 struct wpa_supplicant *wpaSupp;
146 char cmd[CMD_SIZE];
147
148 int32_t ret = 0;
149 (void)self;
150 if (ifName == NULL || name == NULL) {
151 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
152 return HDF_ERR_INVALID_PARAM;
153 }
154 wpaSupp = getWpaP2p();
155 if (!wpaSupp) {
156 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
157 return HDF_FAILURE;
158 }
159
160 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "ssid_postfix %s", name);
161 if (ret < 0) {
162 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
163 return HDF_FAILURE;
164 }
165
166 ret = p2p_ctrl_set(wpaSupp, cmd);
167 if (ret < 0) {
168 HDF_LOGE("%{public}s P2pSetSsidPostfixName fail! ret=%d", __func__, ret);
169 return HDF_FAILURE;
170 }
171 HDF_LOGI("%{public}s success", __func__);
172 return HDF_SUCCESS;
173 }
174
WpaInterfaceP2pSetWpsDeviceType(struct IWpaInterface * self,const char * ifName,const char * type)175 int32_t WpaInterfaceP2pSetWpsDeviceType(struct IWpaInterface *self, const char *ifName, const char *type)
176 {
177 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
178 struct wpa_supplicant *wpaSupp;
179 char cmd[CMD_SIZE];
180
181 int32_t ret = 0;
182 (void)self;
183 if (ifName == NULL || type == NULL) {
184 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
185 return HDF_ERR_INVALID_PARAM;
186 }
187
188 wpaSupp = getWpaP2p();
189 if (!wpaSupp) {
190 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
191 return HDF_FAILURE;
192 }
193
194 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "device_type %s", type);
195 if (ret < 0) {
196 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
197 return HDF_FAILURE;
198 }
199
200 ret = wpa_supplicant_ctrl_iface_set(wpaSupp, cmd);
201 if (ret < 0) {
202 HDF_LOGE("%{public}s P2pSetWpsDeviceType fail! ret=%d", __func__, ret);
203 return HDF_FAILURE;
204 }
205 HDF_LOGI("%{public}s success", __func__);
206 return HDF_SUCCESS;
207 }
208
WpaInterfaceP2pSetWpsConfigMethods(struct IWpaInterface * self,const char * ifName,const char * methods)209 int32_t WpaInterfaceP2pSetWpsConfigMethods(struct IWpaInterface *self, const char *ifName, const char *methods)
210 {
211 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
212 struct wpa_supplicant *wpaSupp;
213 char cmd[CMD_SIZE];
214
215 int32_t ret = 0;
216 (void)self;
217 if (ifName == NULL || methods == NULL) {
218 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
219 return HDF_ERR_INVALID_PARAM;
220 }
221
222 wpaSupp = getWpaP2p();
223 if (!wpaSupp) {
224 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
225 return HDF_FAILURE;
226 }
227
228 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "config_methods %s", methods);
229 if (ret < 0) {
230 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
231 return HDF_FAILURE;
232 }
233
234 ret = wpa_supplicant_ctrl_iface_set(wpaSupp, cmd);
235 if (ret < 0) {
236 HDF_LOGE("%{public}s P2pSetWpsConfigMethods fail! ret=%d", __func__, ret);
237 return HDF_FAILURE;
238 }
239 HDF_LOGI("%{public}s success", __func__);
240 return HDF_SUCCESS;
241 }
242
WpaInterfaceP2pSetGroupMaxIdle(struct IWpaInterface * self,const char * ifName,int32_t time)243 int32_t WpaInterfaceP2pSetGroupMaxIdle(struct IWpaInterface *self, const char *ifName, int32_t time)
244 {
245 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
246 struct wpa_supplicant *wpaSupp;
247 char cmd[CMD_SIZE];
248
249 int32_t ret = 0;
250 (void)self;
251 wpaSupp = getWpaP2p();
252 ret = IsNull(ifName, wpaSupp);
253 if (ret < 0) {
254 return ret;
255 }
256
257 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "p2p_group_idle %d", time);
258 if (ret < 0) {
259 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
260 return HDF_FAILURE;
261 }
262
263 ret = wpa_supplicant_ctrl_iface_set(wpaSupp, cmd);
264 if (ret < 0) {
265 HDF_LOGE("%{public}s P2pSetGroupMaxIdle fail! ret=%d", __func__, ret);
266 return HDF_FAILURE;
267 }
268 HDF_LOGI("%{public}s success", __func__);
269 return HDF_SUCCESS;
270 }
271
WpaInterfaceP2pSetWfdEnable(struct IWpaInterface * self,const char * ifName,int32_t enable)272 int32_t WpaInterfaceP2pSetWfdEnable(struct IWpaInterface *self, const char *ifName, int32_t enable)
273 {
274 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
275 struct wpa_supplicant *wpaSupp;
276 char cmd[CMD_SIZE];
277
278 int32_t ret = 0;
279 (void)self;
280 wpaSupp = getWpaP2p();
281 ret = IsNull(ifName, wpaSupp);
282 if (ret < 0) {
283 return ret;
284 }
285
286 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "wifi_display %d", enable);
287 if (ret < 0) {
288 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
289 return HDF_FAILURE;
290 }
291
292 ret = wpa_supplicant_ctrl_iface_set(wpaSupp, cmd);
293 if (ret < 0) {
294 HDF_LOGE("%{public}s P2pSetWfdEnable fail! ret=%d", __func__, ret);
295 return HDF_FAILURE;
296 }
297 HDF_LOGI("%{public}s success", __func__);
298 return HDF_SUCCESS;
299 }
300
WpaInterfaceP2pSetPersistentReconnect(struct IWpaInterface * self,const char * ifName,int32_t status)301 int32_t WpaInterfaceP2pSetPersistentReconnect(struct IWpaInterface *self, const char *ifName, int32_t status)
302 {
303 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
304 struct wpa_supplicant *wpaSupp;
305 char cmd[CMD_SIZE];
306
307 int32_t ret = 0;
308 (void)self;
309 wpaSupp = getWpaP2p();
310 ret = IsNull(ifName, wpaSupp);
311 if (ret < 0) {
312 return ret;
313 }
314
315 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "persistent_reconnect %d", status);
316 if (ret < 0) {
317 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
318 return HDF_FAILURE;
319 }
320
321 ret = wpa_supplicant_ctrl_iface_set(wpaSupp, cmd);
322 if (ret < 0) {
323 HDF_LOGE("%{public}s P2pSetPersistentReconnect fail! ret=%d", __func__, ret);
324 return HDF_FAILURE;
325 }
326 HDF_LOGI("%{public}s success", __func__);
327 return HDF_SUCCESS;
328 }
329
330
WpaInterfaceP2pSetWpsSecondaryDeviceType(struct IWpaInterface * self,const char * ifName,const char * type)331 int32_t WpaInterfaceP2pSetWpsSecondaryDeviceType(struct IWpaInterface *self, const char *ifName, const char *type)
332 {
333 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
334 struct wpa_supplicant *wpaSupp;
335 char cmd[CMD_SIZE];
336
337 int32_t ret = 0;
338 (void)self;
339 if (ifName == NULL || type == NULL) {
340 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
341 return HDF_ERR_INVALID_PARAM;
342 }
343
344 wpaSupp = getWpaP2p();
345 if (!wpaSupp) {
346 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
347 return HDF_FAILURE;
348 }
349
350 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "sec_device_type %s", type);
351 if (ret < EOK) {
352 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, ret = %{public}d", __func__, cmd, ret);
353 return HDF_FAILURE;
354 }
355 ret = wpa_supplicant_ctrl_iface_set(wpaSupp, cmd);
356 if (ret < 0) {
357 HDF_LOGE("%{public}s P2pSetWpsSecondaryDeviceType fail! ret=%d", __func__, ret);
358 return HDF_FAILURE;
359 }
360 HDF_LOGI("%{public}s success", __func__);
361 return HDF_SUCCESS;
362 }
363
WpaInterfaceP2pSetupWpsPbc(struct IWpaInterface * self,const char * ifName,const char * address)364 int32_t WpaInterfaceP2pSetupWpsPbc(struct IWpaInterface *self, const char *ifName, const char *address)
365 {
366 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
367 struct wpa_supplicant *wpaSupp;
368 char cmd[CMD_SIZE];
369
370 int32_t ret = 0;
371 (void)self;
372 if (ifName == NULL || address == NULL) {
373 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
374 return HDF_ERR_INVALID_PARAM;
375 }
376
377 wpaSupp = getWpaP2p();
378 if (!wpaSupp) {
379 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
380 return HDF_FAILURE;
381 }
382
383 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%s", address);
384 if (ret < 0) {
385 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
386 return HDF_FAILURE;
387 }
388
389 ret = wpa_supplicant_ctrl_iface_wps_pbc(wpaSupp, cmd);
390 if (ret < 0) {
391 HDF_LOGE("%{public}s P2pSetupWpsPbc fail! ret=%d", __func__, ret);
392 return HDF_FAILURE;
393 }
394 HDF_LOGI("%{public}s success", __func__);
395 return HDF_SUCCESS;
396 }
397
WpaInterfaceP2pSetupWpsPin(struct IWpaInterface * self,const char * ifName,const char * address,const char * pin,char * result,uint32_t resultLen)398 int32_t WpaInterfaceP2pSetupWpsPin(struct IWpaInterface *self, const char *ifName, const char *address,
399 const char *pin, char *result, uint32_t resultLen)
400 {
401 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
402 struct wpa_supplicant *wpaSupp;
403 char cmd[CMD_SIZE];
404
405 int32_t ret = 0;
406 (void)self;
407 if (ifName == NULL || result == NULL) {
408 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
409 return HDF_ERR_INVALID_PARAM;
410 }
411
412 wpaSupp = getWpaP2p();
413 if (!wpaSupp) {
414 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
415 return HDF_FAILURE;
416 }
417
418 if (strlen(pin) > 0) {
419 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "any %s", pin);
420 } else if (strlen(address) == 0) {
421 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "any");
422 } else {
423 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%s", address);
424 }
425 if (ret < EOK) {
426 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, ret = %{public}d", __func__, cmd, ret);
427 return HDF_FAILURE;
428 }
429 ret = wpa_supplicant_ctrl_iface_wps_pin(wpaSupp, cmd, result, resultLen);
430 strcpy_s(result, resultLen, "test result");
431 if (ret < 0) {
432 HDF_LOGE("%{public}s P2pSetupWpsPin fail! ret=%d", __func__, ret);
433 return HDF_FAILURE;
434 }
435 HDF_LOGI("%{public}s success", __func__);
436 return HDF_SUCCESS;
437 }
438
WpaInterfaceP2pSetPowerSave(struct IWpaInterface * self,const char * ifName,int32_t enable)439 int32_t WpaInterfaceP2pSetPowerSave(struct IWpaInterface *self, const char *ifName, int32_t enable)
440 {
441 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
442 struct wpa_supplicant *wpaSupp;
443 char cmd[CMD_SIZE];
444
445 int32_t ret = 0;
446 (void)self;
447 wpaSupp = getWpaP2p();
448 ret = IsNull(ifName, wpaSupp);
449 if (ret < 0) {
450 return ret;
451 }
452
453 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "ps %d", enable);
454 if (ret < 0) {
455 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
456 return HDF_FAILURE;
457 }
458
459 ret = p2p_ctrl_set(wpaSupp, cmd);
460 if (ret < 0) {
461 HDF_LOGE("%{public}s P2pSetPowerSave fail! ret=%d", __func__, ret);
462 return HDF_FAILURE;
463 }
464 HDF_LOGI("%{public}s success", __func__);
465 return HDF_SUCCESS;
466 }
467
468
WpaInterfaceP2pSetDeviceName(struct IWpaInterface * self,const char * ifName,const char * name)469 int32_t WpaInterfaceP2pSetDeviceName(struct IWpaInterface *self, const char *ifName, const char *name)
470 {
471 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
472 struct wpa_supplicant *wpaSupp;
473 char cmd[CMD_SIZE];
474
475 int32_t ret = 0;
476 (void)self;
477 if (ifName == NULL || name == NULL) {
478 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
479 return HDF_ERR_INVALID_PARAM;
480 }
481
482 wpaSupp = getWpaP2p();
483 if (!wpaSupp) {
484 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
485 return HDF_FAILURE;
486 }
487
488 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "device_name %s", name);
489 if (ret < 0) {
490 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
491 return HDF_FAILURE;
492 }
493
494 ret = wpa_supplicant_ctrl_iface_set(wpaSupp, cmd);
495 if (ret < 0) {
496 HDF_LOGE("%{public}s P2pSetDeviceName fail! ret=%d", __func__, ret);
497 return HDF_FAILURE;
498 }
499
500 HDF_LOGI("%{public}s success", __func__);
501 return HDF_SUCCESS;
502 }
503
WpaInterfaceP2pSetWfdDeviceConfig(struct IWpaInterface * self,const char * ifName,const char * config)504 int32_t WpaInterfaceP2pSetWfdDeviceConfig(struct IWpaInterface *self, const char *ifName, const char *config)
505 {
506 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
507 struct wpa_supplicant *wpaSupp;
508 char cmd[CMD_SIZE];
509
510 int32_t ret = 0;
511 (void)self;
512 if (ifName == NULL || config == NULL) {
513 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
514 return HDF_ERR_INVALID_PARAM;
515 }
516
517 wpaSupp = getWpaP2p();
518 if (!wpaSupp) {
519 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
520 return HDF_FAILURE;
521 }
522
523 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%s", config);
524 if (ret < 0) {
525 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
526 return HDF_FAILURE;
527 }
528 ret = p2p_wifi_display_subelem_set(wpaSupp->global, cmd);
529 if (ret < 0) {
530 HDF_LOGE("%{public}s P2pSetWfdDeviceConfig fail! ret=%d", __func__, ret);
531 return HDF_FAILURE;
532 }
533 HDF_LOGI("%{public}s success", __func__);
534 return HDF_SUCCESS;
535 }
536
537
WpaInterfaceP2pSetRandomMac(struct IWpaInterface * self,const char * ifName,int32_t networkId)538 int32_t WpaInterfaceP2pSetRandomMac(struct IWpaInterface *self, const char *ifName, int32_t networkId)
539 {
540 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
541 struct wpa_supplicant *wpaSupp;
542 char cmd[CMD_SIZE];
543
544 int32_t ret = 0;
545 (void)self;
546 wpaSupp = getWpaP2p();
547 ret = IsNull(ifName, wpaSupp);
548 if (ret < 0) {
549 return ret;
550 }
551
552 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "p2p_device_random_mac_addr %d", networkId);
553 if (ret < 0) {
554 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
555 return HDF_FAILURE;
556 }
557
558 ret = wpa_supplicant_ctrl_iface_set(wpaSupp, cmd);
559 if (ret < 0) {
560 HDF_LOGE("%{public}s P2pSetRandomMac fail! ret=%d", __func__, ret);
561 return HDF_FAILURE;
562 }
563 HDF_LOGI("%{public}s success", __func__);
564 return HDF_SUCCESS;
565 }
566
WpaInterfaceP2pStartFind(struct IWpaInterface * self,const char * ifName,int32_t timeout)567 int32_t WpaInterfaceP2pStartFind(struct IWpaInterface *self, const char *ifName, int32_t timeout)
568 {
569 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
570 struct wpa_supplicant *wpaSupp;
571 char cmd[CMD_SIZE];
572
573 int32_t ret = 0;
574 (void)self;
575 wpaSupp = getWpaP2p();
576 ret = IsNull(ifName, wpaSupp);
577 if (ret < 0) {
578 return ret;
579 }
580
581 if (timeout >= 0) {
582 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%d", timeout);
583 } else {
584 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "");
585 }
586 if (ret < 0) {
587 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
588 return HDF_FAILURE;
589 }
590
591 HDF_LOGE("%{public}s P2pStartFind timeout=%d", __func__, timeout);
592 ret = p2p_ctrl_find(wpaSupp, cmd);
593 if (ret < 0) {
594 HDF_LOGE("%{public}s P2pStartFind fail! ret=%d", __func__, ret);
595 return HDF_FAILURE;
596 }
597 HDF_LOGI("%{public}s success", __func__);
598 return HDF_SUCCESS;
599 }
600
WpaInterfaceP2pSetExtListen(struct IWpaInterface * self,const char * ifName,int32_t enable,int32_t period,int32_t interval)601 int32_t WpaInterfaceP2pSetExtListen(struct IWpaInterface *self, const char *ifName, int32_t enable,
602 int32_t period, int32_t interval)
603 {
604 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
605 struct wpa_supplicant *wpaSupp;
606 char cmd[CMD_SIZE];
607
608 int32_t ret = 0;
609 (void)self;
610 wpaSupp = getWpaP2p();
611 ret = IsNull(ifName, wpaSupp);
612 if (ret < 0) {
613 return ret;
614 }
615
616 if (enable == 0) {
617 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "");
618 } else {
619 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%d %d", period, interval);
620 }
621 if (ret < 0) {
622 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
623 return HDF_FAILURE;
624 }
625
626 ret = p2p_ctrl_ext_listen(wpaSupp, cmd);
627 if (ret < 0) {
628 HDF_LOGE("%{public}s P2pSetExtListen fail! ret=%d", __func__, ret);
629 return HDF_FAILURE;
630 }
631 HDF_LOGI("%{public}s success", __func__);
632 return HDF_SUCCESS;
633 }
634
WpaInterfaceP2pSetListenChannel(struct IWpaInterface * self,const char * ifName,int32_t channel,int32_t regClass)635 int32_t WpaInterfaceP2pSetListenChannel(struct IWpaInterface *self, const char *ifName,
636 int32_t channel, int32_t regClass)
637 {
638 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
639 struct wpa_supplicant *wpaSupp;
640 char cmd[CMD_SIZE];
641
642 int32_t ret = 0;
643 (void)self;
644 wpaSupp = getWpaP2p();
645 ret = IsNull(ifName, wpaSupp);
646 if (ret < 0) {
647 return ret;
648 }
649
650 if (regClass > 0) {
651 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "listen_channel %d %d", channel, regClass);
652 } else {
653 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "listen_channel %d", channel);
654 }
655 if (ret < 0) {
656 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
657 return HDF_FAILURE;
658 }
659
660 ret = p2p_ctrl_set(wpaSupp, cmd);
661 if (ret < 0) {
662 HDF_LOGE("%{public}s P2pSetListenChannel fail! ret=%d", __func__, ret);
663 return HDF_FAILURE;
664 }
665 HDF_LOGI("%{public}s success", __func__);
666 return HDF_SUCCESS;
667 }
668
WpaInterfaceP2pProvisionDiscovery(struct IWpaInterface * self,const char * ifName,const char * peerBssid,int32_t mode)669 int32_t WpaInterfaceP2pProvisionDiscovery(struct IWpaInterface *self, const char *ifName,
670 const char *peerBssid, int32_t mode)
671 {
672 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
673 struct wpa_supplicant *wpaSupp;
674 char cmd[CMD_SIZE];
675
676 int32_t ret = 0;
677 (void)self;
678 if (ifName == NULL || peerBssid == NULL) {
679 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
680 return HDF_ERR_INVALID_PARAM;
681 }
682
683 wpaSupp = getWpaP2p();
684 if (!wpaSupp) {
685 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
686 return HDF_FAILURE;
687 }
688
689 if (mode == P2P_WPS_METHOD_PBC) {
690 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%s pbc", peerBssid);
691 } else if (mode == P2P_WPS_METHOD_DISPLAY) {
692 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%s display", peerBssid);
693 } else if (mode == P2P_WPS_METHOD_KEYPAD) {
694 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%s keypad", peerBssid);
695 } else {
696 HDF_LOGE("%{public}s mode is error", __func__);
697 return HDF_FAILURE;
698 }
699 if (ret < 0) {
700 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
701 return HDF_FAILURE;
702 }
703
704 ret = p2p_ctrl_prov_disc(wpaSupp, cmd);
705 if (ret < 0) {
706 HDF_LOGE("%{public}s P2pProvisionDiscovery fail! ret=%d", __func__, ret);
707 return HDF_FAILURE;
708 }
709 HDF_LOGI("%{public}s success", __func__);
710 return HDF_SUCCESS;
711 }
712
WpaInterfaceP2pAddGroup(struct IWpaInterface * self,const char * ifName,int32_t isPersistent,int32_t networkId,int32_t freq)713 int32_t WpaInterfaceP2pAddGroup(struct IWpaInterface *self, const char *ifName, int32_t isPersistent,
714 int32_t networkId, int32_t freq)
715 {
716 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
717 struct wpa_supplicant *wpaSupp;
718 char cmd[CMD_SIZE];
719
720 int32_t ret = 0;
721 (void)self;
722 wpaSupp = getWpaP2p();
723 ret = IsNull(ifName, wpaSupp);
724 if (ret < 0) {
725 return ret;
726 }
727
728 if (isPersistent) {
729 if (networkId < 0) {
730 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "persistent freq=%d", freq);
731 } else {
732 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "persistent=%d freq=%d", networkId, freq);
733 }
734 } else {
735 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "freq=%d", freq);
736 }
737 if (ret < 0) {
738 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
739 return HDF_FAILURE;
740 }
741
742 ret = p2p_ctrl_group_add(wpaSupp, cmd);
743 if (ret < 0) {
744 HDF_LOGE("%{public}s P2pAddGroup fail! ret=%d", __func__, ret);
745 return HDF_FAILURE;
746 }
747 HDF_LOGI("%{public}s success", __func__);
748 return HDF_SUCCESS;
749 }
750
WpaInterfaceP2pAddService(struct IWpaInterface * self,const char * ifName,const struct HdiP2pServiceInfo * info)751 int32_t WpaInterfaceP2pAddService(struct IWpaInterface *self, const char *ifName,
752 const struct HdiP2pServiceInfo *info)
753 {
754 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
755 struct wpa_supplicant *wpaSupp;
756 char cmd[CMD_SIZE];
757
758 int32_t ret = 0;
759 (void)self;
760 if (ifName == NULL || info == NULL) {
761 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
762 return HDF_ERR_INVALID_PARAM;
763 }
764
765 wpaSupp = getWpaP2p();
766 if (!wpaSupp) {
767 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
768 return HDF_FAILURE;
769 }
770
771 if (info->mode == 0) {
772 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "upnp %d %s", info->version, info->name);
773 } else {
774 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "bonjour %s %s", info->query, info->resp);
775 }
776 if (ret < 0) {
777 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
778 return HDF_FAILURE;
779 }
780
781 ret = p2p_ctrl_service_add(wpaSupp, cmd);
782 if (ret < 0) {
783 HDF_LOGE("%{public}s P2pAddService fail! ret=%d", __func__, ret);
784 return HDF_FAILURE;
785 }
786 HDF_LOGI("%{public}s success", __func__);
787 return HDF_SUCCESS;
788 }
789
WpaInterfaceP2pRemoveService(struct IWpaInterface * self,const char * ifName,const struct HdiP2pServiceInfo * info)790 int32_t WpaInterfaceP2pRemoveService(struct IWpaInterface *self, const char *ifName,
791 const struct HdiP2pServiceInfo *info)
792 {
793 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
794 struct wpa_supplicant *wpaSupp;
795 char cmd[CMD_SIZE];
796
797 int32_t ret = 0;
798 (void)self;
799 if (ifName == NULL || info == NULL) {
800 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
801 return HDF_ERR_INVALID_PARAM;
802 }
803
804 wpaSupp = getWpaP2p();
805 if (!wpaSupp) {
806 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
807 return HDF_FAILURE;
808 }
809
810 if (info->mode == 0) {
811 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "upnp %d %s", info->version, info->name);
812 } else {
813 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "bonjour %s", info->query);
814 }
815 if (ret < 0) {
816 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
817 return HDF_FAILURE;
818 }
819
820 ret = p2p_ctrl_service_del(wpaSupp, cmd);
821 if (ret < 0) {
822 HDF_LOGE("%{public}s P2pRemoveService fail! ret=%d", __func__, ret);
823 return HDF_FAILURE;
824 }
825 HDF_LOGI("%{public}s success", __func__);
826 return HDF_SUCCESS;
827 }
828
WpaInterfaceP2pStopFind(struct IWpaInterface * self,const char * ifName)829 int32_t WpaInterfaceP2pStopFind(struct IWpaInterface *self, const char *ifName)
830 {
831 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
832 struct wpa_supplicant *wpaSupp;
833
834 int32_t ret = 0;
835 (void)self;
836 wpaSupp = getWpaP2p();
837 ret = IsNull(ifName, wpaSupp);
838 if (ret < 0) {
839 return ret;
840 }
841
842 wpas_p2p_stop_find(wpaSupp);
843 HDF_LOGI("%{public}s success", __func__);
844 return HDF_SUCCESS;
845 }
846
847
WpaInterfaceP2pFlush(struct IWpaInterface * self,const char * ifName)848 int32_t WpaInterfaceP2pFlush(struct IWpaInterface *self, const char *ifName)
849 {
850 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
851 struct wpa_supplicant *wpaSupp;
852
853 int32_t ret = 0;
854 (void)self;
855 wpaSupp = getWpaP2p();
856 ret = IsNull(ifName, wpaSupp);
857 if (ret < 0) {
858 return ret;
859 }
860
861 p2p_ctrl_flush(wpaSupp);
862 HDF_LOGI("%{public}s success", __func__);
863 return HDF_SUCCESS;
864 }
865
WpaInterfaceP2pFlushService(struct IWpaInterface * self,const char * ifName)866 int32_t WpaInterfaceP2pFlushService(struct IWpaInterface *self, const char *ifName)
867 {
868 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
869 struct wpa_supplicant *wpaSupp;
870
871 int32_t ret = 0;
872 (void)self;
873 wpaSupp = getWpaP2p();
874 ret = IsNull(ifName, wpaSupp);
875 if (ret < 0) {
876 return ret;
877 }
878
879 wpas_p2p_service_flush(wpaSupp);
880 HDF_LOGI("%{public}s success", __func__);
881 return HDF_SUCCESS;
882 }
883
WpaInterfaceP2pRemoveNetwork(struct IWpaInterface * self,const char * ifName,int32_t networkId)884 int32_t WpaInterfaceP2pRemoveNetwork(struct IWpaInterface *self, const char *ifName, int32_t networkId)
885 {
886 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
887 struct wpa_supplicant *wpaSupp;
888 char cmd[CMD_SIZE];
889
890 int32_t ret = 0;
891 (void)self;
892 wpaSupp = getWpaP2p();
893 ret = IsNull(ifName, wpaSupp);
894 if (ret < 0) {
895 return ret;
896 }
897
898 if (networkId == -1) {
899 strcpy_s(cmd, sizeof(cmd), "all");
900 } else {
901 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%d", networkId);
902 }
903 if (ret < 0) {
904 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
905 return HDF_FAILURE;
906 }
907
908 ret = wpa_supplicant_ctrl_iface_remove_network(wpaSupp, cmd);
909 if (ret < 0) {
910 HDF_LOGE("%{public}s P2pRemoveNetwork fail! ret=%d", __func__, ret);
911 return HDF_FAILURE;
912 }
913 HDF_LOGI("%{public}s success", __func__);
914 return HDF_SUCCESS;
915 }
916
WpaInterfaceP2pSetGroupConfig(struct IWpaInterface * self,const char * ifName,const int32_t networkId,const char * name,const char * value)917 int32_t WpaInterfaceP2pSetGroupConfig(struct IWpaInterface *self, const char *ifName, const int32_t networkId,
918 const char *name, const char *value)
919 {
920 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
921 struct wpa_supplicant *wpaSupp;
922 char cmd[CMD_SIZE];
923
924 int32_t ret = 0;
925 (void)self;
926 if (ifName == NULL || name == NULL || value == NULL) {
927 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
928 return HDF_ERR_INVALID_PARAM;
929 }
930
931 wpaSupp = getWpaP2p();
932 if (!wpaSupp) {
933 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
934 return HDF_FAILURE;
935 }
936
937 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%d %s %s",
938 networkId, name, value);
939 if (ret < 0) {
940 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
941 return HDF_FAILURE;
942 }
943
944 ret = wpa_supplicant_ctrl_iface_set_network(wpaSupp, cmd);
945 if (ret < 0) {
946 HDF_LOGE("%{public}s P2pSetGroupConfig fail! ret=%d", __func__, ret);
947 return HDF_FAILURE;
948 }
949 HDF_LOGI("%{public}s success", __func__);
950 return HDF_SUCCESS;
951 }
952
WpaInterfaceP2pInvite(struct IWpaInterface * self,const char * ifName,const char * peerBssid,const char * goBssid)953 int32_t WpaInterfaceP2pInvite(struct IWpaInterface *self, const char *ifName,
954 const char *peerBssid, const char *goBssid)
955 {
956 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
957 struct wpa_supplicant *wpaSupp;
958 char cmd[CMD_SIZE];
959
960 int32_t ret = 0;
961 (void)self;
962 if (ifName == NULL || peerBssid == NULL || goBssid == NULL) {
963 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
964 return HDF_ERR_INVALID_PARAM;
965 }
966
967 wpaSupp = getWpaP2p();
968 if (!wpaSupp) {
969 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
970 return HDF_FAILURE;
971 }
972
973 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "group=%s peer=%s go_dev_addr=%s", ifName, peerBssid, goBssid);
974 if (ret < 0) {
975 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
976 return HDF_FAILURE;
977 }
978
979 ret = p2p_ctrl_invite(wpaSupp, cmd);
980 if (ret < 0) {
981 HDF_LOGE("%{public}s P2pInvite fail! ret=%d", __func__, ret);
982 return HDF_FAILURE;
983 }
984 HDF_LOGI("%{public}s success", __func__);
985 return HDF_SUCCESS;
986 }
987
WpaInterfaceP2pReinvoke(struct IWpaInterface * self,const char * ifName,const int32_t networkId,const char * bssid)988 int32_t WpaInterfaceP2pReinvoke(struct IWpaInterface *self, const char *ifName, const int32_t networkId,
989 const char *bssid)
990 {
991 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
992 struct wpa_supplicant *wpaSupp;
993 char cmd[CMD_SIZE];
994
995 int32_t ret = 0;
996 (void)self;
997 if (ifName == NULL || bssid == NULL) {
998 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
999 return HDF_ERR_INVALID_PARAM;
1000 }
1001
1002 wpaSupp = getWpaP2p();
1003 if (!wpaSupp) {
1004 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
1005 return HDF_FAILURE;
1006 }
1007
1008 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "persistent=%d peer=%s", networkId, bssid);
1009 if (ret < 0) {
1010 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
1011 return HDF_FAILURE;
1012 }
1013
1014 ret = p2p_ctrl_invite(wpaSupp, cmd);
1015 if (ret < 0) {
1016 HDF_LOGE("%{public}s P2pReinvoke fail! ret=%d", __func__, ret);
1017 return HDF_FAILURE;
1018 }
1019 HDF_LOGI("%{public}s success", __func__);
1020 return HDF_SUCCESS;
1021 }
1022
WpaInterfaceP2pGetDeviceAddress(struct IWpaInterface * self,const char * ifName,char * deviceAddress,uint32_t deviceAddressLen)1023 int32_t WpaInterfaceP2pGetDeviceAddress(struct IWpaInterface *self, const char *ifName, char *deviceAddress,
1024 uint32_t deviceAddressLen)
1025 {
1026 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
1027 char cmd[CMD_SIZE] = {0};
1028 const int replySize = REPLY_SIZE;
1029 char *reply = (char *)malloc(replySize);
1030 struct wpa_supplicant *wpaSupp;
1031 if (reply == NULL) {
1032 HDF_LOGE("%{public}s reply is NULL!", __func__);
1033 return HDF_FAILURE;
1034 }
1035 if (ifName == NULL || deviceAddress == NULL) {
1036 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1037 free(reply);
1038 return HDF_ERR_INVALID_PARAM;
1039 }
1040 int32_t ret = 0;
1041 (void)self;
1042 wpaSupp = getWpaP2p();
1043 if (!wpaSupp) {
1044 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
1045 free(reply);
1046 return HDF_FAILURE;
1047 }
1048 if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%s", "STATUS") < 0) {
1049 HDF_LOGE("%{public}s snprintf_s failed", __func__);
1050 free(reply);
1051 return HDF_FAILURE;
1052 }
1053 ret = wpa_supplicant_ctrl_iface_status(wpaSupp, cmd + CMD_LEN, reply, replySize);
1054 if (ret < 0) {
1055 HDF_LOGE("%{public}s P2pGetDeviceAddress fail! ret=%d", __func__, ret);
1056 free(reply);
1057 return HDF_FAILURE;
1058 }
1059 char *p = strstr(reply, "p2p_device_address=");
1060 if (p == NULL) {
1061 HDF_LOGE("%{public}s Not find device address!", __func__);
1062 free(reply);
1063 return HDF_FAILURE;
1064 }
1065 p += strlen("p2p_device_address=");
1066 char *q = p;
1067 while (*q != '\0' && *q != '\n') {
1068 ++q;
1069 }
1070 if (strncpy_s(deviceAddress, deviceAddressLen, p, q - p) != EOK) {
1071 HDF_LOGE("%{public}s Failed to copy device address!", __func__);
1072 free(reply);
1073 return HDF_FAILURE;
1074 }
1075 free(reply);
1076 HDF_LOGI("%{public}s success", __func__);
1077 return HDF_SUCCESS;
1078 }
1079
WpaInterfaceP2pReqServiceDiscovery(struct IWpaInterface * self,const char * ifName,const struct HdiP2pReqService * reqService,char * replyDisc,uint32_t replyDiscLen)1080 int32_t WpaInterfaceP2pReqServiceDiscovery(struct IWpaInterface *self, const char *ifName,
1081 const struct HdiP2pReqService *reqService, char *replyDisc, uint32_t replyDiscLen)
1082 {
1083 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
1084 if (ifName == NULL || reqService == NULL || replyDisc == NULL) {
1085 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1086 return HDF_ERR_INVALID_PARAM;
1087 }
1088 char *reply;
1089 const int replySize = REPLY_SIZE;
1090 struct wpa_supplicant *wpaSupp;
1091 reply = (char *)malloc(replySize);
1092 if (reply == NULL) {
1093 HDF_LOGE("%{public}s reply is NULL!", __func__);
1094 return HDF_FAILURE;
1095 }
1096 char cmd[CMD_SIZE];
1097 int32_t ret = 0;
1098 (void)self;
1099
1100 wpaSupp = getWpaP2p();
1101 if (!wpaSupp) {
1102 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
1103 free(reply);
1104 return HDF_FAILURE;
1105 }
1106 if (reqService->bssid) {
1107 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%s %s", macToStr(reqService->bssid), reqService->msg);
1108 }
1109 if (ret < 0) {
1110 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
1111 free(reply);
1112 return HDF_FAILURE;
1113 }
1114
1115 ret = p2p_ctrl_serv_disc_req(wpaSupp, cmd, reply, replySize);
1116 if (strncpy_s(replyDisc, replyDiscLen, reply, replySize) != 0) {
1117 HDF_LOGE("%{public}s Failed to copy response about service discovery sequence!", __func__);
1118 free(reply);
1119 return HDF_FAILURE;
1120 }
1121
1122 if (ret < 0) {
1123 HDF_LOGE("%{public}s P2pReqServiceDiscovery fail! ret=%d", __func__, ret);
1124 free(reply);
1125 return HDF_FAILURE;
1126 }
1127
1128 free(reply);
1129 HDF_LOGI("%{public}s success", __func__);
1130 return HDF_SUCCESS;
1131 }
1132
WpaInterfaceP2pCancelServiceDiscovery(struct IWpaInterface * self,const char * ifName,const char * id)1133 int32_t WpaInterfaceP2pCancelServiceDiscovery(struct IWpaInterface *self, const char *ifName, const char *id)
1134 {
1135 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
1136 struct wpa_supplicant *wpaSupp;
1137 char cmd[CMD_SIZE];
1138
1139 int32_t ret = 0;
1140 (void)self;
1141 if (ifName == NULL || id == NULL) {
1142 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1143 return HDF_ERR_INVALID_PARAM;
1144 }
1145
1146 wpaSupp = getWpaP2p();
1147 if (!wpaSupp) {
1148 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
1149 return HDF_FAILURE;
1150 }
1151
1152 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%s", id);
1153 if (ret < 0) {
1154 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
1155 return HDF_FAILURE;
1156 }
1157
1158 ret = p2p_ctrl_serv_disc_cancel_req(wpaSupp, cmd);
1159 if (ret < 0) {
1160 HDF_LOGE("%{public}s P2pCancelServiceDiscovery fail! ret=%d", __func__, ret);
1161 return HDF_FAILURE;
1162 }
1163 HDF_LOGI("%{public}s success", __func__);
1164 return HDF_SUCCESS;
1165 }
1166
WpaInterfaceP2pRespServerDiscovery(struct IWpaInterface * self,const char * ifName,const struct HdiP2pServDiscReqInfo * info)1167 int32_t WpaInterfaceP2pRespServerDiscovery(struct IWpaInterface *self, const char *ifName,
1168 const struct HdiP2pServDiscReqInfo *info)
1169 {
1170 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
1171 if (ifName == NULL || info == NULL) {
1172 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1173 return HDF_ERR_INVALID_PARAM;
1174 }
1175
1176 struct wpa_supplicant *wpaSupp;
1177 char cmd[CMD_SIZE];
1178
1179 int32_t ret = 0;
1180 (void)self;
1181
1182 wpaSupp = getWpaP2p();
1183 if (!wpaSupp) {
1184 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
1185 return HDF_FAILURE;
1186 }
1187 if (info->mac) {
1188 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%d %s %d %s", info->freq, macToStr(info->mac),
1189 info->dialogToken, info->tlvs);
1190 }
1191
1192 if (ret < 0) {
1193 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
1194 return HDF_FAILURE;
1195 }
1196
1197 ret = p2p_ctrl_serv_disc_resp(wpaSupp, cmd);
1198 if (ret < 0) {
1199 HDF_LOGE("%{public}s P2pRespServerDiscovery fail! ret=%d", __func__, ret);
1200 return HDF_FAILURE;
1201 }
1202 HDF_LOGI("%{public}s success", __func__);
1203 return HDF_SUCCESS;
1204 }
1205
WpaInterfaceP2pConnect(struct IWpaInterface * self,const char * ifName,const struct HdiP2pConnectInfo * info,char * replyPin,uint32_t replyPinLen)1206 int32_t WpaInterfaceP2pConnect(struct IWpaInterface *self, const char *ifName, const struct HdiP2pConnectInfo *info,
1207 char *replyPin, uint32_t replyPinLen)
1208 {
1209 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
1210 if (ifName == NULL || info == NULL || replyPin == NULL) {
1211 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1212 return HDF_ERR_INVALID_PARAM;
1213 }
1214 char *reply;
1215 const int replySize = REPLY_SIZE;
1216 char cmd[CMD_SIZE] = {0};
1217 char join[CMD_SIZE] = {0};
1218 char mode[CMD_SIZE] = {0};
1219 char persistent[CMD_SIZE] = {0};
1220
1221 struct wpa_supplicant *wpaSupp;
1222 reply = (char *)malloc(replySize);
1223 if (reply == NULL) {
1224 HDF_LOGE("%{public}s reply is NULL!", __func__);
1225 return HDF_FAILURE;
1226 }
1227
1228 int32_t ret = 0;
1229 (void)self;
1230
1231 wpaSupp = getWpaP2p();
1232 if (!wpaSupp) {
1233 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
1234 free(reply);
1235 return HDF_FAILURE;
1236 }
1237
1238 if (info->mode != 0) {
1239 StrSafeCopy(join, sizeof(join), " join");
1240 } else {
1241 if (snprintf_s(join, sizeof(join), sizeof(join) - 1, " go_intent=%d", info->goIntent) < 0) {
1242 HDF_LOGE("%{public}s input parameter invalid!", __func__);
1243 free(reply);
1244 return HDF_ERR_INVALID_PARAM;
1245 }
1246 }
1247
1248 if (info->provdisc == P2P_WPS_METHOD_DISPLAY) {
1249 StrSafeCopy(mode, sizeof(mode), " display");
1250 } else if (info->provdisc == P2P_WPS_METHOD_KEYPAD) {
1251 StrSafeCopy(mode, sizeof(mode), " keypad");
1252 } else if (info->provdisc == P2P_WPS_METHOD_PBC && info->pin != NULL && strlen((char *)info->pin) == 0) {
1253 StrSafeCopy((char *)info->pin, strlen((char *)info->pin) + 1, "pbc");
1254 } else {
1255 HDF_LOGE("%{public}s Mode value is invalid %{public}d!", __func__, info->provdisc);
1256 free(reply);
1257 return HDF_ERR_INVALID_PARAM;
1258 }
1259 if (info->peerDevAddr) {
1260 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%s %s%s%s%s", macToStr(info->peerDevAddr), info->pin, mode,
1261 persistent, join);
1262 }
1263 if (ret < 0) {
1264 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
1265 free(reply);
1266 return HDF_FAILURE;
1267 }
1268
1269 ret = p2p_ctrl_connect(wpaSupp, cmd, reply, replySize);
1270 if (ret < 0) {
1271 HDF_LOGE("%{public}s P2pConnect fail! ret=%d", __func__, ret);
1272 free(reply);
1273 return HDF_FAILURE;
1274 }
1275
1276 if (strncmp(reply, "FAIL", strlen("FAIL")) == 0) {
1277 HDF_LOGE("%{public}s P2p connect return %{public}s", __func__, reply);
1278 free(reply);
1279 return HDF_FAILURE;
1280 }
1281 if (info->provdisc == P2P_WPS_METHOD_DISPLAY && strcmp((char *)info->pin, "pin") == 0) {
1282 if (strncpy_s(replyPin, replyPinLen, reply, strlen(reply)) != 0) {
1283 HDF_LOGE("%{public}s Failed to copy response pin code info!", __func__);
1284 free(reply);
1285 return HDF_FAILURE;
1286 }
1287 }
1288
1289 free(reply);
1290 HDF_LOGI("%{public}s success", __func__);
1291 return HDF_SUCCESS;
1292 }
1293
WpaInterfaceP2pHid2dConnect(struct IWpaInterface * self,const char * ifName,const struct HdiHid2dConnectInfo * info)1294 int32_t WpaInterfaceP2pHid2dConnect(struct IWpaInterface *self, const char *ifName,
1295 const struct HdiHid2dConnectInfo *info)
1296 {
1297 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
1298 if (ifName == NULL || info == NULL) {
1299 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1300 return HDF_ERR_INVALID_PARAM;
1301 }
1302 struct wpa_supplicant *wpaSupp;
1303 char cmd[CMD_SIZE];
1304
1305 int32_t ret = 0;
1306 (void)self;
1307
1308 wpaSupp = getWpaP2p();
1309 if (!wpaSupp) {
1310 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
1311 return HDF_FAILURE;
1312 }
1313 if (info->bssid) {
1314 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "\"%s\"\n%s\n\"%s\"\n%d", info->ssid,
1315 macToStr(info->bssid), info->passphrase, info->frequency);
1316 }
1317
1318 if (ret < 0) {
1319 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
1320 return HDF_FAILURE;
1321 }
1322 ret = magiclink_p2p_ctrl_connect(wpaSupp, cmd);
1323 if (ret < 0) {
1324 HDF_LOGE("%{public}s P2pHid2dConnect fail! ret=%d", __func__, ret);
1325 return HDF_FAILURE;
1326 }
1327 HDF_LOGI("%{public}s success", __func__);
1328 return HDF_SUCCESS;
1329 }
1330
WpaInterfaceP2pSetServDiscExternal(struct IWpaInterface * self,const char * ifName,int32_t mode)1331 int32_t WpaInterfaceP2pSetServDiscExternal(struct IWpaInterface *self, const char *ifName, int32_t mode)
1332 {
1333 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
1334 struct wpa_supplicant *wpaSupp;
1335 char cmd[CMD_SIZE];
1336
1337 int32_t ret = 0;
1338 (void)self;
1339 wpaSupp = getWpaP2p();
1340 ret = IsNull(ifName, wpaSupp);
1341 if (ret < 0) {
1342 return ret;
1343 }
1344
1345 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%d", mode);
1346 if (ret < 0) {
1347 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
1348 return HDF_FAILURE;
1349 }
1350
1351 ret = p2p_ctrl_serv_disc_external(wpaSupp, cmd);
1352 if (ret < 0) {
1353 HDF_LOGE("%{public}s P2pSetServDiscExternal fail! ret=%d", __func__, ret);
1354 return HDF_FAILURE;
1355 }
1356 HDF_LOGI("%{public}s success", __func__);
1357 return HDF_SUCCESS;
1358 }
1359
WpaInterfaceP2pRemoveGroup(struct IWpaInterface * self,const char * ifName,const char * groupName)1360 int32_t WpaInterfaceP2pRemoveGroup(struct IWpaInterface *self, const char *ifName, const char *groupName)
1361 {
1362 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
1363 struct wpa_supplicant *wpaSupp;
1364 int32_t ret = 0;
1365 (void)self;
1366 if (ifName == NULL || groupName == NULL) {
1367 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1368 return HDF_ERR_INVALID_PARAM;
1369 }
1370
1371 wpaSupp = getWpaP2p();
1372 if (!wpaSupp) {
1373 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
1374 return HDF_FAILURE;
1375 }
1376
1377 ret = wpas_p2p_group_remove(wpaSupp, groupName);
1378 if (ret < 0) {
1379 HDF_LOGE("%{public}s P2pRemoveGroup fail! ret=%d", __func__, ret);
1380 return HDF_FAILURE;
1381 }
1382
1383 HDF_LOGI("%{public}s success", __func__);
1384 return HDF_SUCCESS;
1385 }
1386
WpaInterfaceP2pCancelConnect(struct IWpaInterface * self,const char * ifName)1387 int32_t WpaInterfaceP2pCancelConnect(struct IWpaInterface *self, const char *ifName)
1388 {
1389 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
1390 struct wpa_supplicant *wpaSupp;
1391 int32_t ret = 0;
1392 (void)self;
1393 wpaSupp = getWpaP2p();
1394 ret = IsNull(ifName, wpaSupp);
1395 if (ret < 0) {
1396 return ret;
1397 }
1398
1399 ret = wpas_p2p_cancel(wpaSupp);
1400 if (ret < 0) {
1401 HDF_LOGE("%{public}s P2pCancelConnect fail! ret=%d", __func__, ret);
1402 return HDF_FAILURE;
1403 }
1404 HDF_LOGI("%{public}s success", __func__);
1405 return HDF_SUCCESS;
1406 }
1407
WpaInterfaceP2pGetGroupConfig(struct IWpaInterface * self,const char * ifName,const int32_t networkId,const char * param,char * value,uint32_t valueLen)1408 int32_t WpaInterfaceP2pGetGroupConfig(struct IWpaInterface *self, const char *ifName, const int32_t networkId,
1409 const char *param, char *value, uint32_t valueLen)
1410 {
1411 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
1412 struct wpa_supplicant *wpaSupp;
1413 char cmd[CMD_SIZE];
1414
1415 int32_t ret = 0;
1416 (void)self;
1417 if (ifName == NULL || param == NULL || value == NULL) {
1418 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1419 return HDF_ERR_INVALID_PARAM;
1420 }
1421
1422 wpaSupp = getWpaP2p();
1423 if (!wpaSupp) {
1424 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
1425 return HDF_FAILURE;
1426 }
1427
1428 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%d %s", networkId, param);
1429 if (ret < 0) {
1430 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
1431 return HDF_FAILURE;
1432 }
1433
1434 ret = wpa_supplicant_ctrl_iface_get_network(wpaSupp, cmd, value, valueLen);
1435 if (ret < 0) {
1436 HDF_LOGE("%{public}s P2pGetGroupConfig fail! ret=%d", __func__, ret);
1437 return HDF_FAILURE;
1438 }
1439 HDF_LOGI("%{public}s success", __func__);
1440 return HDF_SUCCESS;
1441 }
1442
WpaInterfaceP2pAddNetwork(struct IWpaInterface * self,const char * ifName,int32_t * networkId)1443 int32_t WpaInterfaceP2pAddNetwork(struct IWpaInterface *self, const char *ifName, int32_t *networkId)
1444 {
1445 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
1446 if (ifName == NULL || networkId == NULL) {
1447 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1448 return HDF_ERR_INVALID_PARAM;
1449 }
1450 char *reply;
1451 const int replySize = REPLY_SIZE;
1452 struct wpa_supplicant *wpaSupp;
1453 reply = (char *)malloc(replySize);
1454 if (reply == NULL) {
1455 HDF_LOGE("%{public}s reply is NULL!", __func__);
1456 return HDF_FAILURE;
1457 }
1458
1459 int32_t ret = 0;
1460 (void)self;
1461
1462 wpaSupp = getWpaP2p();
1463 if (!wpaSupp) {
1464 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
1465 free(reply);
1466 return HDF_FAILURE;
1467 }
1468
1469 ret = wpa_supplicant_ctrl_iface_add_network(wpaSupp, reply, replySize);
1470 *networkId = atoi(reply);
1471 if (ret < 0) {
1472 HDF_LOGE("%{public}s P2pAddNetwork fail! ret=%d", __func__, ret);
1473 return HDF_FAILURE;
1474 }
1475
1476 free(reply);
1477 HDF_LOGI("%{public}s success", __func__);
1478 return HDF_SUCCESS;
1479 }
1480
WpaInterfaceP2pGetPeer(struct IWpaInterface * self,const char * ifName,const char * bssid,struct HdiP2pDeviceInfo * info)1481 int32_t WpaInterfaceP2pGetPeer(struct IWpaInterface *self, const char *ifName, const char *bssid,
1482 struct HdiP2pDeviceInfo *info)
1483 {
1484 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
1485 if (ifName == NULL || info == NULL || bssid == NULL) {
1486 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1487 return HDF_ERR_INVALID_PARAM;
1488 }
1489 char *reply;
1490 const int replySize = REPLY_SIZE;
1491 char cmd[CMD_SIZE];
1492 struct wpa_supplicant *wpaSupp;
1493 reply = (char *)malloc(replySize);
1494 if (reply == NULL) {
1495 HDF_LOGE("%{public}s reply is NULL!", __func__);
1496 return HDF_FAILURE;
1497 }
1498
1499 int32_t ret = 0;
1500 (void)self;
1501
1502 wpaSupp = getWpaP2p();
1503 if (!wpaSupp) {
1504 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
1505 free(reply);
1506 return HDF_FAILURE;
1507 }
1508
1509 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%s", bssid);
1510 if (ret < 0) {
1511 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
1512 free(reply);
1513 return HDF_FAILURE;
1514 }
1515
1516 ret = p2p_ctrl_peer(wpaSupp, cmd, reply, replySize);
1517 if (ret < 0) {
1518 HDF_LOGE("%{public}s P2pGetPeer fail! ret=%d", __func__, ret);
1519 free(reply);
1520 return HDF_FAILURE;
1521 }
1522
1523 if (strstr(reply, "\n") == NULL) {
1524 HDF_LOGE("%{public}s reply is error", __func__);
1525 free(reply);
1526 return HDF_FAILURE;
1527 }
1528 char *savedPtr = NULL;
1529 char *token = strtok_r(reply, "\n", &savedPtr);
1530 info->srcAddress = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1));
1531 info->p2pDeviceAddress = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1));
1532 info->primaryDeviceType = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_DEVICE_TYPE_LENGTH);
1533 info->deviceName = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_DEVICE_NAME_LENGTH);
1534 info->wfdDeviceInfo = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_WFD_DEVICE_INFO_LENGTH);
1535 info->operSsid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_P2P_DEVICE_NAME_LENGTH);
1536 info->srcAddressLen = ETH_ADDR_LEN + 1;
1537 info->p2pDeviceAddressLen = ETH_ADDR_LEN + 1;
1538 info->primaryDeviceTypeLen = WIFI_P2P_DEVICE_TYPE_LENGTH;
1539 info->deviceNameLen = WIFI_P2P_DEVICE_NAME_LENGTH;
1540 info->wfdDeviceInfoLen = WIFI_P2P_WFD_DEVICE_INFO_LENGTH;
1541 info->operSsidLen = WIFI_P2P_DEVICE_NAME_LENGTH;
1542 uint8_t tmpBssid[ETH_ADDR_LEN] = {0};
1543 hwaddr_aton(token, tmpBssid);
1544 StrSafeCopy((char *)info->p2pDeviceAddress, ETH_ADDR_LEN + 1, (char *)tmpBssid); /* copy first line */
1545 while (token != NULL) {
1546 struct HdiWpaKeyValue retMsg = {{0}, {0}};
1547 GetStrKeyVal(token, "=", &retMsg);
1548 if (strncmp(retMsg.key, "pri_dev_type", strlen("pri_dev_type")) == 0) {
1549 StrSafeCopy((char *)info->primaryDeviceType, WIFI_P2P_DEVICE_TYPE_LENGTH + 1, retMsg.value);
1550 } else if (strncmp(retMsg.key, "device_name", strlen("device_name")) == 0) {
1551 StrSafeCopy((char *)info->deviceName, WIFI_P2P_DEVICE_NAME_LENGTH + 1, retMsg.value);
1552 } else if (strncmp(retMsg.key, "config_methods", strlen("config_methods")) == 0) {
1553 info->configMethods = Hex2Dec(retMsg.value);
1554 } else if (strncmp(retMsg.key, "dev_capab", strlen("dev_capab")) == 0) {
1555 info->deviceCapabilities = Hex2Dec(retMsg.value);
1556 } else if (strncmp(retMsg.key, "group_capab", strlen("group_capab")) == 0) {
1557 info->groupCapabilities = Hex2Dec(retMsg.value);
1558 } else if (strncmp(retMsg.key, "oper_ssid", strlen("oper_ssid")) == 0) {
1559 StrSafeCopy((char *)info->operSsid, WIFI_P2P_DEVICE_NAME_LENGTH + 1, retMsg.value);
1560 }
1561 token = strtok_r(NULL, "\n", &savedPtr);
1562 }
1563 free(reply);
1564 HDF_LOGI("%{public}s P2pGetPeer success", __func__);
1565 return HDF_SUCCESS;
1566 }
1567
WpaInterfaceP2pGetGroupCapability(struct IWpaInterface * self,const char * ifName,const char * bssid,int32_t * cap)1568 int32_t WpaInterfaceP2pGetGroupCapability(struct IWpaInterface *self, const char *ifName,
1569 const char *bssid, int32_t *cap)
1570 {
1571 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
1572 if (ifName == NULL || bssid == NULL || cap == NULL) {
1573 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1574 return HDF_ERR_INVALID_PARAM;
1575 }
1576 char *reply;
1577 const int replySize = REPLY_SIZE;
1578 char cmd[CMD_SIZE];
1579 struct wpa_supplicant *wpaSupp;
1580 struct HdiP2pDeviceInfo *info = {0};
1581 reply = (char *)malloc(replySize);
1582 if (reply == NULL) {
1583 HDF_LOGE("%{public}s reply is NULL!", __func__);
1584 return HDF_FAILURE;
1585 }
1586
1587 int32_t ret = 0;
1588 (void)self;
1589
1590 wpaSupp = getWpaP2p();
1591 if (!wpaSupp) {
1592 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
1593 free(reply);
1594 return HDF_FAILURE;
1595 }
1596
1597 ret = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "%s", bssid);
1598 if (ret < 0) {
1599 HDF_LOGE("%{public}s snprintf_s failed, cmd: %{public}s, count = %{public}d", __func__, cmd, ret);
1600 free(reply);
1601 return HDF_FAILURE;
1602 }
1603
1604 ret = p2p_ctrl_peer(wpaSupp, cmd, reply, replySize);
1605 if (ret < 0) {
1606 HDF_LOGE("%{public}s P2pGetGroupCapability fail! ret=%d", __func__, ret);
1607 free(reply);
1608 return HDF_FAILURE;
1609 }
1610 if (strstr(reply, "\n") == NULL) {
1611 HDF_LOGE("%{public}s reply is error", __func__);
1612 free(reply);
1613 return HDF_FAILURE;
1614 }
1615 char *savedPtr = NULL;
1616 char *token = strtok_r(reply, "\n", &savedPtr);
1617 StrSafeCopy((char *)info->p2pDeviceAddress, ETH_ADDR_LEN + 1, token); /* copy first line */
1618 while (token != NULL) {
1619 struct HdiWpaKeyValue retMsg = {{0}, {0}};
1620 GetStrKeyVal(token, "=", &retMsg);
1621 if (strncmp(retMsg.key, "group_capab", strlen("group_capab")) == 0) {
1622 info->groupCapabilities = Hex2Dec(retMsg.value);
1623 }
1624 token = strtok_r(NULL, "\n", &savedPtr);
1625 }
1626 *cap = info->groupCapabilities;
1627 free(reply);
1628 HDF_LOGI("%{public}s P2pGetGroupCapability success", __func__);
1629 return HDF_SUCCESS;
1630 }
1631
WpaInterfaceP2pListNetworks(struct IWpaInterface * self,const char * ifName,struct HdiP2pNetworkList * infoList)1632 int32_t WpaInterfaceP2pListNetworks(struct IWpaInterface *self, const char *ifName,
1633 struct HdiP2pNetworkList *infoList)
1634 {
1635 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
1636 if (ifName == NULL || infoList == NULL) {
1637 HDF_LOGE("%{public}s: input parameter invalid!", __func__);
1638 return HDF_ERR_INVALID_PARAM;
1639 }
1640 char *reply;
1641 const int replySize = REPLY_SIZE;
1642 struct wpa_supplicant *wpaSupp;
1643 reply = (char *)malloc(replySize);
1644 if (reply == NULL) {
1645 HDF_LOGE("%{public}s reply is NULL!", __func__);
1646 return HDF_FAILURE;
1647 }
1648 int32_t ret = 0;
1649 (void)self;
1650 wpaSupp = getWpaP2p();
1651 if (!wpaSupp) {
1652 HDF_LOGE("%{public}s wpaSupp is NULL!", __func__);
1653 free(reply);
1654 return HDF_FAILURE;
1655 }
1656 ret = wpa_supplicant_ctrl_iface_list_networks(wpaSupp, NULL, reply, replySize);
1657 if (ret < 0) {
1658 HDF_LOGE("%{public}s P2pListNetworks fail! ret=%d", __func__, ret);
1659 free(reply);
1660 return HDF_FAILURE;
1661 }
1662 char *token = strstr(reply, "\n");
1663 if (token == NULL) {
1664 HDF_LOGE("%{public}s token is NULL!", __func__);
1665 free(reply);
1666 return HDF_FAILURE;
1667 }
1668 char *tmpPos = token + 1;
1669 while ((tmpPos = strstr(tmpPos, "\n")) != NULL) {
1670 infoList->infoNum += 1;
1671 ++tmpPos;
1672 }
1673 if (infoList->infoNum <= 0) {
1674 HDF_LOGE("%{public}s infoList->infoNum <= 0", __func__);
1675 free(reply);
1676 return HDF_FAILURE;
1677 }
1678 infoList->infos = (struct HdiP2pNetworkInfo *)OsalMemCalloc(sizeof(struct HdiP2pNetworkInfo) * infoList->infoNum);
1679 infoList->infosLen = (uint32_t)infoList->infoNum;
1680 char *tmpBuf = token + 1;
1681 char *savedPtr = NULL;
1682 token = strtok_r(tmpBuf, "\n", &savedPtr);
1683 int index = 0;
1684 while (token != NULL) {
1685 if (index >= infoList->infoNum) {
1686 break;
1687 }
1688 infoList->infos[index].ssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_SSID_LENGTH);
1689 infoList->infos[index].ssidLen = WIFI_SSID_LENGTH;
1690 infoList->infos[index].bssid = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (ETH_ADDR_LEN + 1));
1691 infoList->infos[index].bssidLen = ETH_ADDR_LEN + 1;
1692 infoList->infos[index].flags = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * WIFI_NETWORK_FLAGS_LENGTH);
1693 infoList->infos[index].flagsLen = WIFI_NETWORK_FLAGS_LENGTH;
1694 GetHalNetworkInfos(token, &(infoList->infos[index]));
1695 index++;
1696 token = strtok_r(NULL, "\n", &savedPtr);
1697 }
1698 if (ret < 0) {
1699 HDF_LOGE("%{public}s P2pListNetworks fail!", __func__);
1700 }
1701 free(reply);
1702 HDF_LOGI("%{public}s P2pListNetworks success", __func__);
1703 return HDF_SUCCESS;
1704 }
1705
WpaInterfaceP2pSaveConfig(struct IWpaInterface * self,const char * ifName)1706 int32_t WpaInterfaceP2pSaveConfig(struct IWpaInterface *self, const char *ifName)
1707 {
1708 HDF_LOGI("Ready to enter hdi %{public}s", __func__);
1709 struct wpa_supplicant *wpaSupp;
1710
1711 int32_t ret = 0;
1712 (void)self;
1713 wpaSupp = getWpaP2p();
1714 ret = IsNull(ifName, wpaSupp);
1715 if (ret < 0) {
1716 return ret;
1717 }
1718
1719 ret = wpa_supplicant_ctrl_iface_save_config(wpaSupp);
1720 if (ret < 0) {
1721 HDF_LOGE("%{public}s P2pSaveConfig fail! ret=%d", __func__, ret);
1722 }
1723 HDF_LOGI("%{public}s P2pSaveConfig success", __func__);
1724 return HDF_SUCCESS;
1725 }
1726
WpaFillP2pDeviceFoundParam(struct P2pDeviceInfoParam * deviceInfoParam,struct HdiP2pDeviceInfoParam * hdiP2pDeviceInfoParam)1727 static int32_t WpaFillP2pDeviceFoundParam(struct P2pDeviceInfoParam *deviceInfoParam,
1728 struct HdiP2pDeviceInfoParam *hdiP2pDeviceInfoParam)
1729 {
1730 int32_t ret = 0;
1731 if (deviceInfoParam == NULL || hdiP2pDeviceInfoParam == NULL) {
1732 HDF_LOGE("%{public}s: deviceInfoParam or hdiP2pDeviceInfo is NULL!", __func__);
1733 return HDF_ERR_INVALID_PARAM;
1734 }
1735 hdiP2pDeviceInfoParam->configMethods = deviceInfoParam->configMethods;
1736 hdiP2pDeviceInfoParam->deviceCapabilities = deviceInfoParam->deviceCapabilities;
1737 hdiP2pDeviceInfoParam->groupCapabilities = deviceInfoParam->groupCapabilities;
1738 hdiP2pDeviceInfoParam->wfdLength = deviceInfoParam->wfdLength;
1739
1740 do {
1741 if (FillData(&hdiP2pDeviceInfoParam->srcAddress, &hdiP2pDeviceInfoParam->srcAddressLen,
1742 deviceInfoParam->srcAddress, ETH_ADDR_LEN) != HDF_SUCCESS) {
1743 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1744 ret = HDF_FAILURE;
1745 break;
1746 }
1747 if (FillData(&hdiP2pDeviceInfoParam->p2pDeviceAddress, &hdiP2pDeviceInfoParam->p2pDeviceAddressLen,
1748 deviceInfoParam->p2pDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) {
1749 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1750 ret = HDF_FAILURE;
1751 break;
1752 }
1753 if (FillData(&hdiP2pDeviceInfoParam->primaryDeviceType, &hdiP2pDeviceInfoParam->primaryDeviceTypeLen,
1754 deviceInfoParam->primaryDeviceType, WIFI_P2P_DEVICE_TYPE_LENGTH) != HDF_SUCCESS) {
1755 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1756 ret = HDF_FAILURE;
1757 break;
1758 }
1759 if (FillData(&hdiP2pDeviceInfoParam->deviceName, &hdiP2pDeviceInfoParam->deviceNameLen,
1760 deviceInfoParam->deviceName, WIFI_P2P_DEVICE_NAME_LENGTH) != HDF_SUCCESS) {
1761 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1762 ret = HDF_FAILURE;
1763 break;
1764 }
1765 if (FillData(&hdiP2pDeviceInfoParam->wfdDeviceInfo, &hdiP2pDeviceInfoParam->wfdDeviceInfoLen,
1766 deviceInfoParam->wfdDeviceInfo, WIFI_P2P_WFD_DEVICE_INFO_LENGTH) != HDF_SUCCESS) {
1767 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1768 ret = HDF_FAILURE;
1769 break;
1770 }
1771 if (FillData(&hdiP2pDeviceInfoParam->operSsid, &hdiP2pDeviceInfoParam->operSsidLen,
1772 deviceInfoParam->operSsid, WIFI_P2P_DEVICE_NAME_LENGTH) != HDF_SUCCESS) {
1773 HDF_LOGE("%{public}s: fill reason fail!", __func__);
1774 ret = HDF_FAILURE;
1775 }
1776 } while (0);
1777
1778 if (ret != HDF_SUCCESS) {
1779 if (hdiP2pDeviceInfoParam->srcAddress != NULL) {
1780 OsalMemFree(hdiP2pDeviceInfoParam->srcAddress);
1781 }
1782 if (hdiP2pDeviceInfoParam->p2pDeviceAddress != NULL) {
1783 OsalMemFree(hdiP2pDeviceInfoParam->p2pDeviceAddress);
1784 }
1785 if (hdiP2pDeviceInfoParam->primaryDeviceType != NULL) {
1786 OsalMemFree(hdiP2pDeviceInfoParam->primaryDeviceType);
1787 }
1788 if (hdiP2pDeviceInfoParam->deviceName != NULL) {
1789 OsalMemFree(hdiP2pDeviceInfoParam->deviceName);
1790 }
1791 if (hdiP2pDeviceInfoParam->wfdDeviceInfo != NULL) {
1792 OsalMemFree(hdiP2pDeviceInfoParam->wfdDeviceInfo);
1793 }
1794 if (hdiP2pDeviceInfoParam->operSsid != NULL) {
1795 OsalMemFree(hdiP2pDeviceInfoParam->operSsid);
1796 }
1797 }
1798 return ret;
1799 }
1800
WpaFillP2pDeviceLostParam(struct P2pDeviceLostParam * deviceLostParam,struct HdiP2pDeviceLostParam * hdiP2pDeviceLostParam)1801 static int32_t WpaFillP2pDeviceLostParam(struct P2pDeviceLostParam *deviceLostParam,
1802 struct HdiP2pDeviceLostParam *hdiP2pDeviceLostParam)
1803 {
1804 int32_t ret = 0;
1805 if (deviceLostParam == NULL || hdiP2pDeviceLostParam == NULL) {
1806 HDF_LOGE("%{public}s: deviceLostParam or hdiP2pDeviceLostParam is NULL!", __func__);
1807 return HDF_ERR_INVALID_PARAM;
1808 }
1809 hdiP2pDeviceLostParam->networkId = deviceLostParam->networkId;
1810
1811 if (FillData(&hdiP2pDeviceLostParam->p2pDeviceAddress, &hdiP2pDeviceLostParam->p2pDeviceAddressLen,
1812 deviceLostParam->p2pDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) {
1813 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1814 ret = HDF_FAILURE;
1815 }
1816 if (ret != HDF_SUCCESS) {
1817 if (hdiP2pDeviceLostParam->p2pDeviceAddress != NULL) {
1818 OsalMemFree(hdiP2pDeviceLostParam->p2pDeviceAddress);
1819 }
1820 }
1821 return ret;
1822 }
1823
WpaFillP2pGoNegotiationRequestParam(struct P2pGoNegotiationRequestParam * goNegotiationRequestParam,struct HdiP2pGoNegotiationRequestParam * hdiP2pGoNegotiationRequestParam)1824 static int32_t WpaFillP2pGoNegotiationRequestParam(struct P2pGoNegotiationRequestParam *goNegotiationRequestParam,
1825 struct HdiP2pGoNegotiationRequestParam *hdiP2pGoNegotiationRequestParam)
1826 {
1827 int32_t ret = 0;
1828 if (goNegotiationRequestParam == NULL || hdiP2pGoNegotiationRequestParam == NULL) {
1829 HDF_LOGE("%{public}s: goNegotiationRequestParam or hdiP2pGoNegotiationRequestParam is NULL!", __func__);
1830 return HDF_ERR_INVALID_PARAM;
1831 }
1832 hdiP2pGoNegotiationRequestParam->passwordId = goNegotiationRequestParam->passwordId;
1833
1834 if (FillData(&hdiP2pGoNegotiationRequestParam->srcAddress, &hdiP2pGoNegotiationRequestParam->srcAddressLen,
1835 goNegotiationRequestParam->srcAddress, ETH_ADDR_LEN) != HDF_SUCCESS) {
1836 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1837 ret = HDF_FAILURE;
1838 }
1839 if (ret != HDF_SUCCESS) {
1840 if (hdiP2pGoNegotiationRequestParam->srcAddress != NULL) {
1841 OsalMemFree(hdiP2pGoNegotiationRequestParam->srcAddress);
1842 }
1843 }
1844 return ret;
1845 }
1846
WpaFillP2pGoNegotiationCompletedParam(struct P2pGoNegotiationCompletedParam * goNegotiationCompletedParam,struct HdiP2pGoNegotiationCompletedParam * hdiP2pGoNegotiationCompletedParam)1847 static int32_t WpaFillP2pGoNegotiationCompletedParam(struct P2pGoNegotiationCompletedParam
1848 *goNegotiationCompletedParam, struct HdiP2pGoNegotiationCompletedParam *hdiP2pGoNegotiationCompletedParam)
1849 {
1850 int32_t ret = 0;
1851 if (goNegotiationCompletedParam == NULL || hdiP2pGoNegotiationCompletedParam == NULL) {
1852 HDF_LOGE("%{public}s: goNegotiationCompletedParam or hdiP2pGoNegotiationCompletedParam is NULL!", __func__);
1853 return HDF_ERR_INVALID_PARAM;
1854 }
1855 hdiP2pGoNegotiationCompletedParam->status = goNegotiationCompletedParam->status;
1856 return ret;
1857 }
1858
WpaFillP2pInvitationReceivedParam(struct P2pInvitationReceivedParam * invitationReceivedParam,struct HdiP2pInvitationReceivedParam * hdiP2pInvitationReceivedParam)1859 static int32_t WpaFillP2pInvitationReceivedParam(struct P2pInvitationReceivedParam *invitationReceivedParam,
1860 struct HdiP2pInvitationReceivedParam *hdiP2pInvitationReceivedParam)
1861 {
1862 int32_t ret = HDF_SUCCESS;
1863 if (invitationReceivedParam == NULL || hdiP2pInvitationReceivedParam == NULL) {
1864 HDF_LOGE("%{public}s: invitationReceivedParam or hdiP2pInvitationReceivedParam is NULL!", __func__);
1865 return HDF_ERR_INVALID_PARAM;
1866 }
1867 hdiP2pInvitationReceivedParam->type = invitationReceivedParam->type;
1868 hdiP2pInvitationReceivedParam->persistentNetworkId = invitationReceivedParam->persistentNetworkId;
1869 hdiP2pInvitationReceivedParam->operatingFrequency = invitationReceivedParam->operatingFrequency;
1870
1871 do {
1872 if (FillData(&hdiP2pInvitationReceivedParam->srcAddress, &hdiP2pInvitationReceivedParam->srcAddressLen,
1873 invitationReceivedParam->srcAddress, ETH_ADDR_LEN) != HDF_SUCCESS) {
1874 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1875 ret = HDF_FAILURE;
1876 break;
1877 }
1878 if (FillData(&hdiP2pInvitationReceivedParam->goDeviceAddress,
1879 &hdiP2pInvitationReceivedParam->goDeviceAddressLen,
1880 invitationReceivedParam->goDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) {
1881 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1882 ret = HDF_FAILURE;
1883 break;
1884 }
1885 if (FillData(&hdiP2pInvitationReceivedParam->bssid, &hdiP2pInvitationReceivedParam->bssidLen,
1886 invitationReceivedParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) {
1887 HDF_LOGE("%{public}s: fill ssid fail!", __func__);
1888 ret = HDF_FAILURE;
1889 }
1890 } while (0);
1891
1892 if (ret != HDF_SUCCESS) {
1893 if (hdiP2pInvitationReceivedParam->srcAddress != NULL) {
1894 OsalMemFree(hdiP2pInvitationReceivedParam->srcAddress);
1895 }
1896 if (hdiP2pInvitationReceivedParam->goDeviceAddress != NULL) {
1897 OsalMemFree(hdiP2pInvitationReceivedParam->goDeviceAddress);
1898 }
1899 if (hdiP2pInvitationReceivedParam->bssid != NULL) {
1900 OsalMemFree(hdiP2pInvitationReceivedParam->bssid);
1901 }
1902 }
1903 return ret;
1904 }
1905
WpaFillP2pInvitationResultParam(struct P2pInvitationResultParam * invitationResultParam,struct HdiP2pInvitationResultParam * hdiP2pInvitationResultParam)1906 static int32_t WpaFillP2pInvitationResultParam(struct P2pInvitationResultParam *invitationResultParam,
1907 struct HdiP2pInvitationResultParam *hdiP2pInvitationResultParam)
1908 {
1909 int32_t ret = HDF_SUCCESS;
1910 if (invitationResultParam == NULL || hdiP2pInvitationResultParam == NULL) {
1911 HDF_LOGE("%{public}s: invitationResultParam or hdiP2pInvitationResultParam is NULL!", __func__);
1912 return HDF_ERR_INVALID_PARAM;
1913 }
1914 hdiP2pInvitationResultParam->status = invitationResultParam->status;
1915
1916 if (FillData(&hdiP2pInvitationResultParam->bssid, &hdiP2pInvitationResultParam->bssidLen,
1917 invitationResultParam->bssid, ETH_ADDR_LEN) != HDF_SUCCESS) {
1918 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1919 ret = HDF_FAILURE;
1920 }
1921 if (ret != HDF_SUCCESS) {
1922 if (hdiP2pInvitationResultParam->bssid != NULL) {
1923 OsalMemFree(hdiP2pInvitationResultParam->bssid);
1924 }
1925 }
1926 return ret;
1927 }
1928
WpaFillP2pGroupStartedParam(struct P2pGroupStartedParam * groupStartedParam,struct HdiP2pGroupStartedParam * hdiP2pGroupStartedParam)1929 static int32_t WpaFillP2pGroupStartedParam(struct P2pGroupStartedParam *groupStartedParam,
1930 struct HdiP2pGroupStartedParam *hdiP2pGroupStartedParam)
1931 {
1932 int32_t ret = HDF_SUCCESS;
1933 if (groupStartedParam == NULL || hdiP2pGroupStartedParam == NULL) {
1934 HDF_LOGE("%{public}s: groupStartedParam or hdiP2pGroupStartedParam is NULL!", __func__);
1935 return HDF_ERR_INVALID_PARAM;
1936 }
1937 hdiP2pGroupStartedParam->isGo = groupStartedParam->isGo;
1938 hdiP2pGroupStartedParam->isPersistent = groupStartedParam->isPersistent;
1939 hdiP2pGroupStartedParam->frequency = groupStartedParam->frequency;
1940
1941 do {
1942 if (FillData(&hdiP2pGroupStartedParam->groupIfName, &hdiP2pGroupStartedParam->groupIfNameLen,
1943 groupStartedParam->groupIfName, WIFI_P2P_GROUP_IFNAME_LENGTH) != HDF_SUCCESS) {
1944 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1945 ret = HDF_FAILURE;
1946 break;
1947 }
1948 if (FillData(&hdiP2pGroupStartedParam->ssid, &hdiP2pGroupStartedParam->ssidLen,
1949 groupStartedParam->ssid, WIFI_SSID_LENGTH) != HDF_SUCCESS) {
1950 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
1951 ret = HDF_FAILURE;
1952 break;
1953 }
1954 if (FillData(&hdiP2pGroupStartedParam->psk, &hdiP2pGroupStartedParam->pskLen,
1955 groupStartedParam->psk, WIFI_P2P_PASSWORD_SIZE) != HDF_SUCCESS) {
1956 HDF_LOGE("%{public}s: fill ssid fail!", __func__);
1957 ret = HDF_FAILURE;
1958 break;
1959 }
1960 if (FillData(&hdiP2pGroupStartedParam->passphrase, &hdiP2pGroupStartedParam->passphraseLen,
1961 groupStartedParam->passphrase, WIFI_P2P_PASSWORD_SIZE) != HDF_SUCCESS) {
1962 HDF_LOGE("%{public}s: fill ssid fail!", __func__);
1963 ret = HDF_FAILURE;
1964 break;
1965 }
1966 if (FillData(&hdiP2pGroupStartedParam->goDeviceAddress, &hdiP2pGroupStartedParam->goDeviceAddressLen,
1967 groupStartedParam->goDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) {
1968 HDF_LOGE("%{public}s: fill ssid fail!", __func__);
1969 ret = HDF_FAILURE;
1970 }
1971 } while (0);
1972
1973 if (ret != HDF_SUCCESS) {
1974 if (hdiP2pGroupStartedParam->groupIfName != NULL) {
1975 OsalMemFree(hdiP2pGroupStartedParam->groupIfName);
1976 }
1977 if (hdiP2pGroupStartedParam->ssid != NULL) {
1978 OsalMemFree(hdiP2pGroupStartedParam->ssid);
1979 }
1980 if (hdiP2pGroupStartedParam->psk != NULL) {
1981 OsalMemFree(hdiP2pGroupStartedParam->psk);
1982 }
1983 if (hdiP2pGroupStartedParam->passphrase != NULL) {
1984 OsalMemFree(hdiP2pGroupStartedParam->passphrase);
1985 }
1986 if (hdiP2pGroupStartedParam->goDeviceAddress != NULL) {
1987 OsalMemFree(hdiP2pGroupStartedParam->goDeviceAddress);
1988 }
1989 }
1990 return ret;
1991 }
1992
WpaFillP2pGroupRemovedParam(struct P2pGroupRemovedParam * groupRemovedParam,struct HdiP2pGroupRemovedParam * hdiP2pGroupRemovedParam)1993 static int32_t WpaFillP2pGroupRemovedParam(struct P2pGroupRemovedParam *groupRemovedParam,
1994 struct HdiP2pGroupRemovedParam *hdiP2pGroupRemovedParam)
1995 {
1996 int32_t ret = HDF_SUCCESS;
1997 if (groupRemovedParam == NULL || hdiP2pGroupRemovedParam == NULL) {
1998 HDF_LOGE("%{public}s: groupStartedParam or hdiP2pGroupRemovedParam is NULL!", __func__);
1999 return HDF_ERR_INVALID_PARAM;
2000 }
2001 hdiP2pGroupRemovedParam->isGo = groupRemovedParam->isGo;
2002
2003 if (FillData(&hdiP2pGroupRemovedParam->groupIfName, &hdiP2pGroupRemovedParam->groupIfNameLen,
2004 groupRemovedParam->groupIfName, WIFI_P2P_GROUP_IFNAME_LENGTH) != HDF_SUCCESS) {
2005 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
2006 ret = HDF_FAILURE;
2007 }
2008 if (ret != HDF_SUCCESS) {
2009 if (hdiP2pGroupRemovedParam->groupIfName != NULL) {
2010 OsalMemFree(hdiP2pGroupRemovedParam->groupIfName);
2011 }
2012 }
2013 return ret;
2014 }
2015
WpaFillP2pProvisionDiscoveryCompletedParam(struct P2pProvisionDiscoveryCompletedParam * provisionDiscoveryCompletedParam,struct HdiP2pProvisionDiscoveryCompletedParam * hdiP2pProvisionDiscoveryCompletedParam)2016 static int32_t WpaFillP2pProvisionDiscoveryCompletedParam(struct P2pProvisionDiscoveryCompletedParam
2017 *provisionDiscoveryCompletedParam,
2018 struct HdiP2pProvisionDiscoveryCompletedParam *hdiP2pProvisionDiscoveryCompletedParam)
2019 {
2020 int32_t ret = HDF_SUCCESS;
2021 if (provisionDiscoveryCompletedParam == NULL || hdiP2pProvisionDiscoveryCompletedParam == NULL) {
2022 HDF_LOGE("%{public}s: provisionDiscoveryCompletedParam or hdiP2pProvisionDiscoveryCompletedParam is NULL!",
2023 __func__);
2024 return HDF_ERR_INVALID_PARAM;
2025 }
2026 hdiP2pProvisionDiscoveryCompletedParam->isRequest = provisionDiscoveryCompletedParam->isRequest;
2027 hdiP2pProvisionDiscoveryCompletedParam->provDiscStatusCode = provisionDiscoveryCompletedParam->provDiscStatusCode;
2028 hdiP2pProvisionDiscoveryCompletedParam->configMethods = provisionDiscoveryCompletedParam->configMethods;
2029
2030 do {
2031 if (FillData(&hdiP2pProvisionDiscoveryCompletedParam->p2pDeviceAddress,
2032 &hdiP2pProvisionDiscoveryCompletedParam->p2pDeviceAddressLen,
2033 provisionDiscoveryCompletedParam->p2pDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) {
2034 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
2035 ret = HDF_FAILURE;
2036 break;
2037 }
2038 if (FillData(&hdiP2pProvisionDiscoveryCompletedParam->generatedPin,
2039 &hdiP2pProvisionDiscoveryCompletedParam->generatedPinLen,
2040 provisionDiscoveryCompletedParam->generatedPin, WIFI_PIN_CODE_LENGTH) != HDF_SUCCESS) {
2041 HDF_LOGE("%{public}s: fill ssid fail!", __func__);
2042 ret = HDF_FAILURE;
2043 }
2044 } while (0);
2045
2046 if (ret != HDF_SUCCESS) {
2047 if (hdiP2pProvisionDiscoveryCompletedParam->p2pDeviceAddress != NULL) {
2048 OsalMemFree(hdiP2pProvisionDiscoveryCompletedParam->p2pDeviceAddress);
2049 }
2050 if (hdiP2pProvisionDiscoveryCompletedParam->generatedPin != NULL) {
2051 OsalMemFree(hdiP2pProvisionDiscoveryCompletedParam->generatedPin);
2052 }
2053 }
2054 return ret;
2055 }
2056
WpaFillP2pServDiscReqParam(struct P2pServDiscReqInfoParam * servDiscReqInfo,struct HdiP2pServDiscReqInfoParam * hdiP2pServDiscReqInfo)2057 static int32_t WpaFillP2pServDiscReqParam(struct P2pServDiscReqInfoParam *servDiscReqInfo,
2058 struct HdiP2pServDiscReqInfoParam *hdiP2pServDiscReqInfo)
2059 {
2060 int32_t ret = HDF_SUCCESS;
2061 if (servDiscReqInfo == NULL || hdiP2pServDiscReqInfo == NULL) {
2062 HDF_LOGE("%{public}s: servDiscReqInfo or hdiP2pServDiscReqInfo is NULL!", __func__);
2063 return HDF_ERR_INVALID_PARAM;
2064 }
2065 hdiP2pServDiscReqInfo->freq = servDiscReqInfo->freq;
2066 hdiP2pServDiscReqInfo->dialogToken = servDiscReqInfo->dialogToken;
2067 hdiP2pServDiscReqInfo->updateIndic = servDiscReqInfo->updateIndic;
2068
2069 do {
2070 if (FillData(&hdiP2pServDiscReqInfo->mac, &hdiP2pServDiscReqInfo->macLen,
2071 servDiscReqInfo->mac, ETH_ADDR_LEN) != HDF_SUCCESS) {
2072 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
2073 ret = HDF_FAILURE;
2074 break;
2075 }
2076 if (FillData(&hdiP2pServDiscReqInfo->tlvs, &hdiP2pServDiscReqInfo->tlvsLen,
2077 servDiscReqInfo->tlvs, WIFI_P2P_TLVS_LENGTH) != HDF_SUCCESS) {
2078 HDF_LOGE("%{public}s: fill ssid fail!", __func__);
2079 ret = HDF_FAILURE;
2080 }
2081 } while (0);
2082
2083 if (ret != HDF_SUCCESS) {
2084 if (hdiP2pServDiscReqInfo->mac != NULL) {
2085 OsalMemFree(hdiP2pServDiscReqInfo->mac);
2086 }
2087 if (hdiP2pServDiscReqInfo->tlvs != NULL) {
2088 OsalMemFree(hdiP2pServDiscReqInfo->tlvs);
2089 }
2090 }
2091 return ret;
2092 }
2093
WpaFillP2pServDiscRespParam(struct P2pServDiscRespParam * servDiscRespParam,struct HdiP2pServDiscRespParam * hdiP2pServDiscRespParam)2094 static int32_t WpaFillP2pServDiscRespParam(struct P2pServDiscRespParam *servDiscRespParam,
2095 struct HdiP2pServDiscRespParam *hdiP2pServDiscRespParam)
2096 {
2097 int32_t ret = HDF_SUCCESS;
2098 if (servDiscRespParam == NULL || hdiP2pServDiscRespParam == NULL) {
2099 HDF_LOGE("%{public}s: servDiscRespParam or hdiP2pServDiscRespParam is NULL!", __func__);
2100 return HDF_ERR_INVALID_PARAM;
2101 }
2102 hdiP2pServDiscRespParam->updateIndicator = servDiscRespParam->updateIndicator;
2103
2104 do {
2105 if (FillData(&hdiP2pServDiscRespParam->srcAddress, &hdiP2pServDiscRespParam->srcAddressLen,
2106 servDiscRespParam->srcAddress, ETH_ADDR_LEN) != HDF_SUCCESS) {
2107 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
2108 ret = HDF_FAILURE;
2109 break;
2110 }
2111 if (FillData(&hdiP2pServDiscRespParam->tlvs, &hdiP2pServDiscRespParam->tlvsLen,
2112 servDiscRespParam->tlvs, WIFI_P2P_TLVS_LENGTH) != HDF_SUCCESS) {
2113 HDF_LOGE("%{public}s: fill ssid fail!", __func__);
2114 ret = HDF_FAILURE;
2115 }
2116 } while (0);
2117
2118 if (ret != HDF_SUCCESS) {
2119 if (hdiP2pServDiscRespParam->srcAddress != NULL) {
2120 OsalMemFree(hdiP2pServDiscRespParam->srcAddress);
2121 }
2122 if (hdiP2pServDiscRespParam->tlvs != NULL) {
2123 OsalMemFree(hdiP2pServDiscRespParam->tlvs);
2124 }
2125 }
2126 return ret;
2127 }
2128
WpaFillP2pStaConnectStateParam(struct P2pStaConnectStateParam * staConnectStateParam,struct HdiP2pStaConnectStateParam * hdiP2pStaConnectStateParam)2129 static int32_t WpaFillP2pStaConnectStateParam(struct P2pStaConnectStateParam *staConnectStateParam,
2130 struct HdiP2pStaConnectStateParam *hdiP2pStaConnectStateParam)
2131 {
2132 int32_t ret = HDF_SUCCESS;
2133 if (staConnectStateParam == NULL || hdiP2pStaConnectStateParam == NULL) {
2134 HDF_LOGE("%{public}s: staConnectStateParam or hdiP2pStaConnectStateParam is NULL!", __func__);
2135 return HDF_ERR_INVALID_PARAM;
2136 }
2137 hdiP2pStaConnectStateParam->state = staConnectStateParam->state;
2138 do {
2139 if (FillData(&hdiP2pStaConnectStateParam->srcAddress, &hdiP2pStaConnectStateParam->srcAddressLen,
2140 staConnectStateParam->srcAddress, ETH_ADDR_LEN) != HDF_SUCCESS) {
2141 HDF_LOGE("%{public}s: fill bssid fail!", __func__);
2142 ret = HDF_FAILURE;
2143 break;
2144 }
2145 if (FillData(&hdiP2pStaConnectStateParam->p2pDeviceAddress, &hdiP2pStaConnectStateParam->p2pDeviceAddressLen,
2146 staConnectStateParam->p2pDeviceAddress, ETH_ADDR_LEN) != HDF_SUCCESS) {
2147 HDF_LOGE("%{public}s: fill ssid fail!", __func__);
2148 ret = HDF_FAILURE;
2149 }
2150 } while (0);
2151
2152 if (ret != HDF_SUCCESS) {
2153 if (hdiP2pStaConnectStateParam->srcAddress != NULL) {
2154 OsalMemFree(hdiP2pStaConnectStateParam->srcAddress);
2155 }
2156 if (hdiP2pStaConnectStateParam->p2pDeviceAddress != NULL) {
2157 OsalMemFree(hdiP2pStaConnectStateParam->p2pDeviceAddress);
2158 }
2159 }
2160 return ret;
2161 }
2162
WpaFillP2pIfaceCreatedParam(struct P2pIfaceCreatedParam * ifaceCreatedParam,struct HdiP2pIfaceCreatedParam * hdiP2pIfaceCreatedParam)2163 static int32_t WpaFillP2pIfaceCreatedParam(struct P2pIfaceCreatedParam *ifaceCreatedParam,
2164 struct HdiP2pIfaceCreatedParam *hdiP2pIfaceCreatedParam)
2165 {
2166 int32_t ret = HDF_SUCCESS;
2167 if (ifaceCreatedParam == NULL || hdiP2pIfaceCreatedParam == NULL) {
2168 HDF_LOGE("%{public}s: ifaceCreatedParam or hdiP2pIfaceCreatedParam is NULL!", __func__);
2169 return HDF_ERR_INVALID_PARAM;
2170 }
2171 hdiP2pIfaceCreatedParam->isGo = ifaceCreatedParam->isGo;
2172 return ret;
2173 }
2174
ProcessEventP2pDeviceFound(struct HdfWpaRemoteNode * node,struct P2pDeviceInfoParam * deviceInfoParam,const char * ifName)2175 int32_t ProcessEventP2pDeviceFound(struct HdfWpaRemoteNode *node,
2176 struct P2pDeviceInfoParam *deviceInfoParam, const char *ifName)
2177 {
2178 struct HdiP2pDeviceInfoParam *hdiP2pDeviceInfo = NULL;
2179 int32_t ret = HDF_FAILURE;
2180 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventDeviceFound == NULL) {
2181 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2182 return HDF_ERR_INVALID_PARAM;
2183 }
2184 hdiP2pDeviceInfo = (struct HdiP2pDeviceInfoParam *)OsalMemCalloc(sizeof(struct P2pDeviceInfoParam));
2185 if ((hdiP2pDeviceInfo == NULL) || (WpaFillP2pDeviceFoundParam(deviceInfoParam, hdiP2pDeviceInfo) != HDF_SUCCESS)) {
2186 HDF_LOGE("%{public}s: hdiP2pDeviceInfo is NULL or deviceInfoParam fialed!", __func__);
2187 } else {
2188 ret = node->callbackObj->OnEventDeviceFound(node->callbackObj, hdiP2pDeviceInfo, ifName);
2189 }
2190 HdiP2pDeviceInfoParamFree(hdiP2pDeviceInfo, true);
2191 return ret;
2192 }
2193
ProcessEventP2pDeviceLost(struct HdfWpaRemoteNode * node,struct P2pDeviceLostParam * deviceLostParam,const char * ifName)2194 int32_t ProcessEventP2pDeviceLost(struct HdfWpaRemoteNode *node,
2195 struct P2pDeviceLostParam *deviceLostParam, const char *ifName)
2196 {
2197 struct HdiP2pDeviceLostParam *hdiP2pDeviceLostParam = NULL;
2198 int32_t ret = HDF_FAILURE;
2199 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventDeviceLost == NULL) {
2200 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2201 return HDF_ERR_INVALID_PARAM;
2202 }
2203 hdiP2pDeviceLostParam = (struct HdiP2pDeviceLostParam *)OsalMemCalloc(sizeof(struct P2pDeviceLostParam));
2204 if ((hdiP2pDeviceLostParam == NULL) || (WpaFillP2pDeviceLostParam(deviceLostParam, hdiP2pDeviceLostParam)
2205 != HDF_SUCCESS)) {
2206 HDF_LOGE("%{public}s: hdiP2pDeviceLostParam is NULL or deviceLostParam fialed!", __func__);
2207 } else {
2208 ret = node->callbackObj->OnEventDeviceLost(node->callbackObj, hdiP2pDeviceLostParam, ifName);
2209 }
2210 HdiP2pDeviceLostParamFree(hdiP2pDeviceLostParam, true);
2211 return ret;
2212 }
2213
ProcessEventP2pGoNegotiationRequest(struct HdfWpaRemoteNode * node,struct P2pGoNegotiationRequestParam * goNegotiationRequestParam,const char * ifName)2214 int32_t ProcessEventP2pGoNegotiationRequest(struct HdfWpaRemoteNode *node,
2215 struct P2pGoNegotiationRequestParam *goNegotiationRequestParam, const char *ifName)
2216 {
2217 struct HdiP2pGoNegotiationRequestParam *hdiP2pGoNegotiationRequestParam = NULL;
2218 int32_t ret = HDF_FAILURE;
2219 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventGoNegotiationRequest == NULL) {
2220 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2221 return HDF_ERR_INVALID_PARAM;
2222 }
2223 hdiP2pGoNegotiationRequestParam = (struct HdiP2pGoNegotiationRequestParam *)OsalMemCalloc(
2224 sizeof(struct P2pGoNegotiationRequestParam));
2225 if ((hdiP2pGoNegotiationRequestParam == NULL) || (WpaFillP2pGoNegotiationRequestParam(goNegotiationRequestParam,
2226 hdiP2pGoNegotiationRequestParam) != HDF_SUCCESS)) {
2227 HDF_LOGE("%{public}s: hdiP2pGoNegotiationRequestParam is NULL or goNegotiationRequestParam fialed!", __func__);
2228 } else {
2229 ret = node->callbackObj->OnEventGoNegotiationRequest(node->callbackObj,
2230 hdiP2pGoNegotiationRequestParam, ifName);
2231 }
2232 HdiP2pGoNegotiationRequestParamFree(hdiP2pGoNegotiationRequestParam, true);
2233 return ret;
2234 }
2235
ProcessEventP2pGoNegotiationCompleted(struct HdfWpaRemoteNode * node,struct P2pGoNegotiationCompletedParam * goNegotiationCompletedParam,const char * ifName)2236 int32_t ProcessEventP2pGoNegotiationCompleted(struct HdfWpaRemoteNode *node, struct P2pGoNegotiationCompletedParam
2237 *goNegotiationCompletedParam, const char *ifName)
2238 {
2239 struct HdiP2pGoNegotiationCompletedParam *hdiP2pGoNegotiationCompletedParam = NULL;
2240 int32_t ret = HDF_FAILURE;
2241 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventGoNegotiationCompleted == NULL) {
2242 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2243 return HDF_ERR_INVALID_PARAM;
2244 }
2245 hdiP2pGoNegotiationCompletedParam->status = goNegotiationCompletedParam->status;
2246 if ((hdiP2pGoNegotiationCompletedParam == NULL) || (WpaFillP2pGoNegotiationCompletedParam(
2247 goNegotiationCompletedParam, hdiP2pGoNegotiationCompletedParam) != HDF_SUCCESS)) {
2248 HDF_LOGE("%{public}s: hdiP2pGoNegotiationCompletedParam is NULL or goNegotiationCompletedParam fialed!",
2249 __func__);
2250 } else {
2251 ret = node->callbackObj->OnEventGoNegotiationCompleted(node->callbackObj,
2252 hdiP2pGoNegotiationCompletedParam, ifName);
2253 }
2254 HdiP2pGoNegotiationCompletedParamFree(hdiP2pGoNegotiationCompletedParam, true);
2255 return ret;
2256 }
2257
ProcessEventP2pInvitationReceived(struct HdfWpaRemoteNode * node,struct P2pInvitationReceivedParam * invitationReceivedParam,const char * ifName)2258 int32_t ProcessEventP2pInvitationReceived(struct HdfWpaRemoteNode *node,
2259 struct P2pInvitationReceivedParam *invitationReceivedParam, const char *ifName)
2260 {
2261 struct HdiP2pInvitationReceivedParam *hdiP2pInvitationReceivedParam = NULL;
2262 int32_t ret = HDF_FAILURE;
2263 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventInvitationReceived == NULL) {
2264 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2265 return HDF_ERR_INVALID_PARAM;
2266 }
2267 hdiP2pInvitationReceivedParam = (struct HdiP2pInvitationReceivedParam *)OsalMemCalloc(
2268 sizeof(struct P2pInvitationReceivedParam));
2269 if ((hdiP2pInvitationReceivedParam == NULL) || (WpaFillP2pInvitationReceivedParam(
2270 invitationReceivedParam, hdiP2pInvitationReceivedParam) != HDF_SUCCESS)) {
2271 HDF_LOGE("%{public}s: hdiP2pInvitationReceivedParam is NULL or invitationReceivedParam fialed!", __func__);
2272 return ret;
2273 } else {
2274 ret = node->callbackObj->OnEventInvitationReceived(node->callbackObj, hdiP2pInvitationReceivedParam, ifName);
2275 }
2276 HdiP2pInvitationReceivedParamFree(hdiP2pInvitationReceivedParam, true);
2277 return ret;
2278 }
2279
ProcessEventP2pInvitationResult(struct HdfWpaRemoteNode * node,struct P2pInvitationResultParam * invitationResultParam,const char * ifName)2280 int32_t ProcessEventP2pInvitationResult(struct HdfWpaRemoteNode *node,
2281 struct P2pInvitationResultParam *invitationResultParam, const char *ifName)
2282 {
2283 struct HdiP2pInvitationResultParam *hdiP2pInvitationResultParam = NULL;
2284 int32_t ret = HDF_FAILURE;
2285 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventInvitationResult == NULL) {
2286 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2287 return HDF_ERR_INVALID_PARAM;
2288 }
2289 hdiP2pInvitationResultParam = (struct HdiP2pInvitationResultParam *)OsalMemCalloc(
2290 sizeof(struct P2pInvitationResultParam));
2291 if ((hdiP2pInvitationResultParam == NULL) || (WpaFillP2pInvitationResultParam(
2292 invitationResultParam, hdiP2pInvitationResultParam) != HDF_SUCCESS)) {
2293 HDF_LOGE("%{public}s: hdiP2pInvitationResultParam is NULL or invitationResultParam fialed!", __func__);
2294 return ret;
2295 } else {
2296 ret = node->callbackObj->OnEventInvitationResult(node->callbackObj, hdiP2pInvitationResultParam, ifName);
2297 }
2298 HdiP2pInvitationResultParamFree(hdiP2pInvitationResultParam, true);
2299 return ret;
2300 }
2301
ProcessEventP2pGroupFormationSuccess(struct HdfWpaRemoteNode * node,const char * ifName)2302 int32_t ProcessEventP2pGroupFormationSuccess(struct HdfWpaRemoteNode *node,
2303 const char *ifName)
2304 {
2305 int32_t ret = HDF_FAILURE;
2306 if (node == NULL || node->callbackObj == NULL) {
2307 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2308 return HDF_ERR_INVALID_PARAM;
2309 }
2310 ret = node->callbackObj->OnEventGroupFormationSuccess(node->callbackObj, ifName);
2311 return ret;
2312 }
2313
ProcessEventP2pGroupFormationFailure(struct HdfWpaRemoteNode * node,char * reason,const char * ifName)2314 int32_t ProcessEventP2pGroupFormationFailure(struct HdfWpaRemoteNode *node, char *reason,
2315 const char *ifName)
2316 {
2317 char *hdiReason = NULL;
2318 int32_t ret = HDF_FAILURE;
2319 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventGroupFormationFailure == NULL) {
2320 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2321 return HDF_ERR_INVALID_PARAM;
2322 }
2323 hdiReason = (char *)OsalMemCalloc(WIFI_REASON_LENGTH);
2324 if ((hdiReason == NULL) || (strncpy_s(hdiReason, WIFI_REASON_LENGTH, reason, WIFI_REASON_LENGTH) != HDF_SUCCESS)) {
2325 HDF_LOGE("%{public}s: hdiReason is NULL or reason fialed!", __func__);
2326 } else {
2327 ret = node->callbackObj->OnEventGroupFormationFailure(node->callbackObj, hdiReason, ifName);
2328 }
2329 OsalMemFree(hdiReason);
2330 return ret;
2331 }
2332
ProcessEventP2pGroupStarted(struct HdfWpaRemoteNode * node,struct P2pGroupStartedParam * groupStartedParam,const char * ifName)2333 int32_t ProcessEventP2pGroupStarted(struct HdfWpaRemoteNode *node,
2334 struct P2pGroupStartedParam *groupStartedParam, const char *ifName)
2335 {
2336 struct HdiP2pGroupStartedParam *hdiP2pGroupStartedParam = NULL;
2337 int32_t ret = HDF_FAILURE;
2338 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventGroupStarted == NULL) {
2339 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2340 return HDF_ERR_INVALID_PARAM;
2341 }
2342 hdiP2pGroupStartedParam = (struct HdiP2pGroupStartedParam *)OsalMemCalloc(sizeof(struct P2pGroupStartedParam));
2343 if ((hdiP2pGroupStartedParam == NULL) || (WpaFillP2pGroupStartedParam(groupStartedParam, hdiP2pGroupStartedParam)
2344 != HDF_SUCCESS)) {
2345 HDF_LOGE("%{public}s: hdiP2pGroupStartedParam is NULL or groupStartedParam fialed!", __func__);
2346 } else {
2347 ret = node->callbackObj->OnEventGroupStarted(node->callbackObj, hdiP2pGroupStartedParam, ifName);
2348 }
2349 HdiP2pGroupStartedParamFree(hdiP2pGroupStartedParam, true);
2350 return ret;
2351 }
2352
ProcessEventP2pGroupRemoved(struct HdfWpaRemoteNode * node,struct P2pGroupRemovedParam * groupRemovedParam,const char * ifName)2353 int32_t ProcessEventP2pGroupRemoved(struct HdfWpaRemoteNode *node,
2354 struct P2pGroupRemovedParam *groupRemovedParam, const char *ifName)
2355 {
2356 struct HdiP2pGroupRemovedParam *hdiP2pGroupRemovedParam = NULL;
2357 int32_t ret = HDF_FAILURE;
2358 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventGroupRemoved == NULL) {
2359 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2360 return HDF_ERR_INVALID_PARAM;
2361 }
2362 hdiP2pGroupRemovedParam = (struct HdiP2pGroupRemovedParam *)OsalMemCalloc(sizeof(struct P2pGroupRemovedParam));
2363 if ((hdiP2pGroupRemovedParam == NULL) || (WpaFillP2pGroupRemovedParam(groupRemovedParam, hdiP2pGroupRemovedParam)
2364 != HDF_SUCCESS)) {
2365 HDF_LOGE("%{public}s: hdiP2pGroupRemovedParam is NULL or groupRemovedParam fialed!", __func__);
2366 } else {
2367 ret = node->callbackObj->OnEventGroupRemoved(node->callbackObj, hdiP2pGroupRemovedParam, ifName);
2368 }
2369 HdiP2pGroupRemovedParamFree(hdiP2pGroupRemovedParam, true);
2370 return ret;
2371 }
2372
ProcessEventP2pProvisionDiscoveryCompleted(struct HdfWpaRemoteNode * node,struct P2pProvisionDiscoveryCompletedParam * provisionDiscoveryCompletedParam,const char * ifName)2373 int32_t ProcessEventP2pProvisionDiscoveryCompleted(struct HdfWpaRemoteNode *node,
2374 struct P2pProvisionDiscoveryCompletedParam *provisionDiscoveryCompletedParam, const char *ifName)
2375 {
2376 struct HdiP2pProvisionDiscoveryCompletedParam *hdiP2pProvisionDiscoveryCompletedParam = NULL;
2377 int32_t ret = HDF_FAILURE;
2378 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventProvisionDiscoveryCompleted == NULL) {
2379 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2380 return HDF_ERR_INVALID_PARAM;
2381 }
2382 hdiP2pProvisionDiscoveryCompletedParam = (struct HdiP2pProvisionDiscoveryCompletedParam *)OsalMemCalloc(
2383 sizeof(struct P2pProvisionDiscoveryCompletedParam));
2384 if ((hdiP2pProvisionDiscoveryCompletedParam == NULL) || (WpaFillP2pProvisionDiscoveryCompletedParam(
2385 provisionDiscoveryCompletedParam, hdiP2pProvisionDiscoveryCompletedParam) != HDF_SUCCESS)) {
2386 HDF_LOGE("%{public}s: Param is NULL or provisionDiscoveryCompletedParam fialed!", __func__);
2387 } else {
2388 ret = node->callbackObj->OnEventProvisionDiscoveryCompleted(node->callbackObj,
2389 hdiP2pProvisionDiscoveryCompletedParam, ifName);
2390 }
2391 HdiP2pProvisionDiscoveryCompletedParamFree(hdiP2pProvisionDiscoveryCompletedParam, true);
2392 return ret;
2393 }
2394
ProcessEventP2pFindStopped(struct HdfWpaRemoteNode * node,const char * ifName)2395 int32_t ProcessEventP2pFindStopped(struct HdfWpaRemoteNode *node,
2396 const char *ifName)
2397 {
2398 int32_t ret = HDF_FAILURE;
2399 if (node == NULL || node->callbackObj == NULL) {
2400 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2401 return HDF_ERR_INVALID_PARAM;
2402 }
2403 ret = node->callbackObj->OnEventFindStopped(node->callbackObj, ifName);
2404 return ret;
2405 }
2406
ProcessEventP2pServDiscReq(struct HdfWpaRemoteNode * node,struct P2pServDiscReqInfoParam * servDiscReqInfo,const char * ifName)2407 int32_t ProcessEventP2pServDiscReq(struct HdfWpaRemoteNode *node,
2408 struct P2pServDiscReqInfoParam *servDiscReqInfo, const char *ifName)
2409 {
2410 struct HdiP2pServDiscReqInfoParam *hdiP2pServDiscReqInfo = NULL;
2411 int32_t ret = HDF_FAILURE;
2412 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventServDiscReq == NULL) {
2413 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2414 return HDF_ERR_INVALID_PARAM;
2415 }
2416 hdiP2pServDiscReqInfo = (struct HdiP2pServDiscReqInfoParam *)OsalMemCalloc(
2417 sizeof(struct P2pServDiscReqInfoParam));
2418 if ((hdiP2pServDiscReqInfo == NULL) || (WpaFillP2pServDiscReqParam(servDiscReqInfo, hdiP2pServDiscReqInfo)
2419 != HDF_SUCCESS)) {
2420 HDF_LOGE("%{public}s: hdiP2pServDiscReqInfo is NULL or servDiscReqInfo fialed!", __func__);
2421 } else {
2422 ret = node->callbackObj->OnEventServDiscReq(node->callbackObj, hdiP2pServDiscReqInfo, ifName);
2423 }
2424 HdiP2pServDiscReqInfoParamFree(hdiP2pServDiscReqInfo, true);
2425 return ret;
2426 }
2427
ProcessEventP2pServDiscResp(struct HdfWpaRemoteNode * node,struct P2pServDiscRespParam * servDiscRespParam,const char * ifName)2428 int32_t ProcessEventP2pServDiscResp(struct HdfWpaRemoteNode *node,
2429 struct P2pServDiscRespParam *servDiscRespParam, const char *ifName)
2430 {
2431 struct HdiP2pServDiscRespParam *hdiP2pServDiscRespParam = NULL;
2432 int32_t ret = HDF_FAILURE;
2433 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventServDiscResp == NULL) {
2434 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2435 return HDF_ERR_INVALID_PARAM;
2436 }
2437 hdiP2pServDiscRespParam = (struct HdiP2pServDiscRespParam *)OsalMemCalloc(sizeof(struct P2pServDiscRespParam));
2438 if ((hdiP2pServDiscRespParam == NULL) || (WpaFillP2pServDiscRespParam(servDiscRespParam, hdiP2pServDiscRespParam)
2439 != HDF_SUCCESS)) {
2440 HDF_LOGE("%{public}s: hdiP2pServDiscRespParam is NULL or servDiscRespParam fialed!", __func__);
2441 } else {
2442 ret = node->callbackObj->OnEventServDiscResp(node->callbackObj, hdiP2pServDiscRespParam, ifName);
2443 }
2444 HdiP2pServDiscRespParamFree(hdiP2pServDiscRespParam, true);
2445 return ret;
2446 }
2447
ProcessEventP2pStaConnectState(struct HdfWpaRemoteNode * node,struct P2pStaConnectStateParam * staConnectStateParam,const char * ifName)2448 int32_t ProcessEventP2pStaConnectState(struct HdfWpaRemoteNode *node,
2449 struct P2pStaConnectStateParam *staConnectStateParam, const char *ifName)
2450 {
2451 struct HdiP2pStaConnectStateParam *hdiP2pStaConnectStateParam = NULL;
2452 int32_t ret = HDF_FAILURE;
2453 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventStaConnectState == NULL) {
2454 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2455 return HDF_ERR_INVALID_PARAM;
2456 }
2457 hdiP2pStaConnectStateParam = (struct HdiP2pStaConnectStateParam *)OsalMemCalloc(
2458 sizeof(struct P2pStaConnectStateParam));
2459 if ((hdiP2pStaConnectStateParam == NULL) || (WpaFillP2pStaConnectStateParam(
2460 staConnectStateParam, hdiP2pStaConnectStateParam) != HDF_SUCCESS)) {
2461 HDF_LOGE("%{public}s: hdiP2pStaConnectStateParam is NULL or staConnectStateParam fialed!", __func__);
2462 } else {
2463 ret = node->callbackObj->OnEventStaConnectState(node->callbackObj, hdiP2pStaConnectStateParam, ifName);
2464 }
2465 HdiP2pStaConnectStateParamFree(hdiP2pStaConnectStateParam, true);
2466 return ret;
2467 }
2468
ProcessEventP2pIfaceCreated(struct HdfWpaRemoteNode * node,struct P2pIfaceCreatedParam * ifaceCreatedParam,const char * ifName)2469 int32_t ProcessEventP2pIfaceCreated(struct HdfWpaRemoteNode *node, struct P2pIfaceCreatedParam *ifaceCreatedParam,
2470 const char *ifName)
2471 {
2472 struct HdiP2pIfaceCreatedParam *hdiP2pIfaceCreatedParam = NULL;
2473 int32_t ret = HDF_FAILURE;
2474 if (node == NULL || node->callbackObj == NULL || node->callbackObj->OnEventIfaceCreated == NULL) {
2475 HDF_LOGE("%{public}s: hdf wlan remote node or callbackObj is NULL!", __func__);
2476 return HDF_ERR_INVALID_PARAM;
2477 }
2478 hdiP2pIfaceCreatedParam = (struct HdiP2pIfaceCreatedParam *)OsalMemCalloc(sizeof(struct P2pIfaceCreatedParam));
2479 if ((hdiP2pIfaceCreatedParam == NULL) || (WpaFillP2pIfaceCreatedParam(ifaceCreatedParam, hdiP2pIfaceCreatedParam)
2480 != HDF_SUCCESS)) {
2481 HDF_LOGE("%{public}s: hdiP2pIfaceCreatedParam is NULL or ifaceCreatedParam fialed!", __func__);
2482 } else {
2483 ret = node->callbackObj->OnEventIfaceCreated(node->callbackObj, hdiP2pIfaceCreatedParam, ifName);
2484 }
2485 HdiP2pIfaceCreatedParamFree(hdiP2pIfaceCreatedParam, true);
2486 return ret;
2487 }
2488