1 /*
2  * Copyright (C) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <hdf_log.h>
17 #include "wpa_p2p_hal.h"
18 #include "hdi_wpa_common.h"
19 #include "utils/common.h"
20 #include "securec.h"
21 #include "wpa_hal_struct.h"
22 #include "wpa_hdi_util.h"
23 
24 #undef LOG_TAG
25 #define LOG_TAG "WpaP2pHal"
26 
27 #define P2P_REPLY_BUF_LENGTH 4096
28 #define P2P_REPLY_BUF_SMALL_LENGTH 64
29 #define P2P_CMD_BUF_LENGTH 256
30 #define P2P_PIN_CODE_LEN 8
31 #define P2P_REMOVE_ALL_NETWORK_CMD (-1)
32 #define P2P_CONNECT_JOIN_LEN 20
33 #define P2P_CONNECT_MODE_LEN 16
34 #define P2P_CONNECT_PERSISTENT_LEN 16
35 #define NETWORKS_LIST_ONE 1
36 #define NETWORKS_LIST_TWO 2
37 #define CMD_INT_MAX_LEN 10
38 #define P2P_GROUP_CONFIG_FIELD_NAME_LENGTH 32
39 
40 WifiWpaP2pInterface *g_wpaP2pInterface = NULL;
41 WifiWpaP2pGroupInterface *g_wpaP2pGroupInterface = NULL; /* list head */
42 
43 typedef struct P2pWpaNetworkField {
44     P2pGroupConfigType field;
45     char fieldName[P2P_GROUP_CONFIG_FIELD_NAME_LENGTH];
46     int flag; /* 0 need add "" 1 no need */
47 } P2pWpaNetworkField;
48 
49 static const P2pWpaNetworkField P2P_WPA_NETWORK_FIELDS[] = {
50     {GROUP_CONFIG_SSID, "ssid", 0},
51     {GROUP_CONFIG_BSSID, "bssid", 1},
52     {GROUP_CONFIG_PSK, "psk", 1},
53     {GROUP_CONFIG_PROTO, "proto", 1},
54     {GROUP_CONFIG_KEY_MGMT, "key_mgmt", 1},
55     {GROUP_CONFIG_PAIRWISE, "pairwise", 1},
56     {GROUP_CONFIG_AUTH_ALG, "auth_alg", 1},
57     {GROUP_CONFIG_MODE, "mode", 1},
58     {GROUP_CONFIG_DISABLED, "disabled", 1}
59 };
60 
WpaP2pCliCmdWpsPbc(WifiWpaP2pGroupInterface * this,const char * bssid)61 static P2pSupplicantErrCode WpaP2pCliCmdWpsPbc(WifiWpaP2pGroupInterface *this, const char *bssid)
62 {
63     if (this == NULL || bssid == NULL) {
64         return P2P_SUP_ERRCODE_INVALID;
65     }
66     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
67     char cmd[P2P_CMD_BUF_LENGTH] = {0};
68     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s WPS_PBC", this->groupIfname) < 0) {
69         HDF_LOGE("snprintf error!");
70         return P2P_SUP_ERRCODE_FAILED;
71     }
72     if (strlen(bssid) > 0) {
73         unsigned pos = strlen(cmd);
74         if (snprintf_s(cmd + pos, sizeof(cmd) - pos, sizeof(cmd) - pos - 1, " %s", bssid) < 0) {
75             HDF_LOGE("snprintf error!");
76             return P2P_SUP_ERRCODE_FAILED;
77         }
78     }
79     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
80         HDF_LOGE("WPS_PBC command failed!");
81         return P2P_SUP_ERRCODE_FAILED;
82     }
83     if (strncmp(buf, "FAIL-PBC-OVERLAP", strlen("FAIL-PBC-OVERLAP")) == 0) {
84         HDF_LOGE("wps_pbc success, but result err: buf =%{public}s", buf);
85         return P2P_SUP_ERRCODE_PBC_OVERLAP;
86     }
87     return P2P_SUP_ERRCODE_SUCCESS;
88 }
89 
WpaP2pCliCmdWpsPin(WifiWpaP2pGroupInterface * this,P2pWpsPinDisplayArgv * argv)90 static P2pSupplicantErrCode WpaP2pCliCmdWpsPin(WifiWpaP2pGroupInterface *this, P2pWpsPinDisplayArgv *argv)
91 {
92     if (this == NULL || argv == NULL) {
93         return P2P_SUP_ERRCODE_INVALID;
94     }
95     if ((argv->mode != P2P_PIN_KEYPAD && argv->mode != P2P_PIN_DISPLAY) ||
96         (argv->mode == P2P_PIN_KEYPAD && strlen(argv->pinCode) == 0)) {
97         return P2P_SUP_ERRCODE_INPUT_ERROR;
98     }
99     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
100     char cmd[P2P_CMD_BUF_LENGTH] = {0};
101     int res;
102     if (argv->mode == P2P_PIN_KEYPAD) {
103         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s WPS_PIN any %s", this->groupIfname,
104             argv->pinCode);
105     } else if (strlen(argv->bssid) == 0) {
106         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s WPS_PIN any", this->groupIfname);
107     } else {
108         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s WPS_PIN %s", this->groupIfname, argv->bssid);
109     }
110     if (res < 0) {
111         HDF_LOGE("snprintf err");
112         return P2P_SUP_ERRCODE_FAILED;
113     }
114     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
115         HDF_LOGE("WPS_PIN command failed!");
116         return P2P_SUP_ERRCODE_FAILED;
117     }
118     if (argv->mode == P2P_PIN_DISPLAY) {
119         if (strncpy_s(argv->pinCode, sizeof(argv->pinCode), buf, P2P_PIN_CODE_LEN) != EOK) {
120             HDF_LOGE("Failed to copy return pin code!");
121             return P2P_SUP_ERRCODE_FAILED;
122         }
123     }
124     return P2P_SUP_ERRCODE_SUCCESS;
125 }
126 
WpaP2pCliCmdSetPowerSave(WifiWpaP2pGroupInterface * this,int enable)127 static P2pSupplicantErrCode WpaP2pCliCmdSetPowerSave(WifiWpaP2pGroupInterface *this, int enable)
128 {
129     if (this == NULL) {
130         return P2P_SUP_ERRCODE_INVALID;
131     }
132     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
133     char cmd[P2P_CMD_BUF_LENGTH] = {0};
134     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_SET ps %d", this->groupIfname, enable) < 0) {
135         HDF_LOGE("snprintf err");
136         return P2P_SUP_ERRCODE_FAILED;
137     }
138     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
139         HDF_LOGE("P2P_SET ps command failed!");
140         return P2P_SUP_ERRCODE_FAILED;
141     }
142     return P2P_SUP_ERRCODE_SUCCESS;
143 }
144 
WpaP2pCliCmdSetGroupIdle(WifiWpaP2pGroupInterface * this,int timeout)145 static P2pSupplicantErrCode WpaP2pCliCmdSetGroupIdle(WifiWpaP2pGroupInterface *this, int timeout)
146 {
147     if (this == NULL) {
148         return P2P_SUP_ERRCODE_INVALID;
149     }
150     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
151     char cmd[P2P_CMD_BUF_LENGTH] = {0};
152     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s SET p2p_group_idle %d", this->groupIfname,
153         timeout) < 0) {
154         HDF_LOGE("snprintf err");
155         return P2P_SUP_ERRCODE_FAILED;
156     }
157     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
158         HDF_LOGE("SET p2p_group_idle command failed!");
159         return P2P_SUP_ERRCODE_FAILED;
160     }
161     return P2P_SUP_ERRCODE_SUCCESS;
162 }
163 
WpaP2pCliCmdSetWpsName(WifiWpaP2pInterface * this,const char * name)164 static P2pSupplicantErrCode WpaP2pCliCmdSetWpsName(WifiWpaP2pInterface *this, const char *name)
165 {
166     if (this == NULL || name == NULL) {
167         return P2P_SUP_ERRCODE_INVALID;
168     }
169     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
170     char cmd[P2P_CMD_BUF_LENGTH] = {0};
171     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s SET device_name %s", this->ifName, name) < 0) {
172         HDF_LOGE("snprintf err");
173         return P2P_SUP_ERRCODE_FAILED;
174     }
175     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
176         HDF_LOGE("set device_name command failed!");
177         return P2P_SUP_ERRCODE_FAILED;
178     }
179     return P2P_SUP_ERRCODE_SUCCESS;
180 }
181 
WpaP2pCliCmdSetWpsDeviceType(WifiWpaP2pInterface * this,const char * type)182 static P2pSupplicantErrCode WpaP2pCliCmdSetWpsDeviceType(WifiWpaP2pInterface *this, const char *type)
183 {
184     if (this == NULL || type == NULL) {
185         return P2P_SUP_ERRCODE_INVALID;
186     }
187     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
188     char cmd[P2P_CMD_BUF_LENGTH] = {0};
189     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s SET device_type %s", this->ifName, type) < 0) {
190         HDF_LOGE("snprintf err");
191         return P2P_SUP_ERRCODE_FAILED;
192     }
193     HDF_LOGI("Set device type CMD: %{public}s", cmd);
194     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
195         HDF_LOGE("set device_type command failed!");
196         return P2P_SUP_ERRCODE_FAILED;
197     }
198     return P2P_SUP_ERRCODE_SUCCESS;
199 }
200 
WpaP2pCliCmdSetWpsSecDeviceType(WifiWpaP2pInterface * this,const char * type)201 static P2pSupplicantErrCode WpaP2pCliCmdSetWpsSecDeviceType(WifiWpaP2pInterface *this, const char *type)
202 {
203     if (this == NULL || type == NULL) {
204         return P2P_SUP_ERRCODE_INVALID;
205     }
206     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
207     char cmd[P2P_CMD_BUF_LENGTH] = {0};
208     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s SET sec_device_type %s", this->ifName, type) < 0) {
209         HDF_LOGE("snprintf err");
210         return P2P_SUP_ERRCODE_FAILED;
211     }
212     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
213         HDF_LOGE("set sec_device_type command failed!");
214         return P2P_SUP_ERRCODE_FAILED;
215     }
216     return P2P_SUP_ERRCODE_SUCCESS;
217 }
218 
WpaP2pCliCmdSetWpsConfigMethods(WifiWpaP2pInterface * this,const char * methods)219 static P2pSupplicantErrCode WpaP2pCliCmdSetWpsConfigMethods(WifiWpaP2pInterface *this, const char *methods)
220 {
221     if (this == NULL || methods == NULL) {
222         return P2P_SUP_ERRCODE_INVALID;
223     }
224     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
225     char cmd[P2P_CMD_BUF_LENGTH] = {0};
226     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s SET config_methods %s", this->ifName, methods) < 0) {
227         HDF_LOGE("snprintf err");
228         return P2P_SUP_ERRCODE_FAILED;
229     }
230     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
231         HDF_LOGE("set config_methods command failed!");
232         return P2P_SUP_ERRCODE_FAILED;
233     }
234     return P2P_SUP_ERRCODE_SUCCESS;
235 }
236 
WpaP2pCliCmdSetSsidPostfixName(WifiWpaP2pInterface * this,const char * name)237 static P2pSupplicantErrCode WpaP2pCliCmdSetSsidPostfixName(WifiWpaP2pInterface *this, const char *name)
238 {
239     if (this == NULL || name == NULL) {
240         return P2P_SUP_ERRCODE_INVALID;
241     }
242     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
243     char cmd[P2P_CMD_BUF_LENGTH] = {0};
244     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_SET ssid_postfix %s", this->ifName, name) < 0) {
245         HDF_LOGE("snprintf err");
246         return P2P_SUP_ERRCODE_FAILED;
247     }
248     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
249         HDF_LOGE("P2P_SET ssid_postfix command failed!");
250         return P2P_SUP_ERRCODE_FAILED;
251     }
252     return P2P_SUP_ERRCODE_SUCCESS;
253 }
254 
WpaP2pCliCmdGetDeviceAddress(WifiWpaP2pInterface * this,char * devAddress,int size)255 static P2pSupplicantErrCode WpaP2pCliCmdGetDeviceAddress(WifiWpaP2pInterface *this, char *devAddress, int size)
256 {
257     if (this == NULL || devAddress == NULL) {
258         return P2P_SUP_ERRCODE_INVALID;
259     }
260     char cmd[P2P_CMD_BUF_LENGTH] = {0};
261     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s STATUS", this->ifName) < 0) {
262         HDF_LOGE("snprintf err");
263         return P2P_SUP_ERRCODE_FAILED;
264     }
265     char *buf = (char *)calloc(P2P_REPLY_BUF_LENGTH, sizeof(char));
266     if (buf == NULL) {
267         return P2P_SUP_ERRCODE_FAILED;
268     }
269     if (WpaCliCmd(cmd, buf, P2P_REPLY_BUF_LENGTH) != 0) {
270         HDF_LOGE("STATUS command failed!");
271         free(buf);
272         return P2P_SUP_ERRCODE_FAILED;
273     }
274     char *p = strstr(buf, "p2p_device_address=");
275     if (p == NULL) {
276         HDF_LOGE("Not find device address!");
277         free(buf);
278         return P2P_SUP_ERRCODE_FAILED;
279     }
280     p += strlen("p2p_device_address=");
281     char *q = p;
282     while (*q != '\0' && *q != '\n') {
283         ++q;
284     }
285     if (strncpy_s(devAddress, size, p, q - p) != EOK) {
286         HDF_LOGE("Failed to copy device address!");
287         free(buf);
288         return P2P_SUP_ERRCODE_FAILED;
289     }
290     free(buf);
291     return P2P_SUP_ERRCODE_SUCCESS;
292 }
293 
WpaP2pCliCmdFlush(WifiWpaP2pInterface * this)294 static P2pSupplicantErrCode WpaP2pCliCmdFlush(WifiWpaP2pInterface *this)
295 {
296     if (this == NULL) {
297         return P2P_SUP_ERRCODE_INVALID;
298     }
299     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
300     char cmd[P2P_CMD_BUF_LENGTH] = {0};
301     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_FLUSH", this->ifName) < 0) {
302         HDF_LOGE("snprintf err");
303         return P2P_SUP_ERRCODE_FAILED;
304     }
305     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
306         HDF_LOGE("P2P_FLUSH command failed!");
307         return P2P_SUP_ERRCODE_FAILED;
308     }
309     return P2P_SUP_ERRCODE_SUCCESS;
310 }
311 
WpaP2pCliCmdFlushService(WifiWpaP2pInterface * this)312 static P2pSupplicantErrCode WpaP2pCliCmdFlushService(WifiWpaP2pInterface *this)
313 {
314     if (this == NULL) {
315         return P2P_SUP_ERRCODE_INVALID;
316     }
317     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
318     char cmd[P2P_CMD_BUF_LENGTH] = {0};
319     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_SERVICE_FLUSH", this->ifName) < 0) {
320         HDF_LOGE("snprintf err");
321         return P2P_SUP_ERRCODE_FAILED;
322     }
323     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
324         HDF_LOGE("P2P_SERVICE_FLUSH command failed!");
325         return P2P_SUP_ERRCODE_FAILED;
326     }
327     return P2P_SUP_ERRCODE_SUCCESS;
328 }
329 
WpaP2pCliCmdP2pStopFind(WifiWpaP2pInterface * this)330 static P2pSupplicantErrCode WpaP2pCliCmdP2pStopFind(WifiWpaP2pInterface *this)
331 {
332     if (this == NULL) {
333         return P2P_SUP_ERRCODE_INVALID;
334     }
335     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
336     char cmd[P2P_CMD_BUF_LENGTH] = {0};
337     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_STOP_FIND", this->ifName) < 0) {
338         HDF_LOGE("snprintf err");
339         return P2P_SUP_ERRCODE_FAILED;
340     }
341     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
342         HDF_LOGE("P2P_STOP_FIND command failed!");
343         return P2P_SUP_ERRCODE_FAILED;
344     }
345     return P2P_SUP_ERRCODE_SUCCESS;
346 }
347 
WpaP2pCliCmdP2pRemoveGroup(WifiWpaP2pInterface * this,const char * groupname)348 static P2pSupplicantErrCode WpaP2pCliCmdP2pRemoveGroup(WifiWpaP2pInterface *this, const char *groupname)
349 {
350     if (this == NULL || groupname == NULL) {
351         return P2P_SUP_ERRCODE_INVALID;
352     }
353     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
354     char cmd[P2P_CMD_BUF_LENGTH] = {0};
355     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_GROUP_REMOVE %s", this->ifName, groupname) < 0) {
356         HDF_LOGE("snprintf err");
357         return P2P_SUP_ERRCODE_FAILED;
358     }
359     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
360         HDF_LOGE("P2P_GROUP_REMOVE command failed!");
361         return P2P_SUP_ERRCODE_FAILED;
362     }
363     return P2P_SUP_ERRCODE_SUCCESS;
364 }
365 
WpaP2pCliCmdP2pFound(WifiWpaP2pInterface * this,int timeout)366 static P2pSupplicantErrCode WpaP2pCliCmdP2pFound(WifiWpaP2pInterface *this, int timeout)
367 {
368     if (this == NULL) {
369         return P2P_SUP_ERRCODE_INVALID;
370     }
371     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
372     char cmd[P2P_CMD_BUF_LENGTH] = {0};
373     int res;
374     if (timeout >= 0) {
375         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_FIND %d", this->ifName, timeout);
376     } else {
377         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_FIND", this->ifName);
378     }
379     if (res < 0) {
380         HDF_LOGE("snprintf err");
381         return P2P_SUP_ERRCODE_FAILED;
382     }
383     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
384         HDF_LOGE("P2P_FIND command failed!");
385         return P2P_SUP_ERRCODE_FAILED;
386     }
387     return P2P_SUP_ERRCODE_SUCCESS;
388 }
389 
WpaP2pCliCmdRemoveNetwork(WifiWpaP2pInterface * this,int networkId)390 static P2pSupplicantErrCode WpaP2pCliCmdRemoveNetwork(WifiWpaP2pInterface *this, int networkId)
391 {
392     if (this == NULL) {
393         return P2P_SUP_ERRCODE_INVALID;
394     }
395     if (networkId < 0 && networkId != P2P_REMOVE_ALL_NETWORK_CMD) {
396         return P2P_SUP_ERRCODE_INPUT_ERROR;
397     }
398     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
399     char cmd[P2P_CMD_BUF_LENGTH] = {0};
400     int res;
401     if (networkId == P2P_REMOVE_ALL_NETWORK_CMD) {
402         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s REMOVE_NETWORK all", this->ifName);
403     } else {
404         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s REMOVE_NETWORK %d", this->ifName, networkId);
405     }
406     if (res < 0) {
407         HDF_LOGE("snprintf err");
408         return P2P_SUP_ERRCODE_FAILED;
409     }
410     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
411         HDF_LOGE("REMOVE_NETWORK command failed!");
412         return P2P_SUP_ERRCODE_FAILED;
413     }
414     return P2P_SUP_ERRCODE_SUCCESS;
415 }
416 
WpaP2pCliCmdSetWfdEnable(WifiWpaP2pInterface * this,int enable)417 static P2pSupplicantErrCode WpaP2pCliCmdSetWfdEnable(WifiWpaP2pInterface *this, int enable)
418 {
419     if (this == NULL) {
420         return P2P_SUP_ERRCODE_INVALID;
421     }
422     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
423     char cmd[P2P_CMD_BUF_LENGTH] = {0};
424     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s SET wifi_display %d", this->ifName, enable) < 0) {
425         HDF_LOGE("snprintf err");
426         return P2P_SUP_ERRCODE_FAILED;
427     }
428     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
429         HDF_LOGE("SET wifi_display command failed!");
430         return P2P_SUP_ERRCODE_FAILED;
431     }
432     return P2P_SUP_ERRCODE_SUCCESS;
433 }
434 
WpaP2pCliCmdSetWfdDeviceInfo(WifiWpaP2pInterface * this,const char * conf)435 static P2pSupplicantErrCode WpaP2pCliCmdSetWfdDeviceInfo(WifiWpaP2pInterface *this, const char *conf)
436 {
437     if (this == NULL || conf == NULL) {
438         return P2P_SUP_ERRCODE_INVALID;
439     }
440     unsigned len = strlen(conf);
441     if (len == 0) {
442         return P2P_SUP_ERRCODE_INPUT_ERROR;
443     }
444     len += strlen("IFNAME=") + strlen(this->ifName) + 1 + strlen("WFD_SUBELEM_SET") + 1;
445     char *cmd = (char *)calloc(len + 1, sizeof(char));
446     if (cmd == NULL) {
447         return P2P_SUP_ERRCODE_FAILED;
448     }
449     if (snprintf_s(cmd, len + 1, len, "IFNAME=%s WFD_SUBELEM_SET %s", this->ifName, conf) < 0) {
450         HDF_LOGE("snprintf err");
451         free(cmd);
452         return P2P_SUP_ERRCODE_FAILED;
453     }
454     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
455     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
456         HDF_LOGE("WFD_SUBELEM_SET command failed!");
457         free(cmd);
458         return P2P_SUP_ERRCODE_FAILED;
459     }
460     free(cmd);
461     return P2P_SUP_ERRCODE_SUCCESS;
462 }
463 
WpaP2pCliCmdExtListen(WifiWpaP2pInterface * this,int enable,int period,int interval)464 static P2pSupplicantErrCode WpaP2pCliCmdExtListen(WifiWpaP2pInterface *this, int enable, int period, int interval)
465 {
466     if (this == NULL) {
467         return P2P_SUP_ERRCODE_INVALID;
468     }
469     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
470     char cmd[P2P_CMD_BUF_LENGTH] = {0};
471     int res;
472     if (enable == 0) {
473         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_EXT_LISTEN", this->ifName);
474     } else {
475         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_EXT_LISTEN %d %d", this->ifName, period,
476             interval);
477     }
478     if (res < 0) {
479         HDF_LOGE("snprintf err");
480         return P2P_SUP_ERRCODE_FAILED;
481     }
482     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
483         HDF_LOGE("P2P_EXT_LISTEN command failed!");
484         return P2P_SUP_ERRCODE_FAILED;
485     }
486     return P2P_SUP_ERRCODE_SUCCESS;
487 }
488 
WpaP2pCliCmdSetListenChannel(WifiWpaP2pInterface * this,int channel,int regClass)489 static P2pSupplicantErrCode WpaP2pCliCmdSetListenChannel(WifiWpaP2pInterface *this, int channel, int regClass)
490 {
491     if (this == NULL) {
492         return P2P_SUP_ERRCODE_INVALID;
493     }
494     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
495     char cmd[P2P_CMD_BUF_LENGTH] = {0};
496     int res;
497     if (regClass > 0) {
498         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_SET listen_channel %d %d", this->ifName,
499             channel, regClass);
500     } else {
501         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_SET listen_channel %d", this->ifName,
502             channel);
503     }
504     if (res < 0) {
505         HDF_LOGE("snprintf err");
506         return P2P_SUP_ERRCODE_FAILED;
507     }
508     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
509         HDF_LOGE("P2P_SET listen_channel command failed!");
510         return P2P_SUP_ERRCODE_FAILED;
511     }
512     return P2P_SUP_ERRCODE_SUCCESS;
513 }
514 
WpaP2pCliCmdCancelConnect(WifiWpaP2pInterface * this)515 static P2pSupplicantErrCode WpaP2pCliCmdCancelConnect(WifiWpaP2pInterface *this)
516 {
517     if (this == NULL) {
518         return P2P_SUP_ERRCODE_INVALID;
519     }
520     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
521     char cmd[P2P_CMD_BUF_LENGTH] = {0};
522     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_CANCEL", this->ifName) < 0) {
523         HDF_LOGE("snprintf err");
524         return P2P_SUP_ERRCODE_FAILED;
525     }
526     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
527         HDF_LOGE("P2P_CANCEL command failed!");
528         return P2P_SUP_ERRCODE_FAILED;
529     }
530     return P2P_SUP_ERRCODE_SUCCESS;
531 }
532 
WpaP2pCliCmdInvite(WifiWpaP2pInterface * this,const P2pHalInviteArgv * argv)533 static P2pSupplicantErrCode WpaP2pCliCmdInvite(WifiWpaP2pInterface *this, const P2pHalInviteArgv *argv)
534 {
535     if (this == NULL || argv == NULL) {
536         return P2P_SUP_ERRCODE_INVALID;
537     }
538     if (strlen(argv->peerbssid) <= 0 || strlen(argv->gobssid) <= 0 || strlen(argv->ifname) <= 0) {
539         return P2P_SUP_ERRCODE_INPUT_ERROR;
540     }
541     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
542     char cmd[P2P_CMD_BUF_LENGTH] = {0};
543     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_INVITE group=%s peer=%s go_dev_addr=%s",
544         this->ifName, argv->ifname, argv->peerbssid, argv->gobssid) < 0) {
545         HDF_LOGE("snprintf err");
546         return P2P_SUP_ERRCODE_FAILED;
547     }
548     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
549         HDF_LOGE("P2P_INVITE command failed!");
550         return P2P_SUP_ERRCODE_FAILED;
551     }
552     return P2P_SUP_ERRCODE_SUCCESS;
553 }
554 
WpaP2pCliCmdReInvite(WifiWpaP2pInterface * this,const P2pHalReInviteArgv * argv)555 static P2pSupplicantErrCode WpaP2pCliCmdReInvite(WifiWpaP2pInterface *this, const P2pHalReInviteArgv *argv)
556 {
557     if (this == NULL || argv == NULL) {
558         return P2P_SUP_ERRCODE_INVALID;
559     }
560     if (strlen(argv->peerbssid) <= 0) {
561         return P2P_SUP_ERRCODE_INPUT_ERROR;
562     }
563     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
564     char cmd[P2P_CMD_BUF_LENGTH] = {0};
565     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_INVITE persistent=%d peer=%s", this->ifName,
566         argv->networkId, argv->peerbssid) < 0) {
567         HDF_LOGE("snprintf err");
568         return P2P_SUP_ERRCODE_FAILED;
569     }
570     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
571         HDF_LOGE("P2P_INVITE reinvite command failed!");
572         return P2P_SUP_ERRCODE_FAILED;
573     }
574     return P2P_SUP_ERRCODE_SUCCESS;
575 }
576 
WpaP2pCliCmdServiceAdd(WifiWpaP2pInterface * this,const struct HdiP2pServiceInfo * argv)577 static P2pSupplicantErrCode WpaP2pCliCmdServiceAdd(WifiWpaP2pInterface *this, const struct HdiP2pServiceInfo *argv)
578 {
579     if (this == NULL || argv == NULL || argv->name == NULL || argv->query == NULL || argv->resp == NULL) {
580         return P2P_SUP_ERRCODE_INVALID;
581     }
582     unsigned nameLen = strlen((char *) argv->name);
583     unsigned queryLen = strlen((char *) argv->query);
584     unsigned respLen = strlen((char *) argv->resp);
585     if ((argv->mode == 0 && nameLen == 0) || (argv->mode != 0 && (queryLen == 0 || respLen == 0))) {
586         return P2P_SUP_ERRCODE_INPUT_ERROR;
587     }
588     unsigned cmdLen;
589     if (argv->mode == 0) {
590         cmdLen = strlen("P2P_SERVICE_ADD") + 1 + strlen("upnp") + 1 + CMD_INT_MAX_LEN + 1 + nameLen;
591     } else {
592         cmdLen = strlen("P2P_SERVICE_ADD") + 1 + strlen("bonjour") + 1 + queryLen + 1 + respLen;
593     }
594     cmdLen += strlen("IFNAME=") + strlen(this->ifName) + 1;
595     char *cmd = (char *)calloc(cmdLen + 1, sizeof(char));
596     if (cmd == NULL) {
597         return P2P_SUP_ERRCODE_FAILED;
598     }
599     int res;
600     if (argv->mode == 0) {
601         res = snprintf_s(cmd, cmdLen + 1, cmdLen, "IFNAME=%s P2P_SERVICE_ADD upnp %d %s", this->ifName,
602             argv->version, (char *) argv->name);
603     } else {
604         res = snprintf_s(cmd, cmdLen + 1, cmdLen, "IFNAME=%s P2P_SERVICE_ADD bonjour %s %s", this->ifName,
605             (char *) argv->query, (char *) argv->resp);
606     }
607     if (res < 0) {
608         HDF_LOGE("snprintf err");
609         free(cmd);
610         return P2P_SUP_ERRCODE_FAILED;
611     }
612     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
613     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
614         HDF_LOGE("P2P_SERVICE_ADD command failed!");
615         free(cmd);
616         return P2P_SUP_ERRCODE_FAILED;
617     }
618     free(cmd);
619     return P2P_SUP_ERRCODE_SUCCESS;
620 }
621 
WpaP2pCliCmdServiceDel(WifiWpaP2pInterface * this,const struct HdiP2pServiceInfo * argv)622 static P2pSupplicantErrCode WpaP2pCliCmdServiceDel(WifiWpaP2pInterface *this, const struct HdiP2pServiceInfo *argv)
623 {
624     if (this == NULL || argv == NULL || argv->name == NULL || argv->query == NULL) {
625         return P2P_SUP_ERRCODE_INVALID;
626     }
627     unsigned nameLen = strlen((char *) argv->name);
628     unsigned queryLen = strlen((char *) argv->query);
629     if ((argv->mode == 0 && nameLen == 0) || (argv->mode == 1 && queryLen == 0)) {
630         return P2P_SUP_ERRCODE_INPUT_ERROR;
631     }
632     unsigned cmdLen;
633     if (argv->mode == 0) {
634         cmdLen = strlen("P2P_SERVICE_DEL") + 1 + strlen("upnp") + 1 + CMD_INT_MAX_LEN + 1 + nameLen;
635     } else {
636         cmdLen = strlen("P2P_SERVICE_DEL") + 1 + strlen("bonjour") + 1 + queryLen;
637     }
638     cmdLen += strlen("IFNAME=") + strlen(this->ifName) + 1;
639     char *cmd = (char *)calloc(cmdLen + 1, sizeof(char));
640     if (cmd == NULL) {
641         return P2P_SUP_ERRCODE_FAILED;
642     }
643     int res;
644     if (argv->mode == 0) {
645         res = snprintf_s(cmd, cmdLen + 1, cmdLen, "IFNAME=%s P2P_SERVICE_DEL upnp %d %s", this->ifName,
646             argv->version, (char *) argv->name);
647     } else {
648         res = snprintf_s(cmd, cmdLen + 1, cmdLen, "IFNAME=%s P2P_SERVICE_DEL bonjour %s", this->ifName,
649             (char *) argv->query);
650     }
651     if (res < 0) {
652         HDF_LOGE("snprintf err");
653         free(cmd);
654         return P2P_SUP_ERRCODE_FAILED;
655     }
656     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
657     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
658         HDF_LOGE("P2P_SERVICE_DEL command failed!");
659         free(cmd);
660         return P2P_SUP_ERRCODE_FAILED;
661     }
662     free(cmd);
663     return P2P_SUP_ERRCODE_SUCCESS;
664 }
665 
WpaP2pCliCmdServDiscReq(WifiWpaP2pInterface * this,const char * peerBssid,const char * tlvs,char * retSeq,unsigned size)666 static P2pSupplicantErrCode WpaP2pCliCmdServDiscReq(
667     WifiWpaP2pInterface *this, const char *peerBssid, const char *tlvs, char *retSeq, unsigned size)
668 {
669     if (this == NULL || peerBssid == NULL || tlvs == NULL || retSeq == NULL || size <= 0) {
670         return P2P_SUP_ERRCODE_INVALID;
671     }
672     unsigned bssidLen = strlen(peerBssid);
673     unsigned tlvsLen = strlen(tlvs);
674     if (bssidLen <= 0 || tlvsLen <= 0) {
675         return P2P_SUP_ERRCODE_INPUT_ERROR;
676     }
677     unsigned cmdLen = strlen("P2P_SERV_DISC_REQ") + 1 + bssidLen + 1 + tlvsLen;
678     cmdLen += strlen("IFNAME=") + strlen(this->ifName) + 1;
679     char *cmd = (char *)calloc(cmdLen + 1, sizeof(char));
680     if (cmd == NULL || snprintf_s(cmd, cmdLen + 1, cmdLen, "IFNAME=%s P2P_SERV_DISC_REQ %s %s", this->ifName, peerBssid,
681         tlvs) < 0) {
682         free(cmd);
683         HDF_LOGE("snprintf err");
684         return P2P_SUP_ERRCODE_FAILED;
685     }
686     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
687     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
688         HDF_LOGE("P2P_SERV_DISC_REQ command failed!");
689         free(cmd);
690         return P2P_SUP_ERRCODE_FAILED;
691     }
692     free(cmd);
693     if (strncpy_s(retSeq, size, buf, strlen(buf)) != EOK) {
694         HDF_LOGE("Failed to copy response about service discovery sequence!");
695         return P2P_SUP_ERRCODE_FAILED;
696     }
697     return P2P_SUP_ERRCODE_SUCCESS;
698 }
699 
WpaP2pCliCmdServDiscCancelReq(WifiWpaP2pInterface * this,const char * val)700 static P2pSupplicantErrCode WpaP2pCliCmdServDiscCancelReq(WifiWpaP2pInterface *this, const char *val)
701 {
702     if (this == NULL || val == NULL) {
703         return P2P_SUP_ERRCODE_INVALID;
704     }
705     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
706     char cmd[P2P_CMD_BUF_LENGTH] = {0};
707     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_SERV_DISC_CANCEL_REQ %s", this->ifName, val) < 0) {
708         HDF_LOGE("snprintf err");
709         return P2P_SUP_ERRCODE_FAILED;
710     }
711     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
712         HDF_LOGE("P2P_SERV_DISC_CANCEL_REQ command failed!");
713         return P2P_SUP_ERRCODE_FAILED;
714     }
715     return P2P_SUP_ERRCODE_SUCCESS;
716 }
717 
WpaP2pCliCmdProvisionDiscovery(WifiWpaP2pInterface * this,const P2pProvisionDiscoveryArgv * argv)718 static P2pSupplicantErrCode WpaP2pCliCmdProvisionDiscovery(
719     WifiWpaP2pInterface *this, const P2pProvisionDiscoveryArgv *argv)
720 {
721     if (this == NULL || argv == NULL) {
722         return P2P_SUP_ERRCODE_INVALID;
723     }
724     if (strlen(argv->peerbssid) <= 0) {
725         return P2P_SUP_ERRCODE_INPUT_ERROR;
726     }
727     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
728     char cmd[P2P_CMD_BUF_LENGTH] = {0};
729     int res = 0;
730     if (argv->mode == HAL_WPS_METHOD_PBC) {
731         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_PROV_DISC %s pbc", this->ifName,
732             argv->peerbssid);
733     } else if (argv->mode == HAL_WPS_METHOD_DISPLAY) {
734         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_PROV_DISC %s display", this->ifName,
735             argv->peerbssid);
736     } else if (argv->mode == HAL_WPS_METHOD_KEYPAD) {
737         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_PROV_DISC %s keypad", this->ifName,
738             argv->peerbssid);
739     } else {
740         return P2P_SUP_ERRCODE_INPUT_ERROR;
741     }
742     if (res < 0) {
743         HDF_LOGE("snprintf err");
744         return P2P_SUP_ERRCODE_FAILED;
745     }
746     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
747         HDF_LOGE("P2P_PROV_DISC command failed!");
748         return P2P_SUP_ERRCODE_FAILED;
749     }
750     return P2P_SUP_ERRCODE_SUCCESS;
751 }
752 
WpaP2pCliCmdGroupAdd(WifiWpaP2pInterface * this,int isPersistent,int networkId,int freq)753 static P2pSupplicantErrCode WpaP2pCliCmdGroupAdd(WifiWpaP2pInterface *this, int isPersistent, int networkId, int freq)
754 {
755     if (this == NULL) {
756         return P2P_SUP_ERRCODE_INVALID;
757     }
758     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
759     char cmd[P2P_CMD_BUF_LENGTH] = {0};
760     int res;
761     if (isPersistent) {
762         if (networkId < 0) {
763             res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_GROUP_ADD persistent freq=%d",
764                 this->ifName, freq);
765         } else {
766             res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_GROUP_ADD persistent=%d freq=%d",
767                 this->ifName, networkId, freq);
768         }
769     } else {
770         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_GROUP_ADD freq=%d", this->ifName, freq);
771     }
772     if (res < 0) {
773         HDF_LOGE("snprintf err");
774         return P2P_SUP_ERRCODE_FAILED;
775     }
776     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
777         HDF_LOGE("P2P_GROUP_ADD command failed!");
778         return P2P_SUP_ERRCODE_FAILED;
779     }
780     return P2P_SUP_ERRCODE_SUCCESS;
781 }
782 
WpaP2pCliCmdStoreConfig(WifiWpaP2pInterface * this)783 static P2pSupplicantErrCode WpaP2pCliCmdStoreConfig(WifiWpaP2pInterface *this)
784 {
785     if (this == NULL) {
786         return P2P_SUP_ERRCODE_INVALID;
787     }
788     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
789     char cmd[P2P_CMD_BUF_LENGTH] = {0};
790     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s SAVE_CONFIG", this->ifName) < 0) {
791         HDF_LOGE("snprintf err");
792         return P2P_SUP_ERRCODE_FAILED;
793     }
794     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
795         HDF_LOGE("SAVE_CONFIG command failed!");
796         return P2P_SUP_ERRCODE_FAILED;
797     }
798     return P2P_SUP_ERRCODE_SUCCESS;
799 }
800 
WpaP2pCliCmdSetPersistentReconnect(WifiWpaP2pInterface * this,int status)801 static P2pSupplicantErrCode WpaP2pCliCmdSetPersistentReconnect(WifiWpaP2pInterface *this, int status)
802 {
803     if (this == NULL) {
804         return P2P_SUP_ERRCODE_INVALID;
805     }
806     if (status != 0 && status != 1) {
807         return P2P_SUP_ERRCODE_FAILED;
808     }
809     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
810     char cmd[P2P_CMD_BUF_LENGTH] = {0};
811     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s SET persistent_reconnect %d",
812         this->ifName, status) < 0) {
813         return P2P_SUP_ERRCODE_FAILED;
814     }
815     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
816         HDF_LOGE("SET persistent_reconnect command failed!");
817         return P2P_SUP_ERRCODE_FAILED;
818     }
819     return P2P_SUP_ERRCODE_SUCCESS;
820 }
821 
WpaP2pCliCmdRespServerDiscovery(WifiWpaP2pInterface * this,const struct HdiP2pServDiscReqInfo * info)822 static P2pSupplicantErrCode WpaP2pCliCmdRespServerDiscovery(WifiWpaP2pInterface *this,
823     const struct HdiP2pServDiscReqInfo *info)
824 {
825     if (this == NULL || info == NULL || info->tlvs == NULL) {
826         return P2P_SUP_ERRCODE_INVALID;
827     }
828     /* info.tlvs may be very large, so here we request a buffer for input the message */
829     unsigned len = strlen("P2P_SERV_DISC_RESP") + 1 + CMD_INT_MAX_LEN + 1 + strlen((char *) info->mac) + 1 +
830         CMD_INT_MAX_LEN + 1 + strlen((char *) info->tlvs) + strlen("IFNAME=") + strlen(this->ifName) + 1;
831     char *cmd = (char *)calloc(len + 1, sizeof(char));
832     if (cmd == NULL || snprintf_s(cmd, len + 1, len, "IFNAME=%s P2P_SERV_DISC_RESP %d %s %d %s", this->ifName,
833         info->freq, (char *) info->mac, info->dialogToken, (char *) info->tlvs) < 0) {
834         free(cmd);
835         return P2P_SUP_ERRCODE_FAILED;
836     }
837     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
838     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
839         HDF_LOGE("P2P_SERV_DISC_RESP command failed!");
840         free(cmd);
841         return P2P_SUP_ERRCODE_FAILED;
842     }
843     free(cmd);
844     return P2P_SUP_ERRCODE_SUCCESS;
845 }
846 
WpaP2pCliCmdSetServDiscExternal(WifiWpaP2pInterface * this,int mode)847 static P2pSupplicantErrCode WpaP2pCliCmdSetServDiscExternal(WifiWpaP2pInterface *this, int mode)
848 {
849     if (this == NULL) {
850         return P2P_SUP_ERRCODE_INVALID;
851     }
852     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
853     char cmd[P2P_CMD_BUF_LENGTH] = {0};
854     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_SERV_DISC_EXTERNAL %d", this->ifName, mode) < 0) {
855         return P2P_SUP_ERRCODE_FAILED;
856     }
857     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
858         HDF_LOGE("P2P_SERV_DISC_EXTERNAL command failed!");
859         return P2P_SUP_ERRCODE_FAILED;
860     }
861     return P2P_SUP_ERRCODE_SUCCESS;
862 }
863 
SetP2pDeviceRandomMacAddr(WifiWpaP2pInterface * this,int mode)864 static P2pSupplicantErrCode SetP2pDeviceRandomMacAddr(WifiWpaP2pInterface *this, int mode)
865 {
866     if (this == NULL) {
867         return P2P_SUP_ERRCODE_INVALID;
868     }
869     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
870     char cmd[P2P_CMD_BUF_LENGTH] = {0};
871     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s SET p2p_device_random_mac_addr %d", this->ifName,
872         mode) < 0) {
873         return P2P_SUP_ERRCODE_FAILED;
874     }
875     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
876         HDF_LOGE("SET p2p_device_random_mac_addr command failed!");
877         return P2P_SUP_ERRCODE_FAILED;
878     }
879     return P2P_SUP_ERRCODE_SUCCESS;
880 }
881 
SetP2pInterfaceRandomMacAddr(WifiWpaP2pInterface * this,int mode)882 static P2pSupplicantErrCode SetP2pInterfaceRandomMacAddr(WifiWpaP2pInterface *this, int mode)
883 {
884     if (this == NULL) {
885         return P2P_SUP_ERRCODE_INVALID;
886     }
887     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
888     char cmd[P2P_CMD_BUF_LENGTH] = {0};
889     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s SET p2p_interface_random_mac_addr %d", this->ifName,
890         mode) < 0) {
891         return P2P_SUP_ERRCODE_FAILED;
892     }
893     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
894         HDF_LOGE("SET p2p_interface_random_mac_addr command failed!");
895         return P2P_SUP_ERRCODE_FAILED;
896     }
897     return P2P_SUP_ERRCODE_SUCCESS;
898 }
899 
CheckDriverRandomCapcb(WifiWpaP2pInterface * this)900 static P2pSupplicantErrCode CheckDriverRandomCapcb(WifiWpaP2pInterface *this)
901 {
902     if (this == NULL) {
903         return P2P_SUP_ERRCODE_INVALID;
904     }
905     char cmd[P2P_CMD_BUF_LENGTH] = {0};
906     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s DRIVER_FLAGS", this->ifName) < 0) {
907         return P2P_SUP_ERRCODE_FAILED;
908     }
909     char *buf = (char *)calloc(P2P_REPLY_BUF_LENGTH, sizeof(char));
910     if (buf == NULL) {
911         return P2P_SUP_ERRCODE_FAILED;
912     }
913     if (WpaCliCmd(cmd, buf, P2P_REPLY_BUF_LENGTH) != 0) {
914         HDF_LOGE("DRIVER_FLAGS command failed!");
915         free(buf);
916         return P2P_SUP_ERRCODE_FAILED;
917     }
918     P2pSupplicantErrCode ret;
919     if (strstr(buf, "DEDICATED_P2P_DEVICE") != NULL) {
920         ret = P2P_SUP_ERRCODE_SUCCESS;
921     } else {
922         ret = P2P_SUP_ERRCODE_FAILED;
923     }
924     free(buf);
925     return ret;
926 }
927 
WpaP2pCliCmdSetRandomMac(WifiWpaP2pInterface * this,int mode)928 static P2pSupplicantErrCode WpaP2pCliCmdSetRandomMac(WifiWpaP2pInterface *this, int mode)
929 {
930     if (this == NULL) {
931         return P2P_SUP_ERRCODE_INVALID;
932     }
933     if (CheckDriverRandomCapcb(this) != P2P_SUP_ERRCODE_SUCCESS) {
934         HDF_LOGE("Dedicated P2P device doesn't support MAC randomization");
935         return P2P_SUP_ERRCODE_INVALID;
936     }
937     if (SetP2pDeviceRandomMacAddr(this, mode) != P2P_SUP_ERRCODE_SUCCESS ||
938         SetP2pInterfaceRandomMacAddr(this, mode) != P2P_SUP_ERRCODE_SUCCESS) {
939         return P2P_SUP_ERRCODE_FAILED;
940     }
941     return P2P_SUP_ERRCODE_SUCCESS;
942 }
943 
WpaP2pCliCmdP2pGetChba0Freq(WifiWpaP2pInterface * this,int * chba0Freq)944 static P2pSupplicantErrCode WpaP2pCliCmdP2pGetChba0Freq(WifiWpaP2pInterface *this, int *chba0Freq)
945 {
946     if (this == NULL || chba0Freq == NULL) {
947         return P2P_SUP_ERRCODE_INVALID;
948     }
949     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
950     char cmd[P2P_CMD_BUF_LENGTH] = {0};
951     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=chba0 STATUS") < 0) {
952         HDF_LOGE("snprintf error");
953         return P2P_SUP_ERRCODE_FAILED;
954     }
955     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
956         HDF_LOGE("chba0 STATUS command failed!");
957         return P2P_SUP_ERRCODE_FAILED;
958     }
959     size_t bufLen = strlen(buf);
960     if (strncmp(cmd, "IFNAME=chba0 STATUS", strlen("IFNAME=chba0 STATUS")) != 0) {
961         HDF_LOGE("chba0 STATUS command failed!");
962         return P2P_SUP_ERRCODE_FAILED;
963     }
964     for (size_t i = 0; i < bufLen; i++) {
965         buf[i] = buf[i] == '\n' ? '*' : buf[i];
966     }
967     char *ptr = NULL;
968     char *retbuf = strtok_r(buf, "*", &ptr);
969     if (retbuf != NULL) {
970         retbuf = strtok_r(NULL, "*", &ptr);
971     } else {
972         HDF_LOGE("retbuf is null");
973         return P2P_SUP_ERRCODE_FAILED;
974     }
975     char *freq = strstr(retbuf, "freq=");
976     if (freq != NULL) {
977         freq += strlen("freq=");
978         *chba0Freq = atoi(freq);
979     } else {
980         HDF_LOGE("chba0Freq is null");
981         return P2P_SUP_ERRCODE_FAILED;
982     }
983     HDF_LOGD("WpaP2pCliCmdP2pGetChba0Freq: buf = %{public}s chba0Freq = %{public}d", buf, *chba0Freq);
984     return P2P_SUP_ERRCODE_SUCCESS;
985 }
986 
CheckValidGroupConfigField(const P2pWpaGroupConfigArgv * argv)987 static int CheckValidGroupConfigField(const P2pWpaGroupConfigArgv *argv)
988 {
989     int pos = -1;
990     for (int i = 0; i < (int)(sizeof(P2P_WPA_NETWORK_FIELDS) / sizeof(P2P_WPA_NETWORK_FIELDS[0])); ++i) {
991         if (P2P_WPA_NETWORK_FIELDS[i].field == argv->param) {
992             pos = i;
993             break;
994         }
995     }
996     return pos;
997 }
998 
WpaP2pCliCmdSetGroupConfig(WifiWpaP2pInterface * this,const P2pWpaGroupConfigArgv * argv)999 static P2pSupplicantErrCode WpaP2pCliCmdSetGroupConfig(WifiWpaP2pInterface *this, const P2pWpaGroupConfigArgv *argv)
1000 {
1001     if (this == NULL || argv == NULL) {
1002         return P2P_SUP_ERRCODE_INVALID;
1003     }
1004     int pos = CheckValidGroupConfigField(argv);
1005     if (pos < 0) {
1006         HDF_LOGE("unsupported param: %{public}d", argv->param);
1007         return P2P_SUP_ERRCODE_FAILED;
1008     }
1009     char cmd[P2P_CMD_BUF_LENGTH] = {0};
1010     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
1011     int res;
1012     if (P2P_WPA_NETWORK_FIELDS[pos].flag == 0) {
1013         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s SET_NETWORK %d %s \"%s\"", this->ifName,
1014             argv->id, P2P_WPA_NETWORK_FIELDS[pos].fieldName, argv->value);
1015     } else {
1016         res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s SET_NETWORK %d %s %s", this->ifName, argv->id,
1017             P2P_WPA_NETWORK_FIELDS[pos].fieldName, argv->value);
1018     }
1019     if (res < 0) {
1020         HDF_LOGE("Internal error, set request message failed!");
1021         return P2P_SUP_ERRCODE_FAILED;
1022     }
1023     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
1024         HDF_LOGE("SET_NETWORK command failed!");
1025         return P2P_SUP_ERRCODE_FAILED;
1026     }
1027     return P2P_SUP_ERRCODE_SUCCESS;
1028 }
1029 
WpaP2pCliCmdGetGroupConfig(WifiWpaP2pInterface * this,P2pWpaGroupConfigArgv * argv)1030 static P2pSupplicantErrCode WpaP2pCliCmdGetGroupConfig(WifiWpaP2pInterface *this, P2pWpaGroupConfigArgv *argv)
1031 {
1032     if (this == NULL || argv == NULL) {
1033         return P2P_SUP_ERRCODE_INVALID;
1034     }
1035     int pos = CheckValidGroupConfigField(argv);
1036     if (pos < 0) {
1037         HDF_LOGD("unsupported param: %{public}d", argv->param);
1038         return P2P_SUP_ERRCODE_FAILED;
1039     }
1040     char cmd[P2P_CMD_BUF_LENGTH] = {0};
1041     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s GET_NETWORK %d %s", this->ifName, argv->id,
1042         P2P_WPA_NETWORK_FIELDS[pos].fieldName) < 0) {
1043         HDF_LOGE("snprintf err");
1044         return P2P_SUP_ERRCODE_FAILED;
1045     }
1046     char *buf = (char *)calloc(P2P_REPLY_BUF_LENGTH, sizeof(char));
1047     if (buf == NULL) {
1048         HDF_LOGE("Failed to init response buffer!");
1049         return P2P_SUP_ERRCODE_FAILED;
1050     }
1051     if (WpaCliCmd(cmd, buf, P2P_REPLY_BUF_LENGTH) != 0) {
1052         HDF_LOGE("GET_NETWORK command failed!");
1053         free(buf);
1054         return P2P_SUP_ERRCODE_FAILED;
1055     }
1056     if (strcpy_s(argv->value, sizeof(argv->value), buf) != EOK) {
1057         HDF_LOGE("strcpy_s P2pWpaGroupConfigArgv failed!");
1058         free(buf);
1059         return P2P_SUP_ERRCODE_FAILED;
1060     }
1061     free(buf);
1062     if (argv->param == GROUP_CONFIG_SSID) {
1063         TrimQuotationMark(argv->value, '\"');
1064     }
1065     return P2P_SUP_ERRCODE_SUCCESS;
1066 }
1067 
WpaP2pCliCmdAddNetwork(WifiWpaP2pInterface * this,int * networkId)1068 static P2pSupplicantErrCode WpaP2pCliCmdAddNetwork(WifiWpaP2pInterface *this, int *networkId)
1069 {
1070     if (this == NULL || networkId == NULL) {
1071         return P2P_SUP_ERRCODE_INVALID;
1072     }
1073     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
1074     char cmd[P2P_CMD_BUF_LENGTH] = {0};
1075     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s ADD_NETWORK", this->ifName) < 0) {
1076         HDF_LOGE("snprintf error");
1077         return P2P_SUP_ERRCODE_FAILED;
1078     }
1079     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
1080         HDF_LOGE("ADD_NETWORK command failed!");
1081         return P2P_SUP_ERRCODE_FAILED;
1082     }
1083     *networkId = atoi(buf);
1084     HDF_LOGD("WpaP2pCliCmdAddNetwork: buf = %{public}s networkId = %{public}d", buf, *networkId);
1085     return P2P_SUP_ERRCODE_SUCCESS;
1086 }
1087 
WpaP2pHid2dCliCmdConnect(WifiWpaP2pInterface * this,Hid2dConnectInfo * info)1088 static P2pSupplicantErrCode WpaP2pHid2dCliCmdConnect(WifiWpaP2pInterface *this, Hid2dConnectInfo *info)
1089 {
1090     if (this == NULL || info == NULL) {
1091         return P2P_SUP_ERRCODE_INVALID;
1092     }
1093 
1094     char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
1095     char cmd[P2P_CMD_BUF_LENGTH] = {0};
1096     if (snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s MAGICLINK \"%s\"\n%s\n\"%s\"\n%d\n%d", this->ifName,
1097         info->ssid, info->bssid, info->passphrase, info->frequency, info->isLegacyGo) < 0) {
1098         HDF_LOGE("hid2d connect snprintf err");
1099         return P2P_SUP_ERRCODE_FAILED;
1100     }
1101 
1102     HDF_LOGI("hid2d_connect, frequency = %{public}d", info->frequency);
1103     if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
1104         HDF_LOGE("hid2d_connect command failed!");
1105         return P2P_SUP_ERRCODE_FAILED;
1106     }
1107     if (strncmp(buf, "FAIL", strlen("FAIL")) == 0) {
1108         HDF_LOGE("P2p hid2d_connect return %{public}s", buf);
1109         return P2P_SUP_ERRCODE_FAILED;
1110     }
1111     return P2P_SUP_ERRCODE_SUCCESS;
1112 }
1113 
InitGlobalWpaP2pFunc(void)1114 static void InitGlobalWpaP2pFunc(void)
1115 {
1116     g_wpaP2pInterface->wpaP2pCliCmdSetWpsName = WpaP2pCliCmdSetWpsName;
1117     g_wpaP2pInterface->wpaP2pCliCmdSetSsidPostfixName = WpaP2pCliCmdSetSsidPostfixName;
1118     g_wpaP2pInterface->wpaP2pCliCmdSetWpsDeviceType = WpaP2pCliCmdSetWpsDeviceType;
1119     g_wpaP2pInterface->wpaP2pCliCmdSetWpsSecDeviceType = WpaP2pCliCmdSetWpsSecDeviceType;
1120     g_wpaP2pInterface->wpaP2pCliCmdSetWpsConfigMethods = WpaP2pCliCmdSetWpsConfigMethods;
1121     g_wpaP2pInterface->wpaP2pCliCmdGetDeviceAddress = WpaP2pCliCmdGetDeviceAddress;
1122     g_wpaP2pInterface->wpaP2pCliCmdFlush = WpaP2pCliCmdFlush;
1123     g_wpaP2pInterface->wpaP2pCliCmdFlushService = WpaP2pCliCmdFlushService;
1124     g_wpaP2pInterface->wpaP2pCliCmdP2pStopFind = WpaP2pCliCmdP2pStopFind;
1125     g_wpaP2pInterface->wpaP2pCliCmdP2pRemoveGroup = WpaP2pCliCmdP2pRemoveGroup;
1126     g_wpaP2pInterface->wpaP2pCliCmdP2pFound = WpaP2pCliCmdP2pFound;
1127     g_wpaP2pInterface->wpaP2pCliCmdRemoveNetwork = WpaP2pCliCmdRemoveNetwork;
1128     g_wpaP2pInterface->wpaP2pCliCmdSetWfdEnable = WpaP2pCliCmdSetWfdEnable;
1129     g_wpaP2pInterface->wpaP2pCliCmdSetWfdDeviceInfo = WpaP2pCliCmdSetWfdDeviceInfo;
1130     g_wpaP2pInterface->wpaP2pCliCmdExtListen = WpaP2pCliCmdExtListen;
1131     g_wpaP2pInterface->wpaP2pCliCmdSetListenChannel = WpaP2pCliCmdSetListenChannel;
1132     g_wpaP2pInterface->wpaP2pCliCmdCancelConnect = WpaP2pCliCmdCancelConnect;
1133     g_wpaP2pInterface->wpaP2pCliCmdInvite = WpaP2pCliCmdInvite;
1134     g_wpaP2pInterface->wpaP2pCliCmdReInvite = WpaP2pCliCmdReInvite;
1135     g_wpaP2pInterface->wpaP2pCliCmdServiceAdd = WpaP2pCliCmdServiceAdd;
1136     g_wpaP2pInterface->wpaP2pCliCmdServiceDel = WpaP2pCliCmdServiceDel;
1137     g_wpaP2pInterface->wpaP2pCliCmdServDiscReq = WpaP2pCliCmdServDiscReq;
1138     g_wpaP2pInterface->wpaP2pCliCmdServDiscCancelReq = WpaP2pCliCmdServDiscCancelReq;
1139     g_wpaP2pInterface->wpaP2pCliCmdProvisionDiscovery = WpaP2pCliCmdProvisionDiscovery;
1140     g_wpaP2pInterface->wpaP2pCliCmdGroupAdd = WpaP2pCliCmdGroupAdd;
1141     g_wpaP2pInterface->wpaP2pCliCmdStoreConfig = WpaP2pCliCmdStoreConfig;
1142     g_wpaP2pInterface->wpaP2pCliCmdSetPersistentReconnect = WpaP2pCliCmdSetPersistentReconnect;
1143     g_wpaP2pInterface->wpaP2pCliCmdRespServerDiscovery = WpaP2pCliCmdRespServerDiscovery;
1144     g_wpaP2pInterface->wpaP2pCliCmdSetServDiscExternal = WpaP2pCliCmdSetServDiscExternal;
1145     g_wpaP2pInterface->wpaP2pCliCmdSetRandomMac = WpaP2pCliCmdSetRandomMac;
1146     g_wpaP2pInterface->wpaP2pCliCmdP2pGetChba0Freq = WpaP2pCliCmdP2pGetChba0Freq;
1147     g_wpaP2pInterface->wpaP2pCliCmdSetGroupConfig = WpaP2pCliCmdSetGroupConfig;
1148     g_wpaP2pInterface->wpaP2pCliCmdGetGroupConfig = WpaP2pCliCmdGetGroupConfig;
1149     g_wpaP2pInterface->wpaP2pCliCmdAddNetwork = WpaP2pCliCmdAddNetwork;
1150     g_wpaP2pInterface->wpaP2pCliCmdHid2dConnect = WpaP2pHid2dCliCmdConnect;
1151     return;
1152 }
1153 
GetWifiWapP2pInterface(const char * ifName)1154 WifiWpaP2pInterface *GetWifiWapP2pInterface(const char *ifName)
1155 {
1156     if (g_wpaP2pInterface != NULL) {
1157         return g_wpaP2pInterface;
1158     }
1159     if (ifName == NULL) {
1160         HDF_LOGE("Input ifName invalid!");
1161         return NULL;
1162     }
1163     g_wpaP2pInterface = (WifiWpaP2pInterface *)calloc(1, sizeof(WifiWpaP2pInterface));
1164     if (g_wpaP2pInterface == NULL) {
1165         HDF_LOGE("alloc memory for p2p interface failed!");
1166         return NULL;
1167     }
1168     if (strcpy_s(g_wpaP2pInterface->ifName, sizeof(g_wpaP2pInterface->ifName), ifName) != 0) {
1169         HDF_LOGE("failed to copy the ifName(%{public}s)!", ifName);
1170         return NULL;
1171     }
1172     InitGlobalWpaP2pFunc();
1173     return g_wpaP2pInterface;
1174 }
1175 
RelesaeWpaP2pInterface(void)1176 void RelesaeWpaP2pInterface(void)
1177 {
1178     while (g_wpaP2pGroupInterface != NULL) {
1179         ReleaseWpaP2pGroupInterface(g_wpaP2pGroupInterface->groupIfname);
1180     }
1181     if (g_wpaP2pInterface != NULL) {
1182         free(g_wpaP2pInterface);
1183         g_wpaP2pInterface = NULL;
1184     }
1185 }
1186 
ConvertP2pErrCode(P2pSupplicantErrCode code)1187 WifiErrorNo ConvertP2pErrCode(P2pSupplicantErrCode code)
1188 {
1189     switch (code) {
1190         case P2P_SUP_ERRCODE_SUCCESS:
1191             return WIFI_HAL_SUCCESS;
1192         case P2P_SUP_ERRCODE_PBC_OVERLAP:
1193             return WIFI_HAL_PBC_OVERLAP;
1194         case P2P_SUP_ERRCODE_INPUT_ERROR:
1195             return WIFI_HAL_INVALID_PARAM;
1196         default:
1197             return WIFI_HAL_FAILED;
1198     }
1199 }
1200 
GetWifiWpaP2pGroupInterface(const char * groupIfc)1201 WifiWpaP2pGroupInterface *GetWifiWpaP2pGroupInterface(const char *groupIfc)
1202 {
1203     if (groupIfc == NULL) {
1204         return NULL;
1205     }
1206     WifiWpaP2pGroupInterface *p = g_wpaP2pGroupInterface;
1207     while (p != NULL) {
1208         if (strcmp(p->groupIfname, groupIfc) == 0) {
1209             return p;
1210         }
1211         p = p->next;
1212     }
1213     p = (WifiWpaP2pGroupInterface *)calloc(1, sizeof(WifiWpaP2pGroupInterface));
1214     if (p == NULL) {
1215         return NULL;
1216     }
1217     if (strcpy_s(p->groupIfname, sizeof(p->groupIfname), groupIfc) != EOK) {
1218         HDF_LOGE("Failed to save group iface!");
1219         free(p);
1220         return NULL;
1221     }
1222     p->wpaP2pCliCmdWpsPbc = WpaP2pCliCmdWpsPbc;
1223     p->wpaP2pCliCmdWpsPin = WpaP2pCliCmdWpsPin;
1224     p->wpaP2pCliCmdSetPowerSave = WpaP2pCliCmdSetPowerSave;
1225     p->wpaP2pCliCmdSetGroupIdle = WpaP2pCliCmdSetGroupIdle;
1226     p->next = g_wpaP2pGroupInterface;
1227     g_wpaP2pGroupInterface = p;
1228     return p;
1229 }
1230 
ReleaseWpaP2pGroupInterface(const char * groupIfc)1231 void ReleaseWpaP2pGroupInterface(const char *groupIfc)
1232 {
1233     if (groupIfc == NULL) {
1234         return;
1235     }
1236     WifiWpaP2pGroupInterface *p = g_wpaP2pGroupInterface;
1237     WifiWpaP2pGroupInterface *q = p;
1238     while (p != NULL) {
1239         if (strcmp(p->groupIfname, groupIfc) == 0) {
1240             break;
1241         }
1242         q = p;
1243         p = p->next;
1244     }
1245     if (p == NULL) {
1246         return;
1247     }
1248     if (p == g_wpaP2pGroupInterface) {
1249         g_wpaP2pGroupInterface = p->next;
1250     } else {
1251         q->next = p->next;
1252     }
1253     free(p);
1254     return;
1255 }
1256