Merge to L1.

Signed-off-by: Nmaoyufeng <maoyufeng3@huawei.com>

wpa_supplicant-2.9/src/ap/hw_features.c

@@ -229,6 +229,12 @@ static int ieee80211n_allowed_ht40_channel_pair(struct hostapd_iface *iface)
 {
 	int pri_chan, sec_chan;
 
+#ifdef CONFIG_OHOS_P2P
+	if (!iface->conf->secondary_channel) {
+		return 1; // HT40 not used.
+	}
+#endif
+
 	pri_chan = iface->conf->channel;
 	sec_chan = pri_chan + iface->conf->secondary_channel * 4;
 

wpa_supplicant-2.9/src/drivers/wpa_hal.c

@@ -8,6 +8,7 @@
 
 #include "wpa_hal.h"
 #include "includes.h"
+#include "utils/common.h"
 #include "driver.h"
 #include "ap/hostapd.h"
 #include "l2_packet/l2_packet.h"
@@ -22,12 +23,82 @@ extern "C" {
 
 WifiDriverData *g_wifiDriverData = NULL;
 enum WifiIfType g_wifiDriverType = WIFI_IFTYPE_UNSPECIFIED;
+#ifdef CONFIG_OHOS_P2P
+uint8_t g_msgInit = TRUE;
+#endif
 
 WifiDriverData *GetDrvData()
 {
     return g_wifiDriverData;
 }
 
+#ifdef CONFIG_OHOS_P2P
+#define WPA_MAX_WIFI_DEV_NUM 3
+
+WifiDev* g_wifiDev[WPA_MAX_WIFI_DEV_NUM] = {NULL};
+
+WifiDev* GetWifiDevByName(const char *ifName)
+{
+    int32_t i;
+    if (ifName == NULL) {
+        return NULL;
+    }
+    for (i = 0; i < WPA_MAX_WIFI_DEV_NUM; i++) {
+        if ((g_wifiDev[i] != NULL) && (strncmp(g_wifiDev[i]->ifName, ifName, strlen(ifName)) == 0)) {
+            g_wifiDev[i]->networkId = i;
+            return g_wifiDev[i];
+        }
+    }
+    return NULL;
+}
+
+int32_t SetWifiDev(WifiDev *wifiDev)
+{
+    int32_t i;
+    if (wifiDev == NULL) {
+        return -EFAIL;
+    }
+    for (i = 0; i < WPA_MAX_WIFI_DEV_NUM; i++) {
+        if ((g_wifiDev[i] != NULL) && (strncmp(g_wifiDev[i]->ifName, wifiDev->ifName, strlen(wifiDev->ifName)) == 0)) {
+            g_wifiDev[i] = wifiDev;
+            return SUCC;
+        } else if (g_wifiDev[i] == NULL) {
+            g_wifiDev[i] = wifiDev;
+            return SUCC;
+        }
+    }
+    return -EFAIL;
+}
+
+void FreeWifiDev(WifiDev *wifiDev)
+{
+    int32_t i;
+    if (wifiDev == NULL) {
+        return;
+    }
+    for (i = 0; i < WPA_MAX_WIFI_DEV_NUM; i++) {
+        if (g_wifiDev[i] == wifiDev) {
+            g_wifiDev[i] = NULL;
+            break;
+        }
+    }
+    os_free(wifiDev);
+    wifiDev = NULL;
+}
+
+int32_t CountWifiDevInUse()
+{
+    int32_t i;
+    int32_t count = 0;
+    for (i = 0; i < WPA_MAX_WIFI_DEV_NUM; i++) {
+        if (g_wifiDev[i] != NULL) {
+            count++;
+        }
+    }
+    return count;
+}
+#endif // CONFIG_OHOS_P2P
+
 static int OnWpaWiFiEvents(uint32_t event, void *data, const char *ifName)
 {
     (void)ifName;
@@ -76,6 +147,7 @@ static int32_t WifiClientInit(void)
 {
     int32_t ret;
 
+    wpa_printf(MSG_INFO, "WifiClientInit enter.");
     ret = WifiDriverClientInit();
     if (ret != SUCC) {
         wpa_printf(MSG_ERROR, "WifiWpa init msg service failed");
@@ -340,6 +412,16 @@ static void WifiWpaPreInit(const WifiDriverData *drv)
     info.ifType = WIFI_IFTYPE_STATION;
     info.mode = WIFI_PHY_MODE_11N;
 
+#ifdef CONFIG_OHOS_P2P
+    if  (strncmp(drv->iface, "p2p-p2p-0", 10) == 0) {
+        info.ifType = WIFI_IFTYPE_P2P_CLIENT;
+        setMode.iftype = WIFI_IFTYPE_P2P_CLIENT;
+    } else if (os_strncmp(drv->iface, "p2p0", 4) == 0) {
+        info.ifType = WIFI_IFTYPE_P2P_DEVICE;
+        setMode.iftype = WIFI_IFTYPE_P2P_DEVICE;
+    }
+#endif //CONFIG_OHOS_P2P
+
     if (WifiCmdSetNetdev(drv->iface, &info) != SUCC) {
         wpa_printf(MSG_ERROR, "%s set netdev failed", __func__);
     }
@@ -361,28 +443,55 @@ static void WifiWpaDeinit(void *priv)
     info.status = FALSE;
     info.ifType = WIFI_IFTYPE_STATION;
     info.mode = WIFI_PHY_MODE_11N;
+#ifdef CONFIG_OHOS_P2P
+    if  (strncmp(drv->iface, "p2p-p2p-0", 10) == 0) {
+        info.ifType = WIFI_IFTYPE_P2P_CLIENT;
+    } else if (os_strncmp(drv->iface, "p2p0", 4) == 0) {
+        info.ifType = WIFI_IFTYPE_P2P_DEVICE;
+    }
+    WifiDev *wifiDev = NULL;
+    wifiDev = GetWifiDevByName(drv->iface);
+    if (wifiDev == NULL) {
+        wpa_printf(MSG_ERROR, "%s: GetWifiDevByName failed.\r\n.", __FUNCTION__);
+    }
+    FreeWifiDev(wifiDev);
+#endif // CONFIG_OHOS_P2P
     WifiCmdSetNetdev(drv->iface, &info);
 
     if (drv->eapolSock != NULL) {
         l2_packet_deinit(drv->eapolSock);
     }
 
+#ifdef CONFIG_OHOS_P2P
+    if (CountWifiDevInUse() == 0) {
+        g_msgInit = TRUE;
+        os_free(g_wifiDriverData);
+        g_wifiDriverData = NULL;
+        (void)WifiClientDeinit();
+    }
+#else
     os_free(g_wifiDriverData);
     g_wifiDriverData = NULL;
     WifiClientDeinit();
+#endif //CONFIG_OHOS_P2P
 
     wpa_printf(MSG_INFO, "WifiWpaDeinit done");
 }
 
-static void *WifiWpaInit(void *ctx, const char *ifname)
+static void *WifiWpaInit(void *ctx, const char *ifName)
 {
     int32_t ret;
     WifiSetNewDev info;
+#ifdef CONFIG_OHOS_P2P
+    WifiDev *wifiDev = NULL;
+    errno_t rc;
+#endif
 
-    if ((ctx == NULL) || (ifname == NULL)) {
+    if ((ctx == NULL) || (ifName == NULL)) {
         return NULL;
     }
 
+    wpa_printf(MSG_INFO, "%s enter, interface name:%s.", __FUNCTION__, ifName);
     (void)memset_s(&info, sizeof(WifiSetNewDev), 0, sizeof(WifiSetNewDev));
     WifiDriverData *drv = os_zalloc(sizeof(WifiDriverData));
     if (drv == NULL) {
@@ -390,20 +499,35 @@ static void *WifiWpaInit(void *ctx, const char *ifname)
     }
 
     drv->ctx = ctx;
-    if (memcpy_s(drv->iface, sizeof(drv->iface), ifname, sizeof(drv->iface)) != EOK) {
+    if (memcpy_s(drv->iface, sizeof(drv->iface), ifName, sizeof(drv->iface)) != EOK) {
         goto failed;
     }
 
+#ifdef CONFIG_OHOS_P2P
+    if (g_msgInit) {
+        if (WifiClientInit() != SUCC) {
+            goto failed;
+        }
+        g_msgInit = FALSE;
+    }
+#else
     if (WifiClientInit() != SUCC) {
         wpa_printf(MSG_INFO, "Wifi client init failed");
         goto failed;
     }
+#endif //  CONFIG_OHOS_P2P
     WifiWpaPreInit(drv);
 
     info.status = TRUE;
     info.ifType = WIFI_IFTYPE_STATION;
     info.mode = WIFI_PHY_MODE_11N;
-
+#ifdef CONFIG_OHOS_P2P
+    if  (strncmp(drv->iface, "p2p-p2p-0", 10) == 0) {
+        info.ifType = WIFI_IFTYPE_P2P_CLIENT;
+    } else if (os_strncmp(drv->iface, "p2p0", 4) == 0) {
+        info.ifType = WIFI_IFTYPE_P2P_DEVICE;
+    }
+#endif // CONFIG_OHOS_P2P
     ret = WifiCmdSetNetdev(drv->iface, &info);
     if (ret != SUCC) {
         wpa_printf(MSG_ERROR, "WifiWpaInit set netdev faild");
@@ -421,10 +545,29 @@ static void *WifiWpaInit(void *ctx, const char *ifname)
     }
 
     g_wifiDriverType = WIFI_IFTYPE_STATION;
+#ifdef CONFIG_OHOS_P2P
+    wifiDev = (WifiDev *)os_zalloc(sizeof(WifiDev));
+    if (wifiDev == NULL) {
+        wpa_printf(MSG_ERROR, "%s wifiDev malloc failed.", __FUNCTION__);
+        goto failed;
+    }
+    wifiDev->priv = drv;
+    wifiDev->ifNameLen = sizeof(ifName);
+    rc = memcpy_s(wifiDev->ifName, sizeof(wifiDev->ifName), drv->iface, sizeof(drv->iface));
+    if (rc != EOK) {
+        wpa_printf(MSG_ERROR, "%s could not copy wifi device name.", __FUNCTION__);
+        goto failed;
+    }
+    wpa_printf(MSG_ERROR, "%s init done, ifname:%s.", __FUNCTION__, wifiDev->ifName);
+    SetWifiDev(wifiDev);
+#endif // CONFIG_OHOS_P2P
     g_wifiDriverData = drv;
     return drv;
 
 failed:
+#ifdef CONFIG_OHOS_P2P
+    FreeWifiDev(wifiDev);
+#endif // CONFIG_OHOS_P2P
     WifiWpaDeinit(drv);
     return NULL;
 }
@@ -446,6 +589,40 @@ static int32_t WifiWpaDeauthenticate(void *priv, const uint8_t *addr, uint16_t r
     return ret;
 }
 
+static int32_t WifiWpaDriverAp(WifiDriverData *drv, struct wpa_driver_associate_params *params)
+{
+    int32_t ret;
+    WifiSetMode setMode;
+    errno_t rc;
+
+    if ((drv == NULL) || (params == NULL)) {
+        wpa_printf(MSG_ERROR, "%s input NULL ptr.", __FUNCTION__);
+        return -EFAIL;
+    }
+    rc = memset_s(&setMode, sizeof(WifiSetMode), 0, sizeof(WifiSetMode));
+    if (rc != EOK) {
+        wpa_printf(MSG_ERROR, "%s: memset failed.", __FUNCTION__);
+        return -EFAIL;
+    }
+    if (params->p2p) {
+        wpa_printf(MSG_INFO, "%s: Setup AP operations for P2P group.(GO).", __FUNCTION__);
+        setMode.iftype = WIFI_IFTYPE_P2P_GO;
+    } else {
+        setMode.iftype = WIFI_IFTYPE_AP;
+    }
+    rc = memcpy_s(setMode.bssid, ETH_ADDR_LEN, drv->ownAddr, ETH_ADDR_LEN);
+    if (rc != EOK) {
+        wpa_printf(MSG_ERROR, "%s memcpy failed.", __FUNCTION__);
+        return -EFAIL;
+    }
+    ret = WifiCmdSetMode(drv->iface, &setMode);
+    if (ret != SUCC) {
+        wpa_printf(MSG_ERROR, "%s: set mode failed.", __FUNCTION__);
+        return -EFAIL;
+    }
+    return SUCC;
+}
+
 static int32_t WifiWpaAssocParamsSet(WifiDriverData *drv, struct wpa_driver_associate_params *params,
     WifiAssociateParams *assocParams)
 {
@@ -742,6 +919,11 @@ static int WifiWpaAssociate(void *priv, struct wpa_driver_associate_params *para
     if ((drv == NULL) || (params == NULL)) {
         return -EFAIL;
     }
+#ifdef CONFIG_OHOS_P2P
+    if (params->mode == IEEE80211_MODE_AP) {
+        return WifiWpaDriverAp(drv, params);
+    }
+#endif
     ret = WifiWpaTryConnect(drv, params);
     if (ret != SUCC) {
         if (WifiWpaDisconnet(drv, WLAN_REASON_PREV_AUTH_NOT_VALID)) {
@@ -1314,6 +1496,9 @@ static WifiDriverData *WifiDrvInit(void *ctx, const struct wpa_init_params *para
     WifiSetNewDev info;
     WifiSetMode setMode;
     int32_t ret;
+#ifdef CONFIG_OHOS_P2P
+    WifiDev *wifiDev = NULL;
+#endif
     if ((ctx == NULL) || (params == NULL)) {
         return NULL;
     }
@@ -1329,6 +1514,23 @@ static WifiDriverData *WifiDrvInit(void *ctx, const struct wpa_init_params *para
         drv = NULL;
         goto failed;
     }
+#ifdef CONFIG_OHOS_P2P
+    wifiDev = (WifiDev *)os_zalloc(sizeof(WifiDev));
+    if (wifiDev == NULL)
+    {
+        wpa_printf(MSG_ERROR, "%s wifiDev malloc failed.", __FUNCTION__);
+        goto failed;
+    }
+    wifiDev->priv = drv;
+    wifiDev->ifNameLen = sizeof(params->ifname);
+    rc = memcpy_s(wifiDev->ifName, sizeof(wifiDev->ifName), drv->iface, sizeof(drv->iface));
+    if (rc != EOK) {
+        wpa_printf(MSG_ERROR, "%s wifiDev could not copy interface name.", __FUNCTION__);
+        goto failed;
+    }
+    wpa_printf(MSG_INFO, "%s init, interface name:%s.", __FUNCTION__, wifiDev->ifName);
+    SetWifiDev(wifiDev);
+#endif // CONFIG_OHOS_P2P
     WifiHapdPreInit(drv);
 
     setMode.iftype = WIFI_IFTYPE_AP;
@@ -1357,6 +1559,9 @@ failed:
         os_free(drv);
         drv = NULL;
     }
+#ifdef CONFIG_OHOS_P2P
+    FreeWifiDev(wifiDev);
+#endif // CONFIG_OHOS_P2P
     return NULL;
 }
 
@@ -1394,17 +1599,25 @@ static void *WifiWpaHapdInit(struct hostapd_data *hapd, struct wpa_init_params *
         return NULL;
     }
 
+#ifdef CONFIG_OHOS_P2P
+    if (g_msgInit) {
+        if (WifiClientInit() != SUCC) {
+            goto failed;
+        }
+        g_msgInit = FALSE;
+    }
+#else
     if (WifiClientInit() != SUCC) {
         wpa_printf(MSG_ERROR, "Wifi client init failed");
         return NULL;
     }
+#endif // CONFIG_OHOS_P2P
 
     drv = WifiDrvInit(hapd, params);
     if (drv == NULL) {
         wpa_printf(MSG_ERROR, "WifiWpaHapdInit drv init failed");
         goto failed;
     }
-
     drv->hapd = hapd;
 
     ret = WifiWpaInitl2(params, drv);
@@ -1558,7 +1771,13 @@ static void WifiActionDataBufFree(WifiActionData *actionData)
 static int32_t WifiWpaSendAction(void *priv, uint32_t freq, uint32_t wait, const uint8_t *dst, const uint8_t *src,
     const uint8_t *bssid, const uint8_t *data, size_t dataLen, int32_t noCck)
 {
-    WifiActionData actionData = { 0 };
+    WifiActionData actionData = {
+        .dst = {0},
+        .src = {0},
+        .bssid = {0},
+        .data = NULL,
+        .dataLen = 0,
+    };
     WifiDriverData *drv = NULL;
     int32_t ret;
 
@@ -1602,6 +1821,228 @@ __attribute__ ((visibility ("default"))) void DeinitWifiService()
     }
 }
 
+#ifdef CONFIG_OHOS_P2P
+static int32_t WifiProbeReqReport(void *priv, int32_t report)
+{
+    WifiDriverData *drv = NULL;
+    wpa_printf(MSG_INFO, "%s enter.", __FUNCTION__);
+    if (priv == NULL)
+    {
+        wpa_printf(MSG_ERROR, "%s input invalid.", __FUNCTION__);
+        return -EFAIL;
+    }
+    drv = (WifiDriverData *)priv;
+    return WifiCmdProbeReqReport(drv->iface, &report);
+}
+
+static int32_t WifiRemainOnChannel(void *priv, uint32_t freq, uint32_t duration)
+{
+    int32_t ret;
+    WifiDriverData *drv = priv;
+    WifiOnChannel *onChannel = NULL;
+    if (priv == NULL)
+    {
+        wpa_printf(MSG_ERROR, "%s input invalid.", __FUNCTION__);
+        return -EFAIL;
+    }
+    onChannel = (WifiOnChannel *)os_zalloc(sizeof(WifiOnChannel));
+    if (onChannel == NULL)
+    {
+        wpa_printf(MSG_ERROR, "%s failed to alloc channel.", __FUNCTION__);
+        return -EFAIL;
+    }
+    onChannel->freq = freq;
+    onChannel->duration = duration;
+    ret = WifiCmdRemainOnChannel(drv->iface, onChannel);
+
+    os_free(onChannel);
+    onChannel = NULL;
+
+    return ret;
+}
+
+static int32_t WifiCancelRemainOnChannel(void *priv)
+{
+    WifiDriverData *drv = priv;
+    if (drv == NULL)
+    {
+        wpa_printf(MSG_ERROR, "%s input invalid.", __FUNCTION__);
+        return -EFAIL;
+    }
+    return WifiCmdCancelRemainOnChannel(drv->iface);
+}
+
+static int32_t WifiAddIf(void *priv, enum wpa_driver_if_type type, const char *ifName, const uint8_t *addr, void *bss_ctx,
+                         void **drv_priv, char *force_ifname, uint8_t *if_addr, const char *bridge, int32_t use_existing, int32_t setup_ap)
+{
+    WifiDriverData *drv = priv;
+    WifiIfAdd *ifAdd = NULL;
+    int32_t ret;
+    WifiDev *wifiDev = NULL;
+    if (priv == NULL)
+    {
+        wpa_printf(MSG_ERROR, "%s input invalid.", __FUNCTION__);
+        return -EFAIL;
+    }
+    ifAdd = (WifiIfAdd *)os_zalloc(sizeof(WifiIfAdd));
+    switch (type)
+    {
+    case WPA_IF_STATION:
+        ifAdd->type = WIFI_IFTYPE_STATION;
+        break;
+    case WPA_IF_P2P_GROUP:
+    case WPA_IF_P2P_CLIENT:
+        ifAdd->type = WIFI_IFTYPE_P2P_CLIENT;
+        break;
+    case WPA_IF_AP_VLAN:
+        ifAdd->type = WIFI_IFTYPE_AP_VLAN;
+        break;
+    case WPA_IF_AP_BSS:
+        ifAdd->type = WIFI_IFTYPE_AP;
+        break;
+    case WPA_IF_P2P_GO:
+        ifAdd->type = WIFI_IFTYPE_P2P_GO;
+        break;
+    case WPA_IF_P2P_DEVICE:
+        ifAdd->type = WIFI_IFTYPE_P2P_DEVICE;
+        break;
+    case WPA_IF_MESH:
+        ifAdd->type = WIFI_IFTYPE_MESH_POINT;
+        break;
+    default:
+        wpa_printf(MSG_ERROR, "%s unsuportted interface type %d.", __FUNCTION__, type);
+    }
+    ret = WifiCmdAddIf(drv->iface, ifAdd);
+    if (ret == SUCC) {
+        wifiDev = (WifiDev *)os_zalloc(sizeof(WifiDev));
+        if (wifiDev == NULL) {
+            wpa_printf(MSG_ERROR, "%s failed to malloc wifiDev.", __FUNCTION__);
+            return -EFAIL;
+        }
+        wifiDev->priv = drv;
+        wifiDev->ifNameLen = sizeof(ifName);
+        errno_t rc = memcpy_s(wifiDev->ifName, sizeof(wifiDev->ifName), ifName, sizeof(drv->iface));
+        if (rc != EOK) {
+            wpa_printf(MSG_ERROR, "Could not copy wifi device name.");
+            FreeWifiDev(wifiDev);
+            return ret;
+        }
+
+        wpa_printf(MSG_INFO, "%s ifName:%s, type:%d", __FUNCTION__, wifiDev->ifName, ifAdd->type);
+        SetWifiDev(wifiDev);
+    }
+    os_free(ifAdd);
+    ifAdd = NULL;
+    return ret;
+}
+
+static int32_t WifiRemoveIf(void *priv, enum wpa_driver_if_type type, const char *ifName)
+{
+    WifiDriverData *drv = priv;
+    WifiIfRemove ifRemove = {0};
+    int32_t ret;
+    errno_t rc;
+    WifiDev *wifiDev = NULL;
+    if (priv == NULL || ifName == NULL) {
+        wpa_printf(MSG_ERROR, "%s input invalid.", __FUNCTION__);
+        return -EFAIL;
+    }
+    if (os_strlen(ifName) > IFNAMSIZ) {
+        wpa_printf(MSG_ERROR, "%s ifName invalid:%s.", __FUNCTION__, ifName);
+        return -EFAIL;
+    }
+    rc = memcpy_s(ifRemove.ifname, IFNAMSIZ, ifName, IFNAMSIZ);
+    if (rc != EOK) {
+        wpa_printf(MSG_ERROR, "%s can not copy interface name.", __FUNCTION__);
+        return -EFAIL;
+    }
+    ret = WifiCmdRemoveIf(drv->iface, &ifRemove);
+    wifiDev = GetWifiDevByName(ifName);
+    if (wifiDev == NULL) {
+        wpa_printf(MSG_ERROR, "%s: GetWifiDevByName failed.", __FUNCTION__);
+        return -EFAIL;
+    }
+    FreeWifiDev(wifiDev);
+    return SUCC;
+}
+
+int32_t WifiSetApWpsP2pIe(void *priv, const struct wpabuf *beacon, const struct wpabuf *probresp, const struct wpabuf *assocresp)
+{
+    int32_t loops;
+    int32_t ret = SUCC;
+    WifiAppIe *appIe = NULL;
+    struct wpabuf *wpabufTmp = NULL;
+    WifiDriverData *drv = (WifiDriverData *)priv;
+    WifiCmd cmdAddr[4] = {{0x1, beacon}, {0x2, probresp}, {0x4, assocresp}, {-1, NULL}};
+    errno_t rc;
+    appIe = (WifiAppIe *)os_zalloc(sizeof(WifiAppIe));
+    if (appIe == NULL) {
+        wpa_printf(MSG_ERROR, "%s:failed to malloc WifiAppIe.", __FUNCTION__);
+        return -EFAIL;
+    }
+    for (loops = 0; cmdAddr[loops].cmd != -1; loops++) {
+        wpabufTmp = (struct wpabuf *)cmdAddr[loops].src;
+        if (wpabufTmp != NULL) {
+            appIe->appIeType = cmdAddr[loops].cmd;
+            appIe->ieLen = wpabuf_len(wpabufTmp);
+            if ((wpabufTmp->buf != NULL) && (appIe->ieLen != 0)) {
+                appIe->ie = os_zalloc(appIe->ieLen);
+                if (appIe->ie == NULL) {
+                    wpa_printf(MSG_ERROR, "%s appIe->ie malloc failed.", __FUNCTION__);
+                    os_free(appIe);
+                    return -EFAIL;
+                }
+                rc = memcpy_s(appIe->ie, appIe->ieLen, wpabuf_head(wpabufTmp), wpabuf_len(wpabufTmp));
+                if (rc != EOK) {
+                    wpa_printf(MSG_ERROR, "%s: ", __FUNCTION__);
+                    os_free(appIe->ie);
+                    os_free(appIe);
+                    return -EFAIL;
+                }
+            }
+            wpa_printf(MSG_INFO, "%s type %d, ie_len %d.", __FUNCTION__, appIe->appIeType, appIe->ieLen);
+            ret = WifiCmdSetApWpsP2pIe(drv->iface, appIe);
+            os_free(appIe->ie);
+            if (ret < 0) {
+                break;
+            }
+        }
+    }
+    os_free(appIe);
+    appIe = NULL;
+    return ret;
+}
+
+int32_t WifiWpaGetDrvFlags(void *priv, uint64_t *drvFlags)
+{
+    WifiDriverData *drv = NULL;
+    WifiGetDrvFlags *params = NULL;
+    int32_t ret;
+    if (priv == NULL || drvFlags == NULL)
+    {
+        return -EFAIL;
+    }
+    drv = (WifiDriverData *)priv;
+    params = (WifiGetDrvFlags *)os_zalloc(sizeof(WifiGetDrvFlags));
+    if (params == NULL)
+    {
+        return -EFAIL;
+    }
+    params->drvFlags = 0;
+    ret = WifiCmdGetDrvFlags(drv->iface, params);
+    if (ret != SUCC)
+    {
+        wpa_printf(MSG_ERROR, "%s WifiCmdGetDrvFlags failed, ret is %d.", __FUNCTION__, ret);
+        os_free(params);
+        return -EFAIL;
+    }
+    *drvFlags = params->drvFlags;
+    wpa_printf(MSG_INFO, "%s drvFlags:%llx.", __FUNCTION__, *drvFlags);
+    os_free(params);
+    return ret;
+}
+#endif // CONFIG_OHOS_P2P
+
 const struct wpa_driver_ops g_wifiDriverOps = {
     .name = "hdf wifi",
     .desc = "wpa hdf adaptor layer",
@@ -1624,6 +2065,14 @@ const struct wpa_driver_ops g_wifiDriverOps = {
     .hapd_send_eapol = WifiWpaHapdSendEapol,
     .send_action = WifiWpaSendAction,
     .get_mac_addr = WifiWpaGetMacAddr,
+#ifdef CONFIG_OHOS_P2P
+    .remain_on_channel = WifiRemainOnChannel,
+    .cancel_remain_on_channel = WifiCancelRemainOnChannel,
+    .probe_req_report = WifiProbeReqReport,
+    .if_add = WifiAddIf,
+    .if_remove = WifiRemoveIf,
+    .set_ap_wps_ie = WifiSetApWpsP2pIe,
+#endif // CONFIG_OHOS_P2P
 };
 
 #ifdef __cplusplus

wpa_supplicant-2.9/src/drivers/wpa_hal.h

@@ -133,15 +133,6 @@ typedef struct {
     void *contex;
 } WifiEnableEapol;
 
-typedef struct {
-    uint32_t freq;
-    uint32_t duration;
-} WifiOnChannel;
-
-typedef struct {
-    uint8_t type;
-} WifiIfAdd;
-
 typedef struct {
     int32_t start;
     int32_t duration;
@@ -156,10 +147,6 @@ typedef struct {
     int8_t resv[2];
 } WifiP2pPowerSave;
 
-typedef struct {
-    uint8_t ifname[IFNAMSIZ];
-} WifiIfRemove;
-
 typedef struct {
     uint8_t type;
     uint8_t macAddr[ETH_ADDR_LEN];
@@ -171,10 +158,6 @@ typedef struct {
     uint8_t *macAddr;
 } WifiIftypeMacAddr;
 
-typedef struct {
-    uint64_t drvFlags;
-} WifiGetDrvFlags;
-
 typedef struct {
     int32_t freq;
 } WifiChannelSwitch;
@@ -214,8 +197,24 @@ typedef struct {
     uint8_t mode;
 } WifiDriverData;
 
+typedef struct {
+    int32_t cmd;
+    const struct wpabuf *src;
+} WifiCmd;
+
+typedef struct {
+    enum WifiIfType ifType;
+    WifiDriverData *priv;
+    int32_t networkId;
+    int32_t ifNameLen;
+    char ifName[IFNAMSIZ + 1];
+    char reserver[1];
+} WifiDev;
+
 WifiDriverData *GetDrvData();
 void WifiWpaScanTimeout(void *eloop, void *ctx);
+int32_t WifiWpaGetDrvFlags(void *priv, uint64_t *drvFlags);
+WifiDev *GetWifiDevByName(const char *ifName);
 
 void WifiWpaNewStaProcess(WifiDriverData *drv, WifiNewStaInfo *staInfo);
 void WifiWpaDelStaProcess(WifiDriverData *drv, uint8_t *addr);

wpa_supplicant-2.9/src/l2_packet/l2_packet_rtos.c

@@ -82,14 +82,6 @@ void l2_packet_receive(void *eloop_ctx, void *sock_ctx)
 #endif /* CONFIG_DRIVER_HDF */
 }
 
-static void l2_packet_eapol_callback(void *ctx, void *context)
-{
-    struct l2_packet_data *l2 = (struct l2_packet_data *)context;
-
-    (void)ctx;
-    printf("l2_packet_eapol_callback");
-    l2_packet_receive(l2, NULL);
-}
 struct l2_packet_data * l2_packet_init(
     const char *ifname, const u8 *own_addr, unsigned short protocol,
     void (*rx_callback)(void *ctx, const u8 *src_addr,

wpa_supplicant-2.9/src/p2p/p2p.c

@@ -3638,7 +3638,11 @@ static void p2p_go_neg_resp_cb(struct p2p_data *p2p, int success)
 		return;
 	}
 	p2p_set_state(p2p, P2P_CONNECT);
+#ifdef CONFIG_OHOS_P2P
+	p2p_set_timeout(p2p, 0, 800000);
+#else
 	p2p_set_timeout(p2p, 0, 500000);
+#endif // CONFIG_OHOS_P2P
 }
 
 

wpa_supplicant-2.9/src/p2p/p2p_parse.c

@@ -175,7 +175,7 @@ static int p2p_parse_attribute(u8 id, const u8 *data, u16 len,
 		}
 		p2p_copy_filter_devname(msg->device_name,
 					sizeof(msg->device_name), pos, nlen);
-		wpa_printf(MSG_DEBUG, "P2P: * Device Info: addr " MACSTR
+		wpa_printf(MSG_INFO, "P2P: * Device Info: addr " MACSTR
 			   " primary device type %s device name '%s' "
 			   "config methods 0x%x",
 			   MAC2STR(msg->p2p_device_addr),

wpa_supplicant-2.9/wpa_supplicant/p2p_supplicant.c

@@ -37,6 +37,9 @@
 #include "wps_supplicant.h"
 #include "p2p_supplicant.h"
 #include "wifi_display.h"
+#ifdef CONFIG_DRIVER_HDF
+#include "drivers/wpa_hal.h"
+#endif /* CONFIG_DRIVER_HDF */
 
 
 /*
@@ -2091,6 +2094,9 @@ static int wpas_p2p_add_group_interface(struct wpa_supplicant *wpa_s,
 			   MAC2STR(wpa_s->pending_interface_addr));
 	}
 
+#ifdef CONFIG_OHOS_P2P
+	(void)WifiCmdGetOwnMac(ifname, (char *)wpa_s->pending_interface_addr, ETH_ALEN);
+#endif // CONFIG_OHOS_P2P
 	if (force_ifname[0]) {
 		wpa_printf(MSG_DEBUG, "P2P: Driver forced interface name %s",
 			   force_ifname);

wpa_supplicant-2.9/wpa_supplicant/wpa_supplicant.c

@@ -67,6 +67,9 @@
 #include "ap/ap_config.h"
 #include "ap/hostapd.h"
 #endif /* CONFIG_MESH */
+#ifdef CONFIG_OHOS_P2P
+#include "wpa_hal.h"
+#endif
 
 const char *const wpa_supplicant_version =
 "wpa_supplicant v" VERSION_STR "\n"
@@ -5835,6 +5838,14 @@ static int wpa_supplicant_init_iface(struct wpa_supplicant *wpa_s,
 		    wpa_s->extended_capa[2] & 0x40)
 			wpa_s->multi_bss_support = 1;
 	}
+#ifdef CONFIG_OHOS_P2P
+	uint64_t drv_flags = 0;
+	if (WifiWpaGetDrvFlags(wpa_s->drv_priv, &drv_flags) == SUCC) {
+		wpa_s->drv_flags |= drv_flags;
+		wpa_printf(MSG_INFO, "%s WifiWpaGetDrvFlags:%11llx.", __FUNCTION__, drv_flags);
+	}
+#endif // CONFIG_OHOS_P2P
+
 	if (wpa_s->max_remain_on_chan == 0)
 		wpa_s->max_remain_on_chan = 1000;
 

wpa_supplicant-2.9_standard/.gitignore

 *.o
 *.d
+*.a
+*.so
+hostapd/hostapd_cli
+wpa_supplicant/wpa_cli
+wpa_supplicant/wpa_passphrase

wpa_supplicant-2.9_standard/src/drivers/wpa_hal_event.c

@@ -250,49 +250,6 @@ static inline void WifiWpaDriverEventEapolRecvProcess(void *ctx, void *data)
     eloop_register_timeout(0, 0, l2_packet_receive, drv->eapolSock, NULL);
 }
 
-#if 0
-static void WifiWpaEventRemainOnChannelProcess(WifiDriverData *drv, struct HdfSbuf *reqData)
-{
-    WifiOnChannel result = {0};
-    union wpa_event_data event;
-    (void)memset_s(&event, sizeof(union wpa_event_data), 0, sizeof(union wpa_event_data));
-    if (!HdfSbufReadUint32(reqData, &(result.freq)))
-    {
-        wpa_printf(MSG_ERROR, "%s failed to get frequence.", __FUNCTION__);
-        return;
-    }
-    if (!HdfSbufReadUint32(reqData, &(result.duration)))
-    {
-        wpa_printf(MSG_ERROR, "%s failed to get duration.", __FUNCTION__);
-        return;
-    }
-    event.remain_on_channel.freq = result.freq;
-    event.remain_on_channel.duration = result.duration;
-    wpa_supplicant_event(drv->ctx, EVENT_REMAIN_ON_CHANNEL, &event);
-    wpa_printf(MSG_INFO, "%s done.", __FUNCTION__);
-}
-
-static void WifiWpaEventCancelRemainOnChannelProcess(WifiDriverData *drv, struct HdfSbuf *reqData)
-{
-    WifiOnChannel result = {0};
-    union wpa_event_data event;
-    (void)memset_s(&event, sizeof(union wpa_event_data), 0, sizeof(union wpa_event_data));
-    if (!HdfSbufReadUint32(reqData, &result.freq))
-    {
-        wpa_printf(MSG_ERROR, "%s failed to get frequence.", __FUNCTION__);
-        return;
-    }
-    if (!HdfSbufReadUint32(reqData, &(result.duration)))
-    {
-        wpa_printf(MSG_ERROR, "%s failed to get duration.", __FUNCTION__);
-        return;
-    }
-    event.remain_on_channel.freq = result.freq;
-    wpa_supplicant_event(drv->ctx, EVENT_CANCEL_REMAIN_ON_CHANNEL, &event);
-    wpa_printf(MSG_INFO, "%s done.", __FUNCTION__);
-}
-#endif
-
 static int32_t AllocAndCopyIe(uint8_t *dstIe, uint32_t ieLen, uint8_t *srcIe)
 {
     int32_t ret = 0;