From dce3106e1c43076ab410af89f817e15cee7959a3 Mon Sep 17 00:00:00 2001
From: Howard Hsu <howard-yh.hsu@mediatek.com>
Date: Thu, 22 Sep 2022 16:08:09 +0800
Subject: [PATCH 037/104] mtk: hostapd: Do not include HE capab IE if
 associated sta's HE capab IE is invalid

The parameter 'sta' passed to send_assoc_resp() might be NULL, so an
NULL check is necessary before access the 'sta'.
Only one such check was missed in this function, and this patch fixs it.

CR-Id: WCNCR00289305
Signed-off-by: Michael-CY Lee <michael-cy.lee@mediatek.com>
Change-Id: I028b7779acfbce5292a60c9f800a83c57c999943
---
 src/ap/ieee802_11.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/ap/ieee802_11.c b/src/ap/ieee802_11.c
index bda61b998..d972a25f1 100644
--- a/src/ap/ieee802_11.c
+++ b/src/ap/ieee802_11.c
@@ -4931,7 +4931,8 @@ static u16 send_assoc_resp(struct hostapd_data *hapd, struct sta_info *sta,
 #endif /* CONFIG_IEEE80211AC */
 
 #ifdef CONFIG_IEEE80211AX
-	if (hapd->iconf->ieee80211ax && !hapd->conf->disable_11ax) {
+	if (hapd->iconf->ieee80211ax && !hapd->conf->disable_11ax && sta &&
+			sta->flags & WLAN_STA_HE) {
 		p = hostapd_eid_he_capab(hapd, p, IEEE80211_MODE_AP);
 		p = hostapd_eid_he_operation(hapd, p);
 		p = hostapd_eid_cca(hapd, p);
-- 
2.39.2

