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
16 #ifdef HDI_WPA_INTERFACE_SUPPORT
17 #include "wifi_hdi_wpa_p2p_impl.h"
18 #include "wifi_hdi_util.h"
19 #include "wifi_log.h"
20 #include "stub_collector.h"
21 #include "wifi_native_define.h"
22
23 #undef LOG_TAG
24 #define LOG_TAG "WifiHdiWpaP2pImpl"
25 #define REPLY_BUF_LENGTH (1024)
26 #define BUFF_SIZE 256
27 #define P2P_RANDOM_MAC_FLAG "p2p_device_random_mac_addr=1\n"
28 #define PERSISENT_MAC_LEN 55
29 #define PERSISENT_MAC_STRING "p2p_device_persistent_mac_addr"
30 #define P2P_SUPPLICANT_PATH CONFIG_ROOR_DIR"/wpa_supplicant/p2p_supplicant.conf"
31
32 typedef struct HdiP2pWpaNetworkField {
33 P2pGroupConfigType field;
34 char fieldName[32];
35 int flag; /* 0 need add "" 1 no need */
36 } HdiP2pWpaNetworkField;
37
38 static const HdiP2pWpaNetworkField g_hdiP2pWpaNetworkFields[] = {
39 {GROUP_CONFIG_SSID, "ssid", 0},
40 {GROUP_CONFIG_BSSID, "bssid", 1},
41 {GROUP_CONFIG_PSK, "psk", 1},
42 {GROUP_CONFIG_PROTO, "proto", 1},
43 {GROUP_CONFIG_KEY_MGMT, "key_mgmt", 1},
44 {GROUP_CONFIG_PAIRWISE, "pairwise", 1},
45 {GROUP_CONFIG_AUTH_ALG, "auth_alg", 1},
46 {GROUP_CONFIG_MODE, "mode", 1},
47 {GROUP_CONFIG_DISABLED, "disabled", 1}
48 };
49
50 static struct IWpaCallback *g_hdiWpaP2pCallbackObj = NULL;
51
RegisterP2pEventCallback()52 static WifiErrorNo RegisterP2pEventCallback()
53 {
54 LOGI("RegisterP2pEventCallback enter");
55 pthread_mutex_lock(GetWpaObjMutex());
56 if (g_hdiWpaP2pCallbackObj == NULL) {
57 pthread_mutex_unlock(GetWpaObjMutex());
58 LOGE("RegisterP2pEventCallback: g_hdiWpaP2pCallbackObj is NULL");
59 return WIFI_HAL_OPT_FAILED;
60 }
61
62 struct IWpaInterface *wpaObj = GetWpaInterface();
63 if (wpaObj == NULL) {
64 pthread_mutex_unlock(GetWpaObjMutex());
65 LOGE("RegisterP2pEventCallback: wpaObj is NULL");
66 return WIFI_HAL_OPT_FAILED;
67 }
68
69 int32_t result = wpaObj->RegisterWpaEventCallback(wpaObj, g_hdiWpaP2pCallbackObj, GetHdiP2pIfaceName());
70 if (result != HDF_SUCCESS) {
71 pthread_mutex_unlock(GetWpaObjMutex());
72 LOGE("RegisterP2pEventCallback: RegisterEventCallback failed result:%{public}d", result);
73 return WIFI_HAL_OPT_FAILED;
74 }
75
76 pthread_mutex_unlock(GetWpaObjMutex());
77 LOGI("RegisterP2pEventCallback success.");
78 return WIFI_HAL_OPT_OK;
79 }
80
UnRegisterP2pEventCallback()81 static WifiErrorNo UnRegisterP2pEventCallback()
82 {
83 LOGI("UnRegisterP2pEventCallback enter");
84 pthread_mutex_lock(GetWpaObjMutex());
85 if (g_hdiWpaP2pCallbackObj != NULL) {
86 struct IWpaInterface *wpaObj = GetWpaInterface();
87 if (wpaObj == NULL) {
88 pthread_mutex_unlock(GetWpaObjMutex());
89 LOGE("UnRegisterP2pEventCallback: wpaObj is NULL");
90 return WIFI_HAL_OPT_FAILED;
91 }
92
93 int32_t result = wpaObj->UnregisterWpaEventCallback(wpaObj, g_hdiWpaP2pCallbackObj, GetHdiP2pIfaceName());
94 if (result != HDF_SUCCESS) {
95 pthread_mutex_unlock(GetWpaObjMutex());
96 LOGE("UnRegisterP2pEventCallback: UnregisterEventCallback failed result:%{public}d", result);
97 return WIFI_HAL_OPT_FAILED;
98 }
99 StubCollectorRemoveObject(IWPACALLBACK_INTERFACE_DESC, g_hdiWpaP2pCallbackObj);
100 free(g_hdiWpaP2pCallbackObj);
101 g_hdiWpaP2pCallbackObj = NULL;
102 }
103
104 pthread_mutex_unlock(GetWpaObjMutex());
105 LOGI("UnRegisterP2pEventCallback success.");
106 return WIFI_HAL_OPT_OK;
107 }
108
AddP2pRandomMacFlag()109 static WifiErrorNo AddP2pRandomMacFlag()
110 {
111 char str[BUFF_SIZE] = { 0 };
112 int indicate = 0;
113 FILE *fp = fopen(P2P_WPA_CONFIG_FILE, "a+");
114 if (fp == NULL) {
115 LOGE("%{public}s: failed to open the file", __func__);
116 return WIFI_HAL_OPT_FAILED;
117 }
118 while (fgets(str, BUFF_SIZE, fp)) {
119 if (strstr(str, P2P_RANDOM_MAC_FLAG) != NULL) {
120 indicate = 1;
121 break;
122 }
123 memset_s(str, sizeof(str), 0x0, sizeof(str));
124 }
125 if (indicate == 0) {
126 int ret = fputs(P2P_RANDOM_MAC_FLAG, fp);
127 if (ret < 0) {
128 LOGE("%{public}s: failed to update the file", __func__);
129 fclose(fp);
130 return WIFI_HAL_OPT_FAILED;
131 } else {
132 LOGD("%{public}s: success to update the file, ret:%{public}d", __func__, ret);
133 }
134 }
135 fclose(fp);
136 return WIFI_HAL_OPT_OK;
137 }
138
GetOldMac(char * mac,int len)139 bool GetOldMac(char *mac, int len)
140 {
141 char line[BUFF_SIZE];
142
143 FILE *fp = fopen(P2P_SUPPLICANT_PATH, "r");
144 if (fp == NULL) {
145 return false;
146 }
147 while (fgets(line, sizeof(line), fp) != NULL) {
148 if (strstr(line, PERSISENT_MAC_STRING) != NULL) {
149 if (memcpy_s(mac, len, line, strlen(line)) != EOK) {
150 fclose(fp);
151 return false;
152 }
153 fclose(fp);
154 return true;
155 }
156 }
157 if (fclose(fp) != 0) {
158 LOGE("close fp failed");
159 }
160 return false;
161 }
162
AppendMac(char * mac,int len)163 void AppendMac(char *mac, int len)
164 {
165 FILE *fp = fopen(P2P_SUPPLICANT_PATH, "a");
166 if (fp == NULL) {
167 LOGE("Error! Could not open file\n");
168 return;
169 }
170 if (fwrite("\n", sizeof(char), strlen("\n"), fp) == 0) {
171 LOGE("write \n faild");
172 }
173 if (fwrite(mac, sizeof(char), len, fp) == 0) {
174 LOGE("write mac faild");
175 }
176 if (fclose(fp) != 0) {
177 LOGE("close fp failed");
178 }
179 }
180
HdiWpaP2pStart(const char * ifaceName,const bool hasPersisentGroup)181 WifiErrorNo HdiWpaP2pStart(const char *ifaceName, const bool hasPersisentGroup)
182 {
183 char persisentMac[PERSISENT_MAC_LEN] = {0};
184 bool hasPersisentMac = false;
185
186 LOGI("HdiWpaP2pStart enter");
187 if (SetHdiP2pIfaceName(ifaceName) != WIFI_HAL_OPT_OK) {
188 LOGE("HdiWpaP2pStart: set p2p iface name failed!");
189 return WIFI_HAL_OPT_FAILED;
190 }
191 if (hasPersisentGroup) {
192 hasPersisentMac = GetOldMac(persisentMac, PERSISENT_MAC_LEN);
193 }
194 if (CopyConfigFile("p2p_supplicant.conf") != WIFI_HAL_OPT_OK) {
195 LOGE("HdiWpaP2pStart: CopyConfigFile failed!");
196 return WIFI_HAL_OPT_FAILED;
197 }
198 if (hasPersisentMac) {
199 AppendMac(persisentMac, PERSISENT_MAC_LEN);
200 }
201 if (HdiWpaStart() != WIFI_HAL_OPT_OK) {
202 LOGE("HdiWpaP2pStart: HdiWpaStart failed!");
203 return WIFI_HAL_OPT_FAILED;
204 }
205
206 if (RegisterP2pEventCallback() != WIFI_HAL_OPT_OK) {
207 LOGE("HdiWpaP2pStart: RegisterEventCallback failed!");
208 return WIFI_HAL_OPT_FAILED;
209 }
210
211 if (HdiAddWpaIface(GetHdiP2pIfaceName(), CONFIG_ROOR_DIR"/wpa_supplicant/p2p_supplicant.conf") != WIFI_HAL_OPT_OK) {
212 LOGE("HdiWpaP2pStart: HdiAddWpaIface failed!");
213 return WIFI_HAL_OPT_FAILED;
214 }
215
216 LOGI("HdiWpaP2pStart success");
217 return WIFI_HAL_OPT_OK;
218 }
219
HdiWpaP2pStop()220 WifiErrorNo HdiWpaP2pStop()
221 {
222 LOGI("HdiWpaP2pStop enter");
223 if (IsHdiWpaStopped() == WIFI_HAL_OPT_OK) {
224 LOGE("HdiWpaP2pStop: HdiWpa already stopped, HdiWpaP2pStop success");
225 return WIFI_HAL_OPT_OK;
226 }
227
228 if (UnRegisterP2pEventCallback() != WIFI_HAL_OPT_OK) {
229 LOGE("HdiWpaP2pStop: UnRegisterP2pEventCallback failed!");
230 return WIFI_HAL_OPT_FAILED;
231 }
232
233 if (HdiRemoveWpaIface(GetHdiP2pIfaceName()) != WIFI_HAL_OPT_OK) {
234 LOGE("HdiWpaP2pStop: HdiRemoveWpaIface failed!");
235 return WIFI_HAL_OPT_FAILED;
236 }
237
238 LOGI("HdiWpaP2pStop success");
239 return WIFI_HAL_OPT_OK;
240 }
241
InitHdiWpaP2pCallbackObj(struct IWpaCallback * callback)242 static void InitHdiWpaP2pCallbackObj(struct IWpaCallback *callback)
243 {
244 g_hdiWpaP2pCallbackObj->OnEventDeviceFound = callback->OnEventDeviceFound;
245 g_hdiWpaP2pCallbackObj->OnEventDeviceLost = callback->OnEventDeviceLost;
246 g_hdiWpaP2pCallbackObj->OnEventGoNegotiationRequest = callback->OnEventGoNegotiationRequest;
247 g_hdiWpaP2pCallbackObj->OnEventGoNegotiationCompleted = callback->OnEventGoNegotiationCompleted;
248 g_hdiWpaP2pCallbackObj->OnEventInvitationReceived = callback->OnEventInvitationReceived;
249 g_hdiWpaP2pCallbackObj->OnEventInvitationResult = callback->OnEventInvitationResult;
250 g_hdiWpaP2pCallbackObj->OnEventGroupFormationSuccess = callback->OnEventGroupFormationSuccess;
251 g_hdiWpaP2pCallbackObj->OnEventGroupFormationFailure = callback->OnEventGroupFormationFailure;
252 g_hdiWpaP2pCallbackObj->OnEventGroupStarted = callback->OnEventGroupStarted;
253 g_hdiWpaP2pCallbackObj->OnEventGroupInfoStarted = callback->OnEventGroupInfoStarted;
254 g_hdiWpaP2pCallbackObj->OnEventGroupRemoved = callback->OnEventGroupRemoved;
255 g_hdiWpaP2pCallbackObj->OnEventProvisionDiscoveryCompleted = callback->OnEventProvisionDiscoveryCompleted;
256 g_hdiWpaP2pCallbackObj->OnEventFindStopped = callback->OnEventFindStopped;
257 g_hdiWpaP2pCallbackObj->OnEventServDiscReq = callback->OnEventServDiscReq;
258 g_hdiWpaP2pCallbackObj->OnEventServDiscResp = callback->OnEventServDiscResp;
259 g_hdiWpaP2pCallbackObj->OnEventStaConnectState = callback->OnEventStaConnectState;
260 g_hdiWpaP2pCallbackObj->OnEventIfaceCreated = callback->OnEventIfaceCreated;
261 }
262
RegisterHdiWpaP2pEventCallback(struct IWpaCallback * callback)263 WifiErrorNo RegisterHdiWpaP2pEventCallback(struct IWpaCallback *callback)
264 {
265 LOGI("RegisterHdiWpaP2pEventCallback enter");
266 pthread_mutex_lock(GetWpaObjMutex());
267 if (callback == NULL || callback->OnEventDeviceFound == NULL) {
268 pthread_mutex_unlock(GetWpaObjMutex());
269 LOGE("RegisterHdiWpaP2pEventCallback: invalid parameter!");
270 return WIFI_HAL_OPT_INVALID_PARAM;
271 }
272
273 if (g_hdiWpaP2pCallbackObj != NULL) {
274 pthread_mutex_unlock(GetWpaObjMutex());
275 LOGI("RegisterHdiWpaP2pEventCallback: already register!");
276 return WIFI_HAL_OPT_OK;
277 }
278
279 g_hdiWpaP2pCallbackObj = (struct IWpaCallback *)malloc(sizeof(struct IWpaCallback));
280 if (g_hdiWpaP2pCallbackObj == NULL) {
281 pthread_mutex_unlock(GetWpaObjMutex());
282 LOGE("RegisterHdiWpaP2pEventCallback: IWpaCallback malloc failed!");
283 return WIFI_HAL_OPT_FAILED;
284 }
285 if (memset_s(g_hdiWpaP2pCallbackObj, sizeof(struct IWpaCallback),
286 0, sizeof(struct IWpaCallback)) != EOK) {
287 pthread_mutex_unlock(GetWpaObjMutex());
288 return WIFI_HAL_OPT_FAILED;
289 }
290 InitHdiWpaP2pCallbackObj(callback);
291 pthread_mutex_unlock(GetWpaObjMutex());
292 LOGI("RegisterHdiWpaP2pEventCallback success.");
293 return WIFI_HAL_OPT_OK;
294 }
295
HdiP2pSetSsidPostfixName(const char * name)296 WifiErrorNo HdiP2pSetSsidPostfixName(const char *name)
297 {
298 LOGI("HdiP2pSetSsidPostfixName enter, name:%{private}s", name);
299 pthread_mutex_lock(GetWpaObjMutex());
300 struct IWpaInterface *wpaObj = GetWpaInterface();
301 if (wpaObj == NULL) {
302 LOGE("HdiP2pSetSsidPostfixName: wpaObj is NULL");
303 pthread_mutex_unlock(GetWpaObjMutex());
304 return WIFI_HAL_OPT_FAILED;
305 }
306
307 int32_t result = wpaObj->P2pSetSsidPostfixName(wpaObj, GetHdiP2pIfaceName(), name);
308 if (result != HDF_SUCCESS) {
309 LOGE("HdiP2pSetSsidPostfixName: P2pSetSsidPostfixName failed result:%{public}d", result);
310 pthread_mutex_unlock(GetWpaObjMutex());
311 return WIFI_HAL_OPT_FAILED;
312 }
313 pthread_mutex_unlock(GetWpaObjMutex());
314 LOGI("HdiP2pSetSsidPostfixName success.");
315 return WIFI_HAL_OPT_OK;
316 }
317
HdiP2pSetWpsDeviceType(const char * type)318 WifiErrorNo HdiP2pSetWpsDeviceType(const char *type)
319 {
320 LOGI("HdiP2pSetWpsDeviceType enter");
321 pthread_mutex_lock(GetWpaObjMutex());
322 struct IWpaInterface *wpaObj = GetWpaInterface();
323 if (wpaObj == NULL) {
324 LOGE("HdiP2pSetWpsDeviceType: wpaObj is NULL");
325 pthread_mutex_unlock(GetWpaObjMutex());
326 return WIFI_HAL_OPT_FAILED;
327 }
328
329 int32_t result = wpaObj->P2pSetWpsDeviceType(wpaObj, GetHdiP2pIfaceName(), type);
330 if (result != HDF_SUCCESS) {
331 LOGE("HdiP2pSetWpsDeviceType: P2pSetWpsDeviceType failed result:%{public}d", result);
332 pthread_mutex_unlock(GetWpaObjMutex());
333 return WIFI_HAL_OPT_FAILED;
334 }
335 pthread_mutex_unlock(GetWpaObjMutex());
336 LOGI("HdiP2pSetWpsDeviceType success.");
337 return WIFI_HAL_OPT_OK;
338 }
339
HdiP2pSetWpsConfigMethods(const char * methods)340 WifiErrorNo HdiP2pSetWpsConfigMethods(const char *methods)
341 {
342 LOGI("HdiP2pSetWpsConfigMethods enter");
343 pthread_mutex_lock(GetWpaObjMutex());
344 struct IWpaInterface *wpaObj = GetWpaInterface();
345 if (wpaObj == NULL) {
346 LOGE("HdiP2pSetWpsConfigMethods: wpaObj is NULL");
347 pthread_mutex_unlock(GetWpaObjMutex());
348 return WIFI_HAL_OPT_FAILED;
349 }
350
351 int32_t result = wpaObj->P2pSetWpsConfigMethods(wpaObj, GetHdiP2pIfaceName(), methods);
352 if (result != HDF_SUCCESS) {
353 LOGE("HdiP2pSetWpsConfigMethods: P2pSetWpsConfigMethods failed result:%{public}d", result);
354 pthread_mutex_unlock(GetWpaObjMutex());
355 return WIFI_HAL_OPT_FAILED;
356 }
357 pthread_mutex_unlock(GetWpaObjMutex());
358 LOGI("HdiP2pSetWpsConfigMethods success.");
359 return WIFI_HAL_OPT_OK;
360 }
361
HdiP2pSetGroupMaxIdle(const char * groupIfc,int time)362 WifiErrorNo HdiP2pSetGroupMaxIdle(const char *groupIfc, int time)
363 {
364 LOGI("HdiP2pSetGroupMaxIdle enter");
365 pthread_mutex_lock(GetWpaObjMutex());
366 struct IWpaInterface *wpaObj = GetWpaInterface();
367 if (wpaObj == NULL) {
368 LOGE("HdiP2pSetGroupMaxIdle: wpaObj is NULL");
369 pthread_mutex_unlock(GetWpaObjMutex());
370 return WIFI_HAL_OPT_FAILED;
371 }
372
373 int32_t result = wpaObj->P2pSetGroupMaxIdle(wpaObj, groupIfc, time);
374 if (result != HDF_SUCCESS) {
375 LOGE("HdiP2pSetGroupMaxIdle: P2pSetGroupMaxIdle failed result:%{public}d", result);
376 pthread_mutex_unlock(GetWpaObjMutex());
377 return WIFI_HAL_OPT_FAILED;
378 }
379 pthread_mutex_unlock(GetWpaObjMutex());
380 LOGI("HdiP2pSetGroupMaxIdle success.");
381 return WIFI_HAL_OPT_OK;
382 }
383
HdiP2pSetWfdEnable(int enable)384 WifiErrorNo HdiP2pSetWfdEnable(int enable)
385 {
386 LOGI("HdiP2pSetWfdEnable enter");
387 pthread_mutex_lock(GetWpaObjMutex());
388 struct IWpaInterface *wpaObj = GetWpaInterface();
389 if (wpaObj == NULL) {
390 LOGE("HdiP2pSetWfdEnable: wpaObj is NULL");
391 pthread_mutex_unlock(GetWpaObjMutex());
392 return WIFI_HAL_OPT_FAILED;
393 }
394
395 int32_t result = wpaObj->P2pSetWfdEnable(wpaObj, GetHdiP2pIfaceName(), enable);
396 if (result != HDF_SUCCESS) {
397 LOGE("HdiP2pSetWfdEnable: P2pSetWfdEnable failed result:%{public}d", result);
398 pthread_mutex_unlock(GetWpaObjMutex());
399 return WIFI_HAL_OPT_FAILED;
400 }
401 pthread_mutex_unlock(GetWpaObjMutex());
402 LOGI("HdiP2pSetWfdEnable success.");
403 return WIFI_HAL_OPT_OK;
404 }
405
HdiP2pSetPersistentReconnect(int status)406 WifiErrorNo HdiP2pSetPersistentReconnect(int status)
407 {
408 LOGI("HdiP2pSetPersistentReconnect enter");
409 pthread_mutex_lock(GetWpaObjMutex());
410 struct IWpaInterface *wpaObj = GetWpaInterface();
411 if (wpaObj == NULL) {
412 LOGE("HdiP2pSetPersistentReconnect: wpaObj is NULL");
413 pthread_mutex_unlock(GetWpaObjMutex());
414 return WIFI_HAL_OPT_FAILED;
415 }
416
417 int32_t result = wpaObj->P2pSetPersistentReconnect(wpaObj, GetHdiP2pIfaceName(), status);
418 if (result != HDF_SUCCESS) {
419 LOGE("HdiP2pSetPersistentReconnect: P2pSetPersistentReconnect failed result:%{public}d", result);
420 pthread_mutex_unlock(GetWpaObjMutex());
421 return WIFI_HAL_OPT_FAILED;
422 }
423 pthread_mutex_unlock(GetWpaObjMutex());
424 LOGI("HdiP2pSetPersistentReconnect success.");
425 return WIFI_HAL_OPT_OK;
426 }
427
HdiP2pSetWpsSecondaryDeviceType(const char * type)428 WifiErrorNo HdiP2pSetWpsSecondaryDeviceType(const char *type)
429 {
430 LOGI("HdiP2pSetWpsSecondaryDeviceType enter");
431 pthread_mutex_lock(GetWpaObjMutex());
432 struct IWpaInterface *wpaObj = GetWpaInterface();
433 if (wpaObj == NULL) {
434 LOGE("HdiP2pSetWpsSecondaryDeviceType: wpaObj is NULL");
435 pthread_mutex_unlock(GetWpaObjMutex());
436 return WIFI_HAL_OPT_FAILED;
437 }
438
439 int32_t result = wpaObj->P2pSetWpsSecondaryDeviceType(wpaObj, GetHdiP2pIfaceName(), type);
440 if (result != HDF_SUCCESS) {
441 LOGE("HdiP2pSetWpsSecondaryDeviceType: P2pSetWpsSecondaryDeviceType failed result:%{public}d", result);
442 pthread_mutex_unlock(GetWpaObjMutex());
443 return WIFI_HAL_OPT_FAILED;
444 }
445 pthread_mutex_unlock(GetWpaObjMutex());
446 LOGI("HdiP2pSetWpsSecondaryDeviceType success.");
447 return WIFI_HAL_OPT_OK;
448 }
449
HdiP2pSetupWpsPbc(const char * groupIfc,const char * address)450 WifiErrorNo HdiP2pSetupWpsPbc(const char *groupIfc, const char *address)
451 {
452 char anonymizeAddr[MAC_STRING_SIZE + 1] = {0};
453 if (ConvertMacArr2String((const unsigned char *)address, MAC_UINT_SIZE,
454 anonymizeAddr, sizeof(anonymizeAddr)) != 0) {
455 LOGE("HdiP2pSetupWpsPbc: failed to convert address!");
456 }
457 LOGI("HdiP2pSetupWpsPbc enter groupIfc=%{public}s anonymizeAddr=%{public}s", groupIfc, anonymizeAddr);
458 pthread_mutex_lock(GetWpaObjMutex());
459 struct IWpaInterface *wpaObj = GetWpaInterface();
460 if (wpaObj == NULL) {
461 LOGE("HdiP2pSetupWpsPbc: wpaObj is NULL");
462 pthread_mutex_unlock(GetWpaObjMutex());
463 return WIFI_HAL_OPT_FAILED;
464 }
465
466 int32_t result = wpaObj->P2pSetupWpsPbc(wpaObj, groupIfc, address);
467 if (result != HDF_SUCCESS) {
468 LOGE("HdiP2pSetupWpsPbc: P2pSetupWpsPbc failed result:%{public}d", result);
469 pthread_mutex_unlock(GetWpaObjMutex());
470 return WIFI_HAL_OPT_FAILED;
471 }
472 pthread_mutex_unlock(GetWpaObjMutex());
473 LOGI("HdiP2pSetupWpsPbc success.");
474 return WIFI_HAL_OPT_OK;
475 }
476
HdiP2pSetupWpsPin(const char * groupIfc,const char * address,const char * pin,char * result)477 WifiErrorNo HdiP2pSetupWpsPin(const char *groupIfc, const char *address, const char *pin, char *result)
478 {
479 LOGI("HdiP2pSetupWpsPin enter");
480 pthread_mutex_lock(GetWpaObjMutex());
481 struct IWpaInterface *wpaObj = GetWpaInterface();
482 if (wpaObj == NULL) {
483 LOGE("HdiP2pSetupWpsPin: wpaObj is NULL");
484 pthread_mutex_unlock(GetWpaObjMutex());
485 return WIFI_HAL_OPT_FAILED;
486 }
487
488 int32_t res = wpaObj->P2pSetupWpsPin(wpaObj, groupIfc, address, pin, result, REPLY_BUF_LENGTH);
489 if (res != HDF_SUCCESS) {
490 LOGE("HdiP2pSetupWpsPin: P2pSetupWpsPin failed res:%{public}s", result);
491 pthread_mutex_unlock(GetWpaObjMutex());
492 return WIFI_HAL_OPT_FAILED;
493 }
494 pthread_mutex_unlock(GetWpaObjMutex());
495 LOGI("HdiP2pSetupWpsPin success.");
496 return WIFI_HAL_OPT_OK;
497 }
498
HdiP2pSetPowerSave(const char * groupIfc,int enable)499 WifiErrorNo HdiP2pSetPowerSave(const char *groupIfc, int enable)
500 {
501 LOGI("HdiP2pSetPowerSave enter");
502 pthread_mutex_lock(GetWpaObjMutex());
503 struct IWpaInterface *wpaObj = GetWpaInterface();
504 if (wpaObj == NULL) {
505 LOGE("HdiP2pSetPowerSave: wpaObj is NULL");
506 pthread_mutex_unlock(GetWpaObjMutex());
507 return WIFI_HAL_OPT_FAILED;
508 }
509
510 int32_t result = wpaObj->P2pSetPowerSave(wpaObj, groupIfc, enable);
511 if (result != HDF_SUCCESS) {
512 LOGE("HdiP2pSetPowerSave: P2pSetPowerSave failed result:%{public}d", result);
513 pthread_mutex_unlock(GetWpaObjMutex());
514 return WIFI_HAL_OPT_FAILED;
515 }
516 pthread_mutex_unlock(GetWpaObjMutex());
517 LOGI("HdiP2pSetPowerSave success.");
518 return WIFI_HAL_OPT_OK;
519 }
520
HdiP2pSetDeviceName(const char * name)521 WifiErrorNo HdiP2pSetDeviceName(const char *name)
522 {
523 LOGI("HdiP2pSetDeviceName enter");
524 pthread_mutex_lock(GetWpaObjMutex());
525 struct IWpaInterface *wpaObj = GetWpaInterface();
526 if (wpaObj == NULL) {
527 LOGE("HdiP2pSetDeviceName: wpaObj is NULL");
528 pthread_mutex_unlock(GetWpaObjMutex());
529 return WIFI_HAL_OPT_FAILED;
530 }
531
532 int32_t result = wpaObj->P2pSetDeviceName(wpaObj, GetHdiP2pIfaceName(), name);
533 if (result != HDF_SUCCESS) {
534 LOGE("HdiP2pSetDeviceName: P2pSetDeviceName failed result:%{public}d", result);
535 pthread_mutex_unlock(GetWpaObjMutex());
536 return WIFI_HAL_OPT_FAILED;
537 }
538 pthread_mutex_unlock(GetWpaObjMutex());
539 LOGI("HdiP2pSetDeviceName success.");
540 return WIFI_HAL_OPT_OK;
541 }
542
HdiP2pSetWfdDeviceConfig(const char * config)543 WifiErrorNo HdiP2pSetWfdDeviceConfig(const char *config)
544 {
545 LOGI("HdiP2pSetWfdDeviceConfig enter");
546 pthread_mutex_lock(GetWpaObjMutex());
547 struct IWpaInterface *wpaObj = GetWpaInterface();
548 if (wpaObj == NULL) {
549 LOGE("HdiP2pSetWfdDeviceConfig: wpaObj is NULL");
550 pthread_mutex_unlock(GetWpaObjMutex());
551 return WIFI_HAL_OPT_FAILED;
552 }
553
554 int32_t result = wpaObj->P2pSetWfdDeviceConfig(wpaObj, GetHdiP2pIfaceName(), config);
555 if (result != HDF_SUCCESS) {
556 LOGE("HdiP2pSetWfdDeviceConfig: P2pSetWfdDeviceConfig failed result:%{public}d", result);
557 pthread_mutex_unlock(GetWpaObjMutex());
558 return WIFI_HAL_OPT_FAILED;
559 }
560 pthread_mutex_unlock(GetWpaObjMutex());
561 LOGI("HdiP2pSetWfdDeviceConfig success.");
562 return WIFI_HAL_OPT_OK;
563 }
564
HdiP2pSetRandomMac(int enable)565 WifiErrorNo HdiP2pSetRandomMac(int enable)
566 {
567 LOGI("HdiP2pSetRandomMac enter");
568 pthread_mutex_lock(GetWpaObjMutex());
569 struct IWpaInterface *wpaObj = GetWpaInterface();
570 if (wpaObj == NULL) {
571 LOGE("HdiP2pSetRandomMac: wpaObj is NULL");
572 pthread_mutex_unlock(GetWpaObjMutex());
573 return WIFI_HAL_OPT_FAILED;
574 }
575
576 int32_t result = wpaObj->P2pSetRandomMac(wpaObj, GetHdiP2pIfaceName(), enable);
577 if (result != HDF_SUCCESS) {
578 LOGE("HdiP2pSetRandomMac: P2pSetRandomMac failed result:%{public}d", result);
579 pthread_mutex_unlock(GetWpaObjMutex());
580 return WIFI_HAL_OPT_FAILED;
581 }
582 if (AddP2pRandomMacFlag() != WIFI_HAL_OPT_OK) {
583 LOGW("%{public}s: failed to write %{public}s", __func__, P2P_RANDOM_MAC_FLAG);
584 }
585 pthread_mutex_unlock(GetWpaObjMutex());
586 LOGI("HdiP2pSetRandomMac success.");
587 return WIFI_HAL_OPT_OK;
588 }
589
HdiP2pStartFind(int timeout)590 WifiErrorNo HdiP2pStartFind(int timeout)
591 {
592 LOGI("HdiP2pStartFind enter");
593 pthread_mutex_lock(GetWpaObjMutex());
594 struct IWpaInterface *wpaObj = GetWpaInterface();
595 if (wpaObj == NULL) {
596 LOGE("HdiP2pStartFind: wpaObj is NULL");
597 pthread_mutex_unlock(GetWpaObjMutex());
598 return WIFI_HAL_OPT_FAILED;
599 }
600
601 int32_t result = wpaObj->P2pStartFind(wpaObj, GetHdiP2pIfaceName(), timeout);
602 if (result != HDF_SUCCESS) {
603 LOGE("HdiP2pStartFind: P2pStartFind failed result:%{public}d", result);
604 pthread_mutex_unlock(GetWpaObjMutex());
605 return WIFI_HAL_OPT_FAILED;
606 }
607 pthread_mutex_unlock(GetWpaObjMutex());
608 LOGI("HdiP2pStartFind success.");
609 return WIFI_HAL_OPT_OK;
610 }
611
HdiP2pSetExtListen(int enable,int period,int interval)612 WifiErrorNo HdiP2pSetExtListen(int enable, int period, int interval)
613 {
614 LOGI("HdiP2pSetExtListen enter");
615 pthread_mutex_lock(GetWpaObjMutex());
616 struct IWpaInterface *wpaObj = GetWpaInterface();
617 if (wpaObj == NULL) {
618 LOGE("HdiP2pSetExtListen: wpaObj is NULL");
619 pthread_mutex_unlock(GetWpaObjMutex());
620 return WIFI_HAL_OPT_FAILED;
621 }
622
623 int32_t result = wpaObj->P2pSetExtListen(wpaObj, GetHdiP2pIfaceName(), enable, period, interval);
624 if (result != HDF_SUCCESS) {
625 LOGE("HdiP2pSetExtListen: P2pSetExtListen failed result:%{public}d", result);
626 pthread_mutex_unlock(GetWpaObjMutex());
627 return WIFI_HAL_OPT_FAILED;
628 }
629 pthread_mutex_unlock(GetWpaObjMutex());
630 LOGI("HdiP2pSetExtListen success.");
631 return WIFI_HAL_OPT_OK;
632 }
633
HdiP2pSetListenChannel(int channel,int regClass)634 WifiErrorNo HdiP2pSetListenChannel(int channel, int regClass)
635 {
636 LOGI("HdiP2pSetListenChannel enter");
637 pthread_mutex_lock(GetWpaObjMutex());
638 struct IWpaInterface *wpaObj = GetWpaInterface();
639 if (wpaObj == NULL) {
640 LOGE("HdiP2pSetListenChannel: wpaObj is NULL");
641 pthread_mutex_unlock(GetWpaObjMutex());
642 return WIFI_HAL_OPT_FAILED;
643 }
644
645 int32_t result = wpaObj->P2pSetListenChannel(wpaObj, GetHdiP2pIfaceName(), channel, regClass);
646 if (result != HDF_SUCCESS) {
647 LOGE("HdiP2pSetListenChannel: P2pSetListenChannel failed result:%{public}d", result);
648 pthread_mutex_unlock(GetWpaObjMutex());
649 return WIFI_HAL_OPT_FAILED;
650 }
651 pthread_mutex_unlock(GetWpaObjMutex());
652 LOGI("HdiP2pSetListenChannel success.");
653 return WIFI_HAL_OPT_OK;
654 }
655
HdiP2pProvisionDiscovery(const char * peerBssid,int mode)656 WifiErrorNo HdiP2pProvisionDiscovery(const char *peerBssid, int mode)
657 {
658 LOGI("HdiP2pProvisionDiscovery enter");
659 pthread_mutex_lock(GetWpaObjMutex());
660 struct IWpaInterface *wpaObj = GetWpaInterface();
661 if (wpaObj == NULL) {
662 LOGE("HdiP2pProvisionDiscovery: wpaObj is NULL");
663 pthread_mutex_unlock(GetWpaObjMutex());
664 return WIFI_HAL_OPT_FAILED;
665 }
666
667 int32_t result = wpaObj->P2pProvisionDiscovery(wpaObj, GetHdiP2pIfaceName(), peerBssid, mode);
668 if (result != HDF_SUCCESS) {
669 LOGE("HdiP2pProvisionDiscovery: P2pProvisionDiscovery failed result:%{public}d", result);
670 pthread_mutex_unlock(GetWpaObjMutex());
671 return WIFI_HAL_OPT_FAILED;
672 }
673 pthread_mutex_unlock(GetWpaObjMutex());
674 LOGI("HdiP2pProvisionDiscovery success.");
675 return WIFI_HAL_OPT_OK;
676 }
677
HdiP2pAddGroup(int isPersistent,int networkId,int freq)678 WifiErrorNo HdiP2pAddGroup(int isPersistent, int networkId, int freq)
679 {
680 LOGI("HdiP2pAddGroup enter isPersistent=%{public}d", isPersistent);
681 pthread_mutex_lock(GetWpaObjMutex());
682 struct IWpaInterface *wpaObj = GetWpaInterface();
683 if (wpaObj == NULL) {
684 LOGE("HdiP2pAddGroup: wpaObj is NULL");
685 pthread_mutex_unlock(GetWpaObjMutex());
686 return WIFI_HAL_OPT_FAILED;
687 }
688
689 int32_t result = wpaObj->P2pAddGroup(wpaObj, GetHdiP2pIfaceName(), isPersistent, networkId, freq);
690 if (result != HDF_SUCCESS) {
691 LOGE("HdiP2pAddGroup: P2pAddGroup failed result:%{public}d", result);
692 pthread_mutex_unlock(GetWpaObjMutex());
693 return WIFI_HAL_OPT_FAILED;
694 }
695 pthread_mutex_unlock(GetWpaObjMutex());
696 LOGI("HdiP2pAddGroup success.");
697 return WIFI_HAL_OPT_OK;
698 }
699
HdiP2pAddService(struct HdiP2pServiceInfo * info)700 WifiErrorNo HdiP2pAddService(struct HdiP2pServiceInfo *info)
701 {
702 LOGI("HdiP2pAddService enter");
703 pthread_mutex_lock(GetWpaObjMutex());
704 struct IWpaInterface *wpaObj = GetWpaInterface();
705 if (wpaObj == NULL) {
706 LOGE("HdiP2pAddService: wpaObj is NULL");
707 pthread_mutex_unlock(GetWpaObjMutex());
708 return WIFI_HAL_OPT_FAILED;
709 }
710
711 int32_t result = wpaObj->P2pAddService(wpaObj, GetHdiP2pIfaceName(), info);
712 if (result != HDF_SUCCESS) {
713 LOGE("HdiP2pAddService: P2pAddService failed result:%{public}d", result);
714 pthread_mutex_unlock(GetWpaObjMutex());
715 return WIFI_HAL_OPT_FAILED;
716 }
717 pthread_mutex_unlock(GetWpaObjMutex());
718 LOGI("HdiP2pAddService success.");
719 return WIFI_HAL_OPT_OK;
720 }
721
HdiP2pRemoveService(struct HdiP2pServiceInfo * info)722 WifiErrorNo HdiP2pRemoveService(struct HdiP2pServiceInfo *info)
723 {
724 LOGI("HdiP2pRemoveService enter");
725 pthread_mutex_lock(GetWpaObjMutex());
726 struct IWpaInterface *wpaObj = GetWpaInterface();
727 if (wpaObj == NULL) {
728 LOGE("HdiP2pRemoveService: wpaObj is NULL");
729 pthread_mutex_unlock(GetWpaObjMutex());
730 return WIFI_HAL_OPT_FAILED;
731 }
732
733 int32_t result = wpaObj->P2pRemoveService(wpaObj, GetHdiP2pIfaceName(), info);
734 if (result != HDF_SUCCESS) {
735 LOGE("HdiP2pRemoveService: P2pRemoveService failed result:%{public}d", result);
736 pthread_mutex_unlock(GetWpaObjMutex());
737 return WIFI_HAL_OPT_FAILED;
738 }
739 pthread_mutex_unlock(GetWpaObjMutex());
740 LOGI("HdiP2pRemoveService success.");
741 return WIFI_HAL_OPT_OK;
742 }
743
HdiP2pStopFind()744 WifiErrorNo HdiP2pStopFind()
745 {
746 LOGI("HdiP2pStopFind enter");
747 pthread_mutex_lock(GetWpaObjMutex());
748 struct IWpaInterface *wpaObj = GetWpaInterface();
749 if (wpaObj == NULL) {
750 LOGE("HdiP2pStopFind: wpaObj is NULL");
751 pthread_mutex_unlock(GetWpaObjMutex());
752 return WIFI_HAL_OPT_FAILED;
753 }
754
755 int32_t result = wpaObj->P2pStopFind(wpaObj, GetHdiP2pIfaceName());
756 if (result != HDF_SUCCESS) {
757 LOGE("HdiP2pStopFind: P2pStopFind failed result:%{public}d", result);
758 pthread_mutex_unlock(GetWpaObjMutex());
759 return WIFI_HAL_OPT_FAILED;
760 }
761 pthread_mutex_unlock(GetWpaObjMutex());
762 LOGI("HdiP2pStopFind success.");
763 return WIFI_HAL_OPT_OK;
764 }
765
HdiP2pFlush()766 WifiErrorNo HdiP2pFlush()
767 {
768 LOGI("HdiP2pFlush enter");
769 pthread_mutex_lock(GetWpaObjMutex());
770 struct IWpaInterface *wpaObj = GetWpaInterface();
771 if (wpaObj == NULL) {
772 LOGE("HdiP2pFlush: wpaObj is NULL");
773 pthread_mutex_unlock(GetWpaObjMutex());
774 return WIFI_HAL_OPT_FAILED;
775 }
776
777 int32_t result = wpaObj->P2pFlush(wpaObj, GetHdiP2pIfaceName());
778 if (result != HDF_SUCCESS) {
779 LOGE("HdiP2pFlush: P2pFlush failed result:%{public}d", result);
780 pthread_mutex_unlock(GetWpaObjMutex());
781 return WIFI_HAL_OPT_FAILED;
782 }
783 pthread_mutex_unlock(GetWpaObjMutex());
784 LOGI("HdiP2pFlush success.");
785 return WIFI_HAL_OPT_OK;
786 }
787
HdiP2pFlushService()788 WifiErrorNo HdiP2pFlushService()
789 {
790 LOGI("HdiP2pFlushService enter");
791 pthread_mutex_lock(GetWpaObjMutex());
792 struct IWpaInterface *wpaObj = GetWpaInterface();
793 if (wpaObj == NULL) {
794 LOGE("HdiP2pFlushService: wpaObj is NULL");
795 pthread_mutex_unlock(GetWpaObjMutex());
796 return WIFI_HAL_OPT_FAILED;
797 }
798
799 int32_t result = wpaObj->P2pFlushService(wpaObj, GetHdiP2pIfaceName());
800 if (result != HDF_SUCCESS) {
801 LOGE("HdiP2pFlushService: P2pFlushService failed result:%{public}d", result);
802 pthread_mutex_unlock(GetWpaObjMutex());
803 return WIFI_HAL_OPT_FAILED;
804 }
805 pthread_mutex_unlock(GetWpaObjMutex());
806 LOGI("HdiP2pFlushService success.");
807 return WIFI_HAL_OPT_OK;
808 }
809
HdiP2pRemoveNetwork(int networkId)810 WifiErrorNo HdiP2pRemoveNetwork(int networkId)
811 {
812 LOGI("HdiP2pRemoveNetwork enter");
813 pthread_mutex_lock(GetWpaObjMutex());
814 struct IWpaInterface *wpaObj = GetWpaInterface();
815 if (wpaObj == NULL) {
816 LOGE("HdiP2pRemoveNetwork: wpaObj is NULL");
817 pthread_mutex_unlock(GetWpaObjMutex());
818 return WIFI_HAL_OPT_FAILED;
819 }
820
821 int32_t result = wpaObj->P2pRemoveNetwork(wpaObj, GetHdiP2pIfaceName(), networkId);
822 if (result != HDF_SUCCESS) {
823 LOGE("HdiP2pRemoveNetwork: P2pRemoveNetwork failed result:%{public}d", result);
824 pthread_mutex_unlock(GetWpaObjMutex());
825 return WIFI_HAL_OPT_FAILED;
826 }
827 pthread_mutex_unlock(GetWpaObjMutex());
828 LOGI("HdiP2pRemoveNetwork success.");
829 return WIFI_HAL_OPT_OK;
830 }
831
HdiP2pSetGroupConfig(int networkId,P2pGroupConfig * pConfig,int size)832 WifiErrorNo HdiP2pSetGroupConfig(int networkId, P2pGroupConfig *pConfig, int size)
833 {
834 LOGI("HdiP2pSetGroupConfig enter size=%{public}d", size);
835 pthread_mutex_lock(GetWpaObjMutex());
836 struct IWpaInterface *wpaObj = GetWpaInterface();
837 if (wpaObj == NULL) {
838 LOGE("HdiP2pSetGroupConfig: wpaObj is NULL");
839 pthread_mutex_unlock(GetWpaObjMutex());
840 return WIFI_HAL_OPT_FAILED;
841 }
842
843 for (int i = 0; i < size; ++i) {
844 int32_t result = wpaObj->P2pSetGroupConfig(wpaObj, GetHdiP2pIfaceName(), networkId,
845 g_hdiP2pWpaNetworkFields[pConfig[i].cfgParam].fieldName, pConfig[i].cfgValue);
846 if (result != HDF_SUCCESS) {
847 LOGE("HdiP2pSetGroupConfig: %{public}s failed result:%{public}d",
848 g_hdiP2pWpaNetworkFields[pConfig[i].cfgParam].fieldName, result);
849 pthread_mutex_unlock(GetWpaObjMutex());
850 return WIFI_HAL_OPT_FAILED;
851 }
852 }
853 pthread_mutex_unlock(GetWpaObjMutex());
854 LOGI("HdiP2pSetGroupConfig success.");
855 return WIFI_HAL_OPT_OK;
856 }
857
HdiP2pInvite(const char * peerBssid,const char * goBssid,const char * ifname)858 WifiErrorNo HdiP2pInvite(const char *peerBssid, const char *goBssid, const char *ifname)
859 {
860 LOGI("HdiP2pInvite enter");
861 pthread_mutex_lock(GetWpaObjMutex());
862 struct IWpaInterface *wpaObj = GetWpaInterface();
863 if (wpaObj == NULL) {
864 LOGE("HdiP2pInvite: wpaObj is NULL");
865 pthread_mutex_unlock(GetWpaObjMutex());
866 return WIFI_HAL_OPT_FAILED;
867 }
868
869 int32_t result = wpaObj->P2pInvite(wpaObj, ifname, peerBssid, goBssid);
870 if (result != HDF_SUCCESS) {
871 LOGE("HdiP2pInvite: P2pInvite failed result:%{public}d", result);
872 pthread_mutex_unlock(GetWpaObjMutex());
873 return WIFI_HAL_OPT_FAILED;
874 }
875 pthread_mutex_unlock(GetWpaObjMutex());
876 LOGI("HdiP2pInvite success.");
877 return WIFI_HAL_OPT_OK;
878 }
879
HdiP2pReinvoke(int networkId,const char * bssid)880 WifiErrorNo HdiP2pReinvoke(int networkId, const char *bssid)
881 {
882 LOGI("HdiP2pReinvoke enter");
883 pthread_mutex_lock(GetWpaObjMutex());
884 struct IWpaInterface *wpaObj = GetWpaInterface();
885 if (wpaObj == NULL) {
886 LOGE("HdiP2pReinvoke: wpaObj is NULL");
887 pthread_mutex_unlock(GetWpaObjMutex());
888 return WIFI_HAL_OPT_FAILED;
889 }
890
891 int32_t result = wpaObj->P2pReinvoke(wpaObj, GetHdiP2pIfaceName(), networkId, bssid);
892 if (result != HDF_SUCCESS) {
893 LOGE("HdiP2pReinvoke: P2pReinvoke failed result:%{public}d", result);
894 pthread_mutex_unlock(GetWpaObjMutex());
895 return WIFI_HAL_OPT_FAILED;
896 }
897 pthread_mutex_unlock(GetWpaObjMutex());
898 LOGI("HdiP2pReinvoke success.");
899 return WIFI_HAL_OPT_OK;
900 }
901
HdiP2pGetDeviceAddress(char * deviceAddress,int size)902 WifiErrorNo HdiP2pGetDeviceAddress(char *deviceAddress, int size)
903 {
904 LOGI("HdiP2pGetDeviceAddress enter");
905 pthread_mutex_lock(GetWpaObjMutex());
906 struct IWpaInterface *wpaObj = GetWpaInterface();
907 if (wpaObj == NULL) {
908 LOGE("HdiP2pGetDeviceAddress: wpaObj is NULL");
909 pthread_mutex_unlock(GetWpaObjMutex());
910 return WIFI_HAL_OPT_FAILED;
911 }
912
913 int32_t result = wpaObj->P2pGetDeviceAddress(wpaObj, GetHdiP2pIfaceName(), deviceAddress, size);
914 if (result != HDF_SUCCESS) {
915 LOGE("HdiP2pGetDeviceAddress: P2pGetDeviceAddress failed result:%{public}d", result);
916 pthread_mutex_unlock(GetWpaObjMutex());
917 return WIFI_HAL_OPT_FAILED;
918 }
919 pthread_mutex_unlock(GetWpaObjMutex());
920 LOGI("HdiP2pGetDeviceAddress success.");
921 return WIFI_HAL_OPT_OK;
922 }
923
HdiP2pReqServiceDiscovery(struct HdiP2pReqService * reqService,char * replyDisc,int size)924 WifiErrorNo HdiP2pReqServiceDiscovery(struct HdiP2pReqService *reqService, char *replyDisc, int size)
925 {
926 LOGI("HdiP2pReqServiceDiscovery enter");
927 pthread_mutex_lock(GetWpaObjMutex());
928 struct IWpaInterface *wpaObj = GetWpaInterface();
929 if (wpaObj == NULL) {
930 LOGE("HdiP2pReqServiceDiscovery: wpaObj is NULL");
931 pthread_mutex_unlock(GetWpaObjMutex());
932 return WIFI_HAL_OPT_FAILED;
933 }
934
935 int32_t result = wpaObj->P2pReqServiceDiscovery(wpaObj, GetHdiP2pIfaceName(), reqService,
936 replyDisc, size);
937 if (result != HDF_SUCCESS) {
938 LOGE("HdiP2pReqServiceDiscovery: P2pReqServiceDiscovery failed result:%{public}d", result);
939 pthread_mutex_unlock(GetWpaObjMutex());
940 return WIFI_HAL_OPT_FAILED;
941 }
942 pthread_mutex_unlock(GetWpaObjMutex());
943 LOGI("HdiP2pReqServiceDiscovery success.");
944 return WIFI_HAL_OPT_OK;
945 }
946
HdiP2pCancelServiceDiscovery(const char * id)947 WifiErrorNo HdiP2pCancelServiceDiscovery(const char *id)
948 {
949 LOGI("HdiP2pCancelServiceDiscovery enter");
950 pthread_mutex_lock(GetWpaObjMutex());
951 struct IWpaInterface *wpaObj = GetWpaInterface();
952 if (wpaObj == NULL) {
953 LOGE("HdiP2pCancelServiceDiscovery: wpaObj is NULL");
954 pthread_mutex_unlock(GetWpaObjMutex());
955 return WIFI_HAL_OPT_FAILED;
956 }
957
958 int32_t result = wpaObj->P2pCancelServiceDiscovery(wpaObj, GetHdiP2pIfaceName(), id);
959 if (result != HDF_SUCCESS) {
960 LOGE("HdiP2pCancelServiceDiscovery: P2pCancelServiceDiscovery failed result:%{public}d", result);
961 pthread_mutex_unlock(GetWpaObjMutex());
962 return WIFI_HAL_OPT_FAILED;
963 }
964 pthread_mutex_unlock(GetWpaObjMutex());
965 LOGI("HdiP2pCancelServiceDiscovery success.");
966 return WIFI_HAL_OPT_OK;
967 }
968
HdiP2pRespServerDiscovery(struct HdiP2pServDiscReqInfo * info)969 WifiErrorNo HdiP2pRespServerDiscovery(struct HdiP2pServDiscReqInfo *info)
970 {
971 LOGI("HdiP2pRespServerDiscovery enter");
972 pthread_mutex_lock(GetWpaObjMutex());
973 struct IWpaInterface *wpaObj = GetWpaInterface();
974 if (wpaObj == NULL) {
975 LOGE("HdiP2pRespServerDiscovery: wpaObj is NULL");
976 pthread_mutex_unlock(GetWpaObjMutex());
977 return WIFI_HAL_OPT_FAILED;
978 }
979
980 int32_t result = wpaObj->P2pRespServerDiscovery(wpaObj, GetHdiP2pIfaceName(), info);
981 if (result != HDF_SUCCESS) {
982 LOGE("HdiP2pRespServerDiscovery: P2pRespServerDiscovery failed result:%{public}d", result);
983 pthread_mutex_unlock(GetWpaObjMutex());
984 return WIFI_HAL_OPT_FAILED;
985 }
986 pthread_mutex_unlock(GetWpaObjMutex());
987 LOGI("HdiP2pRespServerDiscovery success.");
988 return WIFI_HAL_OPT_OK;
989 }
990 #define HDI_POS_TEN 10
hex2num(char c)991 static int hex2num(char c)
992 {
993 if (c >= '0' && c <= '9') {
994 return c - '0';
995 }
996 if (c >= 'a' && c <= 'f') {
997 return c - 'a' + HDI_POS_TEN;
998 }
999 if (c >= 'A' && c <= 'F') {
1000 return c - 'A' + HDI_POS_TEN;
1001 }
1002 return -1;
1003 }
1004
hex2byte(const char * hex)1005 static int hex2byte(const char *hex)
1006 {
1007 int a = hex2num(*hex++);
1008 if (a < 0) {
1009 return -1;
1010 }
1011 int b = hex2num(*hex++);
1012 if (b < 0) {
1013 return -1;
1014 }
1015 return (a << HDI_POS_FOURTH) | b;
1016 }
1017
hwaddr_parse(char * txt,uint8_t * addr)1018 static char* hwaddr_parse(char *txt, uint8_t *addr)
1019 {
1020 size_t i;
1021
1022 for (i = 0; i < ETH_ALEN; i++) {
1023 int a;
1024
1025 a = hex2byte(txt);
1026 if (a < 0)
1027 return NULL;
1028 txt += HDI_MAC_SUB_LEN;
1029 addr[i] = a;
1030 if (i < ETH_ALEN - 1 && *txt++ != ':')
1031 return NULL;
1032 }
1033 return txt;
1034 }
1035
hwaddr_aton(char * txt,uint8_t * addr)1036 static int hwaddr_aton(char *txt, uint8_t *addr)
1037 {
1038 return hwaddr_parse(txt, addr) ? 0 : -1;
1039 }
1040
HdiP2pConnect(P2pConnectInfo * info,char * replyPin,int size)1041 WifiErrorNo HdiP2pConnect(P2pConnectInfo *info, char *replyPin, int size)
1042 {
1043 LOGI("HdiP2pConnect enter");
1044 pthread_mutex_lock(GetWpaObjMutex());
1045 struct IWpaInterface *wpaObj = GetWpaInterface();
1046 if (wpaObj == NULL) {
1047 LOGE("HdiP2pConnect: wpaObj is NULL");
1048 pthread_mutex_unlock(GetWpaObjMutex());
1049 return WIFI_HAL_OPT_FAILED;
1050 }
1051 struct HdiP2pConnectInfo wpsParam = {0};
1052 wpsParam.persistent = info->persistent;
1053 wpsParam.mode = info->mode;
1054 wpsParam.goIntent = info->goIntent;
1055 wpsParam.provdisc = info->provdisc;
1056 uint8_t addr[ETH_ALEN];
1057 hwaddr_aton(info->peerDevAddr, addr);
1058 wpsParam.peerDevAddr = addr;
1059 wpsParam.peerDevAddrLen = ETH_ALEN;
1060 wpsParam.pin = (uint8_t *)info->pin;
1061 wpsParam.pinLen = HDI_PIN_LEN;
1062
1063 int32_t result = wpaObj->P2pConnect(wpaObj, GetHdiP2pIfaceName(), &wpsParam, replyPin, size - 1);
1064 if (result != HDF_SUCCESS) {
1065 LOGE("HdiP2pConnect: P2pConnect failed result:%{public}d", result);
1066 pthread_mutex_unlock(GetWpaObjMutex());
1067 return WIFI_HAL_OPT_FAILED;
1068 }
1069 pthread_mutex_unlock(GetWpaObjMutex());
1070 LOGI("HdiP2pConnect success.");
1071 return WIFI_HAL_OPT_OK;
1072 }
1073
HdiP2pHid2dConnect(struct Hid2dConnectInfo * info)1074 WifiErrorNo HdiP2pHid2dConnect(struct Hid2dConnectInfo *info)
1075 {
1076 LOGI("HdiP2pHid2dConnect enter");
1077 pthread_mutex_lock(GetWpaObjMutex());
1078 struct IWpaInterface *wpaObj = GetWpaInterface();
1079 if (wpaObj == NULL) {
1080 LOGE("HdiP2pHid2dConnect: wpaObj is NULL");
1081 pthread_mutex_unlock(GetWpaObjMutex());
1082 return WIFI_HAL_OPT_FAILED;
1083 }
1084 struct HdiHid2dConnectInfo wpsParam = {0};
1085 uint8_t addr[ETH_ALEN];
1086 hwaddr_aton(info->bssid, addr);
1087 wpsParam.ssid = (uint8_t *)info->ssid;
1088 wpsParam.ssidLen = strlen(info->ssid) + 1;
1089 wpsParam.bssid = addr;
1090 wpsParam.bssidLen = ETH_ALEN;
1091 wpsParam.passphrase = (uint8_t *)info->passphrase;
1092 wpsParam.passphraseLen = strlen(info->passphrase) + 1;
1093 wpsParam.frequency = (info->frequency << 16) | (info->isLegacyGo);
1094 int32_t result = wpaObj->P2pHid2dConnect(wpaObj, GetHdiP2pIfaceName(), &wpsParam);
1095 if (result != HDF_SUCCESS) {
1096 LOGE("HdiP2pHid2dConnect: P2pHid2dConnect failed result:%{public}d", result);
1097 pthread_mutex_unlock(GetWpaObjMutex());
1098 return WIFI_HAL_OPT_FAILED;
1099 }
1100 pthread_mutex_unlock(GetWpaObjMutex());
1101 LOGI("HdiP2pHid2dConnect success.");
1102 return WIFI_HAL_OPT_OK;
1103 }
1104
HdiP2pSetServDiscExternal(int mode)1105 WifiErrorNo HdiP2pSetServDiscExternal(int mode)
1106 {
1107 LOGI("HdiP2pSetServDiscExternal enter");
1108 pthread_mutex_lock(GetWpaObjMutex());
1109 struct IWpaInterface *wpaObj = GetWpaInterface();
1110 if (wpaObj == NULL) {
1111 LOGE("HdiP2pSetServDiscExternal: wpaObj is NULL");
1112 pthread_mutex_unlock(GetWpaObjMutex());
1113 return WIFI_HAL_OPT_FAILED;
1114 }
1115
1116 int32_t result = wpaObj->P2pSetServDiscExternal(wpaObj, GetHdiP2pIfaceName(), mode);
1117 if (result != HDF_SUCCESS) {
1118 LOGE("HdiP2pSetServDiscExternal: P2pSetServDiscExternal failed result:%{public}d", result);
1119 pthread_mutex_unlock(GetWpaObjMutex());
1120 return WIFI_HAL_OPT_FAILED;
1121 }
1122 pthread_mutex_unlock(GetWpaObjMutex());
1123 LOGI("HdiP2pSetServDiscExternal success.");
1124 return WIFI_HAL_OPT_OK;
1125 }
1126
HdiP2pRemoveGroup(const char * groupName)1127 WifiErrorNo HdiP2pRemoveGroup(const char *groupName)
1128 {
1129 LOGI("HdiP2pRemoveGroup enter groupName=%{public}s", groupName);
1130 pthread_mutex_lock(GetWpaObjMutex());
1131 struct IWpaInterface *wpaObj = GetWpaInterface();
1132 if (wpaObj == NULL) {
1133 LOGE("HdiP2pRemoveGroup: wpaObj is NULL");
1134 pthread_mutex_unlock(GetWpaObjMutex());
1135 return WIFI_HAL_OPT_FAILED;
1136 }
1137
1138 int32_t result = wpaObj->P2pRemoveGroup(wpaObj, GetHdiP2pIfaceName(), groupName);
1139 if (result != HDF_SUCCESS) {
1140 LOGE("HdiP2pRemoveGroup: P2pRemoveGroup failed result:%{public}d", result);
1141 pthread_mutex_unlock(GetWpaObjMutex());
1142 return WIFI_HAL_OPT_FAILED;
1143 }
1144 pthread_mutex_unlock(GetWpaObjMutex());
1145 LOGI("HdiP2pRemoveGroup success.");
1146 return WIFI_HAL_OPT_OK;
1147 }
1148
HdiP2pCancelConnect()1149 WifiErrorNo HdiP2pCancelConnect()
1150 {
1151 LOGI("HdiP2pCancelConnect enter");
1152 pthread_mutex_lock(GetWpaObjMutex());
1153 struct IWpaInterface *wpaObj = GetWpaInterface();
1154 if (wpaObj == NULL) {
1155 LOGE("HdiP2pCancelConnect: wpaObj is NULL");
1156 pthread_mutex_unlock(GetWpaObjMutex());
1157 return WIFI_HAL_OPT_FAILED;
1158 }
1159
1160 int32_t result = wpaObj->P2pCancelConnect(wpaObj, GetHdiP2pIfaceName());
1161 if (result != HDF_SUCCESS) {
1162 LOGE("HdiP2pCancelConnect: P2pCancelConnect failed result:%{public}d", result);
1163 pthread_mutex_unlock(GetWpaObjMutex());
1164 return WIFI_HAL_OPT_FAILED;
1165 }
1166 pthread_mutex_unlock(GetWpaObjMutex());
1167 LOGI("HdiP2pCancelConnect success.");
1168 return WIFI_HAL_OPT_OK;
1169 }
1170
HdiP2pGetGroupConfig(int networkId,char * param,char * value)1171 WifiErrorNo HdiP2pGetGroupConfig(int networkId, char *param, char *value)
1172 {
1173 LOGI("HdiP2pGetGroupConfig enter");
1174 pthread_mutex_lock(GetWpaObjMutex());
1175 struct IWpaInterface *wpaObj = GetWpaInterface();
1176 if (wpaObj == NULL) {
1177 LOGE("HdiP2pGetGroupConfig: wpaObj is NULL");
1178 pthread_mutex_unlock(GetWpaObjMutex());
1179 return WIFI_HAL_OPT_FAILED;
1180 }
1181
1182 int32_t result = wpaObj->P2pGetGroupConfig(wpaObj, GetHdiP2pIfaceName(), networkId,
1183 param, value, WIFI_P2P_GROUP_CONFIG_VALUE_LENGTH);
1184 if (result != HDF_SUCCESS) {
1185 LOGE("HdiP2pGetGroupConfig: P2pGetGroupConfig failed result:%{public}d", result);
1186 pthread_mutex_unlock(GetWpaObjMutex());
1187 return WIFI_HAL_OPT_FAILED;
1188 }
1189 pthread_mutex_unlock(GetWpaObjMutex());
1190 LOGI("HdiP2pGetGroupConfig success.");
1191 return WIFI_HAL_OPT_OK;
1192 }
1193
HdiP2pAddNetwork(int * networkId)1194 WifiErrorNo HdiP2pAddNetwork(int *networkId)
1195 {
1196 LOGI("HdiP2pAddNetwork enter");
1197 pthread_mutex_lock(GetWpaObjMutex());
1198 struct IWpaInterface *wpaObj = GetWpaInterface();
1199 if (wpaObj == NULL) {
1200 LOGE("HdiP2pAddNetwork: wpaObj is NULL");
1201 pthread_mutex_unlock(GetWpaObjMutex());
1202 return WIFI_HAL_OPT_FAILED;
1203 }
1204
1205 int32_t result = wpaObj->P2pAddNetwork(wpaObj, GetHdiP2pIfaceName(), networkId);
1206 if (result != HDF_SUCCESS) {
1207 LOGE("HdiP2pAddNetwork: P2pAddNetwork failed result:%{public}d", result);
1208 pthread_mutex_unlock(GetWpaObjMutex());
1209 return WIFI_HAL_OPT_FAILED;
1210 }
1211 pthread_mutex_unlock(GetWpaObjMutex());
1212 LOGI("HdiP2pAddNetwork success networkId=%{public}d.", *networkId);
1213 return WIFI_HAL_OPT_OK;
1214 }
1215
HdiP2pGetPeer(const char * bssid,struct HdiP2pDeviceInfo * info)1216 WifiErrorNo HdiP2pGetPeer(const char *bssid, struct HdiP2pDeviceInfo *info)
1217 {
1218 LOGI("HdiP2pGetPeer enter");
1219 pthread_mutex_lock(GetWpaObjMutex());
1220 struct IWpaInterface *wpaObj = GetWpaInterface();
1221 if (wpaObj == NULL) {
1222 LOGE("HdiP2pGetPeer: wpaObj is NULL");
1223 pthread_mutex_unlock(GetWpaObjMutex());
1224 return WIFI_HAL_OPT_FAILED;
1225 }
1226
1227 int32_t result = wpaObj->P2pGetPeer(wpaObj, GetHdiP2pIfaceName(), bssid, info);
1228 if (result != HDF_SUCCESS) {
1229 LOGE("HdiP2pGetPeer: P2pGetPeer failed result:%{public}d", result);
1230 pthread_mutex_unlock(GetWpaObjMutex());
1231 return WIFI_HAL_OPT_FAILED;
1232 }
1233 pthread_mutex_unlock(GetWpaObjMutex());
1234 LOGI("HdiP2pGetPeer success.");
1235 return WIFI_HAL_OPT_OK;
1236 }
1237
HdiP2pGetGroupCapability(const char * bssid,int cap)1238 WifiErrorNo HdiP2pGetGroupCapability(const char *bssid, int cap)
1239 {
1240 LOGI("HdiP2pGetGroupCapability enter");
1241 pthread_mutex_lock(GetWpaObjMutex());
1242 struct IWpaInterface *wpaObj = GetWpaInterface();
1243 if (wpaObj == NULL) {
1244 LOGE("HdiP2pGetGroupCapability: wpaObj is NULL");
1245 pthread_mutex_unlock(GetWpaObjMutex());
1246 return WIFI_HAL_OPT_FAILED;
1247 }
1248
1249 int32_t result = wpaObj->P2pGetGroupCapability(wpaObj, GetHdiP2pIfaceName(), bssid, &cap);
1250 if (result != HDF_SUCCESS) {
1251 LOGE("HdiP2pGetGroupCapability: P2pGetGroupCapability failed result:%{public}d", result);
1252 pthread_mutex_unlock(GetWpaObjMutex());
1253 return WIFI_HAL_OPT_FAILED;
1254 }
1255 pthread_mutex_unlock(GetWpaObjMutex());
1256 LOGI("HdiP2pGetGroupCapability success.");
1257 return WIFI_HAL_OPT_OK;
1258 }
1259
HdiP2pListNetworks(struct HdiP2pNetworkList * infoList)1260 WifiErrorNo HdiP2pListNetworks(struct HdiP2pNetworkList *infoList)
1261 {
1262 LOGI("HdiP2pListNetworks enter");
1263 pthread_mutex_lock(GetWpaObjMutex());
1264 struct IWpaInterface *wpaObj = GetWpaInterface();
1265 if (wpaObj == NULL) {
1266 LOGE("HdiP2pListNetworks: wpaObj is NULL");
1267 pthread_mutex_unlock(GetWpaObjMutex());
1268 return WIFI_HAL_OPT_FAILED;
1269 }
1270
1271 int32_t result = wpaObj->P2pListNetworks(wpaObj, GetHdiP2pIfaceName(), infoList);
1272 if (result != HDF_SUCCESS) {
1273 LOGE("HdiP2pListNetworks: P2pListNetworks failed result:%{public}d", result);
1274 pthread_mutex_unlock(GetWpaObjMutex());
1275 return WIFI_HAL_OPT_FAILED;
1276 }
1277 pthread_mutex_unlock(GetWpaObjMutex());
1278 LOGI("HdiP2pListNetworks success.");
1279 return WIFI_HAL_OPT_OK;
1280 }
1281
HdiP2pSaveConfig()1282 WifiErrorNo HdiP2pSaveConfig()
1283 {
1284 LOGI("HdiP2pSaveConfig enter");
1285 pthread_mutex_lock(GetWpaObjMutex());
1286 struct IWpaInterface *wpaObj = GetWpaInterface();
1287 if (wpaObj == NULL) {
1288 LOGE("HdiP2pSaveConfig: wpaObj is NULL");
1289 pthread_mutex_unlock(GetWpaObjMutex());
1290 return WIFI_HAL_OPT_FAILED;
1291 }
1292
1293 int32_t result = wpaObj->P2pSaveConfig(wpaObj, GetHdiP2pIfaceName());
1294 if (result != HDF_SUCCESS) {
1295 LOGE("HdiP2pSaveConfig: P2pSaveConfig failed result:%{public}d", result);
1296 pthread_mutex_unlock(GetWpaObjMutex());
1297 return WIFI_HAL_OPT_FAILED;
1298 }
1299 pthread_mutex_unlock(GetWpaObjMutex());
1300 LOGI("HdiP2pSaveConfig success.");
1301 return WIFI_HAL_OPT_OK;
1302 }
1303
HdiDeliverP2pData(int32_t cmdType,int32_t dataType,const char * carryData)1304 WifiErrorNo HdiDeliverP2pData(int32_t cmdType, int32_t dataType, const char *carryData)
1305 {
1306 LOGI("HdiDeliverP2pData enter");
1307 pthread_mutex_lock(GetWpaObjMutex());
1308 struct IWpaInterface *wpaObj = GetWpaInterface();
1309 if (wpaObj == NULL) {
1310 LOGE("HdiDeliverP2pData: wpaObj is NULL");
1311 pthread_mutex_unlock(GetWpaObjMutex());
1312 return WIFI_HAL_OPT_FAILED;
1313 }
1314
1315 int32_t result = wpaObj->DeliverP2pData(wpaObj, "p2p0", cmdType, dataType, carryData);
1316 if (result != HDF_SUCCESS) {
1317 LOGE("HdiDeliverP2pData: send failed result:%{public}d", result);
1318 pthread_mutex_unlock(GetWpaObjMutex());
1319 return WIFI_HAL_OPT_FAILED;
1320 }
1321 pthread_mutex_unlock(GetWpaObjMutex());
1322 LOGI("HdiDeliverP2pData success.");
1323 return WIFI_HAL_OPT_OK;
1324 }
1325 #endif