APC: Fix BDR takes place of DR

Raise the priority of BDR in case
when DR is inactive, so that in the
election process BDR is elected as
DR.

Signed-off-by: Chaitanya Godavarthi <chaitanya.kiran@netexperience.com>

.github/workflows/build.yml

@@ -3,6 +3,8 @@ name: Build OpenWrt with OpenSync
 on:
   push:
     branches: [ trunk ]
+    tags:
+      - '*'
 
 jobs:
   build-ea8300:
@@ -19,6 +21,8 @@ jobs:
           GH_BUILD_PASSWORD: ${{ secrets.GH_BUILD_PASSWORD }}
       run: |
         TAG=$(date +%Y-%m-%d)-$(git rev-parse --short HEAD)
+        [[ "${{ github.ref }}" == "refs/tags/"* ]] && TAG=$(echo "${{ github.ref }}" | sed 's/refs\/tags\/[v]//')
+
         echo "ea8300-$TAG" > feeds/wlan-ap/opensync/src/vendor/tip/.pkgname
         make TARGET=IPQ40XX
         TAR_NAME="ea8300-artifacts-$TAG.tar.gz"
@@ -42,6 +46,8 @@ jobs:
           GH_BUILD_PASSWORD: ${{ secrets.GH_BUILD_PASSWORD }}
       run: |
         TAG=$(date +%Y-%m-%d)-$(git rev-parse --short HEAD)
+        [[ "${{ github.ref }}" == "refs/tags/"* ]] && TAG=$(echo "${{ github.ref }}" | sed 's/refs\/tags\/[v]//')
+
         echo "ecw5410-$TAG" > feeds/wlan-ap/opensync/src/vendor/tip/.pkgname
         make TARGET=ECW5410
         TAR_NAME="ecw5410-artifacts-$TAG.tar.gz"
@@ -65,6 +71,8 @@ jobs:
           GH_BUILD_PASSWORD: ${{ secrets.GH_BUILD_PASSWORD }}
       run: |
         TAG=$(date +%Y-%m-%d)-$(git rev-parse --short HEAD)
+        [[ "${{ github.ref }}" == "refs/tags/"* ]] && TAG=$(echo "${{ github.ref }}" | sed 's/refs\/tags\/[v]//')
+
         echo "ap2220-$TAG" > feeds/wlan-ap/opensync/src/vendor/tip/.pkgname
         make TARGET=AP2220
         TAR_NAME="ap2220-artifacts-$TAG.tar.gz"
@@ -88,6 +96,8 @@ jobs:
           GH_BUILD_PASSWORD: ${{ secrets.GH_BUILD_PASSWORD }}
       run: |
         TAG=$(date +%Y-%m-%d)-$(git rev-parse --short HEAD)
+        [[ "${{ github.ref }}" == "refs/tags/"* ]] && TAG=$(echo "${{ github.ref }}" | sed 's/refs\/tags\/[v]//')
+
         echo "ecw5211-$TAG" > feeds/wlan-ap/opensync/src/vendor/tip/.pkgname
         make TARGET=ECW5211
         TAR_NAME="ecw5211-artifacts-$TAG.tar.gz"
@@ -111,6 +121,8 @@ jobs:
           GH_BUILD_PASSWORD: ${{ secrets.GH_BUILD_PASSWORD }}
       run: |
         TAG=$(date +%Y-%m-%d)-$(git rev-parse --short HEAD)
+        [[ "${{ github.ref }}" == "refs/tags/"* ]] && TAG=$(echo "${{ github.ref }}" | sed 's/refs\/tags\/[v]//')
+
         echo "ec420-$TAG" > feeds/wlan-ap/opensync/src/vendor/tip/.pkgname
         make TARGET=EC420
         TAR_NAME="ec420-artifacts-$TAG.tar.gz"
@@ -134,6 +146,8 @@ jobs:
           GH_BUILD_PASSWORD: ${{ secrets.GH_BUILD_PASSWORD }}
       run: |
         TAG=$(date +%Y-%m-%d)-$(git rev-parse --short HEAD)
+        [[ "${{ github.ref }}" == "refs/tags/"* ]] && TAG=$(echo "${{ github.ref }}" | sed 's/refs\/tags\/[v]//')
+
         echo "eap101-$TAG" > feeds/wlan-ap/opensync/src/vendor/tip/.pkgname
         make TARGET=EAP101
         TAR_NAME="eap101-artifacts-$TAG.tar.gz"
@@ -157,6 +171,8 @@ jobs:
           GH_BUILD_PASSWORD: ${{ secrets.GH_BUILD_PASSWORD }}
       run: |
         TAG=$(date +%Y-%m-%d)-$(git rev-parse --short HEAD)
+        [[ "${{ github.ref }}" == "refs/tags/"* ]] && TAG=$(echo "${{ github.ref }}" | sed 's/refs\/tags\/[v]//')
+
         echo "eap102-$TAG" > feeds/wlan-ap/opensync/src/vendor/tip/.pkgname
         make TARGET=EAP102
         TAR_NAME="eap102-artifacts-$TAG.tar.gz"
@@ -180,6 +196,8 @@ jobs:
           GH_BUILD_PASSWORD: ${{ secrets.GH_BUILD_PASSWORD }}
       run: |
         TAG=$(date +%Y-%m-%d)-$(git rev-parse --short HEAD)
+        [[ "${{ github.ref }}" == "refs/tags/"* ]] && TAG=$(echo "${{ github.ref }}" | sed 's/refs\/tags\/[v]//')
+
         echo "wf188n-$TAG" > feeds/wlan-ap/opensync/src/vendor/tip/.pkgname
         make TARGET=WF188N
         TAR_NAME="wf188n-artifacts-$TAG.tar.gz"
@@ -203,6 +221,8 @@ jobs:
           GH_BUILD_PASSWORD: ${{ secrets.GH_BUILD_PASSWORD }}
       run: |
         TAG=$(date +%Y-%m-%d)-$(git rev-parse --short HEAD)
+        [[ "${{ github.ref }}" == "refs/tags/"* ]] && TAG=$(echo "${{ github.ref }}" | sed 's/refs\/tags\/[v]//')
+
         echo "wf194c-$TAG" > feeds/wlan-ap/opensync/src/vendor/tip/.pkgname
         make TARGET=WF194C
         TAR_NAME="wf194c-artifacts-$TAG.tar.gz"
@@ -226,6 +246,8 @@ jobs:
           GH_BUILD_PASSWORD: ${{ secrets.GH_BUILD_PASSWORD }}
       run: |
         TAG=$(date +%Y-%m-%d)-$(git rev-parse --short HEAD)
+        [[ "${{ github.ref }}" == "refs/tags/"* ]] && TAG=$(echo "${{ github.ref }}" | sed 's/refs\/tags\/[v]//')
+
         echo "wf610d-$TAG" > feeds/wlan-ap/opensync/src/vendor/tip/.pkgname
         make TARGET=WF610D
         TAR_NAME="wf610d-artifacts-$TAG.tar.gz"
@@ -249,6 +271,8 @@ jobs:
           GH_BUILD_PASSWORD: ${{ secrets.GH_BUILD_PASSWORD }}
       run: |
         TAG=$(date +%Y-%m-%d)-$(git rev-parse --short HEAD)
+        [[ "${{ github.ref }}" == "refs/tags/"* ]] && TAG=$(echo "${{ github.ref }}" | sed 's/refs\/tags\/[v]//')
+
         echo "ex227-$TAG" > feeds/wlan-ap/opensync/src/vendor/tip/.pkgname
         make TARGET=EX227
         TAR_NAME="ex227-artifacts-$TAG.tar.gz"
@@ -272,6 +296,8 @@ jobs:
           GH_BUILD_PASSWORD: ${{ secrets.GH_BUILD_PASSWORD }}
       run: |
         TAG=$(date +%Y-%m-%d)-$(git rev-parse --short HEAD)
+        [[ "${{ github.ref }}" == "refs/tags/"* ]] && TAG=$(echo "${{ github.ref }}" | sed 's/refs\/tags\/[v]//')
+
         echo "ex447-$TAG" > feeds/wlan-ap/opensync/src/vendor/tip/.pkgname
         make TARGET=EX447
         TAR_NAME="ex447-artifacts-$TAG.tar.gz"
@@ -280,5 +306,3 @@ jobs:
         UPGRADE_TAR_NAME="ex447-$TAG.tar.gz"
         tar cfz "$UPGRADE_TAR_NAME" -C openwrt/bin/targets/ipq807x/ipq807x $(find openwrt/bin/targets/ipq807x/ipq807x -type f \( -name '*sysupgrade*' -o -name 'sha256sums' \) -printf "%f\n")
         curl -u "$GH_BUILD_USERNAME":"$GH_BUILD_PASSWORD" -T "$UPGRADE_TAR_NAME" "https://tip.jfrog.io/artifactory/tip-wlan-ap-firmware/ex447/trunk/"$UPGRADE_TAR_NAME""
-
-

feeds/wifi-ax/hostapd/Makefile

@@ -99,6 +99,7 @@ ifneq ($(LOCAL_VARIANT),mini)
 endif
 
 ifeq ($(LOCAL_VARIANT),full)
+  DRIVER_MAKEOPTS += CONFIG_HS20=y CONFIG_INTERWORKING=y
   ifeq ($(SSL_VARIANT),openssl)
     DRIVER_MAKEOPTS += CONFIG_TLS=openssl CONFIG_SAE=y CONFIG_OWE=y CONFIG_SUITEB192=y CONFIG_AP=y CONFIG_MESH=y
     TARGET_LDFLAGS += -lcrypto -lssl

feeds/wifi-ax/hostapd/files/hostapd.sh

@@ -47,8 +47,18 @@ hostapd_append_wpa_key_mgmt() {
 			[ "${ieee80211w:-0}" -gt 0 ] && append wpa_key_mgmt "WPA-${auth_type_l}-SHA256"
 			[ "${ieee80211ai:-0}" -gt 0 ] && append wpa_key_mgmt "FILS-SHA256"
 		;;
+		eap-only)
+			append wpa_key_mgmt "WPA-EAP-SHA256"
+			[ "${ieee80211r:-0}" -gt 0 ] && append wpa_key_mgmt "FT-EAP"
+		;;
+		eap-transition)
+			append wpa_key_mgmt "WPA-EAP"
+			append wpa_key_mgmt "WPA-EAP-SHA256"
+			[ "${ieee80211r:-0}" -gt 0 ] && append wpa_key_mgmt "FT-EAP"
+		;;
 		eap192)
 			append wpa_key_mgmt "WPA-EAP-SUITE-B-192"
+			[ "${ieee80211w:-0}" -gt 0 ] && append wpa_key_mgmt "WPA-EAP-SHA256"
 			[ "${ieee80211r:-0}" -gt 0 ] && append wpa_key_mgmt "FT-EAP"
 		;;
 		eap-eap192)
@@ -311,14 +321,15 @@ hostapd_common_add_bss_config() {
 	config_add_string osu_ssid hs20_wan_metrics hs20_operating_class hs20_t_c_filename hs20_t_c_timestamp
 
 	config_add_boolean interworking internet
-	config_add_int access_network_type asra esr uesa venue_group venue_type ipaddr_type_availability \
+	config_add_int access_network_type asra esr uesa venue_group venue_type  \
 		gas_address3
-	config_add_string hessid network_auth_type \
+	config_add_string hessid network_auth_type ipaddr_type_availability \
 		anqp_3gpp_cell_net anqp_elem domain_name qos_map_set hs20_t_c_server_url
 
 	config_add_array airtime_sta_weight
 	config_add_int airtime_bss_weight airtime_bss_limit
 	config_add_int rts_threshold
+	config_add_boolean multicast_to_unicast proxy_arp
 }
 
 hostapd_set_vlan_file() {
@@ -485,7 +496,8 @@ hostapd_set_bss_options() {
 		bss_load_update_period chan_util_avg_period sae_require_mfp \
 		multi_ap multi_ap_backhaul_ssid multi_ap_backhaul_key \
 		airtime_bss_weight airtime_bss_limit airtime_sta_weight \
-		rssi_reject_assoc_rssi rssi_ignore_probe_request rts_threshold 
+		rssi_reject_assoc_rssi rssi_ignore_probe_request rts_threshold \
+		proxy_arp multicast_to_unicast
 
 	set_default isolate 0
 	set_default maxassoc 0
@@ -508,7 +520,8 @@ hostapd_set_bss_options() {
 	set_default rssi_reject_assoc_rssi 0
 	set_default rssi_ignore_probe_request 0
 	set_default rts_threshold -1
-
+	set_default proxy_arp 0
+	set_default multicast_to_unicast 0
 	append bss_conf "ctrl_interface=/var/run/hostapd"
 	if [ "$isolate" -gt 0 ]; then
 		append bss_conf "ap_isolate=$isolate" "$N"
@@ -537,6 +550,9 @@ hostapd_set_bss_options() {
 	append bss_conf "rssi_ignore_probe_request=$rssi_ignore_probe_request" "$N"
 	append bss_conf "rts_threshold=$rts_threshold" "$N"
 
+	[ -n "$proxy_arp" ] && append bss_conf "proxy_arp=$proxy_arp" "$N"
+	[ -n "$multicast_to_unicast" ] && append bss_conf "multicast_to_unicast=$multicast_to_unicast" "$N"
+
 	[ "$tdls_prohibit" -gt 0 ] && append bss_conf "tdls_prohibit=$tdls_prohibit" "$N"
 
 	[ "$wpa" -gt 0 ] && {
@@ -557,11 +573,11 @@ hostapd_set_bss_options() {
 	}
 
 	case "$auth_type" in
-		sae|owe|eap192|eap-eap192)
+		sae|owe|eap192|eap-eap192|eap-only)
 			set_default ieee80211w 2
 			set_default sae_require_mfp 1
 		;;
-		psk-sae)
+		psk-sae|eap-transition)
 			set_default ieee80211w 1
 			set_default sae_require_mfp 1
 		;;
@@ -603,7 +619,7 @@ hostapd_set_bss_options() {
 			vlan_possible=1
 			wps_possible=1
 		;;
-		eap|eap192|eap-eap192)
+		eap|eap192|eap-eap192|eap-only|eap-transition)
 			json_get_vars \
 				auth_server auth_secret auth_port \
 				dae_client dae_secret dae_port \
@@ -932,14 +948,22 @@ hostapd_set_bss_options() {
 	set_default hs20 0
 	set_default disable_dgaf $hs20
 	set_default osen 0
+	set_default internet 0
+	set_default asra 0
+	set_default esr 0
+	set_default uesa  0
 	set_default anqp_domain_id 0
+	set_default access_network_type 0
+	set_default venue_group 0
+	set_default venue_type 0
+	set_default gas_address3 0
 	set_default hs20_deauth_req_timeout 60
 	if [ "$hs20" = "1" ]; then
 		append bss_conf "hs20=1" "$N"
 		append_hs20_icons
 		[ -n "$disable_dgaf"] && append bss_conf "disable_dgaf=$disable_dgaf" "$N"
 		[ -n "$osen"] && append bss_conf "osen=$osen" "$N"
-		[ -n "$anqp_domain_id"] && append bss_conf "anqp_domain_id=$anqp_domain_id" "$N"
+		[ "$anqp_domain_id" -gt 0 ] && append bss_conf "anqp_domain_id=$anqp_domain_id" "$N"
 		[ -n "$hs20_deauth_req_timeout"] && append bss_conf "hs20_deauth_req_timeout=$hs20_deauth_req_timeout" "$N"
 		[ -n "$osu_ssid" ] && append bss_conf "osu_ssid=$osu_ssid" "$N"
 		[ -n "$hs20_wan_metrics" ] && append bss_conf "hs20_wan_metrics=$hs20_wan_metrics" "$N"
@@ -956,15 +980,15 @@ hostapd_set_bss_options() {
 		json_for_each_item append_osu_provider osu_provider
 		json_for_each_item append_operator_icon operator_icon
 		[ -n "$interworking" ] && append bss_conf "interworking=$interworking" "$N"
-		[ -n "$internet" ] && append bss_conf "internet=$internet" "$N"
-		[ -n "$access_network_type" ] && append bss_conf "access_network_type=$access_network_type" "$N"
-		[ -n "$asra" ] && append bss_conf "asra=$asra" "$N"
-		[ -n "$esr" ] && append bss_conf "esr=$esr" "$N"
-		[ -n "$uesa" ] && append bss_conf "uesa=$uesa" "$N"
-		[ -n "$venue_group" ] && append bss_conf "venue_group=$venue_group" "$N"
-		[ -n "$venue_type" ] && append bss_conf "venue_type=$venue_type" "$N"
+		[ "$internet" -gt 0 ] && append bss_conf "internet=$internet" "$N"
+		[ "$access_network_type" -gt 0 ] && append bss_conf "access_network_type=$access_network_type" "$N"
+		[ "$asra" -gt 0 ] && append bss_conf "asra=$asra" "$N"
+		[ "$esr" -gt 0 ] && append bss_conf "esr=$esr" "$N"
+		[ "$uesa" -gt 0 ] && append bss_conf "uesa=$uesa" "$N"
+		[ "$venue_group" -gt 0 ] && append bss_conf "venue_group=$venue_group" "$N"
+		[ "$venue_type" -gt 0 ] && append bss_conf "venue_type=$venue_type" "$N"
 		[ -n "$ipaddr_type_availability" ] && append bss_conf "ipaddr_type_availability=$ipaddr_type_availability" "$N"
-		[ -n "$gas_address3" ] && append bss_conf "gas_address3=$gas_address3" "$N"
+		[ "$gas_address3" -gt 0 ] && append bss_conf "gas_address3=$gas_address3" "$N"
 		[ -n "$hessid" ] && append bss_conf "hessid=$hessid" "$N"
 		[ -n "$network_auth_type" ] && append bss_conf "network_auth_type=$network_auth_type" "$N"
 		[ -n "$anqp_3gpp_cell_net" ] && append bss_conf "anqp_3gpp_cell_net=$anqp_3gpp_cell_net" "$N"

feeds/wifi-ax/hostapd/patches/900-hapd-netlink-ubus-bridge.patch

@@ -0,0 +1,881 @@
+--- a/hostapd/main.c
++++ b/hostapd/main.c
+@@ -41,7 +41,7 @@ struct hapd_global {
+ static struct hapd_global global;
+ static int daemonize = 0;
+ static char *pid_file = NULL;
+-
++uint32_t cached_events_nr = 0;
+ 
+ #ifndef CONFIG_NO_HOSTAPD_LOGGER
+ static void hostapd_logger_cb(void *ctx, const u8 *addr, unsigned int module,
+--- a/src/ap/hostapd.h
++++ b/src/ap/hostapd.h
+@@ -97,6 +97,10 @@ struct hostapd_probereq_cb {
+ };
+ 
+ #define HOSTAPD_RATE_BASIC 0x00000001
++/* max number of cached events */
++#define HOSTAPD_MAX_CACHED_EVENTS 500
++/* event counter */
++uint32_t cached_events_nr;
+ 
+ struct hostapd_rate_data {
+ 	int rate; /* rate in 100 kbps */
+--- a/src/ap/ieee802_11.c
++++ b/src/ap/ieee802_11.c
+@@ -4908,6 +4908,7 @@ int ieee802_11_mgmt(struct hostapd_data
+ 	int ret = 0;
+ 	unsigned int freq;
+ 	int ssi_signal = fi ? fi->ssi_signal : 0;
++	int ubus_resp;
+ 
+ 	if (len < 24)
+ 		return 0;
+@@ -4977,25 +4978,52 @@ int ieee802_11_mgmt(struct hostapd_data
+ 	if (hapd->iconf->track_sta_max_num)
+ 		sta_track_add(hapd->iface, mgmt->sa, ssi_signal);
+ 
++	/* ubus request */
++	struct hostapd_ubus_request req = {
++		.type = HOSTAPD_UBUS_TYPE_MAX,
++		.mgmt_frame = mgmt,
++		.ssi_signal = ssi_signal
++	};
++
+ 	switch (stype) {
+ 	case WLAN_FC_STYPE_AUTH:
+ 		wpa_printf(MSG_DEBUG, "mgmt::auth");
+ 		handle_auth(hapd, mgmt, len, ssi_signal, 0);
++		hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211,
++			       HOSTAPD_LEVEL_DEBUG, "mgmt: [%d] [%s]",
++				   stype,
++			       "AUTH");
++		req.type = HOSTAPD_UBUS_AUTH_REQ;
+ 		ret = 1;
+ 		break;
+ 	case WLAN_FC_STYPE_ASSOC_REQ:
+ 		wpa_printf(MSG_DEBUG, "mgmt::assoc_req");
+ 		handle_assoc(hapd, mgmt, len, 0, ssi_signal);
++		hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211,
++			       HOSTAPD_LEVEL_DEBUG, "mgmt: [%d] [%s]",
++				   stype,
++			       "ASSOC");
++		req.type = HOSTAPD_UBUS_ASSOC_REQ;
+ 		ret = 1;
+ 		break;
+ 	case WLAN_FC_STYPE_REASSOC_REQ:
+ 		wpa_printf(MSG_DEBUG, "mgmt::reassoc_req");
+ 		handle_assoc(hapd, mgmt, len, 1, ssi_signal);
++		hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211,
++			       HOSTAPD_LEVEL_DEBUG, "mgmt: [%d] [%s]",
++				   stype,
++			       "RE-ASSOC");
++		req.type = HOSTAPD_UBUS_REASSOC_REQ;
+ 		ret = 1;
+ 		break;
+ 	case WLAN_FC_STYPE_DISASSOC:
+ 		wpa_printf(MSG_DEBUG, "mgmt::disassoc");
+ 		handle_disassoc(hapd, mgmt, len);
++		hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211,
++			       HOSTAPD_LEVEL_DEBUG, "mgmt: [%d] [%s]",
++				   stype,
++			       "DISASSOC");
++		req.type = HOSTAPD_UBUS_DISASSOC_REQ;
+ 		ret = 1;
+ 		break;
+ 	case WLAN_FC_STYPE_DEAUTH:
+@@ -5014,6 +5042,15 @@ int ieee802_11_mgmt(struct hostapd_data
+ 		break;
+ 	}
+ 
++	/* ubus send */
++	if (req.type != HOSTAPD_UBUS_TYPE_MAX) {
++		ubus_resp = hostapd_ubus_handle_rt_event(hapd, &req);
++		if (ubus_resp) {
++			hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211,
++				       HOSTAPD_LEVEL_INFO,
++				       "hostapd_ubus_handle_rt_event: ERROR");
++		}
++	}
+ 	return ret;
+ }
+ 
+--- a/src/ap/sta_info.c
++++ b/src/ap/sta_info.c
+@@ -423,8 +423,14 @@ void ap_handle_timer(void *eloop_ctx, vo
+ 		hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_IEEE80211,
+ 			       HOSTAPD_LEVEL_INFO, "deauthenticated due to "
+ 			       "local deauth request");
+-		ap_free_sta(hapd, sta);
+ 		hostapd_ubus_notify(hapd, "local-deauth", sta->addr);
++		struct hostapd_ubus_request req = {
++			.type = HOSTAPD_UBUS_DISASSOC_REQ,
++			.sta = sta,
++			.reason = sta->deauth_reason
++		};
++		hostapd_ubus_handle_rt_event(hapd, &req);
++		ap_free_sta(hapd, sta);
+ 		return;
+ 	}
+ 
+@@ -530,6 +536,14 @@ skip_poll:
+ 				WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY :
+ 				WLAN_REASON_PREV_AUTH_NOT_VALID;
+ 
++			/* sessions */
++			struct hostapd_ubus_request req = {
++				.type = HOSTAPD_UBUS_DISASSOC_REQ,
++				.sta = sta,
++				.reason = reason
++			};
++			hostapd_ubus_handle_rt_event(hapd, &req);
++
+ 			hostapd_drv_sta_disassoc(hapd, sta->addr, reason);
+ 		}
+ 	}
+@@ -566,6 +580,15 @@ skip_poll:
+ 			   __func__, MAC2STR(sta->addr), AP_DEAUTH_DELAY);
+ 		eloop_register_timeout(AP_DEAUTH_DELAY, 0, ap_handle_timer,
+ 				       hapd, sta);
++
++		/* sessions */
++		struct hostapd_ubus_request req = {
++			.type = HOSTAPD_UBUS_DISASSOC_REQ,
++			.sta = sta,
++			.reason = reason
++		};
++		hostapd_ubus_handle_rt_event(hapd, &req);
++
+ 		mlme_disassociate_indication(hapd, sta, reason);
+ 		break;
+ 	case STA_DEAUTH:
+--- a/src/ap/sta_info.h
++++ b/src/ap/sta_info.h
+@@ -77,6 +77,9 @@ struct sta_info {
+ 	u8 supported_rates[WLAN_SUPP_RATES_MAX];
+ 	int supported_rates_len;
+ 	u8 qosinfo; /* Valid when WLAN_STA_WMM is set */
++	u64 cl_session_id; /* client fnv1a 64bit session id */
++	u8 fdata; /* client first data flag */
++	u8 first_ip; /* client first ip flag */
+ 
+ #ifdef CONFIG_MESH
+ 	enum mesh_plink_state plink_state;
+--- a/src/ap/ubus.c
++++ b/src/ap/ubus.c
+@@ -24,7 +24,10 @@
+ 
+ static struct ubus_context *ctx;
+ static struct blob_buf b;
++static struct blob_buf b_ev;
+ static int ctx_ref;
++static char** bss_lst = NULL;
++static size_t bss_nr = 0;
+ 
+ static inline struct hapd_interfaces *get_hapd_interfaces_from_object(struct ubus_object *obj)
+ {
+@@ -63,6 +66,21 @@ static void hostapd_ubus_connection_lost
+ 	eloop_register_timeout(1, 0, ubus_reconnect_timeout, ctx, NULL);
+ }
+ 
++static int avl_compare_sess_id(const void *k1, const void *k2, void *ptr)
++{
++	const uint32_t *id1 = k1, *id2 = k2;
++
++	if (*id1 < *id2)
++		return -1;
++	else
++		return *id1 > *id2;
++}
++
++uint64_t get_time_in_ms(struct timespec *ts)
++{
++    return (uint64_t) ts->tv_sec * 1000 + ts->tv_nsec / 1000000;
++}
++
+ static bool hostapd_ubus_init(void)
+ {
+ 	if (ctx)
+@@ -525,6 +543,177 @@ static const struct blobmsg_policy csa_p
+ };
+ 
+ #ifdef NEED_AP_MLME
++enum { CSESS_REQ_SESS_ID,
++       __CSESS_REQ_MAX,
++};
++
++static const struct blobmsg_policy client_session_del_policy[__CSESS_REQ_MAX] = {
++	[CSESS_REQ_SESS_ID] = { .name = "session_id", .type = BLOBMSG_TYPE_INT64 },
++};
++
++static int hostapd_clear_session(struct ubus_context *ctx,
++				 struct ubus_object *obj,
++				 struct ubus_request_data *req,
++				 const char *method,
++				 struct blob_attr *msg)
++{
++	struct blob_attr *tb[__CSESS_REQ_MAX];
++	struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
++	struct hostapd_event_avl_rec *rec = NULL;
++	struct hostapd_event_avl_rec *rec_next = NULL;
++	uint64_t session_id = 0;
++
++	blobmsg_parse(client_session_del_policy, __CSESS_REQ_MAX, tb,
++		      blob_data(msg), blob_len(msg));
++
++	if (!tb[CSESS_REQ_SESS_ID])
++		return UBUS_STATUS_INVALID_ARGUMENT;
++
++	session_id = blobmsg_get_u64(tb[CSESS_REQ_SESS_ID]);
++	/* remove from AVL and ubus session object) */
++	avl_for_each_element_safe(&hapd->ubus.rt_events, rec, avl, rec_next)
++	{
++		if (session_id == rec->session_id) {
++			/* dec counter and delete */
++			cached_events_nr -= rec->rec_nr;
++			avl_delete(&hapd->ubus.rt_events, &rec->avl);
++			os_free(rec->records);
++			os_free(rec);
++		}
++	}
++	return 0;
++}
++
++static int hostapd_clear_sessions(struct ubus_context *ctx,
++				  struct ubus_object *obj,
++				  struct ubus_request_data *req,
++				  const char *method,
++				  struct blob_attr *msg)
++{
++	struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
++	struct hostapd_event_avl_rec *rec = NULL;
++	struct hostapd_event_avl_rec *rec_n = NULL;
++
++	avl_remove_all_elements(&hapd->ubus.rt_events, rec, avl, rec_n)
++	{
++		/* free events array */
++		os_free(rec->records);
++		os_free(rec);
++	}
++	/* reset counter */
++	cached_events_nr = 0;
++	return 0;
++}
++
++static int hostapd_sessions(struct ubus_context *ctx,
++			struct ubus_object *obj,
++		        struct ubus_request_data *req,
++			const char *method,
++                        struct blob_attr *msg)
++{
++	struct hostapd_data *hapd = container_of(obj, struct hostapd_data, ubus.obj);
++	void *a = NULL;
++	void *t = NULL;
++	void *t_msg = NULL;
++	struct hostapd_event_avl_rec *rec = NULL;
++	struct client_session_record *c_rec = NULL;
++
++	blob_buf_init(&b_ev, 0);
++	a = blobmsg_open_table(&b_ev, "sessions");
++	avl_for_each_element(&hapd->ubus.rt_events, rec, avl)
++	{
++		/* open session */
++		t = blobmsg_open_table(&b_ev, "ClientSession");
++		blobmsg_add_u64(&b_ev, "session_id", rec->session_id);
++		/* messages for current session */
++		for (size_t i = 0; i < rec->rec_nr; i++) {
++			c_rec = &rec->records[i];
++			/* check message type */
++			switch (c_rec->type) {
++			/* ClientAuthEvent */
++			case CST_AUTH: {
++				struct client_auth_event *p = &c_rec->u.auth;
++				t_msg = blobmsg_open_table(&b_ev, "ClientAuthEvent");
++				blobmsg_add_u64(&b_ev, "session_id", rec->session_id);
++				blobmsg_add_u64(&b_ev, "timestamp", c_rec->timestamp);
++				blobmsg_add_string(&b_ev, "sta_mac", p->sta_mac);
++				blobmsg_add_u32(&b_ev, "band", p->band);
++				blobmsg_add_u32(&b_ev, "auth_status", p->auth_status);
++				blobmsg_add_string(&b_ev, "ssid", p->ssid);
++				blobmsg_close_table(&b_ev, t_msg);
++				break;
++			}
++
++			/* ClientAssocEvent */
++			case CST_ASSOC: {
++				struct client_assoc_event *p = &c_rec->u.assoc;
++				t_msg = blobmsg_open_table(&b_ev, "ClientAssocEvent");
++				blobmsg_add_u64(&b_ev, "session_id", rec->session_id);
++				blobmsg_add_u64(&b_ev, "timestamp", c_rec->timestamp);
++				blobmsg_add_string(&b_ev, "sta_mac", p->sta_mac);
++				blobmsg_add_u32(&b_ev, "band", p->band);
++				blobmsg_add_u32(&b_ev, "assoc_type", 0);
++				blobmsg_add_u32(&b_ev, "rssi", p->rssi);
++				blobmsg_add_u32(&b_ev, "internal_sc", 0);
++				blobmsg_add_u8(&b_ev, "using11k", p->using11k);
++				blobmsg_add_u8(&b_ev, "using11r", p->using11r);
++				blobmsg_add_u8(&b_ev, "using11v", p->using11v);
++				blobmsg_add_string(&b_ev, "ssid", p->ssid);
++				blobmsg_close_table(&b_ev, t_msg);
++				break;
++			}
++
++			/* ClientDisconnectEvent */
++			case CST_DISASSOC: {
++				struct client_disassoc_event *p = &c_rec->u.disassoc;
++				t_msg = blobmsg_open_table(&b_ev, "ClientDisconnectEvent");
++				blobmsg_add_u64(&b_ev, "session_id", rec->session_id);
++				blobmsg_add_u64(&b_ev, "timestamp", c_rec->timestamp);
++				blobmsg_add_string(&b_ev, "sta_mac", p->sta_mac);
++				blobmsg_add_u32(&b_ev, "band", p->band);
++				blobmsg_add_u32(&b_ev, "rssi", p->rssi);
++				blobmsg_add_u32(&b_ev, "internal_rc", p->internal_rc);
++				blobmsg_add_string(&b_ev, "ssid", p->ssid);
++				blobmsg_close_table(&b_ev, t_msg);
++				break;
++			}
++
++			/* ClientFirstDataEvent */
++			case CST_FDATA: {
++				struct client_fdata_event *p = &c_rec->u.fdata;
++				t_msg = blobmsg_open_table(&b_ev, "ClientFirstDataEvent");
++				blobmsg_add_u64(&b_ev, "session_id", rec->session_id);
++				blobmsg_add_u64(&b_ev, "timestamp", c_rec->timestamp);
++				blobmsg_add_string(&b_ev, "sta_mac", p->sta_mac);
++				blobmsg_add_u64(&b_ev, "fdata_tx_up_ts_in_us", p->tx_ts.tv_sec * (uint64_t)1000000);
++				blobmsg_add_u64(&b_ev, "fdata_rx_up_ts_in_us", p->rx_ts.tv_sec * (uint64_t)1000000);
++				blobmsg_close_table(&b_ev, t_msg);
++				break;
++			}
++
++			/* ClientIpEvent */
++			case CST_IP: {
++				struct client_ip_event *p = &c_rec->u.ip;
++				t_msg = blobmsg_open_table(&b_ev, "ClientIpEvent");
++				blobmsg_add_u64(&b_ev, "session_id", rec->session_id);
++				blobmsg_add_u64(&b_ev, "timestamp", c_rec->timestamp);
++				blobmsg_add_string(&b_ev, "sta_mac", p->sta_mac);
++				blobmsg_add_string(&b_ev, "ip_address", p->ip_addr);
++				blobmsg_close_table(&b_ev, t_msg);
++				break;
++			}
++
++			default:
++				break;
++			}
++		}
++		blobmsg_close_table(&b_ev, t);
++	}
++	blobmsg_close_table(&b_ev, a);
++	ubus_send_reply(ctx, req, b_ev.head);
++	return 0;
++}
++
+ static int
+ hostapd_switch_chan(struct ubus_context *ctx, struct ubus_object *obj,
+ 		    struct ubus_request_data *req, const char *method,
+@@ -1148,6 +1337,9 @@ static const struct ubus_method bss_meth
+ 	UBUS_METHOD_NOARG("get_features", hostapd_bss_get_features),
+ #ifdef NEED_AP_MLME
+ 	UBUS_METHOD("switch_chan", hostapd_switch_chan, csa_policy),
++	UBUS_METHOD_NOARG("get_sessions", hostapd_sessions),
++	UBUS_METHOD_NOARG("clear_sessions", hostapd_clear_sessions),
++	UBUS_METHOD("clear_session", hostapd_clear_session, client_session_del_policy),
+ #endif
+ 	UBUS_METHOD("set_vendor_elements", hostapd_vendor_elements, ve_policy),
+ 	UBUS_METHOD("notify_response", hostapd_notify_response, notify_policy),
+@@ -1187,6 +1379,7 @@ void hostapd_ubus_add_bss(struct hostapd
+ 	if (asprintf(&name, "hostapd.%s", hapd->conf->iface) < 0)
+ 		return;
+ 
++	avl_init(&hapd->ubus.rt_events, avl_compare_sess_id, false, NULL);
+ 	avl_init(&hapd->ubus.banned, avl_compare_macaddr, false, NULL);
+ 	obj->name = name;
+ 	obj->type = &bss_object_type;
+@@ -1194,6 +1387,9 @@ void hostapd_ubus_add_bss(struct hostapd
+ 	obj->n_methods = bss_object_type.n_methods;
+ 	ret = ubus_add_object(ctx, obj);
+ 	hostapd_ubus_ref_inc();
++	bss_nr++;
++	bss_lst = os_realloc(bss_lst, sizeof(char *) * bss_nr);
++	bss_lst[bss_nr - 1] = strdup(name);
+ 	if (hapd->conf->signal_stay_min > -128)
+ 		eloop_register_timeout(3, 0, hostapd_bss_signal_check, NULL, hapd);  /* Start up the poll timer. */
+ }
+@@ -1212,11 +1408,42 @@ void hostapd_ubus_free_bss(struct hostap
+ 	}
+ 
+ 	free(name);
++	for (size_t i = 0; i < bss_nr; i++)
++		os_free(bss_lst[i]);
++	free(bss_lst);
++	bss_lst = NULL;
++}
++
++static int hostapd_get_bss_list(struct ubus_context *ctx,
++				struct ubus_object *obj,
++				struct ubus_request_data *req,
++				const char *method,
++				struct blob_attr *msg)
++{
++	if (!bss_lst)
++		return 0;
++
++	void *a = NULL;
++	void *b = NULL;
++
++	/* create reply */
++	blob_buf_init(&b_ev, 0);
++	a = blobmsg_open_array(&b_ev, "bss_list");
++	/* check bss list from hapd */
++	for (size_t i = 0; i < bss_nr; i++) {
++		b = blobmsg_open_table(&b_ev, NULL);
++		blobmsg_add_string(&b_ev, "name", bss_lst[i]);
++		blobmsg_close_table(&b_ev, b);
++	}
++	blobmsg_close_array(&b_ev, a);
++	ubus_send_reply(ctx, req, b_ev.head);
++	return 0;
+ }
+ 
+ static const struct ubus_method daemon_methods[] = {
+ 	UBUS_METHOD("config_add", hostapd_config_add, config_add_policy),
+ 	UBUS_METHOD("config_remove", hostapd_config_remove, config_remove_policy),
++	UBUS_METHOD_NOARG("get_bss_list", hostapd_get_bss_list),
+ };
+ 
+ static struct ubus_object_type daemon_object_type =
+@@ -1260,6 +1487,18 @@ struct ubus_event_req {
+ 	int resp;
+ };
+ 
++static uint64_t hash_fnv1a_64bit(const void *key, int len)
++{
++	if (key == NULL)
++		return 0;
++	unsigned char *p = (unsigned char *)key;
++	uint64_t h = 14695981039346656037UL;
++	int i;
++	for (i = 0; i < len; i++)
++		h = (h ^ p[i]) * 1099511628211UL;
++	return h;
++}
++
+ static void
+ ubus_event_cb(struct ubus_notify_request *req, int idx, int ret)
+ {
+@@ -1268,6 +1507,224 @@ ubus_event_cb(struct ubus_notify_request
+ 	ureq->resp = ret;
+ }
+ 
++int hostapd_ubus_handle_rt_event(struct hostapd_data *hapd,
++				 struct hostapd_ubus_request *req)
++{
++	/* check event counter */
++	if (cached_events_nr > HOSTAPD_MAX_CACHED_EVENTS) {
++		hostapd_logger(
++			hapd, NULL, HOSTAPD_MODULE_IEEE80211,
++			HOSTAPD_LEVEL_WARNING,
++			"hostapd_ubus_handle_rt_event: HOSTAPD_MAX_CACHED_EVENTS [%d] exceeded",
++			HOSTAPD_MAX_CACHED_EVENTS);
++		return WLAN_STATUS_SUCCESS;
++	}
++	struct hostapd_event_avl_rec *rec = NULL;
++	struct timespec ts;
++	uint64_t timestamp = 0;
++	clock_gettime(CLOCK_REALTIME, &ts);
++	timestamp = get_time_in_ms(&ts);
++	uint64_t session_id = 0;
++	uint8_t new_rec = 0;
++	const struct ieee80211_mgmt *mgmt = req->mgmt_frame;
++	struct sta_info *sta = req->sta ? (void *)req->sta : ap_get_sta(hapd, mgmt->sa);
++	/* null pointer check */
++	if (!sta) return WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA;
++
++	struct hostapd_bss_config *bss_conf = hapd->conf;
++	session_id = sta->cl_session_id;
++
++	/* find by session id */
++	rec = avl_find_element(&hapd->ubus.rt_events, &session_id, rec, avl);
++
++	/* prepare rec if not found */
++	if (!rec) {
++		new_rec = 1;
++		rec = os_zalloc(sizeof(struct hostapd_event_avl_rec));
++		session_id = hash_fnv1a_64bit(&ts, sizeof(struct timespec));
++	}
++	hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211,
++		       HOSTAPD_LEVEL_DEBUG,
++		       "hostapd_ubus_handle_rt_event: REQ TYPE [%d]",
++		       req->type);
++
++	switch (req->type) {
++	case HOSTAPD_UBUS_AUTH_REQ: {
++		/* session id */
++		rec->session_id = session_id;
++		rec->rec_nr++;
++		rec->records = os_realloc(rec->records,
++					  sizeof(struct client_session_record) * rec->rec_nr);
++		struct client_session_record *rp = &rec->records[rec->rec_nr - 1];
++		rp->type = CST_AUTH;
++		rp->u.auth.session_id = rec->session_id;
++
++		/* timestamp */
++		rp->timestamp = timestamp;
++		/* frequency */
++		rp->u.auth.band = hapd->iface->freq;
++		/* STA MAC */
++		sprintf(rp->u.auth.sta_mac, MACSTR, MAC2STR(sta->addr));
++		/* ssid */
++		rp->u.auth.ssid[0] = 0;
++		printf_encode(rp->u.auth.ssid, sizeof(rp->u.auth.ssid),
++			      bss_conf->ssid.ssid, bss_conf->ssid.ssid_len);
++		/* auth status */
++		rp->u.auth.auth_status = le_to_host16(mgmt->u.auth.status_code);
++		hostapd_logger(
++			hapd, NULL, HOSTAPD_MODULE_IEEE80211,
++			HOSTAPD_LEVEL_DEBUG,
++			"hostapd_ubus_handle_rt_event:HOSTAPD_UBUS_AUTH_REQ");
++		/* inc counter */
++		cached_events_nr++;
++		break;
++	}
++	case HOSTAPD_UBUS_ASSOC_REQ: {
++		/* session id */
++		rec->session_id = session_id;
++		rec->rec_nr++;
++		rec->records = os_realloc(rec->records,
++					  sizeof(struct client_session_record) * rec->rec_nr);
++		struct client_session_record *rp = &rec->records[rec->rec_nr - 1];
++		rp->type = CST_ASSOC;
++		rp->u.assoc.session_id = rec->session_id;
++		/* timestamp */
++		rp->timestamp = timestamp;
++		/* frequency */
++		rp->u.assoc.band = hapd->iface->freq;
++		/* STA MAC */
++		sprintf(rp->u.assoc.sta_mac, MACSTR, MAC2STR(sta->addr));
++		/* ssid */
++		rp->u.assoc.ssid[0] = 0;
++		printf_encode(rp->u.assoc.ssid, sizeof(rp->u.assoc.ssid),
++			      bss_conf->ssid.ssid, bss_conf->ssid.ssid_len);
++		/* rssi */
++		rp->u.assoc.rssi = req->ssi_signal;
++		/* using 11r */
++		rp->u.assoc.using11r = (sta->auth_alg & WPA_AUTH_ALG_FT);
++		/* using 11k */
++		if (sta->rrm_enabled_capa[0] || sta->rrm_enabled_capa[1] ||
++		    sta->rrm_enabled_capa[2] || sta->rrm_enabled_capa[3] ||
++		    sta->rrm_enabled_capa[4])
++			rp->u.assoc.using11k = 1;
++		else
++			rp->u.assoc.using11k = 0;
++		/* using 11v */
++		if (bss_conf->time_advertisement || bss_conf->wnm_sleep_mode ||
++		    bss_conf->bss_transition)
++			rp->u.assoc.using11v = 1;
++		else
++			rp->u.assoc.using11v = 0;
++		hostapd_logger(
++			hapd, NULL, HOSTAPD_MODULE_IEEE80211,
++			HOSTAPD_LEVEL_DEBUG,
++			"hostapd_ubus_handle_rt_event:HOSTAPD_UBUS_ASSOC_REQ");
++		/* inc counter */
++		cached_events_nr++;
++		break;
++	}
++	case HOSTAPD_UBUS_DISASSOC_REQ: {
++		/* session id */
++		rec->session_id = session_id;
++		rec->rec_nr++;
++		rec->records = os_realloc(rec->records,
++					  sizeof(struct client_session_record) * rec->rec_nr);
++		struct client_session_record *rp = &rec->records[rec->rec_nr - 1];
++		rp->type = CST_DISASSOC;
++		rp->u.disassoc.session_id = rec->session_id;
++		/* timestamp */
++		rp->timestamp = timestamp;
++		/* frequency */
++		rp->u.disassoc.band = hapd->iface->freq;
++		/* STA MAC */
++		sprintf(rp->u.disassoc.sta_mac, MACSTR, MAC2STR(sta->addr));
++		/* ssid */
++		rp->u.disassoc.ssid[0] = 0;
++		printf_encode(rp->u.disassoc.ssid, sizeof(rp->u.disassoc.ssid),
++			      bss_conf->ssid.ssid, bss_conf->ssid.ssid_len);
++		/* rssi */
++		rp->u.disassoc.rssi = req->ssi_signal;
++		/* internal_rc */
++		rp->u.disassoc.internal_rc = req->reason;
++		hostapd_logger(
++			hapd, NULL, HOSTAPD_MODULE_IEEE80211,
++			HOSTAPD_LEVEL_DEBUG,
++			"hostapd_ubus_handle_rt_event:HOSTAPD_UBUS_DISASSOC_REQ");
++		/* inc counter */
++		cached_events_nr++;
++		break;
++	}
++	case HOSTAPD_UBUS_FDATA_REQ: {
++		/* session id */
++		rec->session_id = session_id;
++		rec->rec_nr++;
++		rec->records = os_realloc(rec->records,
++					  sizeof(struct client_session_record) * rec->rec_nr);
++		struct client_session_record *rp = &rec->records[rec->rec_nr - 1];
++		rp->type = CST_FDATA;
++		rp->u.fdata.session_id = rec->session_id;
++		/* timestamp */
++		rp->timestamp = timestamp;
++		/* STA MAC */
++		sprintf(rp->u.fdata.sta_mac, MACSTR, MAC2STR(sta->addr));
++		/* rx ts */
++		rp->u.fdata.rx_ts = ts;
++		/* tx ts */
++		rp->u.fdata.tx_ts = ts;
++		/* single event only */
++		sta->fdata = 1;
++		hostapd_logger(
++			hapd, NULL, HOSTAPD_MODULE_IEEE80211,
++			HOSTAPD_LEVEL_DEBUG,
++			"hostapd_ubus_handle_rt_event:HOSTAPD_UBUS_FDATA_REQ");
++		/* inc counter */
++		cached_events_nr++;
++		break;
++	}
++	case HOSTAPD_UBUS_IP_REQ: {
++		if(sta->first_ip) break;
++		/* session id */
++		rec->session_id = session_id;
++		rec->rec_nr++;
++		rec->records = os_realloc(rec->records,
++					  sizeof(struct client_session_record) * rec->rec_nr);
++		struct client_session_record *rp = &rec->records[rec->rec_nr - 1];
++		rp->type = CST_IP;
++		rp->u.ip.session_id = rec->session_id;
++		/* timestamp */
++		rp->timestamp = timestamp;
++		/* STA MAC */
++		sprintf(rp->u.ip.sta_mac, MACSTR, MAC2STR(sta->addr));
++		/* ip address */
++		snprintf(rp->u.ip.ip_addr, 20, "%u.%u.%u.%u",
++			 (req->ipaddr >> 24) & 0xFF,
++			 (req->ipaddr >> 16) & 0xFF,
++			 (req->ipaddr >> 8) & 0xFF,
++			 req->ipaddr & 0xFF);
++		/* single event only */
++		sta->first_ip = 1;
++		/* inc counter */
++		cached_events_nr++;
++		break;
++	}
++	default:
++		hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211,
++			       HOSTAPD_LEVEL_DEBUG,
++			       "hostapd_ubus_handle_rt_event:UNKNOWN");
++		new_rec = 0;
++		break;
++	}
++	if (new_rec) {
++		/* insert new client session */
++		rec->avl.key = &rec->session_id;
++		sta->cl_session_id = session_id;
++		if (avl_insert(&hapd->ubus.rt_events, &rec->avl))
++			return WLAN_STATUS_UNSPECIFIED_FAILURE;
++	}
++
++	return WLAN_STATUS_SUCCESS;
++}
++
+ int hostapd_ubus_handle_event(struct hostapd_data *hapd, struct hostapd_ubus_request *req)
+ {
+ 	struct ubus_banned_client *ban;
+--- a/src/ap/ubus.h
++++ b/src/ap/ubus.h
+@@ -12,6 +12,11 @@ enum hostapd_ubus_event_type {
+ 	HOSTAPD_UBUS_PROBE_REQ,
+ 	HOSTAPD_UBUS_AUTH_REQ,
+ 	HOSTAPD_UBUS_ASSOC_REQ,
++	HOSTAPD_UBUS_REASSOC_REQ,
++	HOSTAPD_UBUS_DISASSOC_REQ,
++	HOSTAPD_UBUS_DEAUTH_REQ,
++	HOSTAPD_UBUS_FDATA_REQ,
++	HOSTAPD_UBUS_IP_REQ,
+ 	HOSTAPD_UBUS_TYPE_MAX
+ };
+ 
+@@ -19,8 +24,11 @@ struct hostapd_ubus_request {
+ 	enum hostapd_ubus_event_type type;
+ 	const struct ieee80211_mgmt *mgmt_frame;
+ 	const struct ieee802_11_elems *elems;
++	const struct sta_info *sta;
+ 	int ssi_signal; /* dBm */
++	int reason;
+ 	const u8 *addr;
++	be32 ipaddr;
+ };
+ 
+ struct hostapd_iface;
+@@ -37,6 +45,80 @@ struct hostapd_ubus_bss {
+ 	struct ubus_object obj;
+ 	struct avl_tree banned;
+ 	int notify_response;
++	struct avl_tree rt_events;
++};
++
++enum client_sess_type {
++	CST_ASSOC,
++	CST_AUTH,
++	CST_DISASSOC,
++	CST_FDATA,
++	CST_IP
++};
++
++struct client_assoc_event {
++	unsigned char sta_mac[20];
++	uint64_t session_id;
++	char ssid[SSID_MAX_LEN];
++	int band;
++	int assoc_type;
++	int status;
++	int rssi;
++	int internal_sc;
++	uint8_t using11k;
++	uint8_t using11r;
++	uint8_t using11v;
++};
++
++struct client_disassoc_event {
++	unsigned char sta_mac[20];
++	uint64_t session_id;
++	char ssid[SSID_MAX_LEN];
++	int band;
++	int assoc_type;
++	int status;
++	int rssi;
++	int internal_rc;
++};
++
++struct client_auth_event {
++	unsigned char sta_mac[20];
++	uint64_t session_id;
++	char ssid[SSID_MAX_LEN];
++	int band;
++	uint32_t auth_status;
++};
++
++struct client_fdata_event {
++	unsigned char sta_mac[20];
++	uint64_t session_id;
++	struct timespec rx_ts;
++	struct timespec tx_ts;
++};
++
++struct client_ip_event {
++	unsigned char sta_mac[20];
++	uint64_t session_id;
++	unsigned char ip_addr[16];
++};
++
++struct client_session_record {
++	int type;
++	uint64_t timestamp;
++	union {
++		struct client_assoc_event assoc;
++		struct client_disassoc_event disassoc;
++		struct client_auth_event auth;
++		struct client_fdata_event fdata;
++		struct client_ip_event ip;
++	} u;
++};
++
++struct hostapd_event_avl_rec {
++	uint64_t session_id;
++	struct client_session_record *records;
++	size_t rec_nr;
++	struct avl_node avl;
+ };
+ 
+ void hostapd_ubus_add_iface(struct hostapd_iface *iface);
+@@ -45,6 +127,7 @@ void hostapd_ubus_add_bss(struct hostapd
+ void hostapd_ubus_free_bss(struct hostapd_data *hapd);
+ 
+ int hostapd_ubus_handle_event(struct hostapd_data *hapd, struct hostapd_ubus_request *req);
++int hostapd_ubus_handle_rt_event(struct hostapd_data *hapd, struct hostapd_ubus_request *req);
+ void hostapd_ubus_notify(struct hostapd_data *hapd, const char *type, const u8 *mac);
+ void hostapd_ubus_notify_beacon_report(struct hostapd_data *hapd,
+ 				       const u8 *addr, u8 token, u8 rep_mode,
+@@ -78,6 +161,11 @@ static inline int hostapd_ubus_handle_ev
+ {
+ 	return 0;
+ }
++
++static inline int hostapd_ubus_handle_rt_event(struct hostapd_data *hapd, struct hostapd_ubus_request *req)
++{
++	return 0;
++}
+ 
+ static inline void hostapd_ubus_notify(struct hostapd_data *hapd, const char *type, const u8 *mac)
+ {
+--- a/src/ap/hostapd.c
++++ b/src/ap/hostapd.c
+@@ -1406,19 +1406,22 @@ static int hostapd_setup_bss(struct host
+ 				   "Generic snooping infrastructure initialization failed");
+ 			return -1;
+ 		}
+-
+-		if (dhcp_snoop_init(hapd)) {
+-			wpa_printf(MSG_ERROR,
+-				   "DHCP snooping initialization failed");
+-			return -1;
+-		}
+-
+ 		if (ndisc_snoop_init(hapd)) {
+ 			wpa_printf(MSG_ERROR,
+ 				   "Neighbor Discovery snooping initialization failed");
+ 			return -1;
+ 		}
+ 	}
++	if (dhcp_snoop_init(hapd)) {
++		wpa_printf(MSG_ERROR,
++			   "DHCP snooping initialization failed");
++		hostapd_logger(
++			hapd, NULL, HOSTAPD_MODULE_IEEE80211,
++			HOSTAPD_LEVEL_DEBUG,
++			"dfranusic:DHCP snooping initialization failed");
++
++		return -1;
++	}
+ 
+ 	if (!hostapd_drv_none(hapd) && vlan_init(hapd)) {
+ 		wpa_printf(MSG_ERROR, "VLAN initialization failed.");
+--- a/src/ap/dhcp_snoop.c
++++ b/src/ap/dhcp_snoop.c
+@@ -40,6 +40,7 @@ static void handle_dhcp(void *ctx, const
+ 	int res, msgtype = 0, prefixlen = 32;
+ 	u32 subnet_mask = 0;
+ 	u16 ip_len;
++	int ubus_resp;
+ 
+ 	exten_len = len - ETH_HLEN - (sizeof(*b) - sizeof(b->exten));
+ 	if (exten_len < 4)
+@@ -112,6 +113,19 @@ static void handle_dhcp(void *ctx, const
+ 			   ipaddr_str(be_to_host32(b->your_ip)),
+ 			   prefixlen);
+ 
++			struct hostapd_ubus_request req = {
++				.type = HOSTAPD_UBUS_IP_REQ,
++				.sta = sta,
++				.ipaddr = be_to_host32(b->your_ip)
++			};
++			ubus_resp = hostapd_ubus_handle_rt_event(hapd, &req);
++			if (ubus_resp) {
++				hostapd_logger(
++					hapd, NULL, HOSTAPD_MODULE_IEEE80211,
++					HOSTAPD_LEVEL_DEBUG,
++					"hostapd_ubus_handle_rt_event: ERROR");
++			}
++
+ 		if (sta->ipaddr == b->your_ip)
+ 			return;
+ 

feeds/wifi-ax/hostapd/patches/f00-011-ubus-multi-bss-chan-switch.patch

@@ -0,0 +1,24 @@
+--- a/src/ap/ubus.c
++++ b/src/ap/ubus.c
+@@ -722,6 +722,7 @@ hostapd_switch_chan(struct ubus_context
+ 	struct blob_attr *tb[__CSA_MAX];
+ 	struct hostapd_data *hapd = get_hapd_from_object(obj);
+ 	struct csa_settings css;
++	int i;
+ 
+ 	blobmsg_parse(csa_policy, __CSA_MAX, tb, blob_data(msg), blob_len(msg));
+ 
+@@ -746,9 +747,10 @@ hostapd_switch_chan(struct ubus_context
+ 	SET_CSA_SETTING(CSA_VHT, freq_params.vht_enabled, bool);
+ 	SET_CSA_SETTING(CSA_BLOCK_TX, block_tx, bool);
+ 
+-
+-	if (hostapd_switch_channel(hapd, &css) != 0)
+-		return UBUS_STATUS_NOT_SUPPORTED;
++	for (i = 0; i < hapd->iface->num_bss; i++) {
++		if (hostapd_switch_channel(hapd->iface->bss[i], &css) != 0)
++			return UBUS_STATUS_NOT_SUPPORTED;
++	}
+ 	return UBUS_STATUS_OK;
+ #undef SET_CSA_SETTING
+ }

feeds/wifi-ax/hostapd/patches/f00-012-hapd-ubus-channel-switch-event.patch

@@ -0,0 +1,186 @@
+--- a/src/ap/dfs.c
++++ b/src/ap/dfs.c
+@@ -19,7 +19,7 @@
+ #include "dfs.h"
+ #include "beacon.h"
+ #include "eloop.h"
+-
++#include "ubus.h"
+ 
+ static int dfs_get_used_n_chans(struct hostapd_iface *iface, int *seg1)
+ {
+@@ -1207,6 +1207,11 @@ static int hostapd_dfs_start_channel_swi
+ 			break;
+ 	}
+ 
++	if (!err) {
++		wpa_printf(MSG_DEBUG, "Reporting DFS event to ubus");
++		hostapd_ubus_handle_channel_switch_event(iface, HOSTAPD_UBUS_DFS_SWITCH,  channel->freq);
++	}
++
+ 	if (err) {
+ 		wpa_printf(MSG_WARNING, "DFS failed to schedule CSA (%d) - trying fallback",
+ 			   err);
+--- a/src/ap/ubus.c
++++ b/src/ap/ubus.c
+@@ -29,6 +29,8 @@ static int ctx_ref;
+ static char** bss_lst = NULL;
+ static size_t bss_nr = 0;
+ 
++static LIST_HEAD(chan_events);
++
+ static inline struct hapd_interfaces *get_hapd_interfaces_from_object(struct ubus_object *obj)
+ {
+ 	return container_of(obj, struct hapd_interfaces, ubus);
+@@ -714,6 +716,42 @@ static int hostapd_sessions(struct ubus_
+ 	return 0;
+ }
+ 
++static int hostapd_get_chan_switch_events(struct ubus_context *ctx,
++					  struct ubus_object *obj,
++					  struct ubus_request_data *req,
++					  const char *method,
++					  struct blob_attr *msg)
++{
++	void *a = NULL;
++	void *t = NULL;
++	struct hostapd_chan_event_list *entry, *tmp;
++
++	blob_buf_init(&b_ev, 0);
++	a = blobmsg_open_table(&b_ev, "chan_switch_event");
++	list_for_each_entry(entry, &chan_events, list) {
++		t = blobmsg_open_table(&b_ev, "event");
++		blobmsg_add_u32(&b_ev, "radio_name", entry->records.band);
++		blobmsg_add_u32(&b_ev, "reason", entry->records.reason);
++		blobmsg_add_u64(&b_ev, "timestamp", entry->records.ts);
++		blobmsg_add_u32(&b_ev, "frequency", entry->records.freq);
++		blobmsg_close_table(&b_ev, t);
++	}
++
++	blobmsg_close_table(&b_ev, a);
++	ubus_send_reply(ctx, req, b_ev.head);
++
++	/*delete list*/
++
++	if (!list_empty(&chan_events)) {
++		list_for_each_entry_safe(entry, tmp, &chan_events, list) {
++			list_del(&entry->list);
++			free(entry);
++		}
++	}
++
++	return 0;
++}
++
+ static int
+ hostapd_switch_chan(struct ubus_context *ctx, struct ubus_object *obj,
+ 		    struct ubus_request_data *req, const char *method,
+@@ -751,6 +789,9 @@ hostapd_switch_chan(struct ubus_context
+ 		if (hostapd_switch_channel(hapd->iface->bss[i], &css) != 0)
+ 			return UBUS_STATUS_NOT_SUPPORTED;
+ 	}
++
++	hostapd_ubus_handle_channel_switch_event(hapd->iface, HOSTAPD_UBUS_HIGH_INTERFERENCE, css.freq_params.freq);
++
+ 	return UBUS_STATUS_OK;
+ #undef SET_CSA_SETTING
+ }
+@@ -1446,6 +1487,7 @@ static const struct ubus_method daemon_m
+ 	UBUS_METHOD("config_add", hostapd_config_add, config_add_policy),
+ 	UBUS_METHOD("config_remove", hostapd_config_remove, config_remove_policy),
+ 	UBUS_METHOD_NOARG("get_bss_list", hostapd_get_bss_list),
++	UBUS_METHOD_NOARG("get_chan_switch_events", hostapd_get_chan_switch_events),
+ };
+ 
+ static struct ubus_object_type daemon_object_type =
+@@ -1509,6 +1551,26 @@ ubus_event_cb(struct ubus_notify_request
+ 	ureq->resp = ret;
+ }
+ 
++void hostapd_ubus_handle_channel_switch_event(struct hostapd_iface *iface, int reason,
++					      int freq)
++{
++	struct hostapd_chan_event_list *rec = NULL;
++	struct timespec ts;
++	uint64_t timestamp = 0;
++
++	clock_gettime(CLOCK_REALTIME, &ts);
++	timestamp = get_time_in_ms(&ts);
++
++	rec = os_zalloc(sizeof(struct hostapd_chan_event_list));
++
++	rec->records.reason = reason;
++	rec->records.band = iface->freq;
++	rec->records.ts = timestamp;
++	rec->records.freq = freq;
++
++	list_add_tail(&rec->list, &chan_events);
++}
++
+ int hostapd_ubus_handle_rt_event(struct hostapd_data *hapd,
+ 				 struct hostapd_ubus_request *req)
+ {
+--- a/src/ap/ubus.h
++++ b/src/ap/ubus.h
+@@ -17,9 +17,15 @@ enum hostapd_ubus_event_type {
+ 	HOSTAPD_UBUS_DEAUTH_REQ,
+ 	HOSTAPD_UBUS_FDATA_REQ,
+ 	HOSTAPD_UBUS_IP_REQ,
++	HOSTAPD_UBUS_CHAN_SWITCH,
+ 	HOSTAPD_UBUS_TYPE_MAX
+ };
+ 
++enum hostapd_ubus_chan_event_reason {
++	HOSTAPD_UBUS_DFS_SWITCH,
++	HOSTAPD_UBUS_HIGH_INTERFERENCE
++};
++
+ struct hostapd_ubus_request {
+ 	enum hostapd_ubus_event_type type;
+ 	const struct ieee80211_mgmt *mgmt_frame;
+@@ -40,6 +46,7 @@ struct rrm_measurement_beacon_report;
+ 
+ #include <libubox/avl.h>
+ #include <libubus.h>
++#include <libubox/list.h>
+ 
+ struct hostapd_ubus_bss {
+ 	struct ubus_object obj;
+@@ -121,11 +128,24 @@ struct hostapd_event_avl_rec {
+ 	struct avl_node avl;
+ };
+ 
++struct channel_switch_event {
++	int band; /* Radio name*/
++	uint8_t reason;
++	uint64_t ts;
++	uint32_t freq;
++};
++
++struct hostapd_chan_event_list {
++	struct channel_switch_event records;
++	struct list_head list;
++};
++
+ void hostapd_ubus_add_iface(struct hostapd_iface *iface);
+ void hostapd_ubus_free_iface(struct hostapd_iface *iface);
+ void hostapd_ubus_add_bss(struct hostapd_data *hapd);
+ void hostapd_ubus_free_bss(struct hostapd_data *hapd);
+-
++void hostapd_ubus_handle_channel_switch_event(struct hostapd_iface *iface,
++					      int reason, int channel);
+ int hostapd_ubus_handle_event(struct hostapd_data *hapd, struct hostapd_ubus_request *req);
+ int hostapd_ubus_handle_rt_event(struct hostapd_data *hapd, struct hostapd_ubus_request *req);
+ void hostapd_ubus_notify(struct hostapd_data *hapd, const char *type, const u8 *mac);
+@@ -157,6 +177,11 @@ static inline void hostapd_ubus_free_bss
+ {
+ }
+ 
++static inline void hostapd_ubus_handle_channel_switch_event(struct hostapd_iface *iface,
++							    int reason, int channel)
++{
++}
++
+ static inline int hostapd_ubus_handle_event(struct hostapd_data *hapd, struct hostapd_ubus_request *req)
+ {
+ 	return 0;

feeds/wifi-ax/mac80211/ath.mk

@@ -54,9 +54,13 @@ config-$(CONFIG_ATH10K_THERMAL) += ATH10K_THERMAL
 
 config-$(call config_package,ath9k-htc) += ATH9K_HTC
 config-$(call config_package,ath10k) += ATH10K ATH10K_PCI
-config-$(call config_package,ath11k) += ATH11K ATH11K_AHB
+config-$(call config_package,ath11k) += ATH11K ATH11K_AHB ATH11K_SPECTRAL
 config-$(call config_package,ath11k-pci) += ATH11K_PCI
 
+ifeq ($(CONFIG_KERNEL_IPQ_MEM_PROFILE),512)
+config-y += ATH11K_MEM_PROFILE_512M
+endif
+
 config-$(call config_package,ath5k) += ATH5K
 ifdef CONFIG_TARGET_ath25
   config-y += ATH5K_AHB

feeds/wifi-ax/mac80211/files/lib/netifd/wireless/mac80211.sh

@@ -254,6 +254,11 @@ mac80211_hostapd_setup_base() {
 		[ "$rx_stbc" -lt "$cap_rx_stbc" ] && cap_rx_stbc="$rx_stbc"
 		ht_cap_mask="$(( ($ht_cap_mask & ~(0x300)) | ($cap_rx_stbc << 8) ))"
 
+		conf_tx_ant=$(iw phy "$phy" info | grep 'Configured Antennas:' | cut -d: -f2)
+		set -- $conf_tx_ant
+		if [ "$2" == "0x1" -o "$2" == "0x10" ]; then
+			tx_stbc=0
+		fi
 		mac80211_add_capabilities ht_capab_flags $ht_cap_mask \
 			LDPC:0x1::$ldpc \
 			GF:0x10::$greenfield \
@@ -343,6 +348,11 @@ mac80211_hostapd_setup_base() {
 		[ "$rx_stbc" -lt "$cap_rx_stbc" ] && cap_rx_stbc="$rx_stbc"
 		vht_cap="$(( ($vht_cap & ~(0x700)) | ($cap_rx_stbc << 8) ))"
 
+		conf_tx_ant=$(iw phy "$phy" info | grep 'Configured Antennas:' | cut -d: -f2)
+		set -- $conf_tx_ant
+		if [ "$2" == "0x1" -o "$2" == "0x10" ]; then
+			tx_stbc_2by1=0
+		fi
 		mac80211_add_capabilities vht_capab $vht_cap \
 			RXLDPC:0x10::$rxldpc \
 			SHORT-GI-80:0x20::$short_gi_80 \

feeds/wifi-ax/mac80211/patches/pending/210-memory-optimize.patch

@@ -0,0 +1,26 @@
+Index: backports-20200902_001-4.4.60-931c337125/drivers/net/wireless/ath/ath11k/dp.h
+===================================================================
+--- backports-20200902_001-4.4.60-931c337125.orig/drivers/net/wireless/ath/ath11k/dp.h
++++ backports-20200902_001-4.4.60-931c337125/drivers/net/wireless/ath/ath11k/dp.h
+@@ -209,7 +209,7 @@ struct ath11k_pdev_dp {
+ 
+ #define DP_WBM_RELEASE_RING_SIZE	64
+ #define DP_TCL_DATA_RING_SIZE		512
+-#define DP_TX_COMP_RING_SIZE		32768
++#define DP_TX_COMP_RING_SIZE		4096
+ #define DP_TX_IDR_SIZE			DP_TX_COMP_RING_SIZE
+ #define DP_TCL_CMD_RING_SIZE		32
+ #define DP_TCL_STATUS_RING_SIZE		32
+@@ -224,9 +224,9 @@ struct ath11k_pdev_dp {
+ #define DP_RXDMA_REFILL_RING_SIZE	2048
+ #define DP_RXDMA_ERR_DST_RING_SIZE	1024
+ #define DP_RXDMA_MON_STATUS_RING_SIZE	1024
+-#define DP_RXDMA_MONITOR_BUF_RING_SIZE	4096
+-#define DP_RXDMA_MONITOR_DST_RING_SIZE	2048
+-#define DP_RXDMA_MONITOR_DESC_RING_SIZE	4096
++#define DP_RXDMA_MONITOR_BUF_RING_SIZE	512
++#define DP_RXDMA_MONITOR_DST_RING_SIZE	128
++#define DP_RXDMA_MONITOR_DESC_RING_SIZE	128
+ 
+ #define DP_RX_BUFFER_SIZE	2048
+ #define	DP_RX_BUFFER_SIZE_LITE  1024

feeds/wifi-ax/mac80211/patches/pending/211-coldboot.patch

@@ -0,0 +1,13 @@
+Index: backports-20200902_001-4.4.60-931c337125/drivers/net/wireless/ath/ath11k/qmi.c
+===================================================================
+--- backports-20200902_001-4.4.60-931c337125.orig/drivers/net/wireless/ath/ath11k/qmi.c
++++ backports-20200902_001-4.4.60-931c337125/drivers/net/wireless/ath/ath11k/qmi.c
+@@ -16,7 +16,7 @@
+ #define HOST_CSTATE_BIT			0x04
+ 
+ /* set the default max assoc sta to max supported by driver */
+-bool enable_cold_boot_cal = 1;
++bool enable_cold_boot_cal = 0;
+ EXPORT_SYMBOL(enable_cold_boot_cal);
+ module_param(enable_cold_boot_cal, bool, 0644);
+ MODULE_PARM_DESC(enable_cold_boot_cal, "cold boot calibration enable:1 disable:0");

feeds/wifi-ax/mac80211/patches/qca/224-ath11k-update-HT-cap-to-disable-TX-STBC-with-single-antenna.patch

@@ -0,0 +1,55 @@
+--- a/drivers/net/wireless/ath/ath11k/mac.c
++++ b/drivers/net/wireless/ath/ath11k/mac.c
+@@ -4693,7 +4693,8 @@
+ }
+ 
+ static struct ieee80211_sta_ht_cap
+-ath11k_create_ht_cap(struct ath11k *ar, u32 ar_ht_cap, u32 rate_cap_rx_chainmask)
++ath11k_create_ht_cap(struct ath11k *ar, u32 ar_ht_cap,
++		     u32 rate_cap_tx_chainmask, u32 rate_cap_rx_chainmask)
+ {
+ 	int i;
+ 	struct ieee80211_sta_ht_cap ht_cap = {0};
+@@ -4724,7 +4725,7 @@
+ 		ht_cap.cap |= smps;
+ 	}
+ 
+-	if (ar_ht_cap & WMI_HT_CAP_TX_STBC)
++	if ((ar_ht_cap & WMI_HT_CAP_TX_STBC) && (rate_cap_tx_chainmask > 1))
+ 		ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
+ 
+ 	if (ar_ht_cap & WMI_HT_CAP_RX_STBC) {
+@@ -4903,6 +4904,7 @@
+ 		if (ht_cap_info)
+ 			*ht_cap_info = ht_cap;
+ 		band->ht_cap = ath11k_create_ht_cap(ar, ht_cap,
++						    rate_cap_tx_chainmask,
+ 						    rate_cap_rx_chainmask);
+ 
+ 		band->vht_cap = ath11k_create_vht_cap(ar, rate_cap_tx_chainmask,
+@@ -4915,10 +4917,25 @@
+ 		if (ht_cap_info)
+ 			*ht_cap_info = ht_cap;
+ 		band->ht_cap = ath11k_create_ht_cap(ar, ht_cap,
++						    rate_cap_tx_chainmask,
+ 						    rate_cap_rx_chainmask);
+ 		band->vht_cap = ath11k_create_vht_cap(ar, rate_cap_tx_chainmask,
+ 						      rate_cap_rx_chainmask);
+ 	}
++
++	if (ar->hw->wiphy->bands[NL80211_BAND_5GHZ]) {
++		ar->hw->wiphy->bands[NL80211_BAND_5GHZ]->ht_cap.cap =
++			ar->mac.sbands[NL80211_BAND_5GHZ].ht_cap.cap;
++		ar->hw->wiphy->bands[NL80211_BAND_5GHZ]->vht_cap.cap =
++			ar->mac.sbands[NL80211_BAND_5GHZ].vht_cap.cap;
++	}
++	if (ar->hw->wiphy->bands[NL80211_BAND_2GHZ]) {
++		ar->hw->wiphy->bands[NL80211_BAND_2GHZ]->ht_cap.cap =
++			ar->mac.sbands[NL80211_BAND_2GHZ].ht_cap.cap;
++		ar->hw->wiphy->bands[NL80211_BAND_2GHZ]->vht_cap.cap =
++			ar->mac.sbands[NL80211_BAND_2GHZ].vht_cap.cap;
++	}
++
+ }
+ 
+ static int ath11k_check_chain_mask(struct ath11k *ar, u32 ant, bool is_tx_ant)

feeds/wifi-trunk/ath10k-ct/Makefile

@@ -8,8 +8,8 @@ PKG_LICENSE_FILES:=
 
 PKG_SOURCE_URL:=https://github.com/greearb/ath10k-ct.git
 PKG_SOURCE_PROTO:=git
-PKG_SOURCE_DATE:=2020-08-26
-PKG_SOURCE_VERSION:=13319ff0b5dc3c86e8313f49fca583b829878736
+PKG_SOURCE_DATE:=2021-05-22b
+PKG_SOURCE_VERSION:=54a9ac02f1139596ea4361ebbc3e444955d86cfd
 #PKG_MIRROR_HASH:=97cf22a4a57381c7eb7a9b8a8b1e347e9711ce51c89db971b4ab9a35af476ece
 
 # Build the 5.4 ath10k-ct driver version.  Other option is "-4.19".

feeds/wifi-trunk/hostapd/files/hostapd.sh

@@ -47,8 +47,18 @@ hostapd_append_wpa_key_mgmt() {
 			[ "${ieee80211w:-0}" -gt 0 ] && append wpa_key_mgmt "WPA-${auth_type_l}-SHA256"
 			[ "${ieee80211ai:-0}" -gt 0 ] && append wpa_key_mgmt "FILS-SHA256"
 		;;
+		eap-only)
+			append wpa_key_mgmt "WPA-EAP-SHA256"
+			[ "${ieee80211r:-0}" -gt 0 ] && append wpa_key_mgmt "FT-EAP"
+		;;
+		eap-transition)
+			append wpa_key_mgmt "WPA-EAP"
+			append wpa_key_mgmt "WPA-EAP-SHA256"
+			[ "${ieee80211r:-0}" -gt 0 ] && append wpa_key_mgmt "FT-EAP"
+		;;
 		eap192)
 			append wpa_key_mgmt "WPA-EAP-SUITE-B-192"
+			[ "${ieee80211w:-0}" -gt 0 ] && append wpa_key_mgmt "WPA-EAP-SHA256"
 			[ "${ieee80211r:-0}" -gt 0 ] && append wpa_key_mgmt "FT-EAP"
 		;;
 		eap-eap192)
@@ -294,15 +304,17 @@ hostapd_common_add_bss_config() {
 	config_add_string osu_ssid hs20_wan_metrics hs20_operating_class hs20_t_c_filename hs20_t_c_timestamp
 
 	config_add_boolean interworking internet
-	config_add_int access_network_type asra esr uesa venue_group venue_type ipaddr_type_availability \
+	config_add_int access_network_type asra esr uesa venue_group venue_type \
 		gas_address3
-	config_add_string hessid network_auth_type \
+	config_add_string hessid network_auth_type ipaddr_type_availability \
 		anqp_3gpp_cell_net anqp_elem domain_name qos_map_set hs20_t_c_server_url
 
 	config_add_int airtime_bss_weight airtime_bss_limit
 	config_add_int rts_threshold
 	config_add_array radius_auth_req_attr
 	config_add_array radius_acct_req_attr
+
+	config_add_boolean multicast_to_unicast proxy_arp
 }
 
 hostapd_set_vlan_file() {
@@ -446,7 +458,8 @@ hostapd_set_bss_options() {
 		bss_load_update_period chan_util_avg_period sae_require_mfp \
 		multi_ap multi_ap_backhaul_ssid multi_ap_backhaul_key \
 		airtime_bss_weight airtime_bss_limit \
-		rssi_reject_assoc_rssi rssi_ignore_probe_request rts_threshold 
+		rssi_reject_assoc_rssi rssi_ignore_probe_request rts_threshold \
+		proxy_arp multicast_to_unicast
 
 	set_default isolate 0
 	set_default maxassoc 0
@@ -474,6 +487,9 @@ hostapd_set_bss_options() {
 	set_default signal_poll_time 5
 	set_default signal_drop_reason 3
 	set_default signal_strikes 3
+	set_default proxy_arp 0
+	set_default multicast_to_unicast 0
+
 
 	append bss_conf "ctrl_interface=/var/run/hostapd"
 	if [ "$isolate" -gt 0 ]; then
@@ -507,6 +523,9 @@ hostapd_set_bss_options() {
 	append bss_conf "signal_strikes=$signal_strikes" "$N"
 	append bss_conf "signal_drop_reason=$signal_drop_reason" "$N"
 
+	[ -n "$proxy_arp" ] && append bss_conf "proxy_arp=$proxy_arp" "$N"
+	[ -n "$multicast_to_unicast" ] && append bss_conf "multicast_to_unicast=$multicast_to_unicast" "$N"
+
 	[ "$tdls_prohibit" -gt 0 ] && append bss_conf "tdls_prohibit=$tdls_prohibit" "$N"
 
 	[ "$wpa" -gt 0 ] && {
@@ -529,11 +548,11 @@ hostapd_set_bss_options() {
 	}
 
 	case "$auth_type" in
-		sae|owe|eap192|eap-eap192)
+		sae|owe|eap192|eap-eap192|eap-only)
 			set_default ieee80211w 2
 			set_default sae_require_mfp 1
 		;;
-		psk-sae)
+		psk-sae|eap-transition)
 			set_default ieee80211w 1
 			set_default sae_require_mfp 1
 		;;
@@ -575,7 +594,7 @@ hostapd_set_bss_options() {
 			vlan_possible=1
 			wps_possible=1
 		;;
-		eap|eap192|eap-eap192)
+		eap|eap192|eap-eap192|eap-only|eap-transition)
 			json_get_vars \
 				auth_server auth_secret auth_port \
 				dae_client dae_secret dae_port \
@@ -863,14 +882,22 @@ hostapd_set_bss_options() {
 	set_default hs20 0
 	set_default disable_dgaf $hs20
 	set_default osen 0
+	set_default internet 0
+	set_default asra 0
+	set_default esr 0
+	set_default uesa 0
 	set_default anqp_domain_id 0
+	set_default access_network_type 0
+	set_default venue_group 0
+	set_default venue_type 0
+	set_default gas_address3 0
 	set_default hs20_deauth_req_timeout 60
 	if [ "$hs20" = "1" ]; then
 		append bss_conf "hs20=1" "$N"
 		append_hs20_icons
 		[ -n "$disable_dgaf"] && append bss_conf "disable_dgaf=$disable_dgaf" "$N"
 		[ -n "$osen"] && append bss_conf "osen=$osen" "$N"
-		[ -n "$anqp_domain_id"] && append bss_conf "anqp_domain_id=$anqp_domain_id" "$N"
+		[ "$anqp_domain_id" -gt 0 ] && append bss_conf "anqp_domain_id=$anqp_domain_id" "$N"
 		[ -n "$hs20_deauth_req_timeout"] && append bss_conf "hs20_deauth_req_timeout=$hs20_deauth_req_timeout" "$N"
 		[ -n "$osu_ssid" ] && append bss_conf "osu_ssid=$osu_ssid" "$N"
 		[ -n "$hs20_wan_metrics" ] && append bss_conf "hs20_wan_metrics=$hs20_wan_metrics" "$N"
@@ -887,15 +914,15 @@ hostapd_set_bss_options() {
 		json_for_each_item append_osu_provider osu_provider
 		json_for_each_item append_operator_icon operator_icon
 		[ -n "$interworking" ] && append bss_conf "interworking=$interworking" "$N"
-		[ -n "$internet" ] && append bss_conf "internet=$internet" "$N"
-		[ -n "$access_network_type" ] && append bss_conf "access_network_type=$access_network_type" "$N"
-		[ -n "$asra" ] && append bss_conf "asra=$asra" "$N"
-		[ -n "$esr" ] && append bss_conf "esr=$esr" "$N"
-		[ -n "$uesa" ] && append bss_conf "uesa=$uesa" "$N"
-		[ -n "$venue_group" ] && append bss_conf "venue_group=$venue_group" "$N"
-		[ -n "$venue_type" ] && append bss_conf "venue_type=$venue_type" "$N"
+		[ "$internet" -gt 0 ] && append bss_conf "internet=$internet" "$N"
+		[ "$access_network_type" -gt 0 ] && append bss_conf "access_network_type=$access_network_type" "$N"
+		[ "$asra" -gt 0 ] && append bss_conf "asra=$asra" "$N"
+		[ "$esr" -gt 0 ] && append bss_conf "esr=$esr" "$N"
+		[ "$uesa" -gt 0 ] && append bss_conf "uesa=$uesa" "$N"
+		[ "$venue_group" -gt 0 ] && append bss_conf "venue_group=$venue_group" "$N"
+		[ "$venue_type" -gt 0 ] && append bss_conf "venue_type=$venue_type" "$N"
 		[ -n "$ipaddr_type_availability" ] && append bss_conf "ipaddr_type_availability=$ipaddr_type_availability" "$N"
-		[ -n "$gas_address3" ] && append bss_conf "gas_address3=$gas_address3" "$N"
+		[ "$gas_address3" -gt 0 ] && append bss_conf "gas_address3=$gas_address3" "$N"
 		[ -n "$hessid" ] && append bss_conf "hessid=$hessid" "$N"
 		[ -n "$network_auth_type" ] && append bss_conf "network_auth_type=$network_auth_type" "$N"
 		[ -n "$anqp_3gpp_cell_net" ] && append bss_conf "anqp_3gpp_cell_net=$anqp_3gpp_cell_net" "$N"

feeds/wifi-trunk/hostapd/patches/901-hapd-ubus-channel-switch.patch

@@ -1,7 +1,5 @@
-Index: hostapd-2020-06-08-5a8b3662/src/ap/dfs.c
-===================================================================
---- hostapd-2020-06-08-5a8b3662.orig/src/ap/dfs.c
-+++ hostapd-2020-06-08-5a8b3662/src/ap/dfs.c
+--- a/src/ap/dfs.c
++++ b/src/ap/dfs.c
 @@ -18,7 +18,7 @@
  #include "drivers/driver.h"
  #include "dfs.h"
@@ -23,10 +21,8 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/dfs.c
  	if (err) {
  		wpa_printf(MSG_WARNING, "DFS failed to schedule CSA (%d) - trying fallback",
  			   err);
-Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.c
-===================================================================
---- hostapd-2020-06-08-5a8b3662.orig/src/ap/ubus.c
-+++ hostapd-2020-06-08-5a8b3662/src/ap/ubus.c
+--- a/src/ap/ubus.c
++++ b/src/ap/ubus.c
 @@ -29,6 +29,8 @@ static int ctx_ref;
  static char** bss_lst = NULL;
  static size_t bss_nr = 0;
@@ -36,7 +32,7 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.c
  static inline struct hapd_interfaces *get_hapd_interfaces_from_object(struct ubus_object *obj)
  {
  	return container_of(obj, struct hapd_interfaces, ubus);
-@@ -714,6 +716,43 @@ static int hostapd_sessions(struct ubus_
+@@ -714,6 +716,44 @@ static int hostapd_sessions(struct ubus_
  	return 0;
  }
  
@@ -48,7 +44,7 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.c
 +{
 +	void *a = NULL;
 +	void *t = NULL;
-+	struct hostapd_chan_event_list *entry;
++	struct hostapd_chan_event_list *entry, *tmp;
 +
 +	blob_buf_init(&b_ev, 0);
 +	a = blobmsg_open_table(&b_ev, "chan_switch_event");
@@ -68,9 +64,10 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.c
 +	/*delete list*/
 +
 +	if (!list_empty(&chan_events)) {
-+	list_for_each_entry(entry, &chan_events, list)
++	list_for_each_entry_safe(entry, tmp, &chan_events, list)
 +		{
 +			list_del(&entry->list);
++			free(entry);
 +		}
 +	}
 +
@@ -80,7 +77,7 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.c
  static int
  hostapd_switch_chan(struct ubus_context *ctx, struct ubus_object *obj,
  		    struct ubus_request_data *req, const char *method,
-@@ -749,6 +788,9 @@ hostapd_switch_chan(struct ubus_context
+@@ -749,6 +789,9 @@ hostapd_switch_chan(struct ubus_context
  
  	if (hostapd_switch_channel(hapd, &css) != 0)
  		return UBUS_STATUS_NOT_SUPPORTED;
@@ -90,7 +87,7 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.c
  	return UBUS_STATUS_OK;
  #undef SET_CSA_SETTING
  }
-@@ -1444,6 +1486,7 @@ static const struct ubus_method daemon_m
+@@ -1444,6 +1487,7 @@ static const struct ubus_method daemon_m
  	UBUS_METHOD("config_add", hostapd_config_add, config_add_policy),
  	UBUS_METHOD("config_remove", hostapd_config_remove, config_remove_policy),
  	UBUS_METHOD_NOARG("get_bss_list", hostapd_get_bss_list),
@@ -98,7 +95,7 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.c
  };
  
  static struct ubus_object_type daemon_object_type =
-@@ -1507,6 +1550,28 @@ ubus_event_cb(struct ubus_notify_request
+@@ -1507,6 +1551,28 @@ ubus_event_cb(struct ubus_notify_request
  	ureq->resp = ret;
  }
  
@@ -127,10 +124,8 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.c
  int hostapd_ubus_handle_rt_event(struct hostapd_data *hapd,
  				 struct hostapd_ubus_request *req)
  {
-Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.h
-===================================================================
---- hostapd-2020-06-08-5a8b3662.orig/src/ap/ubus.h
-+++ hostapd-2020-06-08-5a8b3662/src/ap/ubus.h
+--- a/src/ap/ubus.h
++++ b/src/ap/ubus.h
 @@ -17,9 +17,15 @@ enum hostapd_ubus_event_type {
  	HOSTAPD_UBUS_DEAUTH_REQ,
  	HOSTAPD_UBUS_FDATA_REQ,
@@ -140,8 +135,8 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.h
  };
  
 +enum hostapd_ubus_chan_event_reason {
-+	HOSTAPD_UBUS_HIGH_INTERFERENCE,
-+	HOSTAPD_UBUS_DFS_SWITCH
++	HOSTAPD_UBUS_DFS_SWITCH,
++	HOSTAPD_UBUS_HIGH_INTERFERENCE
 +};
 +
  struct hostapd_ubus_request {

feeds/wifi-trunk/hostapd/patches/902-ubus-multi-bss-chan-switch.patch

@@ -0,0 +1,23 @@
+--- a/src/ap/ubus.c
++++ b/src/ap/ubus.c
+@@ -762,6 +762,7 @@ hostapd_switch_chan(struct ubus_context
+ 	struct blob_attr *tb[__CSA_MAX];
+ 	struct hostapd_data *hapd = get_hapd_from_object(obj);
+ 	struct csa_settings css;
++	int i;
+ 
+ 	blobmsg_parse(csa_policy, __CSA_MAX, tb, blob_data(msg), blob_len(msg));
+ 
+@@ -787,8 +788,10 @@ hostapd_switch_chan(struct ubus_context
+ 	SET_CSA_SETTING(CSA_BLOCK_TX, block_tx, bool);
+ 
+ 
+-	if (hostapd_switch_channel(hapd, &css) != 0)
+-		return UBUS_STATUS_NOT_SUPPORTED;
++	for (i = 0; i < hapd->iface->num_bss; i++) {
++		if (hostapd_switch_channel(hapd->iface->bss[i], &css) != 0)
++			return UBUS_STATUS_NOT_SUPPORTED;
++	}
+ 
+ 	hostapd_ubus_handle_channel_switch_event(hapd->iface,HOSTAPD_UBUS_HIGH_INTERFERENCE,  css.freq_params.freq);
+ 

feeds/wifi-trunk/mac80211/files/lib/netifd/wireless/mac80211.sh

@@ -174,6 +174,11 @@ mac80211_hostapd_setup_base() {
 		[ "$rx_stbc" -lt "$cap_rx_stbc" ] && cap_rx_stbc="$rx_stbc"
 		ht_cap_mask="$(( ($ht_cap_mask & ~(0x300)) | ($cap_rx_stbc << 8) ))"
 
+		conf_tx_ant=$(iw phy "$phy" info | grep 'Configured Antennas:' | cut -d: -f2)
+		set -- $conf_tx_ant
+		if [ "$2" == "0x1" -o "$2" == "0x10" ]; then
+			tx_stbc=0
+		fi
 		mac80211_add_capabilities ht_capab_flags $ht_cap_mask \
 			LDPC:0x1::$ldpc \
 			GF:0x10::$greenfield \
@@ -263,6 +268,11 @@ mac80211_hostapd_setup_base() {
 		[ "$rx_stbc" -lt "$cap_rx_stbc" ] && cap_rx_stbc="$rx_stbc"
 		vht_cap="$(( ($vht_cap & ~(0x700)) | ($cap_rx_stbc << 8) ))"
 
+		conf_tx_ant=$(iw phy "$phy" info | grep 'Configured Antennas:' | cut -d: -f2)
+		set -- $conf_tx_ant
+		if [ "$2" == "0x1" -o "$2" == "0x10" ]; then
+			tx_stbc_2by1=0
+		fi
 		mac80211_add_capabilities vht_capab $vht_cap \
 			RXLDPC:0x10::$rxldpc \
 			SHORT-GI-80:0x20::$short_gi_80 \

feeds/wlan-ap/apc/Makefile

@@ -11,7 +11,7 @@ include $(INCLUDE_DIR)/package.mk
 
 define Package/apc
   SECTION:=base
-  DEPENDS:=+libev +libinterapcomm
+  DEPENDS:=+libev +libinterapcomm +libubus +libubox
   CATEGORY:=Base system
   TITLE:=Access Point Coordinator
 endef
@@ -33,5 +33,11 @@ endef
 define Package/apc/install
 	$(INSTALL_DIR) $(1)/usr/bin
 	$(INSTALL_DATA) $(PKG_BUILD_DIR)/apc $(1)/usr/bin
+	chmod 0700 $(1)/usr/bin/apc
+	$(INSTALL_DIR) $(1)/etc/init.d
+	$(INSTALL_BIN) ./files/apc.init $(1)/etc/init.d/apc
+	$(INSTALL_DIR) $(1)/etc/config
+	$(INSTALL_BIN) ./files/apc.config $(1)/etc/config/apc
+
 endef
 $(eval $(call BuildPackage,apc))

feeds/wlan-ap/apc/files/apc.init

@@ -0,0 +1,20 @@
+#!/bin/sh /etc/rc.common
+
+USE_PROCD=1
+START=40
+STOP=40
+
+PROG="/usr/bin/apc"
+
+start_service() {
+    procd_open_instance
+    echo "Starting APC"
+    procd_set_param command ${PROG}
+    procd_set_param respawn
+    procd_close_instance
+}
+
+stop_service() {
+    echo "Killing APC"
+    killall -s SIGTERM apc
+}

feeds/wlan-ap/apc/src/Makefile

@@ -3,19 +3,21 @@ srcdir ?= .
 VPATH ?= $(srcdir)/src
 
 
-LIBS = -lpthread -lrt -linterapcomm -lev
+LIBS = -lpthread -lrt -linterapcomm -lev -lubus -lubox
 $(call output,usr/sbin/wc-apc)
 
 CFLAGS += -I./include/ \
 	-I../include/
 
+CFLAGS += -DUBUS_SUPPORT
+
 CFLAGS  += -Wall -g
 CFLAGS += -MMD -Wall -g -Wpointer-arith -Wcast-qual -Wshadow \
 				-Waggregate-return -Wnested-externs -Wstrict-prototypes \
 				-fno-omit-frame-pointer -g -rdynamic -fexceptions -funwind-tables -funsigned-char
 
 OBJS := apc_main.o \
-               hello.o iface.o neighbor.o apc.o
+               hello.o iface.o neighbor.o apc.o ubus.o
 
 all: apc
 

feeds/wlan-ap/apc/src/include/apc.h

@@ -262,6 +262,8 @@ struct apc_neighbor
 #define APC_IS_DROTHER 4   /* I'm on BCAST or NBMA and I'm not DR */
 #define APC_IS_BACKUP  5   /* I'm BDR */
 #define APC_IS_DR      6   /* I'm DR */
+#define APC_MAX_MODE   7
+
 
 /* Definitions for interface state machine */
 #define ISM_UP      0   /* Interface Up */

feeds/wlan-ap/apc/src/include/lib/timer.h

@@ -30,4 +30,9 @@ static inline timer * tm_new_set( void (*hook)(struct _timer *), void *data, uns
     return t;
 }
 
+static inline void tm_free(timer *t)
+{
+    free(t);
+}
+
 #endif

feeds/wlan-ap/apc/src/include/ubus.h

@@ -0,0 +1,22 @@
+/*
+ * netifd - network interface daemon
+ * Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#ifndef __NETIFD_UBUS_H
+#define __NETIFD_UBUS_H
+
+extern struct ubus_context *ubus_ctx;
+
+int ubus_init();
+void ubus_done(void);
+
+#endif

feeds/wlan-ap/apc/src/src/apc.c

@@ -26,7 +26,8 @@ static void apc_dump( struct proto * P )
 static struct proto * apc_init(struct proto_config * c)
 {
 	struct proto * P = mb_allocz(sizeof(struct apc_proto));
-	
+
+	printf("apc_init\n");
 	P->cf = c;
 	P->debug = c->debug;
 	P->mrtdump = c->mrtdump;

feeds/wlan-ap/apc/src/src/apc_main.c

@@ -21,9 +21,11 @@
 #include <nest/apcn.h>
 #include <apc.h>
 #include <protocol.h>
+#include <ubus.h>
 
-static ev_io iac_io;
-static ev_timer  check_timer;
+#include <libubus.h>
+static struct uloop_timeout check_timer;
+static void check_timer_handler(struct uloop_timeout *timeout);
 static unsigned int CheckIp;
 static int CheckCount;
 
@@ -228,8 +230,7 @@ int set_socket(void)
 /*************************************/
 
 
-static void check_timer_handler(struct ev_loop *loop, ev_timer *timer,
-				 int revents) 
+static void check_timer_handler(struct uloop_timeout *timeout)
 {
 	timers_go();
 	if (WaitingToReelect)
@@ -252,29 +253,56 @@ static void check_timer_handler(struct ev_loop *loop, ev_timer *timer,
 		if (CheckIp && (MyIpAddr != CheckIp))
 		{
 			printf("IP address changed from %x to %x - restart APC election\n", MyIpAddr, CheckIp);
+			system("/usr/opensync/bin/ovsh u APC_State dr_addr:=0.0.0.0 bdr_addr:=0.0.0.0 enabled:=false mode:=NC");
+			uloop_done();
+			ubus_done();
+			interap_rcv_close();
 			exit(0);
 		}
 		
 		CheckCount = 0;
-		if (ApcSpecSaved.IsApc == I_AM_APC)
-		{
-		//Radius stuff
-		}
 	}
+
+	uloop_timeout_set(&check_timer, 1000);
+	uloop_timeout_add(&check_timer);
+
 }
 
+static void handle_signal(int signo)
+{
+	uloop_done();
+	ubus_done();
+	interap_rcv_close();
+	system("/usr/opensync/bin/ovsh u APC_State dr_addr:=0.0.0.0 bdr_addr:=0.0.0.0 enabled:=false mode:=NC");
+}
+
+static void set_signals(void)
+{
+	struct sigaction s;
+
+	memset(&s, 0, sizeof(s));
+	s.sa_handler = handle_signal;
+	s.sa_flags = 0;
+	sigaction(SIGINT, &s, NULL);
+	sigaction(SIGTERM, &s, NULL);
+	sigaction(SIGPIPE, &s, NULL);
+}
+
+extern struct ubus_context *ubus_ctx;
+
 int main(int argc, char *const* argv)
 {
 	struct proto_config c;
 	struct proto * apc_proto;
-	struct ev_loop *loop = EV_DEFAULT;
+	uloop_init();
+	/*init term signals*/
+	set_signals();
 
 	/*Socket*/
 	set_socket();
 
 	/*Radius stuff*/
 
-	printf("Basic MAC\n");
 	memset(MyBasicMac, 0, 6);
 	if (get_mac_addr("br-wan", MyBasicMac) == 0) {
 		printf("APC: br-wan mac:%02X:%02X:%02X:%02X:%02X:%02X\n",
@@ -291,6 +319,7 @@ int main(int argc, char *const* argv)
 
 	/*get local ip of br-wan*/
 	MyIpAddr = 0;
+	printf("Getting br-wan IP\n");
 	while(1)
 	{
 		GetLocalIpv4Addr((unsigned char *)&MyIpAddr, "br-wan");
@@ -303,9 +332,13 @@ int main(int argc, char *const* argv)
 
 	/*listening interAP*/
 	callback cb = receive_from_socket;
+
 	if (interap_recv(IAC_APC_ELECTION_PORT, cb, 1000,
-			 loop, &iac_io) < 0)
+			 NULL, NULL) < 0) {
 		printf("Error: Failed InterAP receive");
+		return 1;
+	}
+
 
 	memset(Timers, 0, sizeof(Timers));
 	
@@ -319,11 +352,15 @@ int main(int argc, char *const* argv)
 	ApcProto = (struct apc_proto *)apc_proto;
 	proto_apc.start(apc_proto);
 
-	ev_timer_init(&check_timer, check_timer_handler, 1, 1);
+	check_timer.cb = check_timer_handler;
+	uloop_timeout_set(&check_timer, 1000);
+	uloop_timeout_add(&check_timer);
 
-	ev_timer_start(loop, &check_timer);
-
-	ev_run(loop, 0);
+	ubus_init();
+	uloop_run();
+	uloop_done();
+	ubus_done();
+	interap_rcv_close();
 
 	return(1);
 }

feeds/wlan-ap/apc/src/src/hello.c

@@ -103,6 +103,7 @@ void apc_send_hello(struct apc_iface * ifa, int kind )
 	struct apc_hello2_packet ps;
 	unsigned int length, report = 0;
 	struct apc_spec ApcSpec;
+	char dst_ip[16];
 	
 	if (WaitingToReelect )
 		return;
@@ -188,8 +189,11 @@ void apc_send_hello(struct apc_iface * ifa, int kind )
 			else
 				ApcSpec.FloatIp = ApcSpecSaved.FloatIp;
 		}
-		else
+		else if (ApcSpec.IsApc == I_AM_BAPC )
 		{
+			ifa->priority = 0x12;
+		}
+		else {
 			ifa->priority = 0x11;
 			if ((ApcSpecSaved.IsApc == I_AM_APC) || BackingUpRadius )
 			{
@@ -202,8 +206,7 @@ void apc_send_hello(struct apc_iface * ifa, int kind )
 
 	length += i * sizeof(u32);
 
-	printf("HELLO packet sent via %s\n", ifa->ifname );
-	char *dst_ip = malloc(16);
+	printf("HELLO packet sent via  %s\n", ifa->ifname );
 	memset(dst_ip, 0, 16);
 	if ((get_current_ip(dst_ip, IAC_IFACE)) < 0) {
 		printf("Error: Cannot get IP for %s", IAC_IFACE);

feeds/wlan-ap/apc/src/src/iface.c

@@ -65,7 +65,7 @@ void apc_iface_chstate(struct apc_iface * ifa, u8 state)
 	
 	if (state == oldstate)
 		return;
-	
+
 	printf("Interface %s changed state from %s to %s\n",
 		ifa->ifname, apc_is_names[oldstate], apc_is_names[state]);
 	

feeds/wlan-ap/apc/src/src/neighbor.c

@@ -33,11 +33,10 @@ reset_lists(struct apc_proto *p, struct apc_neighbor *n)
 {
 }
 
-
 struct apc_neighbor * apc_neighbor_new(struct apc_iface * ifa)
 {
 	struct apc_neighbor * n = mb_allocz(sizeof(struct apc_neighbor));
-	
+	printf("apc_new_neighbor\n");	
 	n->ifa = ifa;
 	add_tail(&ifa->neigh_list, NODE n);
 	n->adj = 0;
@@ -52,7 +51,6 @@ struct apc_neighbor * apc_neighbor_new(struct apc_iface * ifa)
 	return(n);
 }
 
-
 static void apc_neigh_down(struct apc_neighbor * n)
 {
 	struct apc_iface * ifa = n->ifa;
@@ -60,9 +58,10 @@ static void apc_neigh_down(struct apc_neighbor * n)
 	rem_node(NODE n);
 	
 	printf("Neighbor %x on %s removed", n->rid, ifa->ifname );
+	tm_free(n->inactim);
+	mb_free(n);
 }
 
-
 /**
  * apc_neigh_chstate - handles changes related to new or lod state of neighbor
  * @n: APC neighbor
@@ -81,7 +80,8 @@ static void apc_neigh_chstate(struct apc_neighbor * n, u8 state)
 		return;
 	
 	printf("Neighbor %x on %s changed state from %s to %s\n",
-	                n->rid, ifa->ifname, apc_ns_names[old_state], apc_ns_names[state] );
+	                n->rid, ifa->ifname, apc_ns_names[old_state],
+			apc_ns_names[state]);
 	
 	n->state = state;
 
@@ -121,7 +121,6 @@ static void apc_neigh_chstate(struct apc_neighbor * n, u8 state)
 		apc_iface_sm(ifa, ISM_NEICH);
 }
 
-
 /**
  * apc_neigh_sm - apc neighbor state machine
  * @n: neighor
@@ -218,7 +217,6 @@ void apc_neigh_sm(struct apc_neighbor * n, int event)
 	}
 }
 
-
 static int can_do_adj(struct apc_neighbor * n)
 {
 	struct apc_iface * ifa = n->ifa;
@@ -257,13 +255,11 @@ static int can_do_adj(struct apc_neighbor * n)
 	return i;
 }
 
-
 static inline u32 neigh_get_id(struct apc_proto *p, struct apc_neighbor *n)
 {
 	return ipa_to_u32(n->ip);
 }
 
-
 static struct apc_neighbor * elect_bdr( struct apc_proto * p, list nl)
 {
     struct apc_neighbor *neigh, *n1, *n2;
@@ -271,7 +267,7 @@ static struct apc_neighbor * elect_bdr( struct apc_proto * p, list nl)
 
     n1 = NULL;
     n2 = NULL;
-    WALK_LIST( neigh, nl )                      /* First try those decl. themselves */
+    WALK_LIST( neigh, nl )                /* First try those decl. themselves */
     {
         nid = neigh_get_id( p, neigh );
 
@@ -317,7 +313,6 @@ static struct apc_neighbor * elect_bdr( struct apc_proto * p, list nl)
     return( n1 );
 }
 
-
 static struct apc_neighbor * elect_dr( struct apc_proto * p, list nl )
 {
     struct apc_neighbor *neigh, *n;
@@ -351,7 +346,6 @@ static struct apc_neighbor * elect_dr( struct apc_proto * p, list nl )
     return( n );
 }
 
-
 /**
  * apc_dr_election - (Backup) Designed Router election
  * @ifa: actual interface
@@ -450,7 +444,6 @@ void apc_dr_election(struct apc_iface * ifa)
 	}
 }
 
-
 struct apc_neighbor * find_neigh_by_ip(struct apc_iface * ifa, ip_addr ip)
 {
 	struct apc_neighbor * n;
@@ -463,7 +456,6 @@ struct apc_neighbor * find_neigh_by_ip(struct apc_iface * ifa, ip_addr ip)
 	return NULL;
 }
 
-
 static void inactivity_timer_hook(struct _timer * tmr)
 {
 	struct apc_neighbor * n = (struct apc_neighbor *) tmr->data;
@@ -490,10 +482,13 @@ static void inactivity_timer_hook(struct _timer * tmr)
 			n_neigh += 1;
 			//Radius stuff
 			BackingUpRadius = 1;
+			apc_ifa->priority = 0x33;
 		}
+		else
+			apc_ifa->priority = 0x11;
+
 
 		apc_ifa->drip = MyIpAddr;
-		apc_ifa->priority = 0x11;
 		apc_ifa->bdrip = 0;
 		memset(&ApcSpec, 0, sizeof(struct apc_spec));
 		WaitingToReelect = 12;

feeds/wlan-ap/apc/src/src/ubus.c

@@ -0,0 +1,177 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+#define _GNU_SOURCE
+
+#include <arpa/inet.h>
+#include <string.h>
+#include <stdio.h>
+#include <ev.h>
+#include "ubus.h"
+#include <libubus.h>
+#include <libubox/blobmsg.h>
+#include <apc.h>
+#include <libubox/uloop.h>
+
+struct ubus_context *ubus_ctx = NULL;
+static struct blob_buf b;
+static struct blob_buf nb;
+static const char *ubus_path;
+timer *notify_timer;
+extern struct apc_iface * apc_ifa;
+#define APC_NOTIFY_INTERVAL 10
+
+struct apc_state {
+	char mode[4];
+	char dr_addr[17];
+	char bdr_addr[17];
+	bool enabled;
+} state;
+
+static int
+apc_info_handle(struct ubus_context *ctx, struct ubus_object *obj,
+			  struct ubus_request_data *req, const char *method,
+			  struct blob_attr *msg);
+
+static void ubus_reconnect_timer(struct uloop_timeout *timeout);
+static struct uloop_timeout reconnect = {
+	.cb = ubus_reconnect_timer,
+};
+
+static void ubus_reconnect_timer(struct uloop_timeout *timeout)
+{
+        if (ubus_reconnect(ubus_ctx, NULL) != 0) {
+                printf("APC ubus failed to reconnect\n");
+                uloop_timeout_set(&reconnect, 2000);
+                return;
+        }
+
+        printf("APC ubus reconnected\n");
+#ifdef FD_CLOEXEC
+	fcntl(ubus_ctx->sock.fd, F_SETFD,
+	      fcntl(ubus_ctx->sock.fd, F_GETFD) | FD_CLOEXEC);
+#endif
+}
+
+static void ubus_connection_lost(struct ubus_context *ctx)
+{
+	printf("APC ubus connection lost\n");
+        ubus_reconnect_timer(NULL);
+}
+
+static const struct blobmsg_policy apc_policy = {
+	.name = "info",
+	.type = BLOBMSG_TYPE_STRING,
+};
+
+static struct ubus_method apc_object_methods[] = {
+	UBUS_METHOD_NOARG("info", apc_info_handle),
+};
+
+static struct ubus_object_type apc_object_type =
+	UBUS_OBJECT_TYPE("apc", apc_object_methods);
+
+static struct ubus_object apc_object = {
+	.name = "apc",
+	.type = &apc_object_type,
+	.methods = apc_object_methods,
+	.n_methods = ARRAY_SIZE(apc_object_methods),
+};
+
+static int
+apc_info_handle(struct ubus_context *ctx, struct ubus_object *obj,
+			  struct ubus_request_data *req, const char *method,
+			  struct blob_attr *msg)
+{
+	blob_buf_init(&b, 0);
+	blobmsg_add_string(&b, "mode", state.mode);
+	blobmsg_add_string(&b, "dr_addr", state.dr_addr);
+	blobmsg_add_string(&b, "bdr_addr", state.bdr_addr);
+	blobmsg_add_u8(&b, "enabled", state.enabled);
+
+	ubus_notify(ctx, &apc_object, "apc", b.head, -1);
+	ubus_send_event(ctx, "apc", b.head);
+	ubus_send_reply(ctx, req, b.head);
+
+	return 0;
+}
+
+static char apc_mode[APC_MAX_MODE][8] = {"DOWN", "LOOP", "WT", "PTP", "OR", "BDR", "DR"};
+void apc_update_state()
+{
+	struct in_addr dr_addr;
+	struct in_addr bdr_addr;
+	dr_addr.s_addr = htonl(apc_ifa->drip);
+	bdr_addr.s_addr = htonl(apc_ifa->bdrip);
+
+	state.enabled = true;
+	if ((apc_ifa->state == APC_IS_DR) ||
+	    (apc_ifa->state == APC_IS_BACKUP) ||
+	    (apc_ifa->state == APC_IS_DROTHER)) {
+		snprintf(state.mode, sizeof(state.mode), "%s",
+			 &apc_mode[apc_ifa->state][0]);
+		snprintf(state.dr_addr, sizeof(state.dr_addr),
+			 "%s", inet_ntoa(dr_addr));
+		snprintf(state.bdr_addr, sizeof(state.bdr_addr),
+			 "%s", inet_ntoa(bdr_addr));
+	} else if (apc_ifa->state == APC_IS_WAITING) {
+		snprintf(state.mode, sizeof(state.mode), "%s",
+			 &apc_mode[apc_ifa->state][0]);
+		snprintf(state.dr_addr, sizeof(state.dr_addr), "0.0.0.0");
+		snprintf(state.bdr_addr, sizeof(state.bdr_addr), "0.0.0.0");
+	} else {
+		snprintf(state.mode, sizeof(state.mode), "NC");
+		snprintf(state.dr_addr, sizeof(state.dr_addr), "0.0.0.0");
+		snprintf(state.bdr_addr, sizeof(state.bdr_addr), "0.0.0.0");
+	}
+}
+
+void apc_send_notification(struct _timer * tmr)
+{
+	apc_update_state();
+
+	printf("APC send ubus notification\n");
+	blob_buf_init(&nb, 0);
+	blobmsg_add_string(&nb, "mode", state.mode);
+	blobmsg_add_string(&nb, "dr_addr", state.dr_addr);
+	blobmsg_add_string(&nb, "bdr_addr", state.bdr_addr);
+	blobmsg_add_u8(&nb, "enabled", state.enabled);
+	ubus_notify(ubus_ctx, &apc_object, "apc", nb.head, -1);
+}
+
+static void add_object(struct ubus_object *obj)
+{
+	int ret = ubus_add_object(ubus_ctx, obj);
+
+	if (ret != 0)
+		fprintf(stderr, "Add object fail '%s': %s\n",
+			obj->name, ubus_strerror(ret));
+}
+
+int
+ubus_init(void) {
+	ubus_ctx = ubus_connect(NULL);
+	if (!ubus_ctx)
+		return -EIO;
+
+	ubus_add_uloop(ubus_ctx);
+#ifdef FD_CLOEXEC
+	fcntl(ubus_ctx->sock.fd, F_SETFD,
+	      fcntl(ubus_ctx->sock.fd, F_GETFD) | FD_CLOEXEC);
+#endif
+	add_object(&apc_object);
+	notify_timer = tm_new_set(apc_send_notification, NULL,
+				  0, APC_NOTIFY_INTERVAL);
+	if (notify_timer) {
+		printf("APC Start notify timer\n");
+		tm_start(notify_timer, APC_NOTIFY_INTERVAL);
+	}
+
+	ubus_ctx->connection_lost = ubus_connection_lost;
+
+	return 0;
+}
+
+void
+ubus_done(void)
+{
+	ubus_free(ubus_ctx);
+}

feeds/wlan-ap/interAPcomm/Makefile

@@ -11,6 +11,7 @@ include $(INCLUDE_DIR)/package.mk
 
 define Package/libinterapcomm
   SECTION:=libs
+  DEPENDS:=+libev +libubox +libubus
   CATEGORY:=Libraries
   TITLE:=Inter AP communication library
 endef
@@ -29,5 +30,8 @@ endef
 define Package/libinterapcomm/install
 	$(INSTALL_DIR) $(1)/usr/lib
 	$(INSTALL_DATA) $(PKG_BUILD_DIR)/libinterapcomm.so $(1)/usr/lib/
+	$(INSTALL_DIR) $(1)/etc/init.d
+	$(INSTALL_BIN) ./files/interap.init $(1)/etc/init.d/interap
+
 endef
 $(eval $(call BuildPackage,libinterapcomm))

feeds/wlan-ap/interAPcomm/files/interap.init

@@ -0,0 +1,35 @@
+#!/bin/sh /etc/rc.common
+
+START=12
+STOP=12
+
+start() {
+	apc=`cat /etc/config/firewall | grep Allow-APC`
+	ucc=`cat /etc/config/firewall | grep Allow-UCC`
+
+	if [ -z "$apc" ]; then
+		uci add firewall rule
+		uci set firewall.@rule[-1].name='Allow-APC'
+		uci set firewall.@rule[-1].src='wan'
+		uci set firewall.@rule[-1].proto='udp'
+		uci set firewall.@rule[-1].dst_port='50010'
+		uci set firewall.@rule[-1].target='ACCEPT'
+		uci set firewall.@rule[-1].family='ipv4'
+		uci commit firewall
+	fi
+
+	if [ -z "$ucc" ]; then
+		uci add firewall rule
+		uci set firewall.@rule[-1].name='Allow-UCC'
+		uci set firewall.@rule[-1].src='wan'
+		uci set firewall.@rule[-1].proto='udp'
+		uci set firewall.@rule[-1].dst_port='50000'
+		uci set firewall.@rule[-1].target='ACCEPT'
+		uci set firewall.@rule[-1].family='ipv4'
+		uci commit firewall
+	fi
+}
+
+stop() {
+	echo stop
+}

feeds/wlan-ap/interAPcomm/src/Makefile

@@ -6,7 +6,7 @@ subdirs=src/test
 
 CFLAGS += -O -Wall -Werror -Wshadow
 CFLAGS += -I./include/
-LIBS = -lev
+LIBS = -lev -lubox -lubus
 
 all: $(LIBNAME) $(subdirs)
 

feeds/wlan-ap/interAPcomm/src/include/interAPcomm.h

@@ -5,6 +5,7 @@ int interap_send(unsigned short port, char *dst_ip,
 int interap_recv(unsigned short port, int (*recv_cb)(void *, ssize_t),
 		 unsigned int len, struct ev_loop *loop,
 		 ev_io *io);
+void interap_rcv_close(void);
 
 typedef int (*callback)(void *, ssize_t);
 typedef struct recv_arg {

feeds/wlan-ap/interAPcomm/src/src/interAPcomm.c

@@ -7,12 +7,31 @@
 #include <string.h>
 #include <unistd.h>
 #include <interAPcomm.h>
+#include <libubox/uloop.h>
 
 /*Receiver socket*/
 int recv_sock = -1;
 
 recv_arg ra;
 
+static void receive_data_uloop(struct uloop_fd *fd, unsigned int events)
+{
+	void *recv_data;
+	ssize_t recv_data_len;
+
+	recv_data = malloc(ra.len);
+	memset(recv_data, 0, ra.len);
+	if ((recv_data_len = recvfrom(recv_sock, recv_data, ra.len,
+				      0, NULL, 0)) < 0) {
+		printf("recvfrom() failed");
+		return;
+	}
+
+	ra.cb(recv_data, recv_data_len);
+	free(recv_data);
+
+}
+
 static void receive_data(struct ev_loop *ev, ev_io *io, int event)
 {
 	void *recv_data;
@@ -25,11 +44,14 @@ static void receive_data(struct ev_loop *ev, ev_io *io, int event)
 		printf("recvfrom() failed");
 
 	ra.cb(recv_data, recv_data_len);
+	free(recv_data);
 
 }
 
-int interap_recv(unsigned short port, int (*recv_cb)(void *, ssize_t), unsigned int len,
-		 struct ev_loop *loop, ev_io *io)
+static struct uloop_fd server;
+
+int interap_recv(unsigned short port, int (*recv_cb)(void *, ssize_t),
+		 unsigned int len, struct ev_loop *loop, ev_io *io)
 {
 	struct sockaddr_in addr;
 	int bcast_perm;
@@ -65,12 +87,25 @@ int interap_recv(unsigned short port, int (*recv_cb)(void *, ssize_t), unsigned
 	}
 
 	printf("Interap recving: p:%d\n", port);
-	ev_io_init(io, receive_data, recv_sock, EV_READ);
-	ev_io_start(loop, io);
+
+	if (io && loop) {
+		ev_io_init(io, receive_data, recv_sock, EV_READ);
+		ev_io_start(loop, io);
+	} else {
+
+		server.cb = receive_data_uloop;
+		server.fd = recv_sock;
+		uloop_fd_add(&server, ULOOP_READ);
+	}
 
 	return 0;
 }
 
+void interap_rcv_close(void)
+{
+	close(recv_sock);
+}
+
 int interap_send(unsigned short port, char *dst_ip, void *data,
 		 unsigned int len)
 {

feeds/wlan-ap/interAPcomm/src/src/test/Makefile

@@ -3,7 +3,7 @@ OBJS = interapcommtest.o
 
 CFLAGS += -Wall $(EXTRA_CFLAGS) $(extra_cflags-y)
 
-LIBS =	-L ../../ -linterapcomm -lev
+LIBS =	-L ../../ -linterapcomm -lev -lubox -lubus
 
 CFLAGS += -I. \
 	-I../../include/

feeds/wlan-ap/interAPcomm/src/src/test/interapcommtest.c

@@ -6,6 +6,8 @@
 #include <ev.h>
 #include <interAPcomm.h>
 
+#include <libubus.h>
+
 struct my_data {
 	int x;
 	char y;
@@ -13,7 +15,8 @@ struct my_data {
 };
 
 
-int recv_process(void *data) {
+int recv_process(void *data, ssize_t n)
+{
 	struct my_data *dat = (struct my_data*) data;
 
 	printf("Recv process: %d, %c, %d\n", dat->x, dat->y, dat->z);
@@ -22,34 +25,37 @@ int recv_process(void *data) {
 
 int main (int argc, char *argv[ ])
 {
-	unsigned int send = atoi(argv[1]);   /* First arg: broadcast port */
-	unsigned short port = 50000;
+	unsigned int send = atoi(argv[1]);
+	unsigned short port = 50020;
 //	char *dst_ip = "255.255.255.255";
-	char *dst_ip = "192.168.9.255";
+	char *dst_ip = "10.42.0.255";
 //	char *data = "InterAP Hello";
 	struct my_data data;
 	data.x = 1001;
 	data.y = 'H';
 	data.z = 3003;
 
-//	callback cb = recv_process;
-
-
-	printf("arg1 = %d\n", send);
+	printf("send = %d\n", send);
 
 	if (send) {
 		printf("Send");
-		interap_send(port, dst_ip, &data, sizeof(data));
+		while (1)
+		{
+			sleep(3);
+			printf("Sending...\n");
+			interap_send(port, dst_ip, &data, sizeof(data));
+		}
 	}
 	else {
 		printf("Recieve");
-//		interap_recv(port, cb, sizeof(struct my_data));
+		uloop_init();
+		callback cb = recv_process;
+
+		interap_recv(port, cb, sizeof(struct my_data), NULL, NULL);
+		uloop_run();
+		uloop_done();
+
 	}
 
-	while (1)
-	{
-		sleep(3);
-		printf("In while loop\n");
-	}
 	return 1;
 }

feeds/wlan-ap/nft-qos/Makefile

@@ -48,13 +48,8 @@ define Package/nft-qos/install
 	$(INSTALL_DIR) $(1)/lib/nft-qos
 	$(INSTALL_DATA) ./files/lib/* $(1)/lib/nft-qos/
 	chmod 0700 $(1)/lib/nft-qos/mac-rate.sh
-	$(INSTALL_DIR) $(1)/etc/config
-	$(INSTALL_CONF) ./files/nft-qos.config $(1)/etc/config/nft-qos
 	$(INSTALL_DIR) $(1)/etc/init.d
 	$(INSTALL_BIN) ./files/nft-qos.init $(1)/etc/init.d/nft-qos
-	$(INSTALL_DIR) $(1)/etc/hotplug.d/dhcp
-	$(INSTALL_BIN) ./files/nft-qos-monitor.hotplug $(1)/etc/hotplug.d/dhcp/00-nft-qos-monitor
-	$(INSTALL_BIN) ./files/nft-qos-dynamic.hotplug $(1)/etc/hotplug.d/dhcp/01-nft-qos-dynamic
 endef
 
 $(eval $(call BuildPackage,nft-qos))

feeds/wlan-ap/nft-qos/files/lib/mac-rate.sh

@@ -27,23 +27,31 @@ if [ -z "$1" -o -z "$2" -o -z "$3" ]; then
 	exit 1
 fi
 
-logger -t "$1 $2 $3"
+logger -t "mac-rate" "$1 $2 $3"
+
+bridge=`uci get wireless.$iface.network`
+if [ "$bridge" == "lan" ]; then
+	dlchain="download_nat"
+        ulchain="upload_nat"
+else
+        dlchain="download"
+        ulchain="upload"
+fi
 
 if [ "$1" == "add" ]; then
 	config_load wireless
 
 	config_foreach handle_interface wifi-iface download
-
-	exists=`nft list chain bridge nft-qos-ssid-lan-bridge download  -a | grep -ic $3`
+	exists=`nft list chain bridge nft-qos-ssid-lan-bridge $dlchain  -a | grep -ic $3`
 	logger -t "mac-rate" "exists = $exists"
 	if [ "$exists" -ne 0 ]; then
-		old_drate=`nft list chain bridge nft-qos-ssid-lan-bridge download -a | grep -i $3 |  awk -F'kbytes' '{print $1}' | awk '{print $NF}'`
+		old_drate=`nft list chain bridge nft-qos-ssid-lan-bridge $dlchain -a | grep -i $3 |  awk -F'kbytes' '{print $1}' | awk '{print $NF}'`
 		logger -t "mac-rate" "old_drate=$old_drate"
 		if [ "$old_drate" -ne "$rate" ]; then
 			changed=1
-			id=`nft list chain bridge nft-qos-ssid-lan-bridge download  -a | grep -i $3  | awk -F "handle " '{print $2;exit}'`
+			id=`nft list chain bridge nft-qos-ssid-lan-bridge $dlchain  -a | grep -i $3  | awk -F "handle " '{print $2;exit}'`
 			if [ -n "$id" ]; then
-				nft delete rule bridge nft-qos-ssid-lan-bridge download handle $id
+				nft delete rule bridge nft-qos-ssid-lan-bridge $dlchain handle $id
 			fi
 			logger -t "mac-rate" "changed DL $old_drate to $rate, del $3"
 		else
@@ -54,19 +62,19 @@ if [ "$1" == "add" ]; then
 
         if [ "$exists" == 0 -o "$changed" == 1 ]; then
 	        if [ "$rate" -ne 0 ]; then
-			dok=`nft add rule bridge nft-qos-ssid-lan-bridge download ether daddr $3 limit rate over $rate kbytes/second drop`
+			dok=`nft add rule bridge nft-qos-ssid-lan-bridge $dlchain ether daddr $3 limit rate over $rate kbytes/second drop`
 	        fi
         fi
 
 	config_foreach handle_interface wifi-iface upload
-	exists=`nft list chain bridge nft-qos-ssid-lan-bridge upload  -a | grep -ic $3`
+	exists=`nft list chain bridge nft-qos-ssid-lan-bridge $ulchain  -a | grep -ic $3`
 	if [ "$exists" -ne 0 ]; then
-		old_urate=`nft list chain bridge nft-qos-ssid-lan-bridge upload -a | grep -i $3 |  awk -F'kbytes' '{print $1}' | awk '{print $NF}'`
+		old_urate=`nft list chain bridge nft-qos-ssid-lan-bridge $ulchain -a | grep -i $3 |  awk -F'kbytes' '{print $1}' | awk '{print $NF}'`
 		if [ "$old_urate" -ne "$rate" ]; then
 			changed=1
-			id=`nft list chain bridge nft-qos-ssid-lan-bridge upload  -a | grep -i $3  | awk -F "handle " '{print $2;exit}'`
+			id=`nft list chain bridge nft-qos-ssid-lan-bridge $ulchain  -a | grep -i $3  | awk -F "handle " '{print $2;exit}'`
 			if [ -n "$id" ]; then
-				nft delete rule bridge nft-qos-ssid-lan-bridge upload handle $id
+				nft delete rule bridge nft-qos-ssid-lan-bridge $ulchain handle $id
 			fi
 
 			logger -t "mac-rate" "changed UL $old_urate to $rate del $3"
@@ -78,20 +86,20 @@ if [ "$1" == "add" ]; then
 
         if [ "$exists" == 0 -o "$changed" == 1 ]; then
         	if [ "$rate" -ne 0 ]; then
-			uok=`nft add rule bridge nft-qos-ssid-lan-bridge upload ether saddr $3 limit rate over $rate kbytes/second drop`
+			uok=`nft add rule bridge nft-qos-ssid-lan-bridge $ulchain ether saddr $3 limit rate over $rate kbytes/second drop`
 		fi
 	fi
 
 elif [ "$1" == "del" ]; then
-	id=`nft list chain bridge nft-qos-ssid-lan-bridge download  -a | grep -i $3  | awk -F "handle " '{print $2;exit}'`
+	id=`nft list chain bridge nft-qos-ssid-lan-bridge $dlchain  -a | grep -i $3  | awk -F "handle " '{print $2;exit}'`
 	logger -t "mac-rate" "$id $3"
 	if [ -n "$id" ]; then
-		nft delete rule bridge nft-qos-ssid-lan-bridge download handle $id
+		nft delete rule bridge nft-qos-ssid-lan-bridge $dlchain handle $id
 	fi
 
-	id=`nft list chain bridge nft-qos-ssid-lan-bridge upload  -a | grep -i $3  | awk -F "handle " '{print $2;exit}'`
+	id=`nft list chain bridge nft-qos-ssid-lan-bridge $ulchain  -a | grep -i $3  | awk -F "handle " '{print $2;exit}'`
 	if [ -n "$id" ]; then
-		nft delete rule bridge nft-qos-ssid-lan-bridge upload handle $id
+		nft delete rule bridge nft-qos-ssid-lan-bridge $ulchain handle $id
 	fi
 
 fi

feeds/wlan-ap/nft-qos/files/lib/ssid_ratelimit.sh

@@ -42,8 +42,20 @@ qosdef_append_rule_ssid() { # <section> <operator> <bridge>
 		rate=$((rate/8))
 	fi
 
-	if [ -z "$iface" -o -z "$rate" -o $rate == 0 ]; then
-		logger -t "nft-qos" "Error: No interface $iface or rate $rate present"
+	if [ -z "$iface" ]; then
+		logger -t "nft-qos" "Error: No interface $iface present"
+		return
+	fi
+
+	if [ -z "$rate" -o $rate == 0 ]; then
+		logger -t "nft-qos" "ssid-rate disabled $iface, configure client-rate"
+	        maclist=`iwinfo $iface assoclist | grep dBm | cut -f 1 -s -d" "`
+
+		for mac in $maclist
+		do
+			logger -t "nft-qos" "Add $mac"
+			/lib/nft-qos/mac-rate.sh add $iface $mac
+		done
 		return
 	fi
 

feeds/wlan-ap/nft-qos/files/nft-qos.init

@@ -4,49 +4,26 @@
 #
 
 . /lib/nft-qos/core.sh
-. /lib/nft-qos/monitor.sh
-. /lib/nft-qos/dynamic.sh
-. /lib/nft-qos/static.sh
-. /lib/nft-qos/priority.sh
 . /lib/nft-qos/ssid_ratelimit.sh
 
 START=99
 USE_PROCD=1
 
 service_triggers() {
-#	procd_add_reload_trigger nft-qos wireless
-#	procd_add_reload_trigger wireless
 
 	procd_open_validate
-#	qosdef_validate_dynamic
-#	qosdef_validate_static
-#	qosdef_validate_priority
 	procd_close_validate
 }
 
 start_service() {
 	config_load nft-qos
-
-#	qosdef_init_env
-#	qosdef_flush_static
-#	qosdef_flush_dynamic
 	qosdef_flush_ssid_ratelimit
-#	qosdef_remove_priority
-
-#	qosdef_init_header
-#	qosdef_init_monitor
-#	qosdef_validate_dynamic default qosdef_init_dynamic
-#	qosdef_validate_static default qosdef_init_static
-#	qosdef_validate_priority default qosdef_init_priority
 	qosdef_init_ssid_ratelimit
 	qosdef_init_done
 	qosdef_start
 }
 
 stop_service() {
-#	qosdef_flush_dynamic
-#	qosdef_flush_static
-#	qosdef_remove_priority
 	qosdef_flush_ssid_ratelimit
 	qosdef_clean_cache
 }

feeds/wlan-ap/opennds/files/lib/login.sh

@@ -242,7 +242,7 @@ header="<!DOCTYPE html>
 	<meta http-equiv=\"Expires\" content=\"0\">
 	<meta charset=\"utf-8\">
 	<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">
-	<link rel=\"shortcut icon\" href=\"/images/$client_zone/TipLogo.png\" type=\"image/x-icon\">
+	<link rel=\"shortcut icon\" href=\"/images/TipLogo.png\" type=\"image/x-icon\">
 	<link rel=\"stylesheet\" type=\"text/css\" href=\"/splash.css\">
 	<title>$gatewaynamehtml</title>
 	</head>
@@ -257,7 +257,7 @@ header="<!DOCTYPE html>
 version="$(ndsctl status | grep Version)"
 year="$(date | awk -F ' ' '{print $(6)}')"
 footer="
-	<img style=\"height:60px; width:100px; float:left;\" src=\"/images/$client_zone/TipLogo.png\" alt=\"Splash Page: For access to the Internet.\">
+	<img style=\"height:60px; width:100px; float:left;\" src=\"/images/TipLogo.png\" alt=\"Splash Page: For access to the Internet.\">
 
 	<copy-right>
 		<br><br>

feeds/wlan-ap/opennds/files/lib/radius.sh

@@ -302,7 +302,7 @@ header="<!DOCTYPE html>
 	<meta http-equiv=\"Expires\" content=\"0\">
 	<meta charset=\"utf-8\">
 	<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">
-	<link rel=\"shortcut icon\" href=\"/images/$client_zone/TipLogo.png\" type=\"image/x-icon\">
+	<link rel=\"shortcut icon\" href=\"/images/TipLogo.png\" type=\"image/x-icon\">
 	<link rel=\"stylesheet\" type=\"text/css\" href=\"/splash.css\">
 	<title>$gatewaynamehtml</title>
 	</head>
@@ -317,7 +317,7 @@ header="<!DOCTYPE html>
 version="$(ndsctl status | grep Version)"
 year="$(date | awk -F ' ' '{print $(6)}')"
 footer="
-	<img style=\"height:60px; width:60px; float:left;\" src=\"/images/$client_zone/TipLogo.png\" alt=\"Splash Page: For access to the Internet.\">
+	<img style=\"height:60px; width:60px; float:left;\" src=\"/images/TipLogo.png\" alt=\"Splash Page: For access to the Internet.\">
 	<copy-right>
 		<br><br>
 		openNDS $version.

feeds/wlan-ap/opennds/files/lib/splash.css

@@ -1,5 +1,5 @@
 body{
-        background-image:url('/images/wlan1/TipBackLogo.png');
+        background-image:url('/images/TipBackLogo.png');
         background-attachment:fixed;
         background-repeat: no-repeat;
         background-size: contain;

feeds/wlan-ap/opennds/files/lib/userpassword.sh

@@ -48,7 +48,7 @@ validate_client() {
 	# $username, $phone, $emailaddr, $addr, $code
 	#
 	# Return either 0 if validation successful or 1 if not
-	userlist="/etc/opennds/htdocs/images/$client_zone/userpass.dat"
+	userlist="/etc/opennds/htdocs/images/userpass.dat"
 	varlist="username password firstname lastname"
 
 	while read user; do
@@ -282,7 +282,7 @@ header="<!DOCTYPE html>
 	<meta http-equiv=\"Expires\" content=\"0\">
 	<meta charset=\"utf-8\">
 	<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">
-	<link rel=\"shortcut icon\" href=\"/images/$client_zone/TipLogo.png\" type=\"image/x-icon\">
+	<link rel=\"shortcut icon\" href=\"/images/TipLogo.png\" type=\"image/x-icon\">
 	<link rel=\"stylesheet\" type=\"text/css\" href=\"/splash.css\">
 	<title>$gatewaynamehtml</title>
 	</head>
@@ -297,7 +297,7 @@ header="<!DOCTYPE html>
 version="$(ndsctl status | grep Version)"
 year="$(date | awk -F ' ' '{print $(6)}')"
 footer="
-	<img style=\"height:60px; width:60px; float:left;\" src=\"/images/$client_zone/TipLogo.png\" alt=\"Splash Page: For access to the Internet.\">
+	<img style=\"height:60px; width:60px; float:left;\" src=\"/images/TipLogo.png\" alt=\"Splash Page: For access to the Internet.\">
 	<copy-right>
 		<br><br>
 		openNDS $version.

feeds/wlan-ap/opensync/files/bin/wlan_ap_redirector.sh

@@ -8,4 +8,5 @@ fi
 redirector_addr=$1
 
 uci set system.tip.redirector="${redirector_addr}"
+uci commit system
 /etc/init.d/opensync restart

feeds/wlan-ap/opensync/files/etc/hotplug.d/net/90-set-tx-rates

@@ -10,11 +10,11 @@ hwmode=$(uci get wireless.${radio}.hwmode)
 
 [ "${hwmode}" = "11a" ] && band=5 || band=2
 
-bcn_rate=$(uci get wireless.${DEVICENAME}.bcn_rate)
+bcn_rate=$(($(uci get wireless.${DEVICENAME}.bcn_rate)/10))
 mcast_rate=$(uci get wireless.${DEVICENAME}.mcast_rate)
 
 # ath10k rate-codes: 0x43 1M, 0x42 2M, 0x41 5.5M, 0x40 11M, 0x3 6M, 0x7 9M, 0x2 12M, 0x6 18M, 0x1 24M, 0x5 36M, 0x0 48M, 0x4 54M, 0xFF default
-rate_codes="1:0x43 2:0x42 5.5:0x41 11:0x40 6:0x3 9:0x7 12:0x2 18:0x6 24:0x1 36:0x5 48:0x0 54:0x4"
+rate_codes="1:0x43 2:0x42 5:0x41 11:0x40 6:0x3 9:0x7 12:0x2 18:0x6 24:0x1 36:0x5 48:0x0 54:0x4"
 
 # Default codes
 beacon_code=0xFF
@@ -33,6 +33,6 @@ done
 
 # set rates
 logger -t hotplug "Set Tx rates for device ${DEVICENAME}"
-sleep 5
+sleep 20
 echo "${DEVICENAME} beacon ${band} ${beacon_code}" > /sys/kernel/debug/ieee80211/${phy}/ath10k/set_rates
 echo "${DEVICENAME} mcast ${band} ${mcast_code}" > /sys/kernel/debug/ieee80211/${phy}/ath10k/set_rates

feeds/wlan-ap/opensync/patches/19-passpoint-ovsschema

@@ -1,6 +1,6 @@
 --- a/interfaces/opensync.ovsschema
 +++ b/interfaces/opensync.ovsschema
-@@ -8828,6 +8828,442 @@
+@@ -8831,6 +8831,451 @@
              }
          },
          "isRoot": true
@@ -269,6 +269,15 @@
 +                    }
 +                }
 +              },
++            "access_network_type": {
++              "type": {
++                "key": {
++                  "type": "integer"
++                },
++                "min": 0,
++                "max": 1
++              }
++            },
 +            "internet": {
 +              "type": {
 +                "key": {

feeds/wlan-ap/opensync/patches/26-channel-switch-events.patch

@@ -117,7 +117,7 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c
 +		assert(channel_switch);
 +		sts__event_report__channel_switch_event__init(channel_switch);
 +
-+		channel_switch->band = channel_switch_rec->band;
++		channel_switch->band = dppline_to_proto_radio(channel_switch_rec->band);
 +		channel_switch->reason = channel_switch_rec->reason;
 +		channel_switch->channel = channel_switch_rec->freq;
 +		channel_switch->timestamp_ms = channel_switch_rec->timestamp;

feeds/wlan-ap/opensync/patches/29-add-max-clients.patch

@@ -0,0 +1,11 @@
+--- a/src/lib/schema/inc/schema_consts.h
++++ b/src/lib/schema/inc/schema_consts.h
+@@ -176,4 +176,8 @@ typedef enum {
+ #define SCHEMA_CONSTS_MESH_HOP_PENALTY     "hop_penalty"
+ #define SCHEMA_CONSTS_MESH_MCAST_RATE      "mcast_rate"
+ #define SCHEMA_CONSTS_MESH_MTU             "mtu"
++
++/* Max clients per radio */
++#define SCHEMA_CONSTS_MAX_CLIENTS	"max_clients"
++
+ #endif /* SCHEMA_CONSTS_H_INCLUDED */

feeds/wlan-ap/opensync/patches/30-fix-ipv4-string-to-bytes-conversion

@@ -0,0 +1,33 @@
+--- a/src/lib/datapipeline/src/dppline.c
++++ b/src/lib/datapipeline/src/dppline.c
+@@ -2147,9 +2147,11 @@ static void dppline_add_stat_events(Sts_
+ 			ipe->timestamp_ms = cs_rec->ip_event->timestamp;
+ 
+ 			if (cs_rec->ip_event->ip_addr) {
+-				ipe->ip_addr.data = malloc(16);
+-				memcpy(ipe->ip_addr.data, cs_rec->ip_event->ip_addr,16);
+-				ipe->ip_addr.len = 16;
++				uint8_t ip[IPV4_BYTES_LEN] = {0};
++				sscanf(cs_rec->ip_event->ip_addr, "%hhu.%hhu.%hhu.%hhu", &ip[0], &ip[1], &ip[2], &ip[3]);
++				ipe->ip_addr.data = malloc(IPV4_BYTES_LEN);
++				memcpy(ipe->ip_addr.data, ip, IPV4_BYTES_LEN);
++				ipe->ip_addr.len = IPV4_BYTES_LEN;
+ 				ipe->has_ip_addr = true;
+ 			}
+ 		}
+@@ -2224,10 +2226,11 @@ static void dppline_add_stat_events(Sts_
+ 			}
+ 
+ 			if (cs_rec->connect_event->ip_addr) {
+-				coe->ip_addr.data = malloc(16);
+-				memcpy(coe->ip_addr.data, cs_rec->connect_event->ip_addr,
+-				       16);
+-				coe->ip_addr.len = 16;
++				uint8_t ip[IPV4_BYTES_LEN] = {0};
++				sscanf(cs_rec->connect_event->ip_addr, "%hhu.%hhu.%hhu.%hhu", &ip[0], &ip[1], &ip[2], &ip[3]);
++				coe->ip_addr.data = malloc(IPV4_BYTES_LEN);
++				memcpy(coe->ip_addr.data, ip, IPV4_BYTES_LEN);
++				coe->ip_addr.len = IPV4_BYTES_LEN;
+ 				coe->has_ip_addr = true;
+ 			}
+ 

feeds/wlan-ap/opensync/patches/31-adjust-log-levels.patch

@@ -0,0 +1,89 @@
+--- a/src/lib/ovsdb/src/ovsdb_sync_api.c
++++ b/src/lib/ovsdb/src/ovsdb_sync_api.c
+@@ -492,7 +492,7 @@ int ovsdb_sync_mutate_uuid_set(const cha
+     json_t * js;
+     json_t * js_mutations;
+ 
+-    LOG(INFO, "Mutate: %s %s %d %s", table, column, op, uuid);
++    LOG(DEBUG, "Mutate: %s %s %d %s", table, column, op, uuid);
+ 
+     js = ovsdb_mutation(column,
+             ovsdb_tran_operation(op),
+--- a/src/sm/src/sm_scan_schedule.c
++++ b/src/sm/src/sm_scan_schedule.c
+@@ -230,7 +230,7 @@ bool sm_scan_schedule_process(
+                 sm_scan_schedule_cb,
+                 scan_ctx);
+     if (true != rc) {
+-        LOG(ERR,
++        LOG(DEBUG,
+             "Scheduling %s %s %d scan",
+             radio_get_name_from_type(request_ctx->radio_cfg->type),
+             radio_get_scan_name_from_type(request_ctx->scan_type),
+--- a/src/sm/src/sm_survey_report.c
++++ b/src/sm/src/sm_survey_report.c
+@@ -1004,7 +1004,7 @@ bool sm_survey_threshold_util_cb (
+ 
+     rc = sm_scan_schedule(&scan_request);
+     if (true != rc) {
+-        LOGE("Processing %s %s %d survey (Failed to schedule scan)",
++        LOGD("Processing %s %s %d survey (Failed to schedule scan)",
+              radio_get_name_from_cfg(radio_cfg_ctx),
+              radio_get_scan_name_from_type(scan_type),
+              *scan_chan);
+@@ -1153,7 +1153,7 @@ bool sm_survey_stats_update (
+ 
+     rc = sm_scan_schedule(&scan_request);
+     if (true != rc) {
+-        LOG(ERR,
++        LOG(DEBUG,
+             "Processing %s %s %d survey ",
+             radio_get_name_from_cfg(radio_cfg_ctx),
+             radio_get_scan_name_from_type(scan_type),
+--- a/src/wm2/src/wm2_radio.c
++++ b/src/wm2/src/wm2_radio.c
+@@ -517,7 +517,7 @@ wm2_radio_update_port_state_set_inactive
+ 
+ #define CMP(cmp, name) \
+     (changed |= (changedf->name = ((cmp(conf, state, name, changedf->_uuid)) && \
+-                                   (LOGI("%s: '%s' changed", conf->if_name, #name), 1))))
++                                   (LOGT("%s: '%s' changed", conf->if_name, #name), 1))))
+ 
+ static bool
+ wm2_vconf_changed(const struct schema_Wifi_VIF_Config *conf,
+@@ -559,7 +559,7 @@ wm2_vconf_changed(const struct schema_Wi
+     CMP(CHANGED_SET_CASE, captive_allowlist);
+ 
+     if (changed)
+-        LOGD("%s: changed (forced=%d)", conf->if_name, changedf->_uuid);
++        LOGT("%s: changed (forced=%d)", conf->if_name, changedf->_uuid);
+ 
+     return changed;
+ }
+@@ -597,7 +597,7 @@ wm2_rconf_changed(const struct schema_Wi
+     CMP(CHANGED_MAP_STRSTR, custom_options);
+ 
+     if (changed)
+-        LOGD("%s: changed (forced=%d)", conf->if_name, changedf->_uuid);
++        LOGT("%s: changed (forced=%d)", conf->if_name, changedf->_uuid);
+ 
+     return changed;
+ }
+@@ -1351,7 +1351,7 @@ wm2_op_vstate(const struct schema_Wifi_V
+                                   SCHEMA_COLUMN(Wifi_VIF_State, if_name),
+                                   state.if_name);
+     }
+-    LOGI("%s: updated vif state", state.if_name);
++    LOGD("%s: updated vif state", state.if_name);
+ recalc:
+     /* Reconnect workaround is for CAES-771 */
+     if (wm2_sta_has_reconnected(&oldstate, &state))
+@@ -1392,7 +1392,7 @@ wm2_op_rstate(const struct schema_Wifi_R
+     }
+ 
+     REQUIRE(state.if_name, 1 == ovsdb_table_upsert_f(&table_Wifi_Radio_State, &state, false, NULL));
+-    LOGI("%s: updated radio state", state.if_name);
++    LOGD("%s: updated radio state", state.if_name);
+     wm2_delayed_recalc(wm2_rconf_recalc, state.if_name);
+ }
+ 

feeds/wlan-ap/opensync/patches/32-noisy-logs-clean

@@ -0,0 +1,349 @@
+--- a/src/sm/src/sm_client_report.c
++++ b/src/sm/src/sm_client_report.c
+@@ -792,7 +792,7 @@ bool sm_client_report_send(
+         ds_dlist_insert_tail(report_list, report_entry);
+     }
+ 
+-    LOG(INFO,
++    LOG(DEBUG,
+         "Sending %s client report at '%s'",
+         radio_get_name_from_cfg(radio_cfg_ctx),
+         sm_timestamp_ms_to_date(report_ctx->timestamp_ms));
+--- a/src/sm/src/sm_neighbor_report.c
++++ b/src/sm/src/sm_neighbor_report.c
+@@ -390,7 +390,7 @@ bool sm_neighbor_report_send_diff(
+         }
+     }
+ 
+-    LOGI("Sending %s %s neighbor report at '%s'",
++    LOGD("Sending %s %s neighbor report at '%s'",
+          radio_get_name_from_cfg(radio_cfg_ctx),
+          radio_get_scan_name_from_type(scan_type),
+          sm_timestamp_ms_to_date(report_diff.timestamp_ms));
+@@ -503,7 +503,7 @@ bool sm_neighbor_report_send_raw(
+              neighbor_entry->chan);
+     }
+ 
+-    LOGI("Sending %s %s neighbor report at '%s'",
++    LOGD("Sending %s %s neighbor report at '%s'",
+          radio_get_name_from_cfg(radio_cfg_ctx),
+          radio_get_scan_name_from_type(scan_type),
+          sm_timestamp_ms_to_date(report_ctx->timestamp_ms));
+--- a/src/sm/src/sm_capacity_report.c
++++ b/src/sm/src/sm_capacity_report.c
+@@ -288,7 +288,7 @@ bool sm_capacity_report_send(
+         }
+     }
+ 
+-    LOG(INFO,
++    LOG(DEBUG,
+         "Sending %s capacity report at '%s'",
+         radio_get_name_from_cfg(radio_cfg_ctx),
+         sm_timestamp_ms_to_date(report_ctx->timestamp_ms));
+--- a/src/sm/src/sm_device_report.c
++++ b/src/sm/src/sm_device_report.c
+@@ -219,14 +219,14 @@ void sm_device_report (EV_P_ ev_timer *w
+         request_ctx->reporting_timestamp - device_ctx->report_ts +
+         get_timestamp();
+ 
+-    LOG(INFO,
++    LOG(DEBUG,
+         "uptime=%u, mem=%u/%u, cpu=%u",
+         report_ctx->record.uptime,
+         report_ctx->record.mem_util.mem_used,
+         report_ctx->record.mem_util.mem_total,
+         report_ctx->record.cpu_util.cpu_util);
+ 
+-    LOG(INFO,
++    LOG(DEBUG,
+         "Sending device report at '%s'",
+         sm_timestamp_ms_to_date(report_ctx->timestamp_ms));
+ 
+@@ -345,7 +345,7 @@ bool sm_device_report_request(
+         memset(request_ctx, 0, sizeof(*request_ctx));
+         memset(report_ctx, 0, sizeof(*report_ctx));
+ 
+-        LOG(INFO,
++        LOG(DEBUG,
+             "Initializing device reporting");
+ 
+         /* Initialize report device temp list */
+--- a/src/sm/src/sm_network_probe_report.c
++++ b/src/sm/src/sm_network_probe_report.c
+@@ -188,7 +188,7 @@ void sm_network_probe_report (EV_P_ ev_t
+         request_ctx->reporting_timestamp - network_probe_ctx->report_ts +
+         get_timestamp();
+ 
+-    LOG(INFO,
++    LOG(DEBUG,
+         "Sending network probe report at '%s' , latency : '%d'",
+         sm_timestamp_ms_to_date(report_ctx->timestamp_ms), report_ctx->record.dns_probe.latency);
+ 
+--- a/src/sm/src/sm_rssi_report.c
++++ b/src/sm/src/sm_rssi_report.c
+@@ -514,7 +514,7 @@ bool sm_rssi_report_send(
+         }
+     }
+ 
+-    LOGI("Sending %s rssi report at '%s'",
++    LOGD("Sending %s rssi report at '%s'",
+          radio_get_name_from_cfg(radio_cfg_ctx),
+          sm_timestamp_ms_to_date(report_ctx->timestamp_ms));
+ 
+--- a/src/sm/src/sm_survey_report.c
++++ b/src/sm/src/sm_survey_report.c
+@@ -592,7 +592,7 @@ bool sm_survey_report_send(
+             goto exit;
+     }
+ 
+-    LOGI("Sending %s %s survey report at '%s'",
++    LOGD("Sending %s %s survey report at '%s'",
+          radio_get_name_from_cfg(radio_cfg_ctx),
+          radio_get_scan_name_from_type(scan_type),
+          sm_timestamp_ms_to_date(report_ctx->timestamp_ms));
+@@ -979,7 +979,7 @@ bool sm_survey_threshold_util_cb (
+          survey_ctx->threshold_count, request_ctx->radio_chan_list.chan_num);
+ 
+     if (threshold_util >= request_ctx->threshold_util) {
+-        LOGI("Skip processing %s %s survey (threshold util exceeded %d >= %d)",
++        LOGD("Skip processing %s %s survey (threshold util exceeded %d >= %d)",
+              radio_get_name_from_cfg(radio_cfg_ctx),
+              radio_get_scan_name_from_type(scan_type),
+              threshold_util,
+@@ -1103,7 +1103,7 @@ bool sm_survey_stats_update (
+             scan_interval = SURVEY_MIN_SCAN_INTERVAL;
+ 
+             // always scan if max_delay exceeded
+-            LOGI("Force processing %s %s survey delay: %ld/%d count: %d/%d",
++            LOGD("Force processing %s %s survey delay: %ld/%d count: %d/%d",
+                  radio_get_name_from_cfg(radio_cfg_ctx),
+                  radio_get_scan_name_from_type(scan_type),
+                  survey_ctx->threshold_time_delta, request_ctx->threshold_max_delay,
+@@ -1771,7 +1771,7 @@ bool sm_survey_stats_process (
+                     request_ctx->threshold_pod_num * request_ctx->sampling_interval;
+             }
+ 
+-            LOGI("Updated %s %s survey threshold_max_delay (%d + %d) * %d) -> %ds) ",
++            LOGD("Updated %s %s survey threshold_max_delay (%d + %d) * %d) -> %ds) ",
+                  radio_get_name_from_cfg(radio_cfg_ctx),
+                  radio_get_scan_name_from_type(scan_type),
+                  request_ctx->threshold_pod_num,
+@@ -1790,7 +1790,7 @@ bool sm_survey_stats_process (
+                 request_ctx->sampling_interval -
+                 (uint32_t)((request_ctx->reporting_timestamp / 1000) % request_ctx->sampling_interval);
+ 
+-            LOGI("Updated %s %s survey synchronization_delay %d - %d -> %"PRIu64"s) ",
++            LOGD("Updated %s %s survey synchronization_delay %d - %d -> %"PRIu64"s) ",
+                  radio_get_name_from_cfg(radio_cfg_ctx),
+                  radio_get_scan_name_from_type(scan_type),
+                  request_ctx->sampling_interval,
+--- a/src/wm2/src/wm2_radio.c
++++ b/src/wm2/src/wm2_radio.c
+@@ -137,7 +137,7 @@ wm2_delayed(void (*fn)(const char *ifnam
+     ev_timer_init(&i->timer, wm2_delayed_cb, seconds, 0);
+     ev_timer_start(EV_DEFAULT, &i->timer);
+     ds_dlist_insert_tail(&delayed_list, i);
+-    LOGI("%s: scheduling delayed (%us) work %s", ifname, seconds, workname);
++    LOGD("%s: scheduling delayed (%us) work %s", ifname, seconds, workname);
+ }
+ 
+ #define wm2_delayed_recalc(fn, ifname) (wm2_delayed((fn), (ifname), WM2_RECALC_DELAY_SECONDS, #fn))
+@@ -267,7 +267,7 @@ wm2_parent_change(void)
+ static void
+ wm2_dfs_disconnect_check(const char *ifname, bool force)
+ {
+-    LOGN("%s %s called", ifname, __func__);
++    LOGD("%s %s called", ifname, __func__);
+     wm2_parent_change();
+ }
+ 
+@@ -286,7 +286,7 @@ wm2_sta_has_dfs_channel(const struct sch
+         if (rstate->channel != atoi(rstate->channels_keys[i]))
+             continue;
+ 
+-        LOGI("%s: check channel %d (%d) %s", vstate->if_name, rstate->channel, vstate->channel, rstate->channels[i]);
++        LOGD("%s: check channel %d (%d) %s", vstate->if_name, rstate->channel, vstate->channel, rstate->channels[i]);
+         if (!strstr(rstate->channels[i], "allowed"))
+             status = true;
+ 
+@@ -319,7 +319,7 @@ wm2_sta_handle_dfs_link_change(const str
+ 
+     if (wm2_sta_has_disconnected(oldstate, newstate) &&
+         wm2_sta_has_dfs_channel(rstate, oldstate)) {
+-            LOGN("%s: sta: dfs: disconnected from %s - arm fallback parents timer", oldstate->if_name, oldstate->parent);
++            LOGD("%s: sta: dfs: disconnected from %s - arm fallback parents timer", oldstate->if_name, oldstate->parent);
+             wm2_timer(wm2_dfs_disconnect_check, oldstate->if_name, WM2_DFS_FALLBACK_GRACE_PERIOD_SECONDS);
+     }
+ }
+@@ -923,13 +923,13 @@ wm2_vconf_recalc(const char *ifname, boo
+ 
+     wm2_radio_update_port_state(vconf.if_name);
+ 
+-    LOGI("%s@%s: changed, configuring", ifname, rconf.if_name);
++    LOGD("%s@%s: changed, configuring", ifname, rconf.if_name);
+ 
+     if (vchanged.parent)
+-        LOGN("%s: topology change: parent '%s' -> '%s'", ifname, vstate.parent, vconf.parent);
++        LOGD("%s: topology change: parent '%s' -> '%s'", ifname, vstate.parent, vconf.parent);
+ 
+     if (vchanged.ssid && strlen(vconf.ssid) > 0 && !strcmp(vconf.mode, "sta"))
+-        LOGN("%s: topology change: ssid '%s' -> '%s'", ifname, vstate.ssid, vconf.ssid);
++        LOGD("%s: topology change: ssid '%s' -> '%s'", ifname, vstate.ssid, vconf.ssid);
+ 
+     if (!target_vif_config_set2(&vconf, &rconf, cconfs, &vchanged, num_cconfs)) {
+         LOGW("%s: failed to configure, will retry later", ifname);
+@@ -1047,7 +1047,7 @@ wm2_rconf_recalc_fixup_channel(struct sc
+      * i.e. when radio_config channel is more important than
+      * sta vif channel in cases of sta csa, sta (re)assoc.
+      */
+-    LOGN("%s: ignoring channel change %d -> %d because sta vif %s is connected on %d, see CAES-600",
++    LOGD("%s: ignoring channel change %d -> %d because sta vif %s is connected on %d, see CAES-600",
+             rconf->if_name, rstate->channel, rconf->channel,
+             vstate.if_name, vstate.channel);
+     rconf->channel = vstate.channel;
+@@ -1146,10 +1146,10 @@ wm2_rconf_recalc(const char *ifname, boo
+     if (!wm2_rconf_changed(&rconf, &rstate, &changed) && !force)
+         goto recalc;
+ 
+-    LOGI("%s: changed, configuring", ifname);
++    LOGD("%s: changed, configuring", ifname);
+ 
+     if ((changed.channel || changed.ht_mode) && rconf.channel) {
+-        LOGN("%s: topology change: channel %d @ %s -> %d @ %s",
++        LOGD("%s: topology change: channel %d @ %s -> %d @ %s",
+              ifname,
+              rstate.channel, rstate.ht_mode,
+              rconf.channel, rconf.ht_mode);
+@@ -1183,7 +1183,7 @@ wm2_op_vconf(const struct schema_Wifi_VI
+     memcpy(&tmp, vconf, sizeof(tmp));
+     memset(&rconf, 0, sizeof(rconf));
+ 
+-    LOGI("%s @ %s: updating vconf", vconf->if_name, phy);
++    LOGD("%s @ %s: updating vconf", vconf->if_name, phy);
+     REQUIRE(vconf->if_name, strlen(vconf->if_name) > 0);
+     REQUIRE(vconf->if_name, vconf->_partial_update);
+     if (!(where = ovsdb_where_simple(SCHEMA_COLUMN(Wifi_Radio_Config, if_name), phy)))
+@@ -1203,7 +1203,7 @@ wm2_op_vconf(const struct schema_Wifi_VI
+                                                            SCHEMA_TABLE(Wifi_Radio_Config),
+                                                            where,
+                                                            SCHEMA_COLUMN(Wifi_Radio_Config, vif_configs)));
+-    LOGI("%s @ %s: updated vconf", vconf->if_name, phy);
++    LOGD("%s @ %s: updated vconf", vconf->if_name, phy);
+     wm2_delayed_recalc(wm2_vconf_recalc, vconf->if_name);
+ }
+ 
+@@ -1212,14 +1212,14 @@ wm2_op_rconf(const struct schema_Wifi_Ra
+ {
+     struct schema_Wifi_Radio_Config tmp;
+     memcpy(&tmp, rconf, sizeof(tmp));
+-    LOGI("%s: updating rconf", rconf->if_name);
++    LOGD("%s: updating rconf", rconf->if_name);
+     REQUIRE(rconf->if_name, strlen(rconf->if_name) > 0);
+     REQUIRE(rconf->if_name, rconf->_partial_update);
+     OVERRIDE(rconf->if_name, tmp.vif_configs_present, false);
+     tmp.vif_configs_len = 0;
+     tmp.vif_configs_present = true;
+     REQUIRE(rconf->if_name, 1 == ovsdb_table_upsert_f(&table_Wifi_Radio_Config, &tmp, false, NULL));
+-    LOGI("%s: updated rconf", rconf->if_name);
++    LOGD("%s: updated rconf", rconf->if_name);
+     wm2_delayed_recalc(wm2_rconf_recalc, rconf->if_name);
+ }
+ 
+--- a/src/xm/src/xm_ovsdb.c
++++ b/src/xm/src/xm_ovsdb.c
+@@ -91,7 +91,7 @@ static bool xm_device_info_update(const
+ 
+     if (ovsdb_table_upsert_f(&table_AWLAN_Node, &node, false, NULL))
+     {
+-        LOGI("External: Updated device info");
++        LOGD("External: Updated device info");
+     }
+     else
+     {
+@@ -127,7 +127,7 @@ static bool xm_mode_update(const connect
+ 
+     if (ovsdb_table_upsert_f(&table_AWLAN_Node, &node, false, NULL))
+     {
+-        LOGI("External: Updated device mode");
++        LOGD("External: Updated device mode");
+     }
+     else
+     {
+@@ -150,7 +150,7 @@ static bool xm_address_update(const char
+     SCHEMA_SET_STR(node.redirector_addr, cloud_address);
+     if (ovsdb_table_upsert_f(&table_AWLAN_Node, &node, false, NULL))
+     {
+-        LOGI("External: Updated cloud address");
++        LOGD("External: Updated cloud address");
+     }
+     else
+     {
+@@ -165,11 +165,11 @@ static bool xm_radio_update(const struct
+     struct schema_Wifi_Radio_Config tmp;
+ 
+     memcpy(&tmp, rconf, sizeof(tmp));
+-    LOGI("External: Updating radio %s (partial %d)", tmp.if_name, rconf->_partial_update);
++    LOGD("External: Updating radio %s (partial %d)", tmp.if_name, rconf->_partial_update);
+     REQUIRE(rconf->if_name, strlen(rconf->if_name) > 0);
+     tmp.vif_configs_present = false;
+     REQUIRE(rconf->if_name, 1 == ovsdb_table_upsert_f(&table_Wifi_Radio_Config, &tmp, false, NULL));
+-    LOGI("External: Update radio %s", tmp.if_name);
++    LOGD("External: Update radio %s", tmp.if_name);
+ 
+     return true;
+ }
+@@ -181,10 +181,10 @@ static bool xm_vif_update(const struct s
+     json_t *where;
+ 
+     memcpy(&tmp, vconf, sizeof(tmp));
+-    LOGI("External: Updating vif %s @ %s (partial %d)", vconf->if_name, radio_ifname, vconf->_partial_update);
++    LOGD("External: Updating vif %s @ %s (partial %d)", vconf->if_name, radio_ifname, vconf->_partial_update);
+     REQUIRE(vconf->if_name, strlen(vconf->if_name) > 0);
+     if (!(where = ovsdb_where_simple(SCHEMA_COLUMN(Wifi_Radio_Config, if_name), radio_ifname))){
+-        LOGI("External: Updating vif %s @ %s (no radio found)", vconf->if_name, radio_ifname);
++        LOGD("External: Updating vif %s @ %s (no radio found)", vconf->if_name, radio_ifname);
+         return false;
+     }
+     REQUIRE(vconf->if_name,
+@@ -198,7 +198,7 @@ static bool xm_vif_update(const struct s
+                     where,
+                     SCHEMA_COLUMN(Wifi_Radio_Config, vif_configs))
+     );
+-    LOGI("External: Update vif %s @ %s", vconf->if_name, radio_ifname);
++    LOGD("External: Update vif %s @ %s", vconf->if_name, radio_ifname);
+ 
+     return true;
+ }
+@@ -208,10 +208,10 @@ static bool xm_inet_update(const struct
+     struct schema_Wifi_Inet_Config tmp;
+ 
+     memcpy(&tmp, iconf, sizeof(tmp));
+-    LOGI("External: Updating inet %s (partial %d)", tmp.if_name, iconf->_partial_update);
++    LOGD("External: Updating inet %s (partial %d)", tmp.if_name, iconf->_partial_update);
+     REQUIRE(iconf->if_name, strlen(iconf->if_name) > 0);
+     REQUIRE(iconf->if_name, 1 == ovsdb_table_upsert_f(&table_Wifi_Inet_Config, &tmp, false, NULL));
+-    LOGI("External: Update inet %s", tmp.if_name);
++    LOGD("External: Update inet %s", tmp.if_name);
+ 
+     return true;
+ }
+--- a/src/qm/src/qm_mqtt.c
++++ b/src/qm/src/qm_mqtt.c
+@@ -221,7 +221,7 @@ bool qm_mqtt_publish(mosqev_t *mqtt, qm_
+         mlen = len;
+         mbuf = buf;
+     }
+-    LOGI("MQTT: Publishing %ld bytes", mlen);
++    LOGD("MQTT: Publishing %ld bytes", mlen);
+     ret = mosqev_publish(mqtt, NULL, topic, mlen, mbuf, qos, false);
+ exit:
+     if (buf) free(buf);
+@@ -314,7 +314,7 @@ first:
+         void *buf = malloc(size);
+         if (!buf) goto out;
+         size = sts__report__pack(rpt, buf);
+-        LOGI("merged reports stats %zd + %zd = %d", rep->size, qi->size, size);
++        LOGD("merged reports stats %zd + %zd = %d", rep->size, qi->size, size);
+ 
+         // replace message
+         if(rep->buf) free(rep->buf);

feeds/wlan-ap/opensync/patches/32-power-constraint-schema-consts.patch

@@ -0,0 +1,24 @@
+Index: opensync-2.0.5.0/src/lib/schema/inc/schema_consts.h
+===================================================================
+--- opensync-2.0.5.0.orig/src/lib/schema/inc/schema_consts.h
++++ opensync-2.0.5.0/src/lib/schema/inc/schema_consts.h
+@@ -142,7 +142,7 @@ typedef enum {
+ #define SCHEMA_CONSTS_INET_DHCP_LEASE_TIME  "lease_time"
+ #define SCHEMA_CONSTS_INET_DHCP_FORCE       "force"
+ 
+-/* Custom options */
++/* vif Custom options */
+ #define SCHEMA_CONSTS_RATE_LIMIT    "rate_limit_en"
+ #define SCHEMA_CONSTS_RATE_DL       "ssid_dl_limit"
+ #define SCHEMA_CONSTS_RATE_UL       "ssid_ul_limit"
+@@ -154,6 +154,10 @@ typedef enum {
+ #define SCHEMA_CONSTS_DISABLE_B_RATES	"disable_b_rates"
+ #define SCHEMA_CONSTS_IEEE80211k	"ieee80211k"
+ #define SCHEMA_CONSTS_DYNAMIC_VLAN	"dynamic_vlan"
++
++/* radio Custom options */
++#define SCHEMA_CONSTS_LOCAL_PWR_CONSTRAINT "local_pwr_constraint"
++
+ /* Captive Portal */
+ #define SCHEMA_CONSTS_SESSION_TIMEOUT              "session_timeout"
+ #define SCHEMA_CONSTS_BROWSER_TITLE                "browser_title"

feeds/wlan-ap/opensync/patches/33-add-apc-radsecproxy-schema.patch

@@ -0,0 +1,143 @@
+Index: opensync-2.0.5.0/interfaces/opensync.ovsschema
+===================================================================
+--- opensync-2.0.5.0.orig/interfaces/opensync.ovsschema
++++ opensync-2.0.5.0/interfaces/opensync.ovsschema
+@@ -9368,6 +9368,69 @@
+             }
+        },
+       "isRoot": true
++    },
++    "APC_Config": {
++      "columns": {
++        "enabled": {
++          "type": {
++            "key": {
++              "type": "boolean"
++            },
++            "min": 0,
++            "max": 1
++          }
++        }
++      },
++      "isRoot": true,
++      "maxRows": 1
++    },
++    "APC_State": {
++      "columns": {
++        "dr_addr": {
++          "type": {
++            "key": {
++              "type": "string"
++            }
++          }
++        },
++        "bdr_addr": {
++          "type": {
++            "key": {
++              "type": "string"
++            }
++          }
++        },
++        "enabled": {
++          "type": {
++            "key": {
++              "type": "boolean"
++            },
++            "min": 0,
++            "max": 1
++          }
++        },
++        "mode": {
++          "type": {
++            "key": {
++              "type": "string",
++              "enum": [
++                "set",
++                [
++                  "DR",
++                  "BDR",
++                  "OR",
++                  "WT",
++                  "NC"
++                ]
++              ]
++            },
++            "min": 0,
++            "max": 1
++          }
++        }
++      },
++      "isRoot": true,
++      "maxRows": 1
+     }
+   }
+ }
+Index: opensync-2.0.5.0/platform/openwrt/src/lib/target/src/radio_ubus.c
+===================================================================
+--- opensync-2.0.5.0.orig/platform/openwrt/src/lib/target/src/radio_ubus.c
++++ opensync-2.0.5.0/platform/openwrt/src/lib/target/src/radio_ubus.c
+@@ -10,6 +10,7 @@
+ extern struct ev_loop *wifihal_evloop;
+ static struct ubus_context *ubus;
+ extern struct ev_loop *wifihal_evloop;
++extern void apc_state_set(struct blob_attr *msg);
+ 
+ int hapd_rrm_enable(char *name, int neighbor, int beacon)
+ {
+@@ -179,6 +180,7 @@ radio_ubus_add_vif_cb(struct ubus_contex
+ 	return UBUS_STATUS_OK;
+ }
+ 
++
+ static const struct ubus_method radio_ubus_methods[] = {
+         UBUS_METHOD("dbg_add_vif", radio_ubus_add_vif_cb, add_vif_policy),
+         UBUS_METHOD("dummy", radio_ubus_dummy_cb, dummy_policy),
+@@ -201,8 +203,36 @@ static void radio_ubus_connect(struct ub
+ 	ubus_add_object(ubus, &radio_ubus_object);
+ }
+ 
++static int radio_ubus_notify(struct ubus_context *ctx, struct ubus_object *obj,
++			     struct ubus_request_data *req, const char *method,
++			     struct blob_attr *msg)
++{
++	char *str;
++
++	str = blobmsg_format_json(msg, true);
++	LOGD("ubus: Received ubus notify '%s': %s\n", method, str);
++	free(str);
++
++	if (!strncmp(method, "apc", 3)) {
++		LOGD("APC notification Received");
++		apc_state_set(msg);
++	}
++
++	return 0;
++}
++
++
++
+ static struct ubus_instance ubus_instance = {
+ 	.connect = radio_ubus_connect,
++	.notify = radio_ubus_notify,
++	.list = {
++			{
++				.path = "apc",
++			},
++		},
++	.len = 1,
++
+ };
+ 
+ int radio_ubus_init(void)
+Index: opensync-2.0.5.0/src/lib/schema/inc/schema_consts.h
+===================================================================
+--- opensync-2.0.5.0.orig/src/lib/schema/inc/schema_consts.h
++++ opensync-2.0.5.0/src/lib/schema/inc/schema_consts.h
+@@ -154,6 +154,7 @@ typedef enum {
+ #define SCHEMA_CONSTS_DISABLE_B_RATES	"disable_b_rates"
+ #define SCHEMA_CONSTS_IEEE80211k	"ieee80211k"
+ #define SCHEMA_CONSTS_DYNAMIC_VLAN	"dynamic_vlan"
++#define SCHEMA_CONSTS_RADPROXY	"radproxy"
+ 
+ /* radio Custom options */
+ #define SCHEMA_CONSTS_LOCAL_PWR_CONSTRAINT "local_pwr_constraint"

feeds/wlan-ap/opensync/patches/33-add-new-manufacturing-data.patch

@@ -0,0 +1,270 @@
+Index: opensync-2.0.5.0/interfaces/opensync.ovsschema
+===================================================================
+--- opensync-2.0.5.0.orig/interfaces/opensync.ovsschema
++++ opensync-2.0.5.0/interfaces/opensync.ovsschema
+@@ -199,6 +199,59 @@
+               "type": "integer"
+             }
+           }
++        },
++        "qr_code": {
++          "type": {
++            "key": "string",
++            "value": {
++               "type": "string",
++               "maxLength": 128
++            },
++            "min": 0,
++            "max": "unlimited"
++          }
++        },
++        "model_description": {
++          "type": {
++            "key": {
++              "type": "string"
++            }
++          }
++        },
++        "manufacturer_name": {
++          "type": {
++            "key": {
++              "type": "string"
++            }
++          }
++        },
++        "manufacturer_date": {
++          "type": {
++            "key": {
++              "type": "string"
++            }
++          }
++        },
++        "manufacturer_url": {
++          "type": {
++            "key": {
++              "type": "string"
++            }
++          }
++        },
++        "reference_design": {
++          "type": {
++            "key": {
++              "type": "string"
++            }
++          }
++        },
++        "certification_region": {
++          "type": {
++            "key": {
++              "type": "string"
++            }
++          }
+         }
+       },
+       "isRoot": true,
+Index: opensync-2.0.5.0/src/lib/target/inc/target.h
+===================================================================
+--- opensync-2.0.5.0.orig/src/lib/target/inc/target.h
++++ opensync-2.0.5.0/src/lib/target/inc/target.h
+@@ -332,6 +332,115 @@ bool target_hw_revision_get(void *buff,
+  */
+ bool target_platform_version_get(void *buff, size_t buffsz);
+ 
++/**
++ * @brief Return device model revision
++ *
++ * This function provides a null terminated byte string containing the
++ * model revision. The model revision is a part of AWLAN_Node table.
++ *
++ * @param buff   pointer to a string buffer
++ * @param buffsz size of string buffer
++ * @return true on success
++ */
++bool target_model_revision_get(void *buff, size_t buffsz);
++
++/**
++ * @brief Return device model description
++ *
++ * This function provides a null terminated byte string containing the
++ * model description. The model description is a part of AWLAN_Node table.
++ *
++ * @param buff   pointer to a string buffer
++ * @param buffsz size of string buffer
++ * @return true on success
++ */
++bool target_model_description_get(void *buff, size_t buffsz);
++
++/**
++ * @brief Return device manufacturer name
++ *
++ * This function provides a null terminated byte string containing the
++ * manufacturer name. The manufacturer name is a part of AWLAN_Node table.
++ *
++ * @param buff   pointer to a string buffer
++ * @param buffsz size of string buffer
++ * @return true on success
++ */
++bool target_manuf_name_get(void *buff, size_t buffsz);
++
++/**
++ * @brief Return device manufacturer date
++ *
++ * This function provides a null terminated byte string containing the
++ * manufacturer date. The manufacturer date is a part of AWLAN_Node table.
++ *
++ * @param buff   pointer to a string buffer
++ * @param buffsz size of string buffer
++ * @return true on success
++ */
++bool target_manuf_date_get(void *buff, size_t buffsz);
++
++/**
++ * @brief Return device manufacturer url
++ *
++ * This function provides a null terminated byte string containing the
++ * manufacturer url. The manufacturer url is a part of AWLAN_Node table.
++ *
++ * @param buff   pointer to a string buffer
++ * @param buffsz size of string buffer
++ * @return true on success
++ */
++bool target_manuf_url_get(void *buff, size_t buffsz);
++
++/**
++ * @brief Return device manufacturer name abbreviation
++ *
++ * This function provides a null terminated byte string containing the
++ * manufacturer name abbreviation. This is one of the pieces that form
++ * the QR code entry which is a part of AWLAN_Node table.
++ *
++ * @param buff   pointer to a string buffer
++ * @param buffsz size of string buffer
++ * @return true on success
++ */
++bool target_manuf_abbr_get(void *buff, size_t buffsz);
++
++/**
++ * @brief Return device reference design
++ *
++ * This function provides a null terminated byte string containing the
++ * reference design. The reference design is a part of AWLAN_Node table.
++ *
++ * @param buff   pointer to a string buffer
++ * @param buffsz size of string buffer
++ * @return true on success
++ */
++bool target_ref_design_get(void *buff, size_t buffsz);
++
++/**
++ * @brief Return device certification region
++ *
++ * This function provides a null terminated byte string containing the
++ * certification region. The certification region is a part of AWLAN_Node table.
++ *
++ * @param buff   pointer to a string buffer
++ * @param buffsz size of string buffer
++ * @return true on success
++ */
++bool target_cert_region_get(void *buff, size_t buffsz);
++
++/**
++ * @brief Return device mac address
++ *
++ * This function provides a null terminated byte string containing the
++ * mac address. The mac address is a part of AWLAN_Node table.
++ *
++ * @param buff   pointer to a string buffer
++ * @param buffsz size of string buffer
++ * @return true on success
++ */
++bool target_mac_addr_get(void *buff, size_t buffsz);
++
+ /// @} LIB_TARGET_ENTITY
+ 
+ /// @defgroup LIB_TARGET_MAP Interface Mapping API
+Index: opensync-2.0.5.0/src/dm/src/dm_ovsdb.c
+===================================================================
+--- opensync-2.0.5.0.orig/src/dm/src/dm_ovsdb.c
++++ opensync-2.0.5.0/src/dm/src/dm_ovsdb.c
+@@ -326,7 +326,7 @@ void fill_entity_data(struct schema_AWLA
+         s_awlan_node->sku_number_exists = true;
+     }
+ 
+-    if (true == target_hw_revision_get(buff, sizeof(buff)))
++    if (true == target_model_revision_get(buff, sizeof(buff)))
+     {
+         STRSCPY(s_awlan_node->revision, buff);
+     }
+@@ -359,6 +359,58 @@ void fill_entity_data(struct schema_AWLA
+     }
+     s_awlan_node->model_exists = true;
+ 
++    if (true == target_model_description_get(buff, sizeof(buff)))
++    {
++        STRSCPY(s_awlan_node->model_description, buff);
++        s_awlan_node->model_description_exists = true;
++    }
++
++    if (true == target_manuf_name_get(buff, sizeof(buff)))
++    {
++        STRSCPY(s_awlan_node->manufacturer_name, buff);
++        s_awlan_node->manufacturer_name_exists = true;
++    }
++
++    if (true == target_manuf_date_get(buff, sizeof(buff)))
++    {
++        STRSCPY(s_awlan_node->manufacturer_date, buff);
++        s_awlan_node->manufacturer_date_exists = true;
++    }
++
++    if (true == target_manuf_url_get(buff, sizeof(buff)))
++    {
++        STRSCPY(s_awlan_node->manufacturer_url, buff);
++        s_awlan_node->manufacturer_url_exists = true;
++    }
++
++    if (true == target_ref_design_get(buff, sizeof(buff)))
++    {
++        STRSCPY(s_awlan_node->reference_design, buff);
++        s_awlan_node->reference_design_exists = true;
++    }
++
++    if (true == target_cert_region_get(buff, sizeof(buff)))
++    {
++        STRSCPY(s_awlan_node->certification_region, buff);
++        s_awlan_node->certification_region_exists = true;
++    }
++
++    if (true == target_mac_addr_get(buff, sizeof(buff)))
++    {
++        STRSCPY(s_awlan_node->id, buff);
++        s_awlan_node->id_exists = true;
++    }
++
++    SCHEMA_KEY_VAL_APPEND(s_awlan_node->qr_code, "DT", "AP");
++    SCHEMA_KEY_VAL_APPEND(s_awlan_node->qr_code, "DM", s_awlan_node->id);
++    if (true == target_manuf_abbr_get(buff, sizeof(buff)))
++    {
++    	SCHEMA_KEY_VAL_APPEND(s_awlan_node->qr_code, "VN", buff);
++    }
++    SCHEMA_KEY_VAL_APPEND(s_awlan_node->qr_code, "SN", s_awlan_node->serial_number);
++    SCHEMA_KEY_VAL_APPEND(s_awlan_node->qr_code, "MN", s_awlan_node->model);
++    SCHEMA_KEY_VAL_APPEND(s_awlan_node->qr_code, "HW", s_awlan_node->revision);
++
+     LOG(NOTICE, "Device entity {serial=%s id=%s version=%s platform=%s sku=%s}",
+             s_awlan_node->serial_number,
+             s_awlan_node->id,
+@@ -422,6 +474,13 @@ bool act_update_entity (void)
+                                  "sku_number",
+                                  "upgrade_status",
+                                  "upgrade_timer",
++                                 "qr_code",
++                                 "model_description",
++                                 "manufacturer_name",
++                                 "manufacturer_date",
++                                 "manufacturer_url",
++                                 "reference_design",
++                                 "certification_region",
+                                  NULL)
+                              );
+ 

feeds/wlan-ap/opensync/patches/34-radsec-schema-consts.patch

@@ -0,0 +1,140 @@
+--- a/interfaces/opensync.ovsschema
++++ b/interfaces/opensync.ovsschema
+@@ -9492,6 +9492,137 @@
+       },
+       "isRoot": true,
+       "maxRows": 1
++    },
++    "Radius_Proxy_Config": {
++        "columns": {
++            "radius_config_name": {
++                "type": {
++                "key": {
++                  "type": "string"
++                },
++                "min": 1,
++                "max": 1
++              }
++            },
++            "radsec": {
++                "type": {
++                "key": {
++                  "type": "boolean"
++                },
++                "min": 1,
++                "max": 1
++              }
++            },
++            "server": {
++                "type": {
++                "key": {
++                  "type": "string"
++                },
++                "min": 1,
++                "max": 1
++              }
++            },
++            "port": {
++              "type": {
++                "key": {
++                  "type": "integer"
++                },
++                "min": 1,
++                "max": 1
++              }
++            },
++            "secret": {
++                "type": {
++                "key": {
++                  "type": "string"
++                },
++                "min": 1,
++                "max": 1
++              }
++            },
++            "acct_server": {
++                "type": {
++                "key": {
++                  "type": "string"
++                },
++                "min": 0,
++                "max": 1
++              }
++            },
++            "acct_port": {
++              "type": {
++                "key": {
++                  "type": "integer"
++                },
++                "min": 0,
++                "max": 1
++              }
++            },
++            "acct_secret": {
++                "type": {
++                "key": {
++                  "type": "string"
++                },
++                "min": 0,
++                "max": 1
++              }
++            },
++            "ca_cert": {
++                "type": {
++                    "key": {
++                        "type": "string",
++                        "minLength": 1,
++                        "maxLength": 256
++                    },
++                    "min": 0,
++                    "max": 1
++                }
++              },
++            "client_cert": {
++                "type": {
++                    "key": {
++                        "type": "string",
++                        "minLength": 1,
++                        "maxLength": 256
++                    },
++                    "min": 0,
++                    "max": 1
++                }
++              },
++            "client_key": {
++                "type": {
++                    "key": {
++                        "type": "string",
++                        "minLength": 1,
++                        "maxLength": 256
++                    },
++                    "min": 0,
++                    "max": 1
++                }
++              },
++            "passphrase": {
++                "type": {
++                    "key": {
++                        "type": "string",
++                        "minLength": 0,
++                        "maxLength": 128
++                    },
++                    "min": 0,
++                    "max": 1
++                }
++              },
++            "realm": {
++              "type": {
++                "key": {
++                  "type": "string",
++                  "maxLength": 256
++                },
++                "min": 0,
++                "max": 16
++              }
++            }
++         },
++        "isRoot": true
+     }
+   }
+ }

feeds/wlan-ap/opensync/patches/35-add-proxy-arp-schema.patch

@@ -0,0 +1,13 @@
+Index: opensync-2.0.5.0/src/lib/schema/inc/schema_consts.h
+===================================================================
+--- opensync-2.0.5.0.orig/src/lib/schema/inc/schema_consts.h
++++ opensync-2.0.5.0/src/lib/schema/inc/schema_consts.h
+@@ -155,6 +155,8 @@ typedef enum {
+ #define SCHEMA_CONSTS_IEEE80211k	"ieee80211k"
+ #define SCHEMA_CONSTS_DYNAMIC_VLAN	"dynamic_vlan"
+ #define SCHEMA_CONSTS_RADPROXY	"radproxy"
++#define SCHEMA_CONSTS_PROXY_ARP		"proxy_arp"
++#define SCHEMA_CONSTS_MCAST_TO_UCAST	"mcast_to_ucast"
+ 
+ /* radio Custom options */
+ #define SCHEMA_CONSTS_LOCAL_PWR_CONSTRAINT "local_pwr_constraint"

feeds/wlan-ap/opensync/patches/35-channel-switch-fix.patch

@@ -0,0 +1,34 @@
+Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c
+===================================================================
+--- opensync-2.0.5.0.orig/src/lib/datapipeline/src/dppline.c
++++ opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c
+@@ -652,8 +652,8 @@ static bool dppline_copysts(dppline_stat
+ 			dst->u.events.client_event_qty++;
+ 		}
+ 
+-		size = dst->u.events.client_event_qty * sizeof(dpp_event_record_session_t);
+-		dst->u.events.client_event_list = calloc(1, size);
++		int size_cl = dst->u.events.client_event_qty * sizeof(dpp_event_record_session_t);
++		dst->u.events.client_event_list = calloc(1, size_cl);
+ 		int count = 0;
+ 		ds_dlist_foreach(&report_data->client_event_list, result)
+ 		{
+@@ -671,8 +671,8 @@ static bool dppline_copysts(dppline_stat
+ 			dst->u.events.channel_event_qty++;
+ 		}
+ 
+-		size = dst->u.events.channel_event_qty * sizeof(dpp_event_record_channel_switch_t);
+-		dst->u.events.channel_event_list = calloc(1, size);
++		int size_ch = dst->u.events.channel_event_qty * sizeof(dpp_event_record_channel_switch_t);
++		dst->u.events.channel_event_list = calloc(1, size_ch);
+ 		ds_dlist_foreach(&report_data->channel_switch_list, channel_result)
+ 		{
+ 			assert(count < (int)dst->u.events.channel_event_qty);
+@@ -680,6 +680,7 @@ static bool dppline_copysts(dppline_stat
+ 			       sizeof(dpp_event_record_channel_switch_t));
+ 			count++;
+ 		}
++		size = size_cl + size_ch;
+ 
+ 	} break;
+ 

feeds/wlan-ap/opensync/patches/36-add-channel-hop-config.patch

@@ -0,0 +1,66 @@
+Index: opensync-2.0.5.0/interfaces/opensync.ovsschema
+===================================================================
+--- opensync-2.0.5.0.orig/interfaces/opensync.ovsschema
++++ opensync-2.0.5.0/interfaces/opensync.ovsschema
+@@ -8982,6 +8982,61 @@
+                     "min": 0,
+                     "max": 1
+                 }
++            },
++            "noise_floor_thresh": {
++                "type": {
++                    "key": {
++                        "type": "integer",
++                        "minInteger": -90,
++                        "maxInteger": -10
++                    },
++                    "min": 0,
++                    "max": 1
++                }
++            },
++            "noise_floor_time": {
++                "type": {
++                    "key": {
++                        "type": "integer",
++                        "minInteger": 60,
++                        "maxInteger": 600
++                    },
++                    "min": 0,
++                    "max": 1
++                }
++            },
++            "non_wifi_thresh": {
++                "type": {
++                    "key": {
++                        "type": "integer",
++                        "minInteger": 0,
++                        "maxInteger": 100
++                    },
++                    "min": 0,
++                    "max": 1
++                }
++            },
++            "non_wifi_time": {
++                "type": {
++                    "key": {
++                        "type": "integer",
++                        "minInteger": 60,
++                        "maxInteger": 600
++                    },
++                    "min": 0,
++                    "max": 1
++                }
++            },
++            "obss_hop_mode": {
++                "type": {
++                    "key": {
++                        "type": "integer",
++                        "minInteger": 1,
++                        "maxInteger": 2
++                    },
++                    "min": 0,
++                    "max": 1
++                }
+             }
+         },
+         "isRoot": true

feeds/wlan-ap/opensync/src/platform/openwrt/src/command/src/cmd_tcpdump.c

@@ -215,6 +215,7 @@ pid_t cmd_handler_tcpdump_wifi(struct task *task)
 	char *argv[] = { "/usr/sbin/tcpdump", "-c", "1000", "-G", duration, "-W", "1", "-w", pcap, "-i", phy, NULL };
 	char iw[128];
 	pid_t pid;
+	int ret = 0;
 
 	task->arg = SCHEMA_KEY_VAL(task->conf.payload, "wifi");
 	if (!task->arg) {
@@ -225,15 +226,23 @@ pid_t cmd_handler_tcpdump_wifi(struct task *task)
 
 	blob_buf_init(&b, 0);
 	uci = uci_alloc_context();
-	uci_load(uci, "wireless", &p);
-	s = uci_lookup_section(uci, p, task->arg);
-        if (!s) {
-		task_status(task, TASK_FAILED, "unknown wifi");
+
+	ret = uci_load(uci, "wireless", &p);
+	if (ret) {
+		LOGE("%s: uci_load() failed with rc %d", __func__, ret);
 		uci_free_context(uci);
-                return -1;
+		return -1;
+	}
+	s = uci_lookup_section(uci, p, task->arg);
+	if (!s) {
+		task_status(task, TASK_FAILED, "unknown wifi");
+		uci_unload(uci, p);
+		uci_free_context(uci);
+		return -1;
 	}
 
-        uci_to_blob(&b, s, &phy_param);
+	uci_to_blob(&b, s, &phy_param);
+	uci_unload(uci, p);
 	uci_free_context(uci);
 
 	blobmsg_parse(phy_policy, __PHY_ATTR_MAX, tb, blob_data(b.head), blob_len(b.head));

feeds/wlan-ap/opensync/src/platform/openwrt/src/command/src/node_config.c

@@ -88,9 +88,14 @@ static void syslog_state(int config)
 	struct uci_element *e = NULL;
 	struct uci_section *s = NULL;
 	char val[128];
+	int ret = 0;
 
 	blob_buf_init(&b, 0);
-	uci_load(uci, "system", &system);
+	ret = uci_load(uci, "system", &system);
+	if (ret) {
+		LOGE("%s: uci_load() failed with rc %d", __func__, ret);
+		return;
+	}
 	uci_foreach_element(&system->sections, e) {
 		s = uci_to_section(e);
 		if (!strcmp(s->type, "system"))
@@ -179,14 +184,20 @@ static void ntp_state(int config)
         struct uci_section *s;
 	struct blob_attr *cur = NULL;
 	char val[128] = {};
-	int first = 1, rem = 0;
+	int first = 1, rem = 0, ret = 0;
 
 	blob_buf_init(&b, 0);
-	uci_load(uci, "system", &p);
+	ret = uci_load(uci, "system", &p);
+	if (ret) {
+		LOGE("%s: uci_load() failed with rc %d", __func__, ret);
+		return;
+	}
 
 	s = uci_lookup_section(uci, p, "ntp");
-	if (!s)
+	if (!s) {
+		uci_unload(uci, p);
 		return;
+	}
 
 	uci_to_blob(&b, s, &ntp_param);
 	blobmsg_parse(ntp_policy, __NTP_ATTR_MAX, tb, blob_data(b.head), blob_len(b.head));

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/inc/captive.h

@@ -8,7 +8,7 @@ extern struct blob_buf c;
 extern struct schema_Wifi_VIF_State vstate;
 extern const struct schema_Wifi_VIF_Config *vconf;
 extern void vif_captive_portal_set (const struct schema_Wifi_VIF_Config *vconf, char *ifname);
-extern void vif_state_captive_portal_options_get(struct schema_Wifi_VIF_State *vstate, struct uci_section *s);
+extern void vif_state_captive_portal_options_get(struct schema_Wifi_VIF_State *vstate);
 extern void captive_portal_init();
 extern void splash_page_logo(char* dest_file,char* src_url);
 extern void vif_dhcp_opennds_allowlist_set(const struct schema_Wifi_VIF_Config *vconf, char *ifname);

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/inc/nl80211.h

@@ -26,6 +26,7 @@ struct wifi_phy {
 	unsigned int chanpwr[IEEE80211_CHAN_MAX];
 	unsigned int freq[IEEE80211_CHAN_MAX];
 
+	int current_channel;
 	int tx_ant, rx_ant, tx_ant_avail, rx_ant_avail;
 	int band_2g, band_5gl, band_5gu;
 };
@@ -56,7 +57,6 @@ struct wifi_station {
 };
 
 extern int radio_nl80211_init(void);
-
 extern struct wifi_phy *phy_find(const char *name);
 extern struct wifi_iface *vif_find(const char *name);
 extern struct wifi_station *sta_find(const unsigned char *addr);

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/inc/phy.h

@@ -12,11 +12,11 @@ extern int phy_get_tx_available_antenna(const char *name);
 extern int phy_get_rx_available_antenna(const char *name);
 extern int phy_get_max_tx_power(const char *name , int channel);
 extern int phy_get_channels(const char *name, int *channel);
-extern int phy_get_list_channels_dfs(const char *name, int *list);
 extern int phy_get_channels_state(const char *name,
 			struct schema_Wifi_Radio_State *rstate);
 extern int phy_get_band(const char *name, char *band);
 extern int phy_is_ready(const char *name);
 extern int phy_lookup(char *name);
+extern int get_current_channel(char *name);
 
 #endif

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/inc/radio.h

@@ -21,4 +21,6 @@ extern int hapd_rrm_set_neighbors(char *name, struct rrm_neighbor *neigh, int co
 
 extern void radio_maverick(void *arg);
 
+int nl80211_channel_get(char *name, unsigned int *chan);
+
 #endif

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/inc/radius_proxy.h

@@ -0,0 +1,38 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+
+#ifndef RADIUS_PROXY_H_INCLUDED
+#define RADIUS_PROXY_H_INCLUDED
+
+#include <stdbool.h>
+#include <jansson.h>
+#include <ev.h>
+#include <sys/time.h>
+#include <syslog.h>
+
+#include "log.h"
+#include "os_nif.h"
+
+#include "target.h"
+#include "dppline.h"
+
+#include "os.h"
+#include "util.h"
+#include "ovsdb.h"
+#include "ovsdb_update.h"
+#include "ovsdb_sync.h"
+#include "ovsdb_table.h"
+#include "ovsdb_cache.h"
+#include "schema.h"
+#include "target.h"
+
+#include "utils.h"
+#include <libubox/list.h>
+#include <evsched.h>
+
+extern ovsdb_table_t table_Radius_Proxy_Config;
+
+void callback_Radius_Proxy_Config(ovsdb_update_monitor_t *mon,
+		struct schema_Radius_Proxy_Config *old, struct schema_Radius_Proxy_Config *conf);
+
+#endif /* RADIUS_PROXY_H_INCLUDED */
+

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/inc/rrm_config.h

@@ -33,6 +33,7 @@ extern ovsdb_table_t table_Wifi_RRM_Config;
 
 void rrm_config_vif(struct blob_buf *b, struct blob_buf *del, 
 		const char * freq_band, const char * if_name);
+int rrm_get_backup_channel(const char * freq_band);
 void callback_Wifi_RRM_Config(ovsdb_update_monitor_t *mon,
 		struct schema_Wifi_RRM_Config *old, struct schema_Wifi_RRM_Config *conf);
 

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/inc/utils.h

@@ -13,6 +13,7 @@ struct mode_map {
 	char *ucihwmode;
 	char *htmode;
 	char *ucihtmode;
+	int  sec_channel_offset;
 };
 
 extern struct mode_map *mode_map_get_uci(const char *band, const char *htmode, const char *hwmode);
@@ -20,6 +21,7 @@ extern struct mode_map *mode_map_get_cloud(const char *htmode, const char *hwmod
 
 extern int vif_get_mac(char *vap, char *mac);
 extern int vif_is_ready(const char *name);
+bool vif_get_key_for_key_distr(const char *secret, char *key_str);
 
 #define blobmsg_add_bool blobmsg_add_u8
 extern int blobmsg_add_hex16(struct blob_buf *buf, const char *name, uint16_t val);
@@ -38,4 +40,5 @@ extern int iface_is_up(const char *ifname);
 extern int net_get_mtu(char *iface);
 extern int net_get_mac(char *iface, char *mac);
 extern int net_is_bridge(char *iface);
+extern char* get_max_channel_bw_channel(int channel_freq, const char* htmode);
 #endif

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/inc/vif.h

@@ -29,6 +29,7 @@
 
 #define SCHEMA_CONSTS_RADIUS_NAS_ID         "radius_nas_id"
 #define SCHEMA_CONSTS_RADIUS_OPER_NAME      "radius_oper_name"
+#define SCHEMA_CONSTS_RADIUS_NAS_IP         "radius_nas_ip"
 
 bool vif_get_security(struct schema_Wifi_VIF_State *vstate, char *mode, char *encryption, char *radiusServerIP, char *password, char *port);
 extern bool vif_state_update(struct uci_section *s, struct schema_Wifi_VIF_Config *vconf);

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/override.mk

@@ -46,6 +46,7 @@ UNIT_SRC_TOP += $(OVERRIDE_DIR)/src/sysupgrade.c
 UNIT_SRC_TOP += $(OVERRIDE_DIR)/src/dhcpdiscovery.c
 UNIT_SRC_TOP += $(OVERRIDE_DIR)/src/radius_probe.c
 UNIT_SRC_TOP += $(OVERRIDE_DIR)/src/rrm_config.c
+UNIT_SRC_TOP += $(OVERRIDE_DIR)/src/radius_proxy.c
 
 CONFIG_USE_KCONFIG=y
 CONFIG_INET_ETH_LINUX=y

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/src/captive.c

@@ -143,7 +143,7 @@ void vif_state_dhcp_allowlist_get(struct schema_Wifi_VIF_State *vstate)
 	uci_load(dns, "dhcp", &dhcp);
 	ip_section = uci_lookup_section(dns, dhcp,"dnsmasq");
 	if(!ip_section) {
-		LOGN("Section Not Found");
+		uci_unload(dns, dhcp);
 		return;
 	}
 	blob_buf_init(&dnsmas, 0);
@@ -158,7 +158,7 @@ void vif_state_dhcp_allowlist_get(struct schema_Wifi_VIF_State *vstate)
 			if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
 				continue;
 			sscanf(blobmsg_get_string(cur), "/%[^/]/%[^_]_%s", fqdn, set, read_ifname);
-			if(!strcmp(vstate->if_name, read_ifname))
+			if(!strcmp("opennds", read_ifname))
 			{
 				strcpy(vstate->captive_allowlist[vstate->captive_allowlist_len], fqdn);
 				vstate->captive_allowlist_len++;
@@ -171,10 +171,8 @@ void vif_state_dhcp_allowlist_get(struct schema_Wifi_VIF_State *vstate)
 
 void ipset_flush(char *ifname)
 {
-	char com[24]="ipset flush set_wlan1";
-
-	if (!strcmp(ifname,"wlan1"))
-		system(com);
+	char com[32]="ipset flush set_opennds";
+	system(com);
 }
 
 void vif_dhcp_opennds_allowlist_set(const struct schema_Wifi_VIF_Config *vconf, char *ifname)
@@ -189,7 +187,7 @@ void vif_dhcp_opennds_allowlist_set(const struct schema_Wifi_VIF_Config *vconf,
 	for (i = 0; i < vconf->captive_allowlist_len; i++)
 	{
 		strcpy(buff,(char*)vconf->captive_allowlist[i]);
-		sprintf(ips,"/%s/set_%s", buff,ifname);
+		sprintf(ips,"/%s/set_%s", buff,"opennds");
 		blobmsg_add_string(&dnsmas, NULL,ips);
 	}
 	blobmsg_close_array(&dnsmas, e);
@@ -228,134 +226,129 @@ void set_captive_portal_state(struct schema_Wifi_VIF_State *vstate,
 	return;
 }
 
-void vif_state_captive_portal_options_get(struct schema_Wifi_VIF_State *vstate, struct uci_section *s)
+void vif_state_captive_portal_options_get(struct schema_Wifi_VIF_State *vstate)
 {
 	int i;
 	int index = 0;
 	const char *opt;
 	char *buf = NULL;
 	struct blob_attr *tc[__NDS_ATTR_MAX] = { };
-	struct uci_element *e = NULL;
+	struct uci_section *cp_section;
 
 	uci_load(cap_uci, "opennds", &opennds);
-	uci_foreach_element(&opennds->sections, e) {
-		struct uci_section *cp_section = uci_to_section(e);
-		if (!strcmp(s->e.name, cp_section->e.name)){
+	cp_section = uci_lookup_section(cap_uci, opennds,"opennds");
+	if(!cp_section) {
+		uci_unload(cap_uci, opennds);
+		return;
+	}
+	blob_buf_init(&cap, 0);
+	uci_to_blob(&cap, cp_section, &opennds_param);
+	blobmsg_parse(opennds_policy, __NDS_ATTR_MAX, tc, blob_data(cap.head), blob_len(cap.head));
+	for (i = 0; i < SCHEMA_CAPTIVE_PORTAL_OPTS_MAX; i++) {
+		opt = captive_portal_options_table[i];
+		if  (!strcmp(opt, "session_timeout"))
+		{
+			if (tc[NDS_ATTR_SESSIONTIMEOUT])
+			{
+				buf = blobmsg_get_string(tc[NDS_ATTR_SESSIONTIMEOUT]);
+				set_captive_portal_state(vstate, &index,
+						captive_portal_options_table[i],
+						buf);
+			}
+		} else if (!strcmp(opt, "authentication")) {
+			if(tc[NDS_ATTR_AUTHENTICATION]) {
+				buf = blobmsg_get_string(tc[NDS_ATTR_AUTHENTICATION]);
+				if (!strcmp(buf, "None") || !strcmp(buf, "username") || !strcmp(buf, "radius")) {
 
-			blob_buf_init(&cap, 0);
-			uci_to_blob(&cap, cp_section, &opennds_param);
-			blobmsg_parse(opennds_policy, __NDS_ATTR_MAX, tc, blob_data(cap.head), blob_len(cap.head));
-			for (i = 0; i < SCHEMA_CAPTIVE_PORTAL_OPTS_MAX; i++) {
-				opt = captive_portal_options_table[i];
-				if  (!strcmp(opt, "session_timeout"))
-				{
-					if (tc[NDS_ATTR_SESSIONTIMEOUT])
-					{
-						buf = blobmsg_get_string(tc[NDS_ATTR_SESSIONTIMEOUT]);
-						set_captive_portal_state(vstate, &index,
-								captive_portal_options_table[i],
-								buf);
-					}
-				} else if (!strcmp(opt, "authentication")) {
-					if(tc[NDS_ATTR_AUTHENTICATION]) {
-						buf = blobmsg_get_string(tc[NDS_ATTR_AUTHENTICATION]);
-						if (!strcmp(buf, "None")) {
-
-							set_captive_portal_state(vstate, &index,
-									captive_portal_options_table[i],
-									buf);
-						} else if (!strcmp(buf,"username")) {
-							set_captive_portal_state(vstate, &index,
-									captive_portal_options_table[i],
-									buf);
-						}
-					}
-				} else if (strcmp(opt, "browser_title") == 0) {
-					if (tc[NDS_ATTR_GATEWAYNAME]) {
-						buf = blobmsg_get_string(tc[NDS_ATTR_GATEWAYNAME]);
-						set_captive_portal_state(vstate, &index,
-								captive_portal_options_table[i],
-								buf);
-					}
-				} else if (strcmp(opt, "splash_page_logo") == 0) {
-					if (tc[NDS_ATTR_SPLASH_PAGE_LOGO]) {
-						buf = blobmsg_get_string(tc[NDS_ATTR_SPLASH_PAGE_LOGO]);
-						set_captive_portal_state(vstate, &index,
-								captive_portal_options_table[i],
-								buf);
-					}
-				} else if (strcmp(opt, "splash_page_background_logo") == 0) {
-					if (tc[NDS_ATTR_PAGE_BACKGROUND_LOGO]) {
-						buf = blobmsg_get_string(tc[NDS_ATTR_PAGE_BACKGROUND_LOGO]);
-						set_captive_portal_state(vstate, &index,
-								captive_portal_options_table[i],
-								buf);
-					}
-				} else if (strcmp(opt, "splash_page_title") == 0) {
-					if (tc[NDS_ATTR_SPLASH_PAGE_TITLE]) {
-						buf = blobmsg_get_string(tc[NDS_ATTR_SPLASH_PAGE_TITLE]);
-						set_captive_portal_state(vstate, &index,
-								captive_portal_options_table[i],
-								buf);
-					}
-				} else if (strcmp(opt, "redirect_url") == 0) {
-					if (tc[NDS_ATTR_REDIRECT_URL]) {
-						buf = blobmsg_get_string(tc[NDS_ATTR_REDIRECT_URL]);
-						set_captive_portal_state(vstate, &index,
-								captive_portal_options_table[i],
-								buf);
-					}
-				} else if (strcmp(opt, "acceptance_policy") == 0) {
-					if (tc[NDS_ATTR_ACCEPTANCE_POLICY]) {
-						buf = blobmsg_get_string(tc[NDS_ATTR_ACCEPTANCE_POLICY]);
-						set_captive_portal_state(vstate, &index,
-								captive_portal_options_table[i],
-								buf);
-					}
-				} else if (strcmp(opt, "login_success_text") == 0) {
-					if (tc[NDS_ATTR_LOGIN_SUCCESS_TEXT]) {
-						buf = blobmsg_get_string(tc[NDS_ATTR_LOGIN_SUCCESS_TEXT]);
-						set_captive_portal_state(vstate, &index,
-								captive_portal_options_table[i],
-								buf);
-					}
-				} else if (strcmp(opt, "username_password_file") == 0) {
-					if (tc[NDS_ATTR_USERNAMEPASS_FILE]) {
-						buf = blobmsg_get_string(tc[NDS_ATTR_USERNAMEPASS_FILE]);
-						set_captive_portal_state(vstate, &index,
-								captive_portal_options_table[i],
-								buf);
-					}
-				} else if (strcmp(opt, "radius_server_ip") == 0) {
-					if (tc[NDS_ATTR_RADIUS_IP]) {
-						buf = blobmsg_get_string(tc[NDS_ATTR_RADIUS_IP]);
-						set_captive_portal_state(vstate, &index,
-								captive_portal_options_table[i],
-								buf);
-					}
-				} else if (strcmp(opt, "radius_server_port") == 0) {
-					if (tc[NDS_ATTR_RADIUS_PORT]) {
-						buf = blobmsg_get_string(tc[NDS_ATTR_RADIUS_PORT]);
-						set_captive_portal_state(vstate, &index,
-								captive_portal_options_table[i],
-								buf);
-					}
-				} else if (strcmp(opt, "radius_server_secret") == 0) {
-					if (tc[NDS_ATTR_RADIUS_SECRET]) {
-						buf = blobmsg_get_string(tc[NDS_ATTR_RADIUS_SECRET]);
-						set_captive_portal_state(vstate, &index,
-								captive_portal_options_table[i],
-								buf);
-					}
-				} else if (strcmp(opt, "radius_auth_type") == 0) {
-					if (tc[NDS_ATTR_RADIUS_AUTH_TYPE]) {
-						buf = blobmsg_get_string(tc[NDS_ATTR_RADIUS_AUTH_TYPE]);
-						set_captive_portal_state(vstate, &index,
-								captive_portal_options_table[i],
-								buf);
-					}
+					set_captive_portal_state(vstate, &index,
+							captive_portal_options_table[i],
+							buf);
 				}
 			}
+		} else if (strcmp(opt, "browser_title") == 0) {
+			if (tc[NDS_ATTR_GATEWAYNAME]) {
+				buf = blobmsg_get_string(tc[NDS_ATTR_GATEWAYNAME]);
+				set_captive_portal_state(vstate, &index,
+						captive_portal_options_table[i],
+						buf);
+			}
+		} else if (strcmp(opt, "splash_page_logo") == 0) {
+			if (tc[NDS_ATTR_SPLASH_PAGE_LOGO]) {
+				buf = blobmsg_get_string(tc[NDS_ATTR_SPLASH_PAGE_LOGO]);
+				set_captive_portal_state(vstate, &index,
+						captive_portal_options_table[i],
+						buf);
+			}
+		} else if (strcmp(opt, "splash_page_background_logo") == 0) {
+			if (tc[NDS_ATTR_PAGE_BACKGROUND_LOGO]) {
+				buf = blobmsg_get_string(tc[NDS_ATTR_PAGE_BACKGROUND_LOGO]);
+				set_captive_portal_state(vstate, &index,
+						captive_portal_options_table[i],
+						buf);
+			}
+		} else if (strcmp(opt, "splash_page_title") == 0) {
+			if (tc[NDS_ATTR_SPLASH_PAGE_TITLE]) {
+				buf = blobmsg_get_string(tc[NDS_ATTR_SPLASH_PAGE_TITLE]);
+				set_captive_portal_state(vstate, &index,
+						captive_portal_options_table[i],
+						buf);
+			}
+		} else if (strcmp(opt, "redirect_url") == 0) {
+			if (tc[NDS_ATTR_REDIRECT_URL]) {
+				buf = blobmsg_get_string(tc[NDS_ATTR_REDIRECT_URL]);
+				set_captive_portal_state(vstate, &index,
+						captive_portal_options_table[i],
+						buf);
+			}
+		} else if (strcmp(opt, "acceptance_policy") == 0) {
+			if (tc[NDS_ATTR_ACCEPTANCE_POLICY]) {
+				buf = blobmsg_get_string(tc[NDS_ATTR_ACCEPTANCE_POLICY]);
+				set_captive_portal_state(vstate, &index,
+						captive_portal_options_table[i],
+						buf);
+			}
+		} else if (strcmp(opt, "login_success_text") == 0) {
+			if (tc[NDS_ATTR_LOGIN_SUCCESS_TEXT]) {
+				buf = blobmsg_get_string(tc[NDS_ATTR_LOGIN_SUCCESS_TEXT]);
+				set_captive_portal_state(vstate, &index,
+						captive_portal_options_table[i],
+						buf);
+			}
+		} else if (strcmp(opt, "username_password_file") == 0) {
+			if (tc[NDS_ATTR_USERNAMEPASS_FILE]) {
+				buf = blobmsg_get_string(tc[NDS_ATTR_USERNAMEPASS_FILE]);
+				set_captive_portal_state(vstate, &index,
+						captive_portal_options_table[i],
+						buf);
+			}
+		} else if (strcmp(opt, "radius_server_ip") == 0) {
+			if (tc[NDS_ATTR_RADIUS_IP]) {
+				buf = blobmsg_get_string(tc[NDS_ATTR_RADIUS_IP]);
+				set_captive_portal_state(vstate, &index,
+						captive_portal_options_table[i],
+						buf);
+			}
+		} else if (strcmp(opt, "radius_server_port") == 0) {
+			if (tc[NDS_ATTR_RADIUS_PORT]) {
+				buf = blobmsg_get_string(tc[NDS_ATTR_RADIUS_PORT]);
+				set_captive_portal_state(vstate, &index,
+						captive_portal_options_table[i],
+						buf);
+			}
+		} else if (strcmp(opt, "radius_server_secret") == 0) {
+			if (tc[NDS_ATTR_RADIUS_SECRET]) {
+				buf = blobmsg_get_string(tc[NDS_ATTR_RADIUS_SECRET]);
+				set_captive_portal_state(vstate, &index,
+						captive_portal_options_table[i],
+						buf);
+			}
+		} else if (strcmp(opt, "radius_auth_type") == 0) {
+			if (tc[NDS_ATTR_RADIUS_AUTH_TYPE]) {
+				buf = blobmsg_get_string(tc[NDS_ATTR_RADIUS_AUTH_TYPE]);
+				set_captive_portal_state(vstate, &index,
+						captive_portal_options_table[i],
+						buf);
+			}
 		}
 	}
 uci_unload(cap_uci, opennds);
@@ -415,7 +408,6 @@ void splash_page_logo(char* dest_file, char* src_url)
 
 	res = curl_easy_perform(curl);
 	if (res != CURLE_OK){
-		LOGN("Image failed to Download: %s",errbuf);
 		clean_up(curl,imagefile,headerfile);
 		remove(dest_file);
 		return;
@@ -424,10 +416,10 @@ void splash_page_logo(char* dest_file, char* src_url)
 	return ;
 }
 
-int ipset_create(char *ifname)
+int ipset_create(char *ifnds)
 {
 	char command[64];
-	sprintf(command,"ipset create set_%s hash:ip", ifname);
+	sprintf(command,"ipset create set_%s hash:ip", ifnds);
 	return (system(command));
 }
 
@@ -435,94 +427,104 @@ void captive_portal_get_current_urls(char *ifname, char *splash_logo, char *back
 {
 	char *buf = NULL;
 	struct blob_attr *tc[__NDS_ATTR_MAX] = { };
-	struct uci_element *e = NULL;
+	struct blob_buf url_buf={ };
+	struct uci_section *cp_section;
 
 	uci_load(cap_uci, "opennds", &opennds);
-	uci_foreach_element(&opennds->sections, e) {
-		struct uci_section *cp_section = uci_to_section(e);
-		if (!strcmp(ifname, cp_section->e.name)){
+	cp_section = uci_lookup_section(cap_uci, opennds,"opennds");
+	if(!cp_section) {
+		uci_unload(cap_uci, opennds);
+		return;
+	}
 
-			blob_buf_init(&cap, 0);
-			uci_to_blob(&cap, cp_section, &opennds_param);
-			blobmsg_parse(opennds_policy, __NDS_ATTR_MAX, tc, blob_data(cap.head), blob_len(cap.head));
+	blob_buf_init(&url_buf, 0);
+	uci_to_blob(&url_buf, cp_section, &opennds_param);
+	blobmsg_parse(opennds_policy, __NDS_ATTR_MAX, tc, blob_data(url_buf.head), blob_len(url_buf.head));
 
-			if (tc[NDS_ATTR_SPLASH_PAGE_LOGO]) {
-				buf = blobmsg_get_string(tc[NDS_ATTR_SPLASH_PAGE_LOGO]);
-				strcpy(splash_logo, buf);
-			} else {
-				splash_logo[0]=0;
-			}
+	if (tc[NDS_ATTR_SPLASH_PAGE_LOGO]) {
+		buf = blobmsg_get_string(tc[NDS_ATTR_SPLASH_PAGE_LOGO]);
+		strcpy(splash_logo, buf);
+	} else {
+		splash_logo[0]=0;
+	}
 
-			if (tc[NDS_ATTR_PAGE_BACKGROUND_LOGO]) {
-				buf = blobmsg_get_string(tc[NDS_ATTR_PAGE_BACKGROUND_LOGO]);
-				strcpy(back_image, buf);
-			} else {
-				back_image[0]=0;
-			}
-			if (tc[NDS_ATTR_USERNAMEPASS_FILE]) {
-				buf = blobmsg_get_string(tc[NDS_ATTR_USERNAMEPASS_FILE]);
-				strcpy(user_file, buf);
-			} else {
-				user_file[0]=0;
-			}
-		}
+	if (tc[NDS_ATTR_PAGE_BACKGROUND_LOGO]) {
+		buf = blobmsg_get_string(tc[NDS_ATTR_PAGE_BACKGROUND_LOGO]);
+		strcpy(back_image, buf);
+	} else {
+		back_image[0]=0;
+	}
+	if (tc[NDS_ATTR_USERNAMEPASS_FILE]) {
+		buf = blobmsg_get_string(tc[NDS_ATTR_USERNAMEPASS_FILE]);
+		strcpy(user_file, buf);
+	} else {
+		user_file[0]=0;
 	}
 	uci_unload(cap_uci, opennds);
 	return;
 }
-void opennds_parameters()
+void opennds_parameters(char *ifname)
 {
 	int i;
 	char users_router[7][64] = { "allow tcp port 53","allow udp port 53",
 				"allow udp port 67","allow tcp port 22",
 				"allow tcp port 23", "allow tcp port 80", "allow tcp port 443"};
+	struct blob_buf cap_blob={ };
+	blob_buf_init(&cap_blob, 0);
 
-	blobmsg_add_string(&cap, "fwhook_enabled","1");
-	blobmsg_add_string(&cap, "use_outdated_mhd","1");
-	blobmsg_add_string(&cap, "unescape_callback_enabled","0");
-	blobmsg_add_string(&cap, "maxclients","250");
-	blobmsg_add_string(&cap, "preauthidletimeout","30");
-	blobmsg_add_string(&cap, "authidletimeout","120");
-	blobmsg_add_string(&cap, "checkinterval","60");
-	blobmsg_add_string(&cap, "uploadrate","0");
-	blobmsg_add_string(&cap, "downloadrate","0");
-	blobmsg_add_string(&cap, "ratecheckwindow","2");
-	blobmsg_add_string(&cap, "uploadquota","0");
-	blobmsg_add_string(&cap, "downloadquota","0");
-	d = blobmsg_open_array(&cap, "authenticated_users");
-	blobmsg_add_string(&cap, NULL, "allow all");
-	blobmsg_close_array(&cap, d);
-	d = blobmsg_open_array(&cap, "users_to_router");
+	blobmsg_add_string(&cap_blob, "fwhook_enabled","1");
+	blobmsg_add_string(&cap_blob, "use_outdated_mhd","1");
+	blobmsg_add_string(&cap_blob, "unescape_callback_enabled","0");
+	blobmsg_add_string(&cap_blob, "maxclients","250");
+	blobmsg_add_string(&cap_blob, "preauthidletimeout","30");
+	blobmsg_add_string(&cap_blob, "authidletimeout","120");
+	blobmsg_add_string(&cap_blob, "checkinterval","60");
+	blobmsg_add_string(&cap_blob, "uploadrate","0");
+	blobmsg_add_string(&cap_blob, "downloadrate","0");
+	blobmsg_add_string(&cap_blob, "ratecheckwindow","2");
+	blobmsg_add_string(&cap_blob, "uploadquota","0");
+	blobmsg_add_string(&cap_blob, "downloadquota","0");
+	d = blobmsg_open_array(&cap_blob, "authenticated_users");
+	blobmsg_add_string(&cap_blob, NULL, "allow all");
+	blobmsg_close_array(&cap_blob, d);
+	d = blobmsg_open_array(&cap_blob, "users_to_router");
 	for(i = 0; i < 7; i++)
 	{
-		blobmsg_add_string(&cap, NULL, users_router[i]);
+		blobmsg_add_string(&cap_blob, NULL, users_router[i]);
 	}
-	blobmsg_close_array(&cap, d);
+	blobmsg_close_array(&cap_blob, d);
+	blob_to_uci_section(cap_uci, "opennds", "opennds", "opennds", cap_blob.head, &opennds_param, NULL);
+	uci_commit_all(cap_uci);
 	return;
 }
 
 void opennds_section_del(char *section_name)
 {
 	struct uci_package *opennds;
+	struct uci_context *nds_ctx;
 	struct uci_element *e = NULL, *tmp = NULL;
-	int ret=0;
+	int ret = 0;
 
-	ret= uci_load(uci, "opennds", &opennds);
+	nds_ctx = uci_alloc_context();
+	ret = uci_load(nds_ctx, "opennds", &opennds);
 	if (ret) {
-		LOGD("%s: uci_load() failed with rc %d", section_name, ret);
+		LOGE("%s: %s uci_load() failed with rc %d", section_name, __func__, ret);
+		uci_free_context(nds_ctx);
 		return;
 	}
 	uci_foreach_element_safe(&opennds->sections, tmp, e) {
 		struct uci_section *s = uci_to_section(e);
 		if (!strcmp(s->e.name, section_name)) {
-			uci_section_del(uci, "vif", "opennds", (char *)s->e.name, section_name);
+			uci_section_del(nds_ctx, "vif", "opennds", (char *)s->e.name, section_name);
 		}
 		else {
 			continue;
 		}
 	}
-	uci_commit(uci, &opennds, false);
-	uci_unload(uci, opennds);
+
+	uci_commit(nds_ctx, &opennds, false);
+	uci_unload(nds_ctx, opennds);
+	uci_free_context(nds_ctx);
 	reload_config = 1;
 }
 
@@ -541,10 +543,10 @@ void vif_captive_portal_set(const struct schema_Wifi_VIF_Config *vconf, char *if
 	char back_image[84];
 	char user_file[84];
 
-	sprintf(path,"/etc/opennds/htdocs/images/%s/",ifname);
+	sprintf(path,"/etc/opennds/htdocs/images/");
 	sprintf(webroot,"/etc/opennds/htdocs");
-	sprintf(ipset_tcp80,"allow tcp port 80 ipset set_%s", ifname);
-	sprintf(ipset_tcp443,"allow tcp port 443 ipset set_%s", ifname);
+	sprintf(ipset_tcp80,"allow tcp port 80 ipset set_opennds");
+	sprintf(ipset_tcp443,"allow tcp port 443 ipset set_opennds");
 	char file_path[128];
 	struct stat st = {0};
 	if (stat(path, &st) == -1)
@@ -564,12 +566,12 @@ void vif_captive_portal_set(const struct schema_Wifi_VIF_Config *vconf, char *if
 		if (!strcmp(opt, "authentication")) {
 			if (strcmp(value,"None")==0) {
 				blobmsg_add_string(&cap, "webroot",webroot);
-				opennds_parameters();
+				opennds_parameters(ifname);
 				blobmsg_add_string(&cap, "enabled", "1");
 				blobmsg_add_string(&cap, "gatewayinterface","br-lan");
 				blobmsg_add_string(&cap, "authentication", value);
 				blobmsg_add_string(&cap, "preauth","/usr/lib/opennds/login.sh");
-				ipset_create(ifname);
+				ipset_create("opennds");
 				d = blobmsg_open_array(&cap, "preauthenticated_users");
 				blobmsg_add_string(&cap, NULL, ipset_tcp80);
 				blobmsg_add_string(&cap, NULL, ipset_tcp443);
@@ -577,8 +579,8 @@ void vif_captive_portal_set(const struct schema_Wifi_VIF_Config *vconf, char *if
 
 			} else if (strcmp(value,"username")==0) {
 				blobmsg_add_string(&cap, "webroot",webroot);
-				opennds_parameters();
-				ipset_create(ifname);
+				opennds_parameters(ifname);
+				ipset_create("opennds");
 				blobmsg_add_string(&cap, "enabled", "1");
 				blobmsg_add_string(&cap, "gatewayinterface","br-lan");
 				blobmsg_add_string(&cap, "authentication", value);
@@ -590,19 +592,19 @@ void vif_captive_portal_set(const struct schema_Wifi_VIF_Config *vconf, char *if
 
 			} else if (strcmp(value,"radius")==0)  {
 				blobmsg_add_string(&cap, "webroot",webroot);
-				opennds_parameters();
+				opennds_parameters("opennds");
 				blobmsg_add_string(&cap, "authentication", value);
 				blobmsg_add_string(&cap, "enabled", "1");
 				blobmsg_add_string(&cap, "gatewayinterface","br-lan");
 				blobmsg_add_string(&cap, "preauth", "/usr/lib/opennds/radius.sh");
-				ipset_create(ifname);
+				ipset_create("opennds");
 				d = blobmsg_open_array(&cap, "preauthenticated_users");
 				blobmsg_add_string(&cap, NULL, ipset_tcp80);
 				blobmsg_add_string(&cap, NULL, ipset_tcp443);
 				blobmsg_close_array(&cap, d);
 			}
 			else {
-				opennds_section_del(ifname);
+				opennds_section_del("opennds");
 				return;
 			}
 		}
@@ -615,8 +617,12 @@ void vif_captive_portal_set(const struct schema_Wifi_VIF_Config *vconf, char *if
 		else if (strcmp(opt, "radius_server_secret") == 0)
 			blobmsg_add_string(&cap, "radius_server_secret", value);
 
-		else if (strcmp(opt, "radius_auth_type") == 0)
-			blobmsg_add_string(&cap, "radius_auth_type", value);
+		else if (strcmp(opt, "radius_auth_type") == 0) {
+			if(!strcmp(value, "MSCHAPv2"))
+				blobmsg_add_string(&cap, "radius_auth_type", "MSCHAPV2");
+			else
+				blobmsg_add_string(&cap, "radius_auth_type", value);
+		}
 
 		else if (strcmp(opt, "session_timeout") == 0)
 			blobmsg_add_string(&cap, "sessiontimeout", value);
@@ -626,8 +632,6 @@ void vif_captive_portal_set(const struct schema_Wifi_VIF_Config *vconf, char *if
 
 		else if (strcmp(opt, "splash_page_logo") == 0) {
 			blobmsg_add_string(&cap, "splash_page_logo", value);
-			sprintf(file_path,"%s%s",path,"TipLogo.png");
-			splash_page_logo(file_path,value);
 			if (strcmp(splash_logo,value) !=0) {
 				sprintf(file_path,"%s%s",path,"TipLogo.png");
 				splash_page_logo(file_path,value);
@@ -641,8 +645,9 @@ void vif_captive_portal_set(const struct schema_Wifi_VIF_Config *vconf, char *if
 			}
 		}
 
-		else if (strcmp(opt, "splash_page_title") == 0)
+		else if (strcmp(opt, "splash_page_title") == 0) {
 			blobmsg_add_string(&cap, "splash_page_title", value);
+		}
 
 		else if (strcmp(opt, "acceptance_policy") == 0)
 			blobmsg_add_string(&cap, "acceptance_policy", value);
@@ -655,15 +660,13 @@ void vif_captive_portal_set(const struct schema_Wifi_VIF_Config *vconf, char *if
 
 		else if (strcmp(opt, "username_password_file") == 0) {
 			blobmsg_add_string(&cap, "username_password_file", value);
-			sprintf(file_path,"%s%s",path,"userpass.dat");
-			splash_page_logo(file_path,value);
 			if (strcmp(user_file,value) !=0) {
 				sprintf(file_path,"%s%s",path,"userpass.dat");
 				splash_page_logo(file_path,value);
 			}
 		}
 	}
-	blob_to_uci_section(cap_uci, "opennds", ifname, "opennds", cap.head, &opennds_param, NULL);
+	blob_to_uci_section(cap_uci, "opennds", "opennds", "opennds", cap.head, &opennds_param, NULL);
 	uci_commit_all(cap_uci);
 	return;
 }

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/src/radio.c

@@ -26,11 +26,16 @@
 #include "captive.h"
 #include "rrm_config.h"
 #include "vlan.h"
+#include "radius_proxy.h"
 
 ovsdb_table_t table_Hotspot20_Config;
 ovsdb_table_t table_Hotspot20_OSU_Providers;
 ovsdb_table_t table_Hotspot20_Icon_Config;
 
+ovsdb_table_t table_APC_Config;
+ovsdb_table_t table_APC_State;
+unsigned int radproxy_apc = 0;
+
 static struct uci_package *wireless;
 struct uci_context *uci;
 struct blob_buf b = { };
@@ -53,6 +58,8 @@ enum {
 	WDEV_ATTR_FREQ_BAND,
 	WDEV_AATR_CHANNELS,
 	WDEV_ATTR_DISABLE_B_RATES,
+	WDEV_ATTR_MAXASSOC_CLIENTS,
+	WDEV_ATTR_LOCAL_PWR_CONSTRAINT,
 	__WDEV_ATTR_MAX,
 };
 
@@ -71,14 +78,18 @@ static const struct blobmsg_policy wifi_device_policy[__WDEV_ATTR_MAX] = {
 	[WDEV_ATTR_FREQ_BAND] = { .name = "freq_band", .type = BLOBMSG_TYPE_STRING },
 	[WDEV_AATR_CHANNELS] = {.name = "channels", .type = BLOBMSG_TYPE_ARRAY},
         [WDEV_ATTR_DISABLE_B_RATES] = { .name = "legacy_rates", .type = BLOBMSG_TYPE_BOOL },
+	[WDEV_ATTR_MAXASSOC_CLIENTS] = { .name = "maxassoc", .type = BLOBMSG_TYPE_INT32 },
+	[WDEV_ATTR_LOCAL_PWR_CONSTRAINT] = { .name = "local_pwr_constraint", .type = BLOBMSG_TYPE_INT32 },
 };
 
-#define SCHEMA_CUSTOM_OPT_SZ            20
-#define SCHEMA_CUSTOM_OPTS_MAX          1
+#define SCHEMA_CUSTOM_OPT_SZ            24
+#define SCHEMA_CUSTOM_OPTS_MAX          3
 
 static const char custom_options_table[SCHEMA_CUSTOM_OPTS_MAX][SCHEMA_CUSTOM_OPT_SZ] =
 {
 	SCHEMA_CONSTS_DISABLE_B_RATES,
+	SCHEMA_CONSTS_MAX_CLIENTS,
+	SCHEMA_CONSTS_LOCAL_PWR_CONSTRAINT,
 };
 
 static void radio_config_custom_opt_set(struct blob_buf *b, struct blob_buf *del,
@@ -103,6 +114,25 @@ static void radio_config_custom_opt_set(struct blob_buf *b, struct blob_buf *del
 				blobmsg_add_bool(b, "legacy_rates", 0);
 			else 
 				blobmsg_add_bool(del, "legacy_rates", 0);
+		} else if (strcmp(opt, SCHEMA_CONSTS_MAX_CLIENTS) == 0) {
+			int maxassoc;
+			maxassoc = strtol(value, NULL, 10);
+			if (maxassoc <= 0) {
+				blobmsg_add_u32(del, "maxassoc", maxassoc);
+			} else {
+				if (maxassoc > 100)
+					maxassoc = 100;
+				blobmsg_add_u32(b, "maxassoc", maxassoc);
+			}
+		} else if (strcmp(opt, SCHEMA_CONSTS_LOCAL_PWR_CONSTRAINT) == 0) {
+			int pwr = atoi(value);
+			if (!strcmp(rconf->freq_band, "2.4G")) {
+				blobmsg_add_u32(del, "local_pwr_constraint", pwr);
+			} else if (pwr >= 0 && pwr <=255) {
+				blobmsg_add_u32(b, "local_pwr_constraint", pwr);
+			} else {
+				blobmsg_add_u32(del, "local_pwr_constraint", pwr);
+			}
 		}
 	}
 }
@@ -123,6 +153,7 @@ static void radio_state_custom_options_get(struct schema_Wifi_Radio_State *rstat
 	int i;
 	int index = 0;
 	const char *opt;
+	char buf[5];
 
 	for (i = 0; i < SCHEMA_CUSTOM_OPTS_MAX; i++) {
 		opt = custom_options_table[i];
@@ -133,7 +164,19 @@ static void radio_state_custom_options_get(struct schema_Wifi_Radio_State *rstat
 			} else {
 				set_custom_option_state(rstate, &index, opt, "1");
 			}
-                }
+		} else if (strcmp(opt, SCHEMA_CONSTS_MAX_CLIENTS) == 0) {
+			if (tb[WDEV_ATTR_MAXASSOC_CLIENTS]) {
+				snprintf(buf, sizeof(buf), "%d", blobmsg_get_u32(tb[WDEV_ATTR_MAXASSOC_CLIENTS]));
+				set_custom_option_state(rstate, &index, opt, buf);
+			} else {
+                                set_custom_option_state(rstate, &index, opt, "0");
+			}
+		} else if (strcmp(opt, SCHEMA_CONSTS_LOCAL_PWR_CONSTRAINT) == 0) {
+			if (tb[WDEV_ATTR_LOCAL_PWR_CONSTRAINT]) {
+				snprintf(buf, sizeof(buf), "%d", blobmsg_get_u32(tb[WDEV_ATTR_LOCAL_PWR_CONSTRAINT]));
+				set_custom_option_state(rstate, &index, opt, buf);
+			}
+		}
 	}
 }
 
@@ -148,6 +191,7 @@ static bool radio_state_update(struct uci_section *s, struct schema_Wifi_Radio_C
 	struct schema_Wifi_Radio_State  rstate;
 	char phy[6];
 	int antenna;
+	uint32_t chan = 0;
 
 	LOGT("%s: get state", s->e.name);
 
@@ -171,8 +215,13 @@ static bool radio_state_update(struct uci_section *s, struct schema_Wifi_Radio_C
 		return false;
 	}
 
-	if (tb[WDEV_ATTR_CHANNEL])
-		SCHEMA_SET_INT(rstate.channel, blobmsg_get_u32(tb[WDEV_ATTR_CHANNEL]));
+	if (tb[WDEV_ATTR_CHANNEL]) {
+		nl80211_channel_get(phy, &chan);
+		if(chan)
+			SCHEMA_SET_INT(rstate.channel, chan);
+		else
+			SCHEMA_SET_INT(rstate.channel, blobmsg_get_u32(tb[WDEV_ATTR_CHANNEL]));
+	}
 
 	SCHEMA_SET_INT(rstate.enabled, 1);
 	if (!force && tb[WDEV_ATTR_DISABLED] && blobmsg_get_bool(tb[WDEV_ATTR_DISABLED]))
@@ -201,15 +250,22 @@ static bool radio_state_update(struct uci_section *s, struct schema_Wifi_Radio_C
 
 	if (tb[WDEV_ATTR_TX_ANTENNA]) {
 		antenna = blobmsg_get_u32(tb[WDEV_ATTR_TX_ANTENNA]);
-		if (!antenna)   antenna = phy_get_tx_available_antenna(phy);
+		if (!antenna)
+			antenna = phy_get_tx_available_antenna(phy);
+		if ((antenna & 0xf0) && !(antenna & 0x0f))
+			antenna= antenna >> 4;
 		SCHEMA_SET_INT(rstate.tx_chainmask, antenna);
 	}
 	else
 		SCHEMA_SET_INT(rstate.tx_chainmask, phy_get_tx_chainmask(phy));
 
 	if (tb[WDEV_ATTR_RX_ANTENNA]) {
+
 		antenna = blobmsg_get_u32(tb[WDEV_ATTR_RX_ANTENNA]);
-		if (!antenna)   antenna = phy_get_rx_available_antenna(phy);
+		if (!antenna)
+			antenna = phy_get_rx_available_antenna(phy);
+		if ((antenna & 0xf0) && !(antenna & 0x0f))
+			antenna= antenna >> 4;
 		SCHEMA_SET_INT(rstate.rx_chainmask, antenna);
 	}
 	else
@@ -281,7 +337,6 @@ bool target_radio_config_set2(const struct schema_Wifi_Radio_Config *rconf,
 
 	char phy[6];
 	char ifname[8];
-	int list_channels[IEEE80211_CHAN_MAX] , list_channels_len = 0;
 
 	strncpy(ifname, rconf->if_name, sizeof(ifname));
 	strncpy(phy, target_map_ifname(ifname), sizeof(phy));
@@ -304,28 +359,38 @@ bool target_radio_config_set2(const struct schema_Wifi_Radio_Config *rconf,
 	}
 
 	if (changed->tx_chainmask) {
-		int tx_ant_avail;
+		int tx_ant_avail,txchainmask;
 		tx_ant_avail=phy_get_tx_available_antenna(phy);
 
+		if ((tx_ant_avail & 0xf0) && !(tx_ant_avail & 0x0f)) {
+			txchainmask = rconf->tx_chainmask << 4;
+		} else {
+			txchainmask = rconf->tx_chainmask;
+		}
 		if (rconf->tx_chainmask == 0) {
 			blobmsg_add_u32(&b, "txantenna", tx_ant_avail);
-		} else if ((rconf->tx_chainmask & tx_ant_avail) != rconf->tx_chainmask) {
+		} else if ((txchainmask & tx_ant_avail) != txchainmask) {
 			blobmsg_add_u32(&b, "txantenna", tx_ant_avail);
 		} else {
-			blobmsg_add_u32(&b, "txantenna", rconf->tx_chainmask);
+			blobmsg_add_u32(&b, "txantenna", txchainmask);
 		}
 	}
 
 	if (changed->rx_chainmask) {
-		int rx_ant_avail;
+		int rx_ant_avail, rxchainmask;
 		rx_ant_avail=phy_get_rx_available_antenna(phy);
 
+		if ((rx_ant_avail & 0xf0) && !(rx_ant_avail & 0x0f)) {
+			rxchainmask = rconf->rx_chainmask << 4;
+		} else {
+			rxchainmask = rconf->rx_chainmask;
+		}
 		if (rconf->rx_chainmask == 0) {
 			blobmsg_add_u32(&b, "rxantenna", rx_ant_avail);
-		} else if ((rconf->rx_chainmask & rx_ant_avail) != rconf->rx_chainmask) {
+		} else if ((rxchainmask & rx_ant_avail) != rxchainmask) {
 			blobmsg_add_u32(&b, "rxantenna", rx_ant_avail);
 		} else {
-			blobmsg_add_u32(&b, "rxantenna", rconf->rx_chainmask);
+			blobmsg_add_u32(&b, "rxantenna", rxchainmask);
 		}
 	}
 
@@ -341,8 +406,9 @@ bool target_radio_config_set2(const struct schema_Wifi_Radio_Config *rconf,
 	}
 
 	if ((changed->ht_mode) || (changed->hw_mode) || (changed->freq_band)) {
-		struct mode_map *m = mode_map_get_uci(rconf->freq_band, rconf->ht_mode,
-						      rconf->hw_mode);
+		int channel_freq;
+		channel_freq = ieee80211_channel_to_frequency(rconf->channel);
+		struct mode_map *m = mode_map_get_uci(rconf->freq_band, get_max_channel_bw_channel(channel_freq, rconf->ht_mode), rconf->hw_mode);
 		if (m) {
 			blobmsg_add_string(&b, "htmode", m->ucihtmode);
 			blobmsg_add_string(&b, "hwmode", m->ucihwmode);
@@ -351,16 +417,18 @@ bool target_radio_config_set2(const struct schema_Wifi_Radio_Config *rconf,
 			 LOGE("%s: failed to set ht/hwmode", rconf->if_name);
 	}
 
-	list_channels_len = phy_get_list_channels_dfs(phy, list_channels);
-	if (list_channels_len) {
-		struct blob_attr *n;
+	struct blob_attr *n;
+	int backup_channel = 0;
+	backup_channel = rrm_get_backup_channel(rconf->freq_band);
+	if(backup_channel) {
 		n = blobmsg_open_array(&b, "channels");
-		for(int i = 0; i < list_channels_len; i++)
-		{
-			blobmsg_add_u32(&b, NULL, list_channels[i]);
-		}
+		blobmsg_add_u32(&b, NULL, backup_channel);
 		blobmsg_close_array(&b, n);
-	}
+	} else {
+		n = blobmsg_open_array(&del, "channels");
+		blobmsg_add_u32(&del, NULL, backup_channel);
+		blobmsg_close_array(&del, n);
+	}	
 
 	if (changed->custom_options)
 		radio_config_custom_opt_set(&b, &del, rconf);
@@ -377,6 +445,7 @@ static void periodic_task(void *arg)
 {
 	static int counter = 0;
 	struct uci_element *e = NULL, *tmp = NULL;
+	int ret = 0;
 
 	if ((counter % 15) && !reload_config)
 		goto done;
@@ -400,9 +469,12 @@ static void periodic_task(void *arg)
 		system("reload_config");
 	}
 
-	LOGT("periodic: start state update ");
-
-	uci_load(uci, "wireless", &wireless);
+	LOGD("periodic: start state update ");
+	ret = uci_load(uci, "wireless", &wireless);
+	if (ret) {
+		LOGE("%s: uci_load() failed with rc %d", __func__, ret);
+		return;
+	}
 	uci_foreach_element_safe(&wireless->sections, tmp, e) {
 		struct uci_section *s = uci_to_section(e);
 
@@ -417,7 +489,7 @@ static void periodic_task(void *arg)
 			vif_state_update(s, NULL);
 	}
 	uci_unload(uci, wireless);
-	LOGT("periodic: stop state update ");
+	LOGD("periodic: stop state update ");
 
 done:
 	counter++;
@@ -607,6 +679,148 @@ static void callback_Hotspot20_Icon_Config(ovsdb_update_monitor_t *mon,
 
 }
 
+enum {
+	WIF_APC_ENABLE,
+	__WIF_APC_MAX,
+};
+
+static const struct blobmsg_policy apc_enpolicy[__WIF_APC_MAX] = {
+		[WIF_APC_ENABLE] = { .name = "enabled", BLOBMSG_TYPE_BOOL },
+};
+
+const struct uci_blob_param_list apc_param = {
+	.n_params = __WIF_APC_MAX,
+	.params = apc_enpolicy,
+};
+
+void APC_config_update(struct schema_APC_Config *conf)
+{
+	struct blob_buf apcb = { };
+	struct uci_context *apc_uci;
+
+	apc_uci = uci_alloc_context();
+
+	blob_buf_init(&apcb, 0);
+	if (conf && conf->enabled == true) {
+		blobmsg_add_bool(&apcb, "enabled", 1);
+		system("/etc/init.d/apc start");
+	} else {
+		blobmsg_add_bool(&apcb, "enabled", 0);
+		system("/etc/init.d/apc stop");
+	}
+
+	blob_to_uci_section(apc_uci, "apc", "apc", "apc",
+			apcb.head, &apc_param, NULL);
+
+	uci_commit_all(apc_uci);
+	uci_free_context(apc_uci);
+}
+
+static void callback_APC_Config(ovsdb_update_monitor_t *mon,
+                                struct schema_APC_Config *old,
+                                struct schema_APC_Config *conf)
+{
+	if (mon->mon_type == OVSDB_UPDATE_DEL)
+		APC_config_update(NULL);
+	else
+		APC_config_update(conf);
+
+}
+
+static void callback_APC_State(ovsdb_update_monitor_t *mon,
+                                struct schema_APC_State *old,
+                                struct schema_APC_State *conf)
+{
+	LOGN("APC_state: enabled:%s dr_addr:%s bdr_addr:%s mode:%s",
+	     (conf->enabled_changed)? "changed":"unchanged", 
+	     (conf->dr_addr_changed)? "changed":"unchanged",
+	     (conf->bdr_addr_changed)? "changed":"unchanged",
+	     (conf->mode_changed)? "changed":"unchanged");
+
+	/* APC changed: if radproxy enabled then restart wireless */
+	if (radproxy_apc) {
+		radproxy_apc = 0;
+		system("ubus call service event '{\"type\": \"config.change\", \"data\": { \"package\": \"wireless\" }}'");
+	}
+}
+
+struct schema_APC_State apc_state;
+enum {
+	APC_ATTR_MODE,
+	APC_ATTR_DR_ADDR,
+	APC_ATTR_BDR_ADDR,
+	APC_ATTR_ENABLED,
+	__APC_ATTR_MAX,
+};
+
+static const struct blobmsg_policy apc_policy[__APC_ATTR_MAX] = {
+	[APC_ATTR_MODE] = { .name = "mode", .type = BLOBMSG_TYPE_STRING },
+	[APC_ATTR_DR_ADDR] = { .name = "dr_addr", .type = BLOBMSG_TYPE_STRING },
+	[APC_ATTR_BDR_ADDR] = { .name = "bdr_addr", .type = BLOBMSG_TYPE_STRING },
+	[APC_ATTR_ENABLED] = { .name = "enabled", .type = BLOBMSG_TYPE_BOOL },
+};
+
+struct schema_APC_Config apc_conf;
+
+void apc_state_set(struct blob_attr *msg)
+{
+	struct blob_attr *tb[__APC_ATTR_MAX] = { };
+
+	blobmsg_parse(apc_policy, __APC_ATTR_MAX, tb,
+		      blob_data(msg), blob_len(msg));
+
+	if (tb[APC_ATTR_MODE]) {
+		LOGD("APC mode: %s", blobmsg_get_string(tb[APC_ATTR_MODE]));
+		SCHEMA_SET_STR(apc_state.mode,
+			       blobmsg_get_string(tb[APC_ATTR_MODE]));
+	}
+	if (tb[APC_ATTR_DR_ADDR]) {
+		LOGD("APC br-addr: %s", blobmsg_get_string(tb[APC_ATTR_DR_ADDR]));
+		SCHEMA_SET_STR(apc_state.dr_addr,
+			       blobmsg_get_string(tb[APC_ATTR_DR_ADDR]));
+	}
+	if (tb[APC_ATTR_BDR_ADDR]) {
+		LOGD("APC dbr-addr: %s", blobmsg_get_string(tb[APC_ATTR_BDR_ADDR]));
+		SCHEMA_SET_STR(apc_state.bdr_addr,
+			       blobmsg_get_string(tb[APC_ATTR_BDR_ADDR]));
+	}
+	if (tb[APC_ATTR_ENABLED]) {
+		LOGD("APC enabled: %d", blobmsg_get_bool(tb[APC_ATTR_ENABLED]));
+		if (blobmsg_get_bool(tb[APC_ATTR_ENABLED])) {
+			SCHEMA_SET_INT(apc_state.enabled, true);
+		}
+		else {
+			SCHEMA_SET_INT(apc_state.enabled, false);
+		}
+	}
+
+	LOGD("APC_state Updating");
+	if (!ovsdb_table_update(&table_APC_State, &apc_state))
+		LOG(ERR, "APC_state: failed to update");
+}
+
+
+void apc_init()
+{
+	/* APC Config */
+	OVSDB_TABLE_INIT(APC_Config, _uuid);
+	OVSDB_TABLE_MONITOR(APC_Config, false);
+	SCHEMA_SET_INT(apc_conf.enabled, true);
+	LOGI("APC state/config Initialize");
+	if (!ovsdb_table_insert(&table_APC_Config, &apc_conf))
+		LOG(ERR, "APC_Config: failed to initialize");
+
+	/* APC State */
+	OVSDB_TABLE_INIT_NO_KEY(APC_State);
+	OVSDB_TABLE_MONITOR(APC_State, false);
+	SCHEMA_SET_STR(apc_state.mode, "NC");
+	SCHEMA_SET_STR(apc_state.dr_addr, "0.0.0.0");
+	SCHEMA_SET_STR(apc_state.bdr_addr, "0.0.0.0");
+	SCHEMA_SET_INT(apc_state.enabled, false);
+	if (!ovsdb_table_insert(&table_APC_State, &apc_state))
+		LOG(ERR, "APC_state: failed to initialize");
+}
+
 bool target_radio_init(const struct target_radio_ops *ops)
 {
 	uci = uci_alloc_context();
@@ -629,8 +843,13 @@ bool target_radio_init(const struct target_radio_ops *ops)
 	OVSDB_TABLE_INIT(Hotspot20_Icon_Config, _uuid);
 	OVSDB_TABLE_MONITOR(Hotspot20_Icon_Config, false);
 
-        OVSDB_TABLE_INIT(Wifi_RRM_Config, _uuid);
-        OVSDB_TABLE_MONITOR(Wifi_RRM_Config, false);
+	OVSDB_TABLE_INIT(Wifi_RRM_Config, _uuid);
+	OVSDB_TABLE_MONITOR(Wifi_RRM_Config, false);
+
+	OVSDB_TABLE_INIT(Radius_Proxy_Config, _uuid);
+	OVSDB_TABLE_MONITOR(Radius_Proxy_Config, false);
+
+	apc_init();
 
 	evsched_task(&periodic_task, NULL, EVSCHED_SEC(5));
 

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/src/radio_nl80211.c

@@ -103,7 +103,7 @@ static void vif_add_sta_rate_rule(uint8_t *addr, char *ifname)
 	char *rule;
 	ssize_t rule_sz;
 
-	LOGI("Add mac rate rule: %s %02X:%02X:%02X:%02X:%02X:%02X",
+	LOGI("Add mac rate rule:%s: %02X:%02X:%02X:%02X:%02X:%02X",
 	     ifname, addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
 
 	rule_sz = snprintf(NULL, 0, "/lib/nft-qos/mac-rate.sh add %s %02X:%02X:%02X:%02X:%02X:%02X",
@@ -123,7 +123,7 @@ static void vif_del_sta_rate_rule(uint8_t *addr, char *ifname)
 	char *rule;
 	ssize_t rule_sz;
 
-	LOGI("Del mac rate rule: %s %02X:%02X:%02X:%02X:%02X:%02X",
+	LOGI("Del mac rate rule:%s: %02X:%02X:%02X:%02X:%02X:%02X",
 	     ifname, addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
 
 	rule_sz = snprintf(NULL, 0, "/lib/nft-qos/mac-rate.sh del %s %02X:%02X:%02X:%02X:%02X:%02X",
@@ -137,46 +137,6 @@ static void vif_del_sta_rate_rule(uint8_t *addr, char *ifname)
     free(rule);
 }
 
-static void vif_update_stats(struct wifi_station *sta, struct nlattr **tb)
-{
-	static struct nla_policy stats_policy[NL80211_STA_INFO_MAX + 1] = {
-		[NL80211_STA_INFO_INACTIVE_TIME] = { .type = NLA_U32    },
-		[NL80211_STA_INFO_RX_PACKETS]    = { .type = NLA_U32    },
-		[NL80211_STA_INFO_TX_PACKETS]    = { .type = NLA_U32    },
-		[NL80211_STA_INFO_RX_BITRATE]    = { .type = NLA_NESTED },
-		[NL80211_STA_INFO_TX_BITRATE]    = { .type = NLA_NESTED },
-		[NL80211_STA_INFO_SIGNAL]        = { .type = NLA_U8     },
-		[NL80211_STA_INFO_SIGNAL_AVG]    = { .type = NLA_U8     },
-		[NL80211_STA_INFO_RX_BYTES]      = { .type = NLA_U32    },
-		[NL80211_STA_INFO_TX_BYTES]      = { .type = NLA_U32    },
-		[NL80211_STA_INFO_TX_RETRIES]    = { .type = NLA_U32    },
-		[NL80211_STA_INFO_TX_FAILED]     = { .type = NLA_U32    },
-		[NL80211_STA_INFO_T_OFFSET]      = { .type = NLA_U64    },
-		[NL80211_STA_INFO_STA_FLAGS] =
-			{ .minlen = sizeof(struct nl80211_sta_flag_update) },
-	};
-
-	struct nlattr *sinfo[NL80211_STA_INFO_MAX + 1] = { };
-
-	if (!tb[NL80211_ATTR_STA_INFO])
-		return;
-	if (nla_parse_nested(sinfo, NL80211_STA_INFO_MAX,
-			     tb[NL80211_ATTR_STA_INFO], stats_policy))
-		return;
-	if (sinfo[NL80211_STA_INFO_SIGNAL_AVG])
-		sta->rssi = (int32_t) nla_get_u8(sinfo[NL80211_STA_INFO_SIGNAL_AVG]);
-	if (sinfo[NL80211_STA_INFO_RX_PACKETS])
-		sta->rx_packets = nla_get_u32(sinfo[NL80211_STA_INFO_RX_PACKETS]);
-	if (sinfo[NL80211_STA_INFO_TX_PACKETS])
-		sta->tx_packets = nla_get_u32(sinfo[NL80211_STA_INFO_TX_PACKETS]);
-	if (sinfo[NL80211_STA_INFO_RX_BYTES])
-		sta->rx_bytes = nla_get_u32(sinfo[NL80211_STA_INFO_RX_BYTES]);
-	if (sinfo[NL80211_STA_INFO_TX_BYTES])
-		sta->tx_bytes = nla_get_u32(sinfo[NL80211_STA_INFO_TX_BYTES]);
-
-	sta->last_update = time(NULL);
-}
-
 static void nl80211_add_station(struct nlattr **tb, char *ifname)
 {
 	struct wifi_station *sta;
@@ -187,12 +147,10 @@ static void nl80211_add_station(struct nlattr **tb, char *ifname)
 		return;
 
 	addr = nla_data(tb[NL80211_ATTR_MAC]);
+	vif_add_sta_rate_rule(addr, ifname);
 	sta = avl_find_element(&sta_tree, addr, sta, avl);
-	if (sta) {
-		vif_add_sta_rate_rule(addr, ifname);
-		vif_update_stats(sta, tb);
+	if (sta)
 		return;
-	}
 
 	wif = avl_find_element(&wif_tree, ifname, wif, avl);
 	if (!wif)
@@ -209,8 +167,6 @@ static void nl80211_add_station(struct nlattr **tb, char *ifname)
 	list_add(&sta->iface, &wif->stas);
 
 	vif_add_station(sta, ifname, 1);
-	vif_add_sta_rate_rule(addr, ifname);
-	vif_update_stats(sta, tb);
 }
 
 static void _nl80211_del_station(char *ifname, struct wifi_station *sta)
@@ -279,6 +235,8 @@ static void vif_sync_stations(char *ifname)
 		if (sta_tree.count > 0 && sta_tree.count == j)
 		{
 			LOGI("%s: remove stale client %s", ifname, ovs_clients[i].mac);
+			schema_Wifi_Associated_Clients_mark_all_present(ovs_clients + i);
+			ovs_clients[i]._partial_update = true;
 			radio_ops->op_client(ovs_clients + i, ifname, false);
 		}
 
@@ -305,24 +263,6 @@ free:
 	free(ovs_clients);
 }
 
-static void remove_stale_station(char *ifname)
-{
-	struct wifi_station *sta = NULL, *tmp = NULL;
-	char mac[ETH_ALEN * 3];
-	time_t timeout = 0, t = 0;
-
-	avl_for_each_element_safe(&sta_tree, sta, avl, tmp) {
-		timeout = sta->last_update + (EVSCHED_SEC(STA_POLL_INTERVAL*2));
-		t = time(NULL);
-		if (t > timeout) {
-			print_mac(mac, sta->addr);
-			LOGN("%s: Remove stale STA %s %ld %ld %ld", __func__, mac,
-					t, timeout, sta->last_update);
-			_nl80211_del_station(ifname, sta);
-		}
-	}
-}
-
 static void nl80211_add_iface(struct nlattr **tb, char *ifname, char *phyname, int ifidx)
 {
 	struct wifi_iface *wif;
@@ -442,18 +382,20 @@ static void nl80211_add_phy(struct nlattr **tb, char *name)
 					freq = nla_get_u32(tb_freq[NL80211_FREQUENCY_ATTR_FREQ]);
 					chan = ieee80211_frequency_to_channel(freq);
 					if (chan >= IEEE80211_CHAN_MAX) {
-						LOGE("%s: found invalid channel %d", phy->name, chan);
+						LOG(DEBUG, "%s: found invalid channel %d", phy->name, chan);
 						continue;
 					}
 
 					if (tb_freq[NL80211_FREQUENCY_ATTR_DISABLED]) {
 						phy->chandisabled[chan] = 1;
+						phy->chandfs[chan] = 0;
 						continue;
 					}
 
 					if (tb_freq[NL80211_FREQUENCY_ATTR_RADAR]) {
 						phy->chandfs[chan] = 1;
-						LOGE("%s: found dfs channel %d", phy->name, chan);
+						phy->chandisabled[chan] = 0;
+						LOG(DEBUG, "%s: found dfs channel %d", phy->name, chan);
 						continue;
 					}
 					phy->freq[chan] = freq;
@@ -488,6 +430,57 @@ static void nl80211_del_phy(struct nlattr **tb, char *name)
 	free(phy);
 }
 
+static int nl80211_channel_recv(struct nl_msg *msg, void *arg)
+{
+	struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
+	struct nlattr *tb[NL80211_ATTR_MAX + 1];
+	unsigned int *chan = (unsigned int *)arg;
+
+	memset(tb, 0, sizeof(tb));
+	nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
+		  genlmsg_attrlen(gnlh, 0), NULL);
+
+	if (tb[NL80211_ATTR_WIPHY_FREQ]) {
+		*chan = ieee80211_frequency_to_channel(nla_get_u32(tb[NL80211_ATTR_WIPHY_FREQ]));
+	}
+
+	return NL_OK;
+}
+
+int nl80211_channel_get(char *name, unsigned int *chan)
+{
+	struct nl_msg *msg;
+	struct wifi_phy *phy;
+	struct wifi_iface *wif=NULL;
+	int idx = 0;
+
+	phy = avl_find_element(&phy_tree, name, phy, avl);
+	if (!phy)
+		return -1;
+
+	if (list_empty(&phy->wifs))
+		return -1;
+
+	wif = list_first_entry(&phy->wifs, struct wifi_iface, phy);
+
+	if (!wif)
+		return -1;
+
+	idx = if_nametoindex(wif->name);
+
+	if (!idx)
+		return -1;
+
+	msg = unl_genl_msg(&unl, NL80211_CMD_GET_INTERFACE, true);
+	nla_put_u32(msg, NL80211_ATTR_IFINDEX, idx);
+
+	unl_genl_request(&unl, msg, nl80211_channel_recv, chan);
+
+	phy->current_channel = *chan;
+
+	return NL_OK;
+}
+
 static int nl80211_recv(struct nl_msg *msg, void *arg)
 {
 	struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
@@ -496,7 +489,6 @@ static int nl80211_recv(struct nl_msg *msg, void *arg)
 	char *pif_name=NULL;
 	char phyname[IFNAMSIZ] = {};
 	int ifidx = -1, phy = -1;
-
 	memset(tb, 0, sizeof(tb));
 
 	nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
@@ -512,9 +504,10 @@ static int nl80211_recv(struct nl_msg *msg, void *arg)
 
 	if (tb[NL80211_ATTR_WIPHY]) {
 		phy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
-		if (tb[NL80211_ATTR_WIPHY_NAME])
+		snprintf(phyname, sizeof(phyname), "phy%d", phy);
+	} else if (tb[NL80211_ATTR_WIPHY_NAME]) {
 			strncpy(phyname, nla_get_string(tb[NL80211_ATTR_WIPHY_NAME]), IFNAMSIZ);
-		else
+	} else if (sscanf(ifname, "wlan%d", &phy)) {
 			snprintf(phyname, sizeof(phyname), "phy%d", phy);
 	}
 
@@ -542,7 +535,6 @@ static int nl80211_recv(struct nl_msg *msg, void *arg)
 		syslog(0, "%s:%s[%d]%d\n", __FILE__, __func__, __LINE__, gnlh->cmd);
 		break;
 	}
-
 	return NL_OK;
 }
 
@@ -576,16 +568,9 @@ static void nl80211_ev(struct ev_loop *ev, struct ev_io *io, int event)
 
 static void vif_poll_stations(void *arg)
 {
-	 struct wifi_iface *wif = NULL;
-
+	struct wifi_iface *wif = NULL;
 
 	avl_for_each_element(&wif_tree, wif, avl) {
-		struct nl_msg *msg;
-
-		msg = unl_genl_msg(&unl, NL80211_CMD_GET_STATION, true);
-		nla_put_u32(msg, NL80211_ATTR_IFINDEX, wif->ifidx);
-		unl_genl_request(&unl, msg, nl80211_recv, NULL);
-		remove_stale_station(wif->name);
 		vif_sync_stations(wif->name);
 	}
 	evsched_task_reschedule_ms(EVSCHED_SEC(STA_POLL_INTERVAL));
@@ -609,6 +594,9 @@ int radio_nl80211_init(void)
 	unl_genl_subscribe(&unl, "mlme");
 	unl_genl_subscribe(&unl, "vendor");
 
+	if (nl_socket_set_buffer_size(unl.sock, 262144, 0) < 0)
+		LOGE("radio_nl80211: Failed to set nl socket buffer size");
+
 	ev_io_init(&unl_io, nl80211_ev, unl.sock->s_fd, EV_READ);
         ev_io_start(wifihal_evloop, &unl_io);
 	evsched_task(&vif_poll_stations, NULL, EVSCHED_SEC(5));

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/src/radius_proxy.c

@@ -0,0 +1,415 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <time.h>
+
+#include <uci.h>
+#include <uci_blob.h>
+
+#include <target.h>
+
+#include <curl/curl.h>
+
+#include "ovsdb.h"
+#include "ovsdb_update.h"
+#include "ovsdb_sync.h"
+#include "ovsdb_table.h"
+#include "ovsdb_cache.h"
+
+#include "nl80211.h"
+#include "radio.h"
+#include "vif.h"
+#include "phy.h"
+#include "log.h"
+#include "evsched.h"
+#include "uci.h"
+#include "utils.h"
+#include "radius_proxy.h"
+
+ovsdb_table_t table_Radius_Proxy_Config;
+struct blob_buf uci_buf = {};
+struct blob_attr *n;
+extern ovsdb_table_t table_APC_State;
+extern json_t* ovsdb_table_where(ovsdb_table_t *table, void *record);
+
+enum {
+	RADIUS_PROXY_OPTIONS_LISTEN_UDP,
+	__RADIUS_PROXY_OPTIONS_MAX
+};
+
+enum {
+	RADIUS_PROXY_CLIENT_NAME,
+	RADIUS_PROXY_CLIENT_TYPE,
+	RADIUS_PROXY_CLIENT_SECRET,
+	__RADIUS_PROXY_CLIENT_MAX
+};
+
+enum {
+	RADIUS_PROXY_SERVER_NAME,
+	RADIUS_PROXY_SERVER_HOST,
+	RADIUS_PROXY_SERVER_TYPE,
+	RADIUS_PROXY_SERVER_SECRET,
+	RADIUS_PROXY_SERVER_PORT,
+	RADIUS_PROXY_SERVER_STATUS,
+	RADIUS_PROXY_SERVER_TLS,
+	RADIUS_PROXY_SERVER_CERT_NAME_CHECK,
+	__RADIUS_PROXY_SERVER_MAX
+};
+
+enum {
+	RADIUS_PROXY_TLS_NAME,
+	RADIUS_PROXY_TLS_CA_CERT,
+	RADIUS_PROXY_TLS_CLIENT_CERT,
+	RADIUS_PROXY_TLS_CLIENT_KEY,
+	RADIUS_PROXY_TLS_CERT_PASSWORD,
+	__RADIUS_PROXY_TLS_MAX,
+};
+
+enum {
+	RADIUS_PROXY_REALM_NAME,
+	RADIUS_PROXY_REALM_AUTH_SERVER,
+	RADIUS_PROXY_REALM_ACCT_SERVER,
+	__RADIUS_PROXY_REALM_MAX
+};
+
+
+static const struct blobmsg_policy radius_proxy_options_policy[__RADIUS_PROXY_OPTIONS_MAX] = {
+		[RADIUS_PROXY_OPTIONS_LISTEN_UDP] = { .name = "ListenUDP", BLOBMSG_TYPE_ARRAY },
+};
+
+static const struct blobmsg_policy radius_proxy_client_policy[__RADIUS_PROXY_CLIENT_MAX] = {
+		[RADIUS_PROXY_CLIENT_NAME] = { .name = "name", BLOBMSG_TYPE_STRING },
+		[RADIUS_PROXY_CLIENT_TYPE] = { .name = "type", BLOBMSG_TYPE_STRING },
+		[RADIUS_PROXY_CLIENT_SECRET] = { .name = "secret", BLOBMSG_TYPE_STRING },
+};
+
+static const struct blobmsg_policy radius_proxy_tls_policy[__RADIUS_PROXY_TLS_MAX] = {
+		[RADIUS_PROXY_TLS_NAME] = { .name = "name", BLOBMSG_TYPE_STRING },
+		[RADIUS_PROXY_TLS_CA_CERT] = { .name = "CACertificateFile", BLOBMSG_TYPE_STRING },
+		[RADIUS_PROXY_TLS_CLIENT_CERT] = { .name = "certificateFile", BLOBMSG_TYPE_STRING },
+		[RADIUS_PROXY_TLS_CLIENT_KEY] = { .name = "certificateKeyFile", BLOBMSG_TYPE_STRING },
+		[RADIUS_PROXY_TLS_CERT_PASSWORD] = { .name = "certificateKeyPassword", BLOBMSG_TYPE_STRING },
+};
+
+static const struct blobmsg_policy radius_proxy_server_policy[__RADIUS_PROXY_SERVER_MAX] = {
+		[RADIUS_PROXY_SERVER_NAME] = { .name = "name", BLOBMSG_TYPE_STRING },
+		[RADIUS_PROXY_SERVER_HOST] = { .name = "host", BLOBMSG_TYPE_STRING },
+		[RADIUS_PROXY_SERVER_TYPE] = { .name = "type", BLOBMSG_TYPE_STRING },
+		[RADIUS_PROXY_SERVER_SECRET] = { .name = "secret", BLOBMSG_TYPE_STRING },
+		[RADIUS_PROXY_SERVER_PORT] = { .name = "port", BLOBMSG_TYPE_INT32 },
+		[RADIUS_PROXY_SERVER_STATUS] = { .name = "statusServer", BLOBMSG_TYPE_BOOL },
+		[RADIUS_PROXY_SERVER_TLS] = { .name = "tls", BLOBMSG_TYPE_STRING },
+		[RADIUS_PROXY_SERVER_CERT_NAME_CHECK] = { .name = "certificateNameCheck", BLOBMSG_TYPE_BOOL },
+};
+
+static const struct blobmsg_policy radius_proxy_realm_policy[__RADIUS_PROXY_REALM_MAX] = {
+		[RADIUS_PROXY_REALM_NAME] = { .name = "name", BLOBMSG_TYPE_STRING },
+		[RADIUS_PROXY_REALM_AUTH_SERVER] = { .name = "server", BLOBMSG_TYPE_ARRAY },
+		[RADIUS_PROXY_REALM_ACCT_SERVER] = { .name = "accountingServer", BLOBMSG_TYPE_ARRAY },
+};
+
+const struct uci_blob_param_list radius_proxy_options_param = {
+	.n_params = __RADIUS_PROXY_OPTIONS_MAX,
+	.params = radius_proxy_options_policy,
+};
+
+const struct uci_blob_param_list radius_proxy_client_param = {
+	.n_params = __RADIUS_PROXY_CLIENT_MAX,
+	.params = radius_proxy_client_policy,
+};
+
+const struct uci_blob_param_list radius_proxy_tls_param = {
+	.n_params = __RADIUS_PROXY_TLS_MAX,
+	.params = radius_proxy_tls_policy,
+};
+
+const struct uci_blob_param_list radius_proxy_server_param = {
+	.n_params = __RADIUS_PROXY_SERVER_MAX,
+	.params = radius_proxy_server_policy,
+};
+
+const struct uci_blob_param_list radius_proxy_realm_param = {
+	.n_params = __RADIUS_PROXY_REALM_MAX,
+	.params = radius_proxy_realm_policy,
+};
+
+
+size_t file_write(void *ptr, size_t size, size_t nmemb, FILE *stream) {
+	size_t written = fwrite(ptr, size, nmemb, stream);
+	return written;
+}
+
+static bool radsec_download_cert(char *cert_name, char *dir_name, char *cert_url)
+{
+	CURL *curl;
+	FILE *fp;
+	CURLcode curl_ret;
+	char path[200];
+	char dir_path[200];
+	char name[32];
+	char dir[32];
+	char *gw_clientcert = "/usr/opensync/certs/client.pem";
+	char *gw_clientkey = "/usr/opensync/certs/client_dec.key";
+	struct stat stat_buf;
+
+	strcpy(name, cert_name);
+	strcpy(dir, dir_name);
+	sprintf(dir_path, "/tmp/radsec/certs/%s", dir);
+	sprintf(path, "/tmp/radsec/certs/%s/%s", dir, name);
+
+	if (stat(dir_path, &stat_buf) == -1)
+	{
+		char cmd[200];
+		sprintf(cmd, "mkdir -p %s", dir_path);
+		system(cmd);
+	}
+
+	curl = curl_easy_init();
+	if (curl)
+	{
+		fp = fopen(path, "wb");
+
+		if (fp == NULL)
+		{
+			curl_easy_cleanup(curl);
+			return false;
+		}
+
+		if (cert_url == NULL)
+		{
+			curl_easy_cleanup(curl);
+			fclose(fp);
+			return false;
+		}
+
+		curl_easy_setopt(curl, CURLOPT_SSLCERT, gw_clientcert);
+		curl_easy_setopt(curl, CURLOPT_SSLKEY, gw_clientkey);
+		curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
+		curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
+		curl_easy_setopt(curl, CURLOPT_HEADER, 0L);
+		curl_easy_setopt(curl, CURLOPT_URL, cert_url);
+		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, file_write);
+		curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
+		curl_ret = curl_easy_perform(curl);
+
+		if (curl_ret != CURLE_OK)
+		{
+			LOGE("radsec: certificate download failed %s", curl_easy_strerror(curl_ret));
+			curl_easy_cleanup(curl);
+			fclose(fp);
+			remove(path);
+			return false;
+		}
+
+		curl_easy_cleanup(curl);
+		fclose(fp);
+	}
+
+	return true;
+}
+
+static bool radius_proxy_config_set(struct schema_Radius_Proxy_Config *conf )
+{
+	int i=0;
+	char path[200];
+	char name[256];
+	char server_name[256] = {};
+	char acct_server_name[256] = {};
+	char tls_name[256] = {};
+	struct schema_APC_State apc_conf;
+
+	/* Configure only if APC selects this as master AP (DR) */
+	json_t *where = ovsdb_table_where(&table_APC_State, &apc_conf);
+	if (false == ovsdb_table_select_one_where(&table_APC_State,
+			where, &apc_conf)) {
+		LOG(INFO, "APC_State read failed");
+		return false;
+	}
+
+	if (!strncmp(apc_conf.mode, "OR", 2) || !strncmp(apc_conf.mode, "BDR", 2))
+		return false;
+
+	/* Configure options block */
+	blob_buf_init(&uci_buf, 0);
+	n = blobmsg_open_array(&uci_buf,"ListenUDP");
+	blobmsg_add_string(&uci_buf, NULL, "127.0.0.1:1812");
+	blobmsg_add_string(&uci_buf, NULL, "127.0.0.1:1813");
+	blobmsg_close_array(&uci_buf, n);
+	memset(name, '\0', sizeof(name));
+	sprintf(name, "%s%s", conf->radius_config_name, "options");
+	blob_to_uci_section(uci, "radsecproxy", name, "options",
+			uci_buf.head, &radius_proxy_options_param, NULL);
+
+	/* Configure client block */
+	blob_buf_init(&uci_buf, 0);
+	blobmsg_add_string(&uci_buf, "name", "localhost");
+	blobmsg_add_string(&uci_buf, "type", "udp");
+	blobmsg_add_string(&uci_buf, "secret", "secret");
+	memset(name, '\0', sizeof(name));
+	sprintf(name, "%s%s", conf->radius_config_name, "client");
+	blob_to_uci_section(uci, "radsecproxy", name, "client",
+			uci_buf.head, &radius_proxy_client_param, NULL);
+
+	/* Configure TLS/non-TLS and server blocks */
+	sprintf(server_name, "%s%s", conf->radius_config_name, "server");
+	sprintf(acct_server_name, "%s%s", conf->radius_config_name, "Acctserver");
+	sprintf(tls_name, "%s%s", conf->radius_config_name, "tls");
+	if (conf->radsec)
+	{
+		blob_buf_init(&uci_buf, 0);
+		radsec_download_cert("cacert.pem",
+				conf->radius_config_name, conf->ca_cert);
+		radsec_download_cert("clientcert.pem",
+				conf->radius_config_name, conf->client_cert);
+		radsec_download_cert("clientdec.key",
+				conf->radius_config_name, conf->client_key);
+
+		blobmsg_add_string(&uci_buf, "name", tls_name);
+
+		memset(path, '\0', sizeof(path));
+		sprintf(path, "/tmp/radsec/certs/%s/cacert.pem",
+				conf->radius_config_name);
+		blobmsg_add_string(&uci_buf, "CACertificateFile", path);
+
+		memset(path, '\0', sizeof(path));
+		sprintf(path, "/tmp/radsec/certs/%s/clientcert.pem",
+				conf->radius_config_name);
+		blobmsg_add_string(&uci_buf, "certificateFile", path);
+
+		memset(path, '\0', sizeof(path));
+		sprintf(path, "/tmp/radsec/certs/%s/clientdec.key",
+				conf->radius_config_name);
+		blobmsg_add_string(&uci_buf, "certificateKeyFile", path);
+
+		if (strlen(conf->passphrase) > 0)
+			blobmsg_add_string(&uci_buf, "certificateKeyPassword", conf->passphrase);
+
+		blob_to_uci_section(uci, "radsecproxy", tls_name,
+				"tls", uci_buf.head, &radius_proxy_tls_param, NULL);
+
+		blob_buf_init(&uci_buf, 0);
+		blobmsg_add_string(&uci_buf, "name", server_name);
+		blobmsg_add_string(&uci_buf, "host", conf->server);
+		blobmsg_add_string(&uci_buf, "type", "tls");
+		blobmsg_add_string(&uci_buf, "tls", tls_name);
+		blobmsg_add_u32(&uci_buf, "port", conf->port);
+		blobmsg_add_string(&uci_buf, "secret", "radsec");
+		blobmsg_add_bool(&uci_buf, "statusServer", 0);
+		blobmsg_add_bool(&uci_buf, "certificateNameCheck", 0);
+		blob_to_uci_section(uci, "radsecproxy", server_name, "server",
+				uci_buf.head, &radius_proxy_server_param, NULL);
+	}
+	else /* non-TLS block */
+	{
+		/* Authentication server */
+		blob_buf_init(&uci_buf, 0);
+		blobmsg_add_string(&uci_buf, "name", server_name);
+		blobmsg_add_string(&uci_buf, "host", conf->server);
+		blobmsg_add_string(&uci_buf, "type", "udp");
+		if (strlen(conf->secret) > 0)
+			blobmsg_add_string(&uci_buf, "secret", conf->secret);
+		if (conf->port > 0)
+			blobmsg_add_u32(&uci_buf, "port", conf->port);
+		blob_to_uci_section(uci, "radsecproxy", server_name, "server",
+				uci_buf.head, &radius_proxy_server_param, NULL);
+
+		/* Accounting server */
+		if (strlen(conf->acct_server) > 0)
+		{
+			blob_buf_init(&uci_buf, 0);
+			blobmsg_add_string(&uci_buf, "name", acct_server_name);
+			blobmsg_add_string(&uci_buf, "host", conf->acct_server);
+			blobmsg_add_string(&uci_buf, "type", "udp");
+			if (strlen(conf->secret) > 0)
+				blobmsg_add_string(&uci_buf, "secret", conf->acct_secret);
+			if (conf->acct_port > 0)
+				blobmsg_add_u32(&uci_buf, "port", conf->acct_port);
+			blob_to_uci_section(uci, "radsecproxy", acct_server_name, "server",
+								uci_buf.head, &radius_proxy_server_param, NULL);
+		}
+	}
+
+	/* Configure realm block */
+	for (i = 0; i < conf->realm_len; i++)
+	{
+		blob_buf_init(&uci_buf, 0);
+		blobmsg_add_string(&uci_buf, "name", conf->realm[i]);
+		n = blobmsg_open_array(&uci_buf,"server");
+		blobmsg_add_string(&uci_buf, NULL, server_name);
+		blobmsg_close_array(&uci_buf, n);
+		if (conf->radsec)
+		{ /* Accounting server same as auth server */
+			n = blobmsg_open_array(&uci_buf, "accountingServer");
+			blobmsg_add_string(&uci_buf, NULL, server_name);
+			blobmsg_close_array(&uci_buf, n);
+		}
+		else if (strlen(conf->acct_server) > 0)
+		{ /* non-TLS case where accounting server is configured */
+			n = blobmsg_open_array(&uci_buf, "accountingServer");
+			blobmsg_add_string(&uci_buf, NULL, acct_server_name);
+			blobmsg_close_array(&uci_buf, n);
+		}
+		memset(name, '\0', sizeof(name));
+		sprintf(name, "%s%s%d", conf->radius_config_name, "realm", i);
+		blob_to_uci_section(uci, "radsecproxy", name, "realm",
+				uci_buf.head, &radius_proxy_realm_param, NULL);
+	}
+
+	uci_commit_all(uci);
+	return true;
+}
+
+static bool radius_proxy_config_delete()
+{
+	struct uci_package *radsecproxy;
+	struct uci_context *rad_uci;
+	struct uci_element *e = NULL, *tmp = NULL;
+	int ret = 0;
+
+	rad_uci = uci_alloc_context();
+
+	ret = uci_load(rad_uci, "radsecproxy", &radsecproxy);
+	if (ret) {
+		LOGE("%s: uci_load() failed with rc %d", __func__, ret);
+		uci_free_context(rad_uci);
+		return false;
+	}
+	uci_foreach_element_safe(&radsecproxy->sections, tmp, e) {
+		struct uci_section *s = uci_to_section(e);
+		if ((s == NULL) || (s->type == NULL)) continue;
+		uci_section_del(rad_uci, "radsecproxy", "radsecproxy",
+				(char *)s->e.name, s->type);
+	}
+	uci_commit(rad_uci, &radsecproxy, false);
+	uci_unload(rad_uci, radsecproxy);
+	uci_free_context(rad_uci);
+	reload_config = 1;
+	return true;
+}
+
+void callback_Radius_Proxy_Config(ovsdb_update_monitor_t *self,
+				 struct schema_Radius_Proxy_Config *old,
+				 struct schema_Radius_Proxy_Config *conf)
+{
+	switch (self->mon_type)
+	{
+	case OVSDB_UPDATE_NEW:
+	case OVSDB_UPDATE_MODIFY:
+		(void) radius_proxy_config_set(conf);
+		break;
+
+	case OVSDB_UPDATE_DEL:
+		(void) radius_proxy_config_delete();
+		(void) radius_proxy_config_set(conf);
+		break;
+
+	default:
+		LOG(ERR, "Radius_Proxy_Config: unexpected mon_type %d %s",
+				self->mon_type, self->mon_uuid);
+		break;
+	}	
+	return;
+}
+
+

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/src/rrm_config.c

@@ -37,7 +37,7 @@ void rrm_config_vif(struct blob_buf *b, struct blob_buf *del, const char * freq_
 	if (false == ovsdb_table_select_one(&table_Wifi_RRM_Config,
 			SCHEMA_COLUMN(Wifi_RRM_Config, freq_band), freq_band, &conf))
 	{
-		LOG(INFO, "Wifi_VIF_Config: No RRM for band %s", freq_band );
+		LOG(DEBUG, "Wifi_VIF_Config: No RRM for band %s", freq_band );
 		blobmsg_add_u32(del, "rssi_ignore_probe_request", -90);
 		blobmsg_add_u32(del, "signal_connect", -90);
 		blobmsg_add_u32(del, "signal_stay", -90);
@@ -47,12 +47,39 @@ void rrm_config_vif(struct blob_buf *b, struct blob_buf *del, const char * freq_
 		blobmsg_add_u32(b, "rssi_ignore_probe_request", conf.probe_resp_threshold);
 		blobmsg_add_u32(b, "signal_connect", conf.client_disconnect_threshold);
 		blobmsg_add_u32(b, "signal_stay", conf.client_disconnect_threshold);
-		blobmsg_add_u32(b, "bcn_rate", conf.beacon_rate);
 		blobmsg_add_u32(b, "mcast_rate", conf.mcast_rate);
+
+		if (conf.beacon_rate == 0) {
+			// Default to the lowest possible bit rate for each frequency band
+			if (!strcmp(freq_band, "2.4G")) {
+				blobmsg_add_u32(b, "bcn_rate", 10);
+			} else {
+				blobmsg_add_u32(b, "bcn_rate", 60);
+			}
+		} else {
+			blobmsg_add_u32(b, "bcn_rate", conf.beacon_rate);
+		}
+		
 	}
 	return;
 }
 
+int rrm_get_backup_channel(const char * freq_band)
+{
+	struct schema_Wifi_RRM_Config conf;
+
+	memset(&conf, 0, sizeof(conf));
+	if (false == ovsdb_table_select_one(&table_Wifi_RRM_Config,
+			SCHEMA_COLUMN(Wifi_RRM_Config, freq_band), freq_band, &conf))
+	{
+		LOG(ERR, "Wifi_Radio_Config: No RRM for band %s", freq_band );
+		return 0;
+	}
+
+	return conf.backup_channel;
+
+}
+
 static bool rrm_config_update( struct schema_Wifi_RRM_Config *conf, bool addNotDelete)
 {
 	struct schema_Wifi_Radio_Config rconf;
@@ -76,7 +103,7 @@ static bool rrm_config_update( struct schema_Wifi_RRM_Config *conf, bool addNotD
 		memset(&vconf, 0, sizeof(vconf));
 		if (ovsdb_table_select_one_where(&table_Wifi_VIF_Config, where, &vconf))
 		{
-			LOG(INFO, "RRM band %s updates vif %s", conf->freq_band, vconf.if_name);
+			LOG(DEBUG, "RRM band %s updates vif %s", conf->freq_band, vconf.if_name);
 			target_vif_config_set2(&vconf, &rconf, NULL, &changed, 0);
 		}
 	}
@@ -96,12 +123,35 @@ static bool rrm_config_changed( struct schema_Wifi_RRM_Config *old,
 	return false;
 }
 
+static bool rrm_radio_config_update(struct schema_Wifi_RRM_Config *conf )
+{
+	struct schema_Wifi_Radio_Config_flags changed;
+	struct schema_Wifi_Radio_Config rconf;
+
+	if (false == ovsdb_table_select_one(&table_Wifi_Radio_Config,
+			SCHEMA_COLUMN(Wifi_Radio_Config, freq_band), conf->freq_band, &rconf))
+	{
+		LOG(WARN, "Wifi_RRM_Config: No radio for band %s", conf->freq_band );
+		return false;
+	}
+
+	memset(&changed, 0, sizeof(changed));
+	target_radio_config_set2(&rconf, &changed);
+
+	return true;
+}
+
 static bool rrm_config_set( struct schema_Wifi_RRM_Config *old,
 	struct schema_Wifi_RRM_Config *conf ) 
 {
 	if (rrm_config_changed(old, conf)) {
-		return( rrm_config_update(conf, true));
+		rrm_config_update(conf, true);
 	}
+
+	if(conf->backup_channel != old->backup_channel) {
+		rrm_radio_config_update(conf);
+	}
+
 	return true;
 }
 

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/src/stats.c

@@ -304,8 +304,7 @@ bool target_stats_scan_start(radio_entry_t *radio_cfg, uint32_t *chan_list, uint
 	LOGT("%s: scan trigger returned %d", radio_cfg->if_name, ret);
 
 	if (ret == false) {
-		LOG(ERR, "%s: failed to trigger scan, aborting", radio_cfg->if_name);
-		(*scan_cb)(scan_ctx, ret);
+		LOG(DEBUG, "%s: failed to trigger scan, aborting", radio_cfg->if_name);
 	}
 	return ret;
 }
@@ -384,7 +383,7 @@ bool target_stats_device_txchainmask_get(radio_entry_t *radio_cfg, dpp_device_tx
 	txchainmask_entry->type  = radio_cfg->type;
 	if (nl80211_get_tx_chainmask(target_map_ifname(radio_cfg->phy_name), &txchainmask_entry->value) < 0)
 		ret = false;
-	LOGT("%s: tx_chainmask %d", radio_cfg->phy_name, txchainmask_entry->value);
+	LOGD("%s: tx_chainmask %d", radio_cfg->phy_name, txchainmask_entry->value);
 
 	return ret;
 }

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/src/stats_nl80211.c

@@ -356,7 +356,7 @@ struct nl80211_scan *nl80211_scan_find(const char *name)
 	struct nl80211_scan *nl80211_scan = avl_find_element(&nl80211_scan_tree, name, nl80211_scan, avl);
 
 	if (!nl80211_scan)
-		LOGN("%s: scan context does not exist", name);
+		LOGD("%s: scan context does not exist", name);
 
 	return nl80211_scan;
 }
@@ -373,7 +373,7 @@ static int nl80211_scan_add(char *name, target_scan_cb_t *scan_cb, void *scan_ct
 		strncpy(nl80211_scan->name, name, IF_NAMESIZE);
 		nl80211_scan->avl.key = nl80211_scan->name;
 		avl_insert(&nl80211_scan_tree, &nl80211_scan->avl);
-		LOGN("%s: added scan context", name);
+		LOGD("%s: added scan context", name);
 	}
 
 	nl80211_scan->scan_cb = scan_cb;
@@ -383,7 +383,7 @@ static int nl80211_scan_add(char *name, target_scan_cb_t *scan_cb, void *scan_ct
 
 static void nl80211_scan_del(struct nl80211_scan *nl80211_scan)
 {
-	LOGN("%s: delete scan context", nl80211_scan->name);
+	LOGD("%s: delete scan context", nl80211_scan->name);
 	ev_async_stop(EV_DEFAULT, &nl80211_scan->async);
 	avl_delete(&nl80211_scan_tree, &nl80211_scan->avl);
 	free(nl80211_scan);
@@ -394,7 +394,7 @@ static void nl80211_scan_finish(char *name, bool state)
 	struct nl80211_scan *nl80211_scan = nl80211_scan_find(name);
 
 	if (nl80211_scan) {
-		LOGN("%s: calling context cb", nl80211_scan->name);
+		LOGD("%s: calling context cb", nl80211_scan->name);
 		(*nl80211_scan->scan_cb)(nl80211_scan->scan_ctx, state);
 		nl80211_scan_del(nl80211_scan);
 	}
@@ -421,14 +421,14 @@ static int nl80211_recv(struct nl_msg *msg, void *arg)
 
 	switch (gnlh->cmd) {
 	case NL80211_CMD_TRIGGER_SCAN:
-		LOGN("%s: scan started\n", ifname);
+		LOGD("%s: scan started\n", ifname);
 		break;
 	case NL80211_CMD_SCAN_ABORTED:
-		LOGN("%s: scan aborted\n", ifname);
+		LOGD("%s: scan aborted\n", ifname);
 		nl80211_scan_finish(ifname, false);
 		break;
 	case NL80211_CMD_NEW_SCAN_RESULTS:
-		LOGN("%s: scan completed\n", ifname);
+		LOGD("%s: scan completed\n", ifname);
 		nl80211_scan_finish(ifname, true);
 		break;
 	default:
@@ -547,22 +547,33 @@ int nl80211_scan_trigger(struct nl_call_param *nl_call_param, uint32_t *chan_lis
 {
 	struct nl_msg *msg = nl80211_call_vif(nl_call_param, NL80211_CMD_TRIGGER_SCAN, false);
 	struct nlattr *freq;
-	unsigned int i;
+	unsigned int i, flags = 0;
+	int ret = 0;
 
 	if (!msg)
 		return -1;
 
-	LOGN("%s: not setting dwell time\n", nl_call_param->ifname);
+	LOGT("%s: not setting dwell time\n", nl_call_param->ifname);
 	//nla_put_u16(msg, NL80211_ATTR_MEASUREMENT_DURATION, dwell_time);
+
+	/* Add the ap-force flag, otherwise the scan fails on wifi6 APs */
+	flags |= NL80211_SCAN_FLAG_AP;
+	nla_put(msg, NL80211_ATTR_SCAN_FLAGS, sizeof(uint32_t), &flags);
+
 	freq = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
 	for (i = 0; i < chan_num; i ++)
 		nla_put_u32(msg, i, ieee80211_channel_to_frequency(chan_list[i]));
 	nla_nest_end(msg, freq);
 
-	if (nl80211_scan_add(nl_call_param->ifname, scan_cb, scan_ctx))
+	ret = nl80211_scan_add(nl_call_param->ifname, scan_cb, scan_ctx); 
+	if (ret ) {
+		LOG(DEBUG,"%s: scan add failed %d\n", nl_call_param->ifname, ret);
 		return -1;
+	}
 
-	return unl_genl_request(&unl, msg, nl80211_scan_trigger_recv, NULL);
+	ret = unl_genl_request(&unl, msg, nl80211_scan_trigger_recv, NULL);
+	if (ret)	LOG(DEBUG, "%s: scan request failed %d\n", nl_call_param->ifname, ret);
+	return ret;
 }
 
 int nl80211_scan_abort(struct nl_call_param *nl_call_param)
@@ -595,5 +606,9 @@ int stats_nl80211_init(void)
 		LOGE("failed to spawn nl80211");
 		return -1;
 	}
+
+	if (nl_socket_set_buffer_size(unl.sock, 262144, 0) < 0)
+		LOGE("stats_nl80211: Failed to set nl socket buffer size");
+
 	return 0;
 }

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/src/uci.c

@@ -210,8 +210,10 @@ int uci_section_to_blob(struct uci_context *uci, char *package, char *section,
 
 	if (uci_load(uci, package, &p))
 		p = uci_lookup_package(uci, package);
-	if (!p)
+	if (!p) {
+		uci_unload(uci, p);
 		return -1;
+	}
 	s = uci_lookup_section(uci, p, section);
 	if (!s)
 		goto out;

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/src/utils.c

@@ -23,41 +23,79 @@
 #include "vif.h"
 
 static struct mode_map mode_map[] = {
-	{ 0, "11b", "11b", NULL, "NOHT" },
-	{ 0, "11g", "11g", NULL, "NOHT" },
-	{ 1, "11a", "11a", NULL, "NOHT" },
-	{ 0, "11n", "11g", "HT20", "HT20" },
-	{ 0, "11n", "11g", "HT40", "HT40" },
-	{ 0, "11n", "11g", "HT40-", "HT40-" },
-	{ 0, "11n", "11g", "HT40+", "HT40+" },
-	{ 0, "11n", "11g", "HT80", "HT40" },
-	{ 0, "11n", "11g", "HT160", "HT40" },
-	{ 1, "11n", "11a", "HT20", "HT20" },
-	{ 1, "11n", "11a", "HT40", "HT40" },
-	{ 1, "11n", "11a", "HT40-", "HT40-" },
-	{ 1, "11n", "11a", "HT40+", "HT40+" },
-	{ 1, "11n", "11a", "HT80", "HT40" },
-	{ 1, "11n", "11a", "HT160", "HT40" },
-	{ 1, "11ac", "11a", "HT20", "VHT20" },
-	{ 1, "11ac", "11a", "HT40", "VHT40" },
-	{ 1, "11ac", "11a", "HT40-", "VHT40" },
-	{ 1, "11ac", "11a", "HT40+", "VHT40" },
-	{ 1, "11ac", "11a", "HT80", "VHT80" },
-	{ 1, "11ac", "11a", "HT160", "VHT160" },
-	{ 0, "11ax", "11g", "HT20", "HE20" },
-	{ 0, "11ax", "11g", "HT40", "HE40" },
-	{ 0, "11ax", "11g", "HT40-", "HE40" },
-	{ 0, "11ax", "11g", "HT40+", "HE40" },
-	{ 0, "11ax", "11g", "HT80", "HE80" },
-	{ 0, "11ax", "11g", "HT160", "HE80" },
-	{ 1, "11ax", "11a", "HT20", "HE20" },
-	{ 1, "11ax", "11a", "HT40", "HE40" },
-	{ 1, "11ax", "11a", "HT40-", "HE40" },
-	{ 1, "11ax", "11a", "HT40+", "HE40" },
-	{ 1, "11ax", "11a", "HT80", "HE80" },
-	{ 1, "11ax", "11a", "HT160", "HE160" },
+	{ 0, "11b", "11b", NULL, "NOHT", 0 },
+	{ 0, "11g", "11g", NULL, "NOHT", 0 },
+	{ 1, "11a", "11a", NULL, "NOHT", 0 },
+	{ 0, "11n", "11g", "HT20", "HT20", 0 },
+	{ 0, "11n", "11g", "HT40", "HT40", 1 },
+	{ 0, "11n", "11g", "HT40-", "HT40-", 1 },
+	{ 0, "11n", "11g", "HT40+", "HT40+", 1 },
+	{ 0, "11n", "11g", "HT80", "HT40", 1 },
+	{ 0, "11n", "11g", "HT160", "HT40", 1 },
+	{ 1, "11n", "11a", "HT20", "HT20", 0 },
+	{ 1, "11n", "11a", "HT40", "HT40", 1 },
+	{ 1, "11n", "11a", "HT40-", "HT40-", 1 },
+	{ 1, "11n", "11a", "HT40+", "HT40+", 1 },
+	{ 1, "11n", "11a", "HT80", "HT40", 1 },
+	{ 1, "11n", "11a", "HT160", "HT40", 1 },
+	{ 1, "11ac", "11a", "HT20", "VHT20", 0 },
+	{ 1, "11ac", "11a", "HT40", "VHT40", 1 },
+	{ 1, "11ac", "11a", "HT40-", "VHT40", 1 },
+	{ 1, "11ac", "11a", "HT40+", "VHT40", 1 },
+	{ 1, "11ac", "11a", "HT80", "VHT80", 1 },
+	{ 1, "11ac", "11a", "HT160", "VHT160", 1 },
+	{ 0, "11ax", "11g", "HT20", "HE20", 0 },
+	{ 0, "11ax", "11g", "HT40", "HE40", 1 },
+	{ 0, "11ax", "11g", "HT40-", "HE40", 1 },
+	{ 0, "11ax", "11g", "HT40+", "HE40", 1 },
+	{ 0, "11ax", "11g", "HT80", "HE80", 1 },
+	{ 0, "11ax", "11g", "HT160", "HE80", 1 },
+	{ 1, "11ax", "11a", "HT20", "HE20", 0 },
+	{ 1, "11ax", "11a", "HT40", "HE40", 1 },
+	{ 1, "11ax", "11a", "HT40-", "HE40", 1 },
+	{ 1, "11ax", "11a", "HT40+", "HE40", 1 },
+	{ 1, "11ax", "11a", "HT80", "HE80", 1 },
+	{ 1, "11ax", "11a", "HT160", "HE160", 1 },
 };
 
+typedef enum {
+	MHz20=0,
+	MHz40 = 1,
+	MHz80 = 2,
+	MHz160 = 4
+} bm_AllowedBw;
+
+typedef struct {
+	int freq;
+	bm_AllowedBw bw;
+} freqBwListEntry;
+
+freqBwListEntry freqBwList[] ={{2412, MHz20},{2417, MHz20},{2422, MHz20},{2427, MHz20},{2432, MHz20},{2437, MHz20},{2442, MHz20},{2447, MHz20},{2452, MHz20},{2457, MHz20},{2462, MHz20},{2467, MHz20},{2472, MHz20}, {2484, MHz20},
+		{ 5180, MHz20|MHz40|MHz80},{5200, MHz20},{5220, MHz20|MHz40},{5240, MHz20},{5260, MHz20|MHz40|MHz80},{5280, MHz20},{5300,MHz20|MHz40},{5320, MHz20},{5500, MHz20|MHz40|MHz80},{5520, MHz20},{5540,  MHz20|MHz40}, {5560, MHz20},
+		{5580, MHz20|MHz40|MHz80},{5600, MHz20},{5620, MHz20|MHz40},{5640, MHz20},{5660, MHz20|MHz40|MHz80},{5680, MHz20},{5700, MHz20|MHz40},{5720, MHz20},{5745, MHz20|MHz40|MHz80},{5765, MHz20},{5785, MHz20|MHz40},{5805, MHz20},{5825, MHz20}};
+
+#define REQ_BW(htmode) (!strcmp(htmode, "HT20") ? MHz20 : !strcmp(htmode, "HT40") ? MHz40 : !strcmp(htmode, "HT80") ? MHz80 : !strcmp(htmode, "HT160") ? MHz160 : MHz20)
+#define REQ_MODE(bw) (bw==MHz20 ? "HT20": bw==MHz40 ? "HT40" : bw==MHz80 ? "HT80" : bw==MHz160 ? "HT160" : "HT20")
+
+char * get_max_channel_bw_channel(int channel_freq, const char* htmode)
+{
+	unsigned int i;
+	bm_AllowedBw requestedBw;
+
+	requestedBw = REQ_BW(htmode);
+
+	for ( i = 0; i < ARRAY_SIZE(freqBwList); i++) {
+		if(freqBwList[i].freq == channel_freq) {
+			while (requestedBw) {
+				if (freqBwList[i].bw & requestedBw) {
+					return REQ_MODE(requestedBw);
+				}
+				requestedBw >>= 1;
+			}
+		}
+	}
+	return "HT20";
+}
 struct mode_map *mode_map_get_uci(const char *band, const char *htmode, const char *hwmode)
 {
 	unsigned int i;
@@ -283,7 +321,7 @@ int phy_get_channels_state(const char *name, struct schema_Wifi_Radio_State *rst
 	if (!phy)
 		return 0;
 
-	LOGN("phy name :%s", name);
+	LOGD("phy name :%s", name);
 
 	for (i = 0; (i < IEEE80211_CHAN_MAX); i++) {
 		if (phy->chandisabled[i]) {
@@ -310,27 +348,6 @@ int phy_get_channels_state(const char *name, struct schema_Wifi_Radio_State *rst
 	return ret;
 }
 
-int phy_get_list_channels_dfs(const char *name, int *list)
-{
-	struct wifi_phy *phy = phy_find(name);
-	int i = 0, len = 0;
-
-	if (!phy)
-		return 0;
-
-	for (i = 0; (i < IEEE80211_CHAN_MAX); i++) {
-		if (phy->chandfs[i]) {
-			list[len] = i;
-			len++;
-		} else if (phy->channel[i]) {
-			list[len] = i;
-			len++;
-		}
-	}
-
-	return len;
-}
-
 int phy_get_band(const char *name, char *band)
 {
 	struct wifi_phy *phy = phy_find(name);
@@ -611,6 +628,15 @@ int ieee80211_channel_to_frequency(int chan)
 		return 5000 + chan * 5;
 	return 0;
 }
+int get_current_channel(char *name)
+{
+	struct wifi_phy *phy = phy_find(name);
+
+	if(phy)
+		return phy->current_channel;
+
+	return 0;
+}
 
 bool vif_get_security(struct schema_Wifi_VIF_State *vstate,  char *mode,  char *encryption, char *radiusServerIP,  char *password, char *port)
 {
@@ -636,3 +662,22 @@ bool vif_get_security(struct schema_Wifi_VIF_State *vstate,  char *mode,  char *
 	return true;
 
 }
+
+bool vif_get_key_for_key_distr(const char *secret, char *key_str)
+{
+	bool err = false;
+	FILE *fp;
+	char cmd_buf[256] = "openssl aes-128-cbc -nosalt -k ";
+
+	strcat(cmd_buf, secret);
+	strcat(cmd_buf, " -P 2>/dev/null | grep key | cut -d = -f2");
+	fp = popen(cmd_buf, "r");
+
+	
+	if (fp && fscanf(fp, "%s", key_str)) {
+		err = true;
+	}
+
+	fclose(fp);
+	return err;
+}

feeds/wlan-ap/opensync/src/platform/openwrt/src/lib/target/src/vif.c

@@ -94,11 +94,20 @@ enum {
 	WIF_ATTR_VENUE_URL,
 	WIF_ATTR_NETWORK_AUTH_TYPE,
 	WIF_ATTR_IPADDR_TYPE_AVAILABILITY,
+	WIF_ATTR_CONNECTION_CAPABILITY,
 	WIF_ATTR_DOMAIN_NAME,
 	WIF_ATTR_MCC_MNC,
 	WIF_ATTR_NAI_REALM,
 	WIF_ATTR_GAS_ADDR3,
+	WIF_ATTR_QOS_MAP_SET,
 	WIF_ATTR_OSEN,
+	WIF_ATTR_ACCESS_NETWORK_TYPE,
+	WIF_ATTR_INTERNET,
+	WIF_ATTR_ESR,
+	WIF_ATTR_ASRA,
+	WIF_ATTR_UESA,
+	WIF_ATTR_DISABLE_DGAF,
+	WIF_ATTR_WAN_METRICS,
 	WIF_ATTR_ANQP_DOMAIN_ID,
 	WIF_ATTR_DEAUTH_REQUEST_TIMEOUT,
 	WIF_ATTR_OPER_FRIENDLY_NAME,
@@ -110,6 +119,7 @@ enum {
 	WIF_ATTR_BEACON_RATE,
 	WIF_ATTR_MCAST_RATE,
 	WIF_ATTR_RADIUS_NAS_ID_ATTR,
+	WIF_ATTR_RADIUS_NAS_IP_ATTR,
 	WIF_ATTR_RADIUS_AUTH_REQ_ATTR,
 	WIF_ATTR_RADIUS_ACCT_REQ_ATTR,
 	WIF_ATTR_MESH_ID,
@@ -120,6 +130,11 @@ enum {
 	WIF_ATTR_DVLAN_NAMING,
 	WIF_ATTR_DVLAN_BRIDGE,
 	WIF_ATTR_MIN_HW_MODE,
+	WIF_ATTR_11R_R0KH,
+	WIF_ATTR_11R_R1KH,
+	WIF_ATTR_RADPROXY,
+	WIF_ATTR_PROXY_ARP,
+	WIF_ATTR_MCAST_TO_UCAST,
 	__WIF_ATTR_MAX,
 };
 
@@ -175,12 +190,21 @@ static const struct blobmsg_policy wifi_iface_policy[__WIF_ATTR_MAX] = {
 	[WIF_ATTR_VENUE_TYPE] = { .name = "venue_type", BLOBMSG_TYPE_INT32 },
 	[WIF_ATTR_VENUE_URL] = { .name = "venue_url", BLOBMSG_TYPE_ARRAY },
 	[WIF_ATTR_NETWORK_AUTH_TYPE] = { .name = "network_auth_type", BLOBMSG_TYPE_STRING },
-	[WIF_ATTR_IPADDR_TYPE_AVAILABILITY] = { .name = "ipaddr_type_availability", BLOBMSG_TYPE_INT32 },
+	[WIF_ATTR_IPADDR_TYPE_AVAILABILITY] = { .name = "ipaddr_type_availability", BLOBMSG_TYPE_STRING },
+	[WIF_ATTR_CONNECTION_CAPABILITY] = { .name = "hs20_conn_capab", BLOBMSG_TYPE_ARRAY },
 	[WIF_ATTR_DOMAIN_NAME] = { .name = "domain_name", BLOBMSG_TYPE_STRING },
 	[WIF_ATTR_MCC_MNC] = { .name = "anqp_3gpp_cell_net", BLOBMSG_TYPE_STRING },
 	[WIF_ATTR_NAI_REALM] = { .name = "nai_realm", BLOBMSG_TYPE_ARRAY },
 	[WIF_ATTR_GAS_ADDR3] = { .name = "gas_address3", BLOBMSG_TYPE_STRING },
+	[WIF_ATTR_QOS_MAP_SET] = { .name = "qos_map_set", BLOBMSG_TYPE_STRING },
 	[WIF_ATTR_OSEN] = { .name = "osen", BLOBMSG_TYPE_BOOL },
+	[WIF_ATTR_ACCESS_NETWORK_TYPE] = { .name = "access_network_type", BLOBMSG_TYPE_INT32 },
+	[WIF_ATTR_INTERNET] = { .name = "internet", BLOBMSG_TYPE_BOOL },
+	[WIF_ATTR_ESR] = { .name = "esr", BLOBMSG_TYPE_BOOL },
+	[WIF_ATTR_ASRA] = { .name = "asra", BLOBMSG_TYPE_BOOL },
+	[WIF_ATTR_UESA] = { .name = "uesa", BLOBMSG_TYPE_BOOL },
+	[WIF_ATTR_DISABLE_DGAF] = { .name = "disable_dgaf", BLOBMSG_TYPE_BOOL },
+	[WIF_ATTR_WAN_METRICS] = { .name = "hs20_wan_metrics", BLOBMSG_TYPE_STRING },
 	[WIF_ATTR_ANQP_DOMAIN_ID] = { .name = "anqp_domain_id", BLOBMSG_TYPE_INT32 },
 	[WIF_ATTR_DEAUTH_REQUEST_TIMEOUT] = { .name = "hs20_deauth_req_timeout", BLOBMSG_TYPE_INT32 },
 	[WIF_ATTR_OPER_FRIENDLY_NAME] = { .name = "hs20_oper_friendly_name", BLOBMSG_TYPE_ARRAY },
@@ -192,6 +216,7 @@ static const struct blobmsg_policy wifi_iface_policy[__WIF_ATTR_MAX] = {
 	[WIF_ATTR_BEACON_RATE] = { .name = "bcn_rate", .type = BLOBMSG_TYPE_INT32 },
 	[WIF_ATTR_MCAST_RATE] = { .name = "mcast_rate", .type = BLOBMSG_TYPE_INT32 },
 	[WIF_ATTR_RADIUS_NAS_ID_ATTR] = { .name = "nasid", BLOBMSG_TYPE_STRING },
+	[WIF_ATTR_RADIUS_NAS_IP_ATTR] = { .name = "ownip", BLOBMSG_TYPE_STRING },
 	[WIF_ATTR_RADIUS_AUTH_REQ_ATTR] = { .name = "radius_auth_req_attr", BLOBMSG_TYPE_ARRAY },
 	[WIF_ATTR_RADIUS_ACCT_REQ_ATTR] = { .name = "radius_acct_req_attr", BLOBMSG_TYPE_ARRAY },
 	[WIF_ATTR_MESH_ID] = { .name = "mesh_id", BLOBMSG_TYPE_STRING },
@@ -202,6 +227,11 @@ static const struct blobmsg_policy wifi_iface_policy[__WIF_ATTR_MAX] = {
 	[WIF_ATTR_DVLAN_NAMING] = { .name = "vlan_naming", BLOBMSG_TYPE_STRING },
 	[WIF_ATTR_DVLAN_BRIDGE] = { .name = "vlan_bridge", BLOBMSG_TYPE_STRING },
 	[WIF_ATTR_MIN_HW_MODE] = { .name = "min_hw_mode", BLOBMSG_TYPE_STRING },
+	[WIF_ATTR_11R_R0KH] = { .name = "r0kh", BLOBMSG_TYPE_STRING },
+	[WIF_ATTR_11R_R1KH] = { .name = "r1kh", BLOBMSG_TYPE_STRING },
+	[WIF_ATTR_RADPROXY] = { .name = "radproxy", BLOBMSG_TYPE_STRING },
+	[WIF_ATTR_PROXY_ARP] = { .name = "proxy_arp", BLOBMSG_TYPE_BOOL },
+	[WIF_ATTR_MCAST_TO_UCAST] = { .name = "multicast_to_unicast", BLOBMSG_TYPE_BOOL },
 };
 
 const struct uci_blob_param_list wifi_iface_param = {
@@ -289,10 +319,67 @@ static struct vif_crypto {
 	{ "wpa-mixed", OVSDB_SECURITY_ENCRYPTION_WPA_EAP, OVSDB_SECURITY_MODE_MIXED, 1 },
 	{ "sae", OVSDB_SECURITY_ENCRYPTION_WPA_SAE, OVSDB_SECURITY_MODE_WPA3, 0 },
 	{ "sae-mixed", OVSDB_SECURITY_ENCRYPTION_WPA_SAE, OVSDB_SECURITY_MODE_MIXED, 0 },
-	{ "wpa3", OVSDB_SECURITY_ENCRYPTION_WPA3_EAP, OVSDB_SECURITY_MODE_WPA3, 1 },
+	{ "wpa3-only", OVSDB_SECURITY_ENCRYPTION_WPA3_EAP, OVSDB_SECURITY_MODE_WPA3, 1 },
 	{ "wpa3-mixed", OVSDB_SECURITY_ENCRYPTION_WPA3_EAP, OVSDB_SECURITY_MODE_MIXED, 1 },
 };
 
+extern ovsdb_table_t table_APC_State;
+extern json_t* ovsdb_table_where(ovsdb_table_t *table, void *record);
+extern unsigned int radproxy_apc;
+
+/* Custom options table */
+#define SCHEMA_CUSTOM_OPT_SZ            20
+#define SCHEMA_CUSTOM_OPTS_MAX          15
+
+const char custom_options_table[SCHEMA_CUSTOM_OPTS_MAX][SCHEMA_CUSTOM_OPT_SZ] =
+{
+	SCHEMA_CONSTS_RATE_LIMIT,
+	SCHEMA_CONSTS_RATE_DL,
+	SCHEMA_CONSTS_RATE_UL,
+	SCHEMA_CONSTS_CLIENT_RATE_DL,
+	SCHEMA_CONSTS_CLIENT_RATE_UL,
+	SCHEMA_CONSTS_IEEE80211k,
+	SCHEMA_CONSTS_RTS_THRESHOLD,
+	SCHEMA_CONSTS_DTIM_PERIOD,
+	SCHEMA_CONSTS_RADIUS_OPER_NAME,
+	SCHEMA_CONSTS_RADIUS_NAS_ID,
+	SCHEMA_CONSTS_RADIUS_NAS_IP,
+	SCHEMA_CONSTS_DYNAMIC_VLAN,
+	SCHEMA_CONSTS_RADPROXY,
+	SCHEMA_CONSTS_PROXY_ARP,
+	SCHEMA_CONSTS_MCAST_TO_UCAST,
+};
+
+static bool vif_config_custom_opt_get_proxy(
+		const struct schema_Wifi_VIF_Config *vconf)
+{
+	int i;
+	const char *opt;
+	const char *val;
+	char value[20];
+
+	for (i = 0; i < SCHEMA_CUSTOM_OPTS_MAX; i++) {
+		opt = custom_options_table[i];
+		val = SCHEMA_KEY_VAL(vconf->custom_options, opt);
+		if (!val)
+			strncpy(value, "0", 20);
+		else
+			strncpy(value, val, 20);
+
+		if (strcmp(opt, "radproxy") == 0) {
+			if (strcmp(value, "1") == 0) {
+				radproxy_apc |= 1;
+				return true;
+			}
+			else {
+				radproxy_apc |= 0;
+				return false;
+			}
+		}
+	}
+	return false;
+}
+
 static int vif_config_security_set(struct blob_buf *b,
 				    const struct schema_Wifi_VIF_Config *vconf)
 {
@@ -300,7 +387,10 @@ static int vif_config_security_set(struct blob_buf *b,
 	const char *mode = SCHEMA_KEY_VAL(vconf->security, SCHEMA_CONSTS_SECURITY_MODE);
 	unsigned int i;
 	unsigned int acct_interval;
-	const char *auth_server, *auth_port, *auth_secret, *security_key;
+	const char *auth_server, *auth_port, *auth_secret, *security_key, *acct_server;
+	char key_str[64], key_holder_str[128];
+	struct schema_APC_State apc_conf;
+	const char *local_server = "127.0.0.1";
 
 	if (!strcmp(encryption, OVSDB_SECURITY_ENCRYPTION_OPEN) || !mode)
 		goto open;
@@ -318,20 +408,48 @@ static int vif_config_security_set(struct blob_buf *b,
 		}
 
 		if (vif_crypto[i].enterprise) {
+
+			if (vif_config_custom_opt_get_proxy(vconf)) {
+				LOGN("%s: Apply Proxy Security Settings", vconf->if_name);
+				json_t *where = ovsdb_table_where(&table_APC_State, &apc_conf);
+				if (false == ovsdb_table_select_one_where(&table_APC_State,
+						where, &apc_conf)) {
+					LOG(INFO, "APC_State read failed");
+					return -1;
+				}
+				if (!strncmp(apc_conf.mode, "DR", 2)) {
+					auth_server = local_server;
+					acct_server = local_server;
+				} else if (!strncmp(apc_conf.mode, "OR", 2) ||
+					   !strncmp(apc_conf.mode, "BDR", 2)) {
+					auth_server = apc_conf.dr_addr;
+					acct_server = apc_conf.dr_addr;
+				}
+				else {
+					auth_server = local_server;
+					acct_server = local_server;
+				}
+			}
+			else
+			{
+				auth_server = SCHEMA_KEY_VAL(vconf->security, SCHEMA_CONSTS_SECURITY_RADIUS_IP);
+				acct_server = SCHEMA_KEY_VAL(vconf->security, OVSDB_SECURITY_RADIUS_ACCT_IP);
+			}
+
 			acct_interval = 0;
-			auth_server = SCHEMA_KEY_VAL(vconf->security, SCHEMA_CONSTS_SECURITY_RADIUS_IP);
 			auth_port   = SCHEMA_KEY_VAL(vconf->security, SCHEMA_CONSTS_SECURITY_RADIUS_PORT);
 			auth_secret = SCHEMA_KEY_VAL(vconf->security, SCHEMA_CONSTS_SECURITY_RADIUS_SECRET);
+
 			LOGT("%s: Server IP %s port %s secret %s", vconf->if_name, auth_server, auth_port, auth_secret);
 			if (!auth_server[0] || !auth_port[0] || !auth_secret[0]) {
 				LOGI("%s: Incomplete RADIUS security config - SSID not created", vconf->if_name);
 				return -1;
 			}
+
 			blobmsg_add_string(b, "auth_server", auth_server);
 			blobmsg_add_string(b, "auth_port",   auth_port );
 			blobmsg_add_string(b, "auth_secret", auth_secret );
-			blobmsg_add_string(b, "acct_server",
-					   SCHEMA_KEY_VAL(vconf->security, OVSDB_SECURITY_RADIUS_ACCT_IP));
+			blobmsg_add_string(b, "acct_server", acct_server);
 			blobmsg_add_string(b, "acct_port",
 					   SCHEMA_KEY_VAL(vconf->security, OVSDB_SECURITY_RADIUS_ACCT_PORT));
 			blobmsg_add_string(b, "acct_secret",
@@ -343,6 +461,26 @@ static int vif_config_security_set(struct blob_buf *b,
 			{
 				blobmsg_add_u32(b, "acct_interval", acct_interval);
 			}
+
+			/*
+			 * If Radius is configured and Roaming is enabled,
+			 * - disable ft_psk_generate_local. This is required for hostapd to populate R0/R1.
+			 * - populate r0KH and r1KH with broadcast addressing so that the corresponding
+			 * Key Holders are auto-generated
+			 */
+			if (vconf->ft_mobility_domain) {
+				blobmsg_add_bool(b, "ft_psk_generate_local", 0);
+
+				vif_get_key_for_key_distr(auth_secret, key_str);
+
+				strcpy(key_holder_str, "ff:ff:ff:ff:ff:ff,*,");
+				strcat(key_holder_str, key_str);
+				blobmsg_add_string(b, "r0kh", key_holder_str);
+
+				strcpy(key_holder_str, "00:00:00:00:00:00,00:00:00:00:00:00,");
+				strcat(key_holder_str, key_str);
+				blobmsg_add_string(b, "r1kh", key_holder_str);
+			}
 		} else {
 			security_key = SCHEMA_KEY_VAL(vconf->security, SCHEMA_CONSTS_SECURITY_KEY);
 			if (security_key == NULL) {
@@ -350,6 +488,8 @@ static int vif_config_security_set(struct blob_buf *b,
 				return -1;
 			}
 			blobmsg_add_string(b, "key", security_key);
+			if (vconf->ft_mobility_domain)
+				blobmsg_add_bool(b, "ft_psk_generate_local", vconf->ft_psk);
 		}
 	}
 	return 0;
@@ -436,24 +576,6 @@ out_none:
 				  OVSDB_SECURITY_ENCRYPTION_OPEN);
 }
 
-/* Custom options table */
-#define SCHEMA_CUSTOM_OPT_SZ            20
-#define SCHEMA_CUSTOM_OPTS_MAX          11
-
-const char custom_options_table[SCHEMA_CUSTOM_OPTS_MAX][SCHEMA_CUSTOM_OPT_SZ] =
-{
-	SCHEMA_CONSTS_RATE_LIMIT,
-	SCHEMA_CONSTS_RATE_DL,
-	SCHEMA_CONSTS_RATE_UL,
-	SCHEMA_CONSTS_CLIENT_RATE_DL,
-	SCHEMA_CONSTS_CLIENT_RATE_UL,
-	SCHEMA_CONSTS_IEEE80211k,
-	SCHEMA_CONSTS_RTS_THRESHOLD,
-	SCHEMA_CONSTS_DTIM_PERIOD,
-	SCHEMA_CONSTS_RADIUS_OPER_NAME,
-	SCHEMA_CONSTS_RADIUS_NAS_ID,
-	SCHEMA_CONSTS_DYNAMIC_VLAN,
-};
 
 static void vif_config_custom_opt_set(struct blob_buf *b, struct blob_buf *del,
                                       const struct schema_Wifi_VIF_Config *vconf)
@@ -464,6 +586,9 @@ static void vif_config_custom_opt_set(struct blob_buf *b, struct blob_buf *del,
 	const char *opt;
 	const char *val;
 	struct blob_attr *n;
+	bool found_nasid = false;
+	char mac[ETH_ALEN * 3];
+	struct blob_attr *tb[__WIF_ATTR_MAX] = { };
 
 	for (i = 0; i < SCHEMA_CUSTOM_OPTS_MAX; i++) {
 		opt = custom_options_table[i];
@@ -498,8 +623,14 @@ static void vif_config_custom_opt_set(struct blob_buf *b, struct blob_buf *del,
 			blobmsg_add_string(b, "rts_threshold", value);
 		else if (strcmp(opt, "dtim_period") == 0)
 			blobmsg_add_string(b, "dtim_period", value);
-		else if (strcmp(opt, "radius_nas_id") == 0)
-			blobmsg_add_string(b, "nasid", value);
+		else if (strcmp(opt, "radius_nas_id") == 0) {
+			if (strcmp(value, "\0") != 0) {
+				blobmsg_add_string(b, "nasid", value);
+				found_nasid = true;
+			}
+		}
+		else if (strcmp(opt, "radius_nas_ip") == 0)
+			blobmsg_add_string(b, "ownip", value);
 		else if (strcmp(opt, "radius_oper_name") == 0 && strlen(value) > 0)
 		{
 			memset(operator_name, '\0', sizeof(operator_name));
@@ -531,8 +662,29 @@ static void vif_config_custom_opt_set(struct blob_buf *b, struct blob_buf *del,
 				strncpy(value, "br-wan.", 20);
 				blobmsg_add_string(del, "vlan_bridge", value);
 			}
+		} else if (strcmp(opt, "radproxy") == 0) {
+			blobmsg_add_string(b, "radproxy", value);
+		} else if (strcmp(opt, "proxy_arp") == 0) {
+			if (strcmp(value, "1") == 0)
+				blobmsg_add_bool(b, "proxy_arp", 1);
+			else if (strcmp(value, "0") == 0)
+				blobmsg_add_bool(del, "proxy_arp", 1);
+		} else if (strcmp(opt, "mcast_to_ucast") == 0) {
+			if (strcmp(value, "1") == 0)
+				blobmsg_add_bool(b, "multicast_to_unicast", 1);
+			else if (strcmp(value, "0") == 0)
+				blobmsg_add_bool(del, "multicast_to_unicast", 1);
 		}
 	}
+
+	/* No NASID was found from blob, so use BSSID as NASID */
+	if (found_nasid == false) {
+		blobmsg_parse(wifi_iface_policy, __WIF_ATTR_MAX, tb, blob_data(b->head), blob_len(b->head));
+		if (tb[WIF_ATTR_IFNAME] && !vif_get_mac(blobmsg_get_string(tb[WIF_ATTR_IFNAME]), mac))
+			blobmsg_add_string(b, "nasid", mac);
+		else
+			LOGE("Failed to get base BSSID (mac)\n");
+	}
 }
 
 static void set_custom_option_state(struct schema_Wifi_VIF_State *vstate,
@@ -629,6 +781,13 @@ static void vif_state_custom_options_get(struct schema_Wifi_VIF_State *vstate,
 						custom_options_table[i],
 						buf);
 			}
+		} else if (strcmp(opt, "radius_nas_ip") == 0) {
+			if (tb[WIF_ATTR_RADIUS_NAS_IP_ATTR]) {
+				buf = blobmsg_get_string(tb[WIF_ATTR_RADIUS_NAS_IP_ATTR]);
+				set_custom_option_state(vstate, &index,
+						custom_options_table[i],
+						buf);
+			}
 		} else if (strcmp(opt, "radius_oper_name") == 0) {
 			static struct blobmsg_policy policy[1] = {
 					{ .type = BLOBMSG_TYPE_STRING },
@@ -658,6 +817,39 @@ static void vif_state_custom_options_get(struct schema_Wifi_VIF_State *vstate,
 							custom_options_table[i],
 							buf);
 			}
+		} else if (strcmp(opt, "radproxy") == 0) {
+			if (tb[WIF_ATTR_RADPROXY]) {
+				buf = blobmsg_get_string(tb[WIF_ATTR_RADPROXY]);
+				set_custom_option_state(vstate, &index,
+							custom_options_table[i],
+							buf);
+			}
+
+
+		} else if (strcmp(opt, "proxy_arp") == 0) {
+			if (tb[WIF_ATTR_PROXY_ARP]) {
+				if (blobmsg_get_bool(tb[WIF_ATTR_PROXY_ARP])) {
+					set_custom_option_state(vstate, &index,
+								custom_options_table[i],
+								"1");
+				} else {
+					set_custom_option_state(vstate, &index,
+								custom_options_table[i],
+								"0");
+				}
+			}
+		} else if (strcmp(opt, "mcast_to_ucast") == 0) {
+			if (tb[WIF_ATTR_MCAST_TO_UCAST]) {
+				if (blobmsg_get_bool(tb[WIF_ATTR_MCAST_TO_UCAST])) {
+					set_custom_option_state(vstate, &index,
+								custom_options_table[i],
+								"1");
+				} else {
+					set_custom_option_state(vstate, &index,
+								custom_options_table[i],
+								"0");
+				}
+			}
 		}
 	}
 }
@@ -669,6 +861,7 @@ bool vif_state_update(struct uci_section *s, struct schema_Wifi_VIF_Config *vcon
 	char mac[ETH_ALEN * 3];
 	char *ifname, radio[IF_NAMESIZE];
 	bool vifIsActive = false;
+	char network_name[IF_NAMESIZE];
 
 	LOGT("%s: get state", s->e.name);
 
@@ -736,8 +929,10 @@ bool vif_state_update(struct uci_section *s, struct schema_Wifi_VIF_Config *vcon
 //	else
 //		SCHEMA_SET_INT(vstate.uapsd_enable, false);
 
-	if (tb[WIF_ATTR_NETWORK])
-		SCHEMA_SET_STR(vstate.bridge, blobmsg_get_string(tb[WIF_ATTR_NETWORK]));
+	if (tb[WIF_ATTR_NETWORK]) {
+		strncpy(network_name, blobmsg_get_string(tb[WIF_ATTR_NETWORK]), IF_NAMESIZE);
+		SCHEMA_SET_STR(vstate.bridge, network_name);
+	}
 	else
 		LOGW("%s: unknown bridge/network", s->e.name);
 
@@ -803,9 +998,10 @@ bool vif_state_update(struct uci_section *s, struct schema_Wifi_VIF_Config *vcon
 	}
 	vif_state_security_get(&vstate, tb);
 	vif_state_custom_options_get(&vstate, tb);
-	vif_state_captive_portal_options_get(&vstate, s);
-	vif_state_dhcp_allowlist_get(&vstate);
-
+	if(!strcmp(network_name,"lan")) {
+		vif_state_captive_portal_options_get(&vstate);
+		vif_state_dhcp_allowlist_get(&vstate);
+	}
 	if (vconf) {
 		LOGN("%s: updating vif config", radio);
 		vif_state_to_conf(&vstate, vconf);
@@ -824,30 +1020,93 @@ size_t write_file(void *ptr, size_t size, size_t nmemb, FILE *stream) {
 
 void vif_section_del(char *section_name)
 {
-
 	struct uci_package *wireless;
+	struct uci_context *sec_ctx;
 	struct uci_element *e = NULL, *tmp = NULL;
 	int ret=0;
-
-	ret= uci_load(uci, "wireless", &wireless);
+	sec_ctx = uci_alloc_context();
+	ret= uci_load(sec_ctx, "wireless", &wireless);
 	if (ret) {
-		LOGD("%s: uci_load() failed with rc %d", section_name, ret);
+		LOGE("%s: %s uci_load() failed with rc %d", section_name, __func__, ret);
+		uci_free_context(sec_ctx);
 		return;
 	}
 	uci_foreach_element_safe(&wireless->sections, tmp, e) {
 		struct uci_section *s = uci_to_section(e);
 		if ((s == NULL) || (s->type == NULL)) continue;
 		if (!strcmp(s->type, section_name)) {
-			uci_section_del(uci, "vif", "wireless", (char *)s->e.name, section_name);
+			uci_section_del(sec_ctx, "vif", "wireless", (char *)s->e.name, section_name);
 		}
 		else {
 			continue;
 		}
 	}
-	uci_commit(uci, &wireless, false);
-	uci_unload(uci, wireless);
+	uci_commit(sec_ctx, &wireless, false);
+	uci_unload(sec_ctx, wireless);
+	uci_free_context(sec_ctx);
 	reload_config = 1;
+}
 
+static void vif_check_radius_proxy()
+{
+	struct uci_context *uci_ctx;
+	struct uci_package *wireless;
+	struct schema_APC_State apc_conf;
+	struct uci_element *e = NULL, *tmp = NULL;
+	char *buf = NULL;
+	int rc = 0;
+
+	json_t *where = ovsdb_table_where(&table_APC_State, &apc_conf);
+	if (false == ovsdb_table_select_one_where(&table_APC_State, where, &apc_conf))
+	{
+		LOGI("APC_State read failed");
+		return;
+	}
+
+	uci_ctx = uci_alloc_context();
+	rc = uci_load(uci_ctx, "wireless", &wireless);
+
+	if (rc) {
+		LOGE("%s: uci_load() failed with rc %d", __func__, rc);
+		goto free;
+	}
+
+	uci_foreach_element_safe(&wireless->sections, tmp, e)
+	{
+		struct blob_attr *tb[__WIF_ATTR_MAX];
+		struct uci_section *s = uci_to_section(e);
+		if ((s == NULL) || (s->type == NULL))
+			continue;
+
+		if (strcmp(s->type, "wifi-iface"))
+			continue;
+
+		blob_buf_init(&b, 0);
+		uci_to_blob(&b, s, &wifi_iface_param);
+		blobmsg_parse(wifi_iface_policy, __WIF_ATTR_MAX, tb, blob_data(b.head), blob_len(b.head));
+
+		if (tb[WIF_ATTR_RADPROXY])
+		{
+			buf = blobmsg_get_string(tb[WIF_ATTR_RADPROXY]);
+
+			if (!strcmp(buf, "1") && !strcmp(apc_conf.mode, "DR"))
+			{
+				if (!system("pidof radsecproxy"))
+					goto free;
+
+				system("/etc/init.d/radsecproxy start");
+
+				goto free;
+			}
+		}
+	}
+
+	system("/etc/init.d/radsecproxy stop");
+
+free:
+	uci_unload(uci_ctx, wireless);
+	uci_free_context(uci_ctx);
+	return;
 }
 
 static bool hs20_download_icon(char *icon_name, char *icon_url)
@@ -904,6 +1163,7 @@ static void hs20_vif_config(struct blob_buf *b,
 	int i = 0;
 	unsigned int len = 0;
 	char domain_name[256];
+	char str[3] = {};
 
 	if (hs2conf->enable) {
 		blobmsg_add_bool(b, "interworking", 1);
@@ -971,6 +1231,9 @@ static void hs20_vif_config(struct blob_buf *b,
 	if (strlen(hs2conf->qos_map_set))
 		blobmsg_add_string(b, "qos_map_set", hs2conf->qos_map_set);
 
+	if (hs2conf->access_network_type > 0)
+		blobmsg_add_u32(b, "access_network_type", hs2conf->access_network_type);
+
 	if (hs2conf->osen)
 		blobmsg_add_bool(b, "osen", 1);
 	else
@@ -1013,6 +1276,20 @@ static void hs20_vif_config(struct blob_buf *b,
 	if (strlen(hs2conf->wan_metrics))
 		blobmsg_add_string(b, "hs20_wan_metrics", hs2conf->wan_metrics);
 
+	len = strlen(hs2conf->ipaddr_type_availability);
+	if (len)
+	{
+		if (len == 1)
+		{
+			snprintf(str, sizeof(str), "0%s", hs2conf->ipaddr_type_availability);
+			blobmsg_add_string(b, "ipaddr_type_availability", str);
+		}
+		else
+		{
+			blobmsg_add_string(b, "ipaddr_type_availability", hs2conf->ipaddr_type_availability);
+		}
+	}
+
 	n = blobmsg_open_array(b, "hs20_oper_friendly_name");
 	for (i = 0; i < hs2conf->operator_friendly_name_len; i++)
 	{
@@ -1029,6 +1306,13 @@ static void hs20_vif_config(struct blob_buf *b,
 		blobmsg_add_u32(b, "venue_type", venue_type);
 	}
 
+	n = blobmsg_open_array(b, "hs20_conn_capab");
+	for (i = 0; i < hs2conf->connection_capability_len; i++)
+	{
+		blobmsg_add_string(b, NULL, hs2conf->connection_capability[i]);
+	}
+	blobmsg_close_array(b, n);
+
 	if (hs2conf->operator_icons_len)
 	{
 		n = blobmsg_open_array(b, "operator_icon");
@@ -1049,14 +1333,17 @@ static void hs20_vif_config(struct blob_buf *b,
 bool target_vif_config_del(const struct schema_Wifi_VIF_Config *vconf)
 {
 	struct uci_package *wireless;
+	struct uci_context *vif_ctx;
 	struct uci_element *e = NULL, *tmp = NULL;
 	const char *ifname;
-	int ret=0;
+	int ret = 0;
 
 	vlan_del((char *)vconf->if_name);
-	ret= uci_load(uci, "wireless", &wireless);
+	vif_ctx = uci_alloc_context();
+	ret= uci_load(vif_ctx, "wireless", &wireless);
 	if (ret) {
-		LOGD("%s: uci_load() failed with rc %d", vconf->if_name, ret);
+		LOGE("%s: %s uci_load() failed with rc %d", vconf->if_name, __func__, ret);
+		uci_free_context(vif_ctx);
 		return false;
 	}
 	uci_foreach_element_safe(&wireless->sections, tmp, e) {
@@ -1064,14 +1351,15 @@ bool target_vif_config_del(const struct schema_Wifi_VIF_Config *vconf)
 		if ((s == NULL) || (s->type == NULL)) continue; 
 		if (strcmp(s->type, "wifi-iface")) continue;
 
-		ifname = uci_lookup_option_string( uci, s, "ifname" );
+		ifname = uci_lookup_option_string( vif_ctx, s, "ifname" );
 		if (!strcmp(ifname,vconf->if_name)) {
-			uci_section_del(uci, "vif", "wireless", (char *)s->e.name, "wifi-iface");
+			uci_section_del(vif_ctx, "vif", "wireless", (char *)s->e.name, "wifi-iface");
 			break;
 		}
 	}
-	uci_commit(uci, &wireless, false);
-	uci_unload(uci, wireless);
+	uci_commit(vif_ctx, &wireless, false);
+	uci_unload(vif_ctx, wireless);
+	uci_free_context(vif_ctx);
 	reload_config = 1;
 	return true;
 }
@@ -1264,7 +1552,6 @@ static int ap_vif_config_set(const struct schema_Wifi_Radio_Config *rconf,
 
 	blob_buf_init(&b, 0);
 	blob_buf_init(&del,0);
-
 	blobmsg_add_string(&b, "ifname", vconf->if_name);
 	blobmsg_add_string(&b, "device", rconf->if_name);
 	blobmsg_add_string(&b, "mode", "ap");
@@ -1300,10 +1587,9 @@ static int ap_vif_config_set(const struct schema_Wifi_Radio_Config *rconf,
 		blobmsg_add_string(&b, "min_hw_mode", vconf->min_hw_mode);
 
 	if (changed->ft_psk || changed->ft_mobility_domain) {
-		if (vconf->ft_psk && vconf->ft_mobility_domain) {
+		if (vconf->ft_mobility_domain) {
 			blobmsg_add_bool(&b, "ieee80211r", 1);
 			blobmsg_add_hex16(&b, "mobility_domain", vconf->ft_mobility_domain);
-			blobmsg_add_bool(&b, "ft_psk_generate_local", vconf->ft_psk);
 			blobmsg_add_bool(&b, "ft_over_ds", 0);
 			blobmsg_add_bool(&b, "reassociation_deadline", 1);
 		} else {
@@ -1350,9 +1636,8 @@ static int ap_vif_config_set(const struct schema_Wifi_Radio_Config *rconf,
 	blobmsg_add_bool(&b, "wpa_disable_eapol_key_retries", 1);
 	blobmsg_add_u32(&b, "channel", rconf->channel);
 
-	if (vif_config_security_set(&b, vconf)) {
-                return -1;
-        }
+	if (vif_config_security_set(&b, vconf))
+		return -1;
 
 	if (changed->custom_options)
 		vif_config_custom_opt_set(&b, &del, vconf);
@@ -1375,6 +1660,9 @@ static int ap_vif_config_set(const struct schema_Wifi_Radio_Config *rconf,
 		vif_dhcp_opennds_allowlist_set(vconf,(char*)vconf->if_name);
 	}
 
+	if (changed->custom_options)
+		vif_check_radius_proxy();
+
 	reload_config = 1;
 	return 0;
 }

feeds/wlan-ap/opensync/src/platform/openwrt/src/netifd/inc/inet_conf.h

@@ -6,7 +6,9 @@
 #include "netifd.h"
 #include "inet_iface.h"
 
-struct netifd_iface *netifd_add_inet_conf(struct schema_Wifi_Inet_Config *iconf);
+#define DHCP_SNIFF_MAX_VLAN 4
+
+void netifd_add_inet_conf(struct schema_Wifi_Inet_Config *iconf);
 void netifd_del_inet_conf(struct schema_Wifi_Inet_Config *old_rec);
 struct netifd_iface *netifd_modify_inet_conf(struct schema_Wifi_Inet_Config *iconf);
 bool netifd_inet_config_set(struct netifd_iface *piface);

feeds/wlan-ap/opensync/src/platform/openwrt/src/netifd/src/inet_conf.c

@@ -6,30 +6,43 @@
 
 #include "inet_conf.h"
 
-struct netifd_iface* netifd_add_inet_conf(struct schema_Wifi_Inet_Config *iconf)
-{
+static int vlan_count = 0;
 
+void netifd_add_inet_conf(struct schema_Wifi_Inet_Config *iconf)
+{
 	struct netifd_iface *piface = NULL;
 
-	piface = netifd_iface_get_by_name(iconf->if_name);
-	if (piface == NULL)
-	{
-		piface = netifd_iface_new(iconf->if_name, iconf->if_type);
-		if (piface == NULL)
-		{
-			LOG(ERR, "netifd_add_inet_conf: %s: Unable to create interface.", iconf->if_name);
-			return NULL;
-		}
+	if (strcmp(iconf->if_type, "bridge") && strcmp(iconf->if_type, "vlan")) {
+		return;
+	}
 
-		if (!strcmp(iconf->if_type, "bridge") || !strcmp(iconf->if_type, "vlan"))
-		{
-			LOGN("Setting up dhsnif for %s", piface->if_base->inet.in_ifname);
+	piface = netifd_iface_get_by_name(iconf->if_name);
+
+	if (piface)
+		return;
+
+	if (!strcmp(iconf->if_name, "wan") || !strcmp(iconf->if_name, "lan")) {
+		piface = netifd_iface_new(iconf->if_name, iconf->if_type);
+		if (!piface) {
+			LOG(ERR, "netifd_add_inet_conf: %s: Unable to create interface.", iconf->if_name);
+			return;
+		}
+		netifd_inet_config_set(piface);
+		netifd_inet_config_apply(piface);
+	} else if (iconf->vlan_id_exists && iconf->vlan_id > 2) {
+		if (vlan_count < DHCP_SNIFF_MAX_VLAN && !strstr(iconf->if_name,"lan_")) {
+			piface = netifd_iface_new(iconf->if_name, iconf->if_type);
+			if (!piface) {
+				LOG(ERR, "netifd_add_inet_conf: %s: Unable to create interface.", iconf->if_name);
+				return;
+			}
 			netifd_inet_config_set(piface);
 			netifd_inet_config_apply(piface);
+			vlan_count++;
 		}
 	}
 
-	return piface;
+	return;
 }
 
 void netifd_del_inet_conf(struct schema_Wifi_Inet_Config *old_rec)
@@ -37,14 +50,14 @@ void netifd_del_inet_conf(struct schema_Wifi_Inet_Config *old_rec)
 	struct netifd_iface *piface = NULL;
 
 	piface = netifd_iface_get_by_name(old_rec->if_name);
-	if (piface == NULL)
-	{
-		LOG(ERR, "netifd_del_inet_conf: Unable to delete non-existent interface %s.",
-				old_rec->if_name);
-	}
 
-	if (piface != NULL && !netifd_iface_del(piface))
-			{
+	if (!piface)
+		return;
+
+	if (netifd_iface_del(piface)) {
+		if (old_rec->vlan_id_exists && old_rec->vlan_id > 2)
+			vlan_count--;
+	} else {
 		LOG(ERR, "netifd_del_inet_conf: Error during destruction of interface %s.",
 				old_rec->if_name);
 	}

feeds/wlan-ap/opensync/src/platform/openwrt/src/netifd/src/inet_iface.c

@@ -24,8 +24,6 @@ struct netifd_iface *netifd_iface_get_by_name(char *_ifname)
 	if (piface != NULL)
 		return piface;
 
-	LOG(ERR, "netifd_iface_get_by_name: Couldn't find the interface(%s)", ifname);
-
 	return NULL;
 }
 
@@ -102,7 +100,7 @@ inet_base_t *netifd_iface_new_inet(const char *ifname, const char *iftype)
 		goto error;
 	}
 	memset(self, 0, sizeof(inet_base_t));
-	if((!strcmp(ifname, "wan") && !strcmp(iftype,"bridge")) || (!strcmp(ifname, "lan") && !strcmp(iftype,"bridge"))) {
+	if(!strcmp(iftype,"bridge")) {
 		snprintf(self->inet.in_ifname, sizeof(self->inet.in_ifname), "br-%s", ifname);
 	} else if (!strcmp(iftype,"vlan")) {
 		char name[15]= {};

feeds/wlan-ap/opensync/src/platform/openwrt/src/netifd/src/wifi_inet_config.c

@@ -368,16 +368,14 @@ static void callback_Wifi_Inet_Config(ovsdb_update_monitor_t *mon,
 			       struct schema_Wifi_Inet_Config *old_rec,
 			       struct schema_Wifi_Inet_Config *iconf)
 {
-	struct netifd_iface *piface = NULL;
-
 	switch (mon->mon_type) {
 	case OVSDB_UPDATE_NEW:
 		wifi_inet_conf_add(iconf);
-		piface = netifd_add_inet_conf(iconf);
+		netifd_add_inet_conf(iconf);
 		break;
 	case OVSDB_UPDATE_MODIFY:
 		wifi_inet_conf_add(iconf);
-		piface = netifd_modify_inet_conf(iconf);
+		netifd_modify_inet_conf(iconf);
 		break;
 	case OVSDB_UPDATE_DEL:
 		wifi_inet_conf_del(old_rec);
@@ -387,12 +385,6 @@ static void callback_Wifi_Inet_Config(ovsdb_update_monitor_t *mon,
 		LOG(ERR, "Invalid Wifi_Inet_Config mon_type(%d)", mon->mon_type);
 	}
 
-	if(!piface) {
-		LOG(ERR, "callback_Wifi_Inet_Config: Couldn't get the netifd interface(%s)",
-				iconf->if_name);
-		return;
-	}
-
 	return;
 }
 

feeds/wlan-ap/opensync/src/platform/openwrt/src/rrm/inc/rrm.h

@@ -75,7 +75,7 @@ int rrm_setup_monitor(void);
 void rrm_channel_init(void);
 int rrm_ubus_init(struct ev_loop *loop);
 int ubus_get_noise(const char *if_name, uint32_t *noise);
-int ubus_set_channel_switch(const char *if_name, uint32_t frequency);
+int ubus_set_channel_switch(const char *if_name, uint32_t frequency, int channel_bandwidth, int sec_chan_offset);
 void set_rrm_parameters(rrm_entry_t *rrm_data);
 ds_tree_t* rrm_get_rrm_config_list(void);
 ds_tree_t* rrm_get_radio_list(void);

feeds/wlan-ap/opensync/src/platform/openwrt/src/rrm/src/rrm_channel.c

@@ -94,6 +94,15 @@ radio_entry_t* rrm_get_radio_config(radio_type_t band)
 	}
 	return NULL;
 }
+void get_channel_bandwidth(const char* htmode, int *channel_bandwidth)
+{
+	if(!strcmp(htmode, "HT20"))
+		*channel_bandwidth=20;
+	else if (!strcmp(htmode, "HT40"))
+		*channel_bandwidth=40;
+	else if(!strcmp(htmode, "HT80"))
+		*channel_bandwidth=80;
+}
 
 void rrm_nf_timer_handler(struct ev_loop *loop, ev_timer *timer, int revents)
 {
@@ -131,7 +140,7 @@ void rrm_nf_timer_handler(struct ev_loop *loop, ev_timer *timer, int revents)
 		if (nf < rrm_config->rrm_data.noise_lwm )
 		{
 			rrm_config->rrm_data.noise_lwm = nf;
-			LOGN("[%s] noise_lwm set to %d", radio->config.if_name, nf);
+			LOGD("[%s] noise_lwm set to %d", radio->config.if_name, nf);
 			continue;
 		}
 
@@ -144,7 +153,7 @@ void rrm_nf_timer_handler(struct ev_loop *loop, ev_timer *timer, int revents)
 		nf_drop_threshold = ((int32_t)(100 - rrm_config->rrm_data.snr_percentage_drop) *
 				rrm_config->rrm_data.noise_lwm) / 100;
 
-		LOGN("[%s] backup=%d nf=%d nf_lwm=%d drop=%d thresh=%d",
+		LOGD("[%s] backup=%d nf=%d nf_lwm=%d drop=%d thresh=%d",
 				radio->config.if_name,
 				rrm_config->rrm_data.backup_channel,
 				nf,
@@ -154,16 +163,26 @@ void rrm_nf_timer_handler(struct ev_loop *loop, ev_timer *timer, int revents)
 
 		if (nf > nf_drop_threshold)
 		{
-			LOGN("[%s] backup=%d nf=%d nf_lwm=%d drop=%d thresh=%d",
+			LOGI("Interference detected on [%s], switching to backup_channel=%d nf=%d nf_lwm=%d drop=%d thresh=%d",
 					radio->config.if_name,
 					rrm_config->rrm_data.backup_channel,
 					nf,
 					rrm_config->rrm_data.noise_lwm,
 					rrm_config->rrm_data.snr_percentage_drop,
 					nf_drop_threshold);
+			int channel_bandwidth;
+			int sec_chan_offset=0;
+			struct mode_map *m = mode_map_get_uci(radio->schema.freq_band, get_max_channel_bw_channel(ieee80211_channel_to_frequency(rrm_config->rrm_data.backup_channel),
+						radio->schema.ht_mode), radio->schema.hw_mode);
+			if (m) {
+				sec_chan_offset = m->sec_channel_offset;
+			} else
+				 LOGE("failed to get channel offset");
 
+			get_channel_bandwidth(get_max_channel_bw_channel(ieee80211_channel_to_frequency(rrm_config->rrm_data.backup_channel),
+					radio->schema.ht_mode), &channel_bandwidth);
 			ubus_set_channel_switch(radio->config.if_name,
-					ieee80211_channel_to_frequency(rrm_config->rrm_data.backup_channel));
+					ieee80211_channel_to_frequency(rrm_config->rrm_data.backup_channel), channel_bandwidth, sec_chan_offset);
 		}
 	}
 }

feeds/wlan-ap/opensync/src/platform/openwrt/src/rrm/src/rrm_ubus.c

@@ -51,7 +51,7 @@ int ubus_get_noise(const char *if_name, uint32_t *noise)
 
 }
 
-int ubus_set_channel_switch(const char *if_name, uint32_t frequency)
+int ubus_set_channel_switch(const char *if_name, uint32_t frequency, int channel_bandwidth, int sec_chan_offset)
 {
 	uint32_t id;
 	static struct blob_buf b;
@@ -61,10 +61,21 @@ int ubus_set_channel_switch(const char *if_name, uint32_t frequency)
 
 	if (ubus_lookup_id(ubus, path, &id))
 		return -1;
-
 	blob_buf_init(&b, 0);
+
+	if (channel_bandwidth == 20 || channel_bandwidth == 40) {
+		blobmsg_add_bool(&b, "ht", 1);
+	} else if (channel_bandwidth == 80) {
+		blobmsg_add_bool(&b, "vht", 1);
+	}
+	if (channel_bandwidth == 40 || channel_bandwidth == 80) {
+		blobmsg_add_u32(&b, "center_freq1", frequency+30);
+	}
+
 	blobmsg_add_u32(&b, "freq", frequency);
-	blobmsg_add_u32(&b, "bcn_count", 1);
+	blobmsg_add_u32(&b, "bcn_count", 5);
+	blobmsg_add_u32(&b, "bandwidth", channel_bandwidth);
+	blobmsg_add_u32(&b, "sec_channel_offset", sec_chan_offset);
 	return ubus_invoke(ubus, id, "switch_chan", b.head, NULL, NULL, 1000);
 }
 

feeds/wlan-ap/opensync/src/platform/openwrt/src/ucc_detect/src/main.c

@@ -130,6 +130,7 @@ static int rx_msg(struct nl_msg *msg, void* arg)
 	struct nlattr *attr[GENL_UCC_ATTR_MAX+1];
 
 	struct voip_session *data;
+	char dst_ip[16];
 	genlmsg_parse(nlmsg_hdr(msg), 0, attr, 
 			GENL_UCC_ATTR_MAX, genl_ucc_policy);
 
@@ -140,7 +141,6 @@ static int rx_msg(struct nl_msg *msg, void* arg)
 		return NL_OK;
 	}
 
-	char *dst_ip = malloc(16);
 	memset(dst_ip, 0, 16);
 	if((get_current_ip(dst_ip, IAC_IFACE)) < 0) {
 		LOGI("Error: Cannot get IP for %s", IAC_IFACE);
@@ -275,8 +275,10 @@ int main(int argc, char ** argv)
 	callback cb = recv_process;
 	LOGI("Call interap_recv");
 	if( interap_recv(IAC_VOIP_PORT, cb, sizeof(struct voip_session),
-			 loop, &iac_io) < 0)
+			 loop, &iac_io) < 0) {
 		LOGI("Error: Failed InterAP receive");
+		return 1;
+	}
 
 //	task_init();
 	netlink_listen(loop);
@@ -291,6 +293,7 @@ int main(int argc, char ** argv)
 #endif
 	ev_default_destroy();
 
+	interap_rcv_close();
 	LOGN("Exiting UCCM");
 
 	return 0;

feeds/wlan-ap/opensync/src/src/lib/datapipeline/inc/dpp_events.h

@@ -13,6 +13,7 @@
 #define DPP_CLT_ID_LEN 129
 #define MAC_ADDRESS_STRING_LEN 17
 #define IP_ADDRESS_STRING_LEN 15
+#define IPV4_BYTES_LEN 4
 
 /* proto: EventType */
 typedef enum {
@@ -101,7 +102,7 @@ typedef struct {
 	radio_essid_t ssid;
 	sec_type_t sec_type;
 	bool fbt_used;
-	uint8_t ip_addr[16];
+	char ip_addr[IP_ADDRESS_STRING_LEN + 1];
 	char clt_id[DPP_CLT_ID_LEN];
 	int64_t ev_time_bootup_in_us_auth;
 	int64_t ev_time_bootup_in_us_assoc;
@@ -152,7 +153,7 @@ typedef struct {
 	char sta_mac[MAC_ADDRESS_STRING_LEN + 1];
 	uint64_t session_id;
 	uint64_t timestamp;
-	uint8_t ip_addr[16];
+	char ip_addr[IP_ADDRESS_STRING_LEN + 1];
 } dpp_event_record_ip_t;
 
 /* proto: ClientTimeoutEvent */
@@ -462,6 +463,19 @@ dpp_event_record_alloc()
 	return record;
 }
 
+static inline dpp_event_channel_switch_t *
+dpp_event_channel_switch_alloc()
+{
+	dpp_event_channel_switch_t *record = NULL;
+
+	record = calloc(1, sizeof(dpp_event_channel_switch_t));
+	if (record) {
+		memset(record, 0, sizeof(dpp_event_channel_switch_t));
+	}
+	return record;
+}
+
+
 static inline void
 dpp_event_channel_record_free(dpp_event_channel_switch_t *record)
 {

feeds/wlan-ap/opensync/src/src/sm/src/sm_events_report.c

@@ -105,7 +105,6 @@ static void sm_events_report_clear_client(ds_dlist_t *report_list)
 static void sm_events_report_clear_channel(ds_dlist_t *report_list)
 {
 	if (!ds_dlist_is_empty(report_list)) {
-
 		dpp_event_channel_switch_t      *record = NULL;
 		ds_dlist_iter_t                 record_iter;
 
@@ -129,6 +128,8 @@ static void sm_events_report(EV_P_ ev_timer *w, int revents)
 	/* Event Record */
 	dpp_event_record_t *dpp_record = NULL;
 	dpp_event_record_t *sm_record = NULL;
+	dpp_event_channel_switch_t *dpp_record_cs = NULL;
+	dpp_event_channel_switch_t *sm_record_cs = NULL;
 	ds_dlist_iter_t record_iter;
 
 	dpp_events_report_timer_restart(report_timer);
@@ -153,11 +154,26 @@ static void sm_events_report(EV_P_ ev_timer *w, int revents)
 		ds_dlist_insert_tail(&report_ctx->client_event_list, dpp_record);
 	}
 
-	if(!ds_dlist_is_empty(&g_event_report.channel_switch_list))
-		report_ctx->channel_switch_list = g_event_report.channel_switch_list;
+	for (sm_record_cs = ds_dlist_ifirst(&record_iter, &g_event_report.channel_switch_list); sm_record_cs != NULL; sm_record_cs = ds_dlist_inext(&record_iter)) {
+		dpp_record_cs = dpp_event_channel_switch_alloc();
+
+		dpp_record_cs->channel_event.band = sm_record_cs->channel_event.band;
+		dpp_record_cs->channel_event.reason =  sm_record_cs->channel_event.reason;
+		dpp_record_cs->channel_event.freq =  sm_record_cs->channel_event.freq;
+		dpp_record_cs->channel_event.timestamp =  sm_record_cs->channel_event.timestamp;
+
+		ds_dlist_iremove(&record_iter);
+		dpp_event_channel_record_free(sm_record_cs);
+		sm_record_cs = NULL;
+
+		if (ds_dlist_is_empty(&report_ctx->channel_switch_list)) {
+			ds_dlist_init(&report_ctx->channel_switch_list, dpp_event_channel_switch_t, node);
+		}
+		ds_dlist_insert_tail(&report_ctx->channel_switch_list, dpp_record_cs);
+	}
 
 	if (!ds_dlist_is_empty(&report_ctx->client_event_list) || !ds_dlist_is_empty(&report_ctx->channel_switch_list)) {
-		LOG(INFO, "Sending events report...");
+		LOG(DEBUG, "Sending events report...");
 		dpp_put_events(report_ctx);
 	}
 

feeds/wlan-ap/opensync/src/src/sm/src/ubus_collector.c

@@ -126,13 +126,13 @@ static int frequency_to_channel(int freq)
 static radio_type_t frequency_to_band(int freq)
 {
 	int chan = frequency_to_channel(freq);
-
+	/*Need to add support for differentiating between 5G,5GU and 5GL*/
 	if (chan <= 16)
 		return RADIO_TYPE_2G;
 	else if (chan >= 32 && chan <= 68)
-		return RADIO_TYPE_5GL;
+		return RADIO_TYPE_5G;
 	else if (chan >= 96)
-		return RADIO_TYPE_5GU;
+		return RADIO_TYPE_5G;
 	else
 		return RADIO_TYPE_NONE;
 }
@@ -615,7 +615,7 @@ static void ubus_collector_chan_switch_events_cb(struct ubus_request *req, int t
 	if (!msg)
 		return;
 
-	LOG(INFO, "ubus_collector: received ubus collector chan event message");
+	LOG(DEBUG, "ubus_collector: received ubus collector chan event message");
 
 	error = blobmsg_parse(ubus_collector_chan_switch_event_policy,
 			      __CHANNEL_SWITCH_EVENT_MAX, tb_chan_event_lst,

feeds/wlan-ap/opensync/src/vendor/tip/src/lib/target/src/entity.c

@@ -19,6 +19,16 @@ enum {
 	SYSTEM_ATTR_FIRMWARE,
 	SYSTEM_ATTR_REDIRECTOR,
 	SYSTEM_ATTR_INACTIVEFW,
+	SYSTEM_ATTR_SKU,
+	SYSTEM_ATTR_MODEL_REV,
+	SYSTEM_ATTR_MODEL_DESCR,
+	SYSTEM_ATTR_MANUFACT_NAME,
+	SYSTEM_ATTR_MANUFACT_DATE,
+	SYSTEM_ATTR_MANUFACT_URL,
+	SYSTEM_ATTR_MANUF_ABBR,
+	SYSTEM_ATTR_REF_DESIGN,
+	SYSTEM_ATTR_CERT_REGION,
+	SYSTEM_ATTR_MAC_ADDR,
 	__SYSTEM_ATTR_MAX,
 };
 
@@ -29,6 +39,16 @@ static const struct blobmsg_policy system_policy[__SYSTEM_ATTR_MAX] = {
 	[SYSTEM_ATTR_FIRMWARE] = { .name = "firmware", .type = BLOBMSG_TYPE_STRING },
 	[SYSTEM_ATTR_REDIRECTOR] = { .name = "redirector", .type = BLOBMSG_TYPE_STRING },
 	[SYSTEM_ATTR_INACTIVEFW] = { .name = "inactivefw", .type = BLOBMSG_TYPE_STRING },
+	[SYSTEM_ATTR_SKU] = { .name = "sku_number", .type = BLOBMSG_TYPE_STRING },
+	[SYSTEM_ATTR_MODEL_REV] = { .name = "revision", .type = BLOBMSG_TYPE_STRING },
+	[SYSTEM_ATTR_MODEL_DESCR] = { .name = "model_description", .type = BLOBMSG_TYPE_STRING },
+	[SYSTEM_ATTR_MANUFACT_NAME] = { .name = "manufacturer_name", .type = BLOBMSG_TYPE_STRING },
+	[SYSTEM_ATTR_MANUFACT_DATE] = { .name = "manufacturer_date", .type = BLOBMSG_TYPE_STRING },
+	[SYSTEM_ATTR_MANUFACT_URL] = { .name = "manufacturer_url", .type = BLOBMSG_TYPE_STRING },
+	[SYSTEM_ATTR_MANUF_ABBR] = { .name = "manuf_abbr", .type = BLOBMSG_TYPE_STRING },
+	[SYSTEM_ATTR_REF_DESIGN] = { .name = "reference_design", .type = BLOBMSG_TYPE_STRING },
+	[SYSTEM_ATTR_CERT_REGION] = { .name = "certification_region", .type = BLOBMSG_TYPE_STRING },
+	[SYSTEM_ATTR_MAC_ADDR] = { .name = "id", .type = BLOBMSG_TYPE_STRING },
 };
 
 const struct uci_blob_param_list system_param = {
@@ -110,6 +130,56 @@ bool target_platform_version_get(void *buf, size_t len)
 	return copy_data(SYSTEM_ATTR_PLATFORM, buf, len);
 }
 
+bool target_sku_get(void *buf, size_t len)
+{
+	return copy_data(SYSTEM_ATTR_SKU, buf, len);
+}
+
+bool target_model_revision_get(void *buf, size_t len)
+{
+	return copy_data(SYSTEM_ATTR_MODEL_REV, buf, len);
+}
+
+bool target_model_description_get(void *buf, size_t len)
+{
+	return copy_data(SYSTEM_ATTR_MODEL_DESCR, buf, len);
+}
+
+bool target_manuf_name_get(void *buf, size_t len)
+{
+	return copy_data(SYSTEM_ATTR_MANUFACT_NAME, buf, len);
+}
+
+bool target_manuf_date_get(void *buf, size_t len)
+{
+	return copy_data(SYSTEM_ATTR_MANUFACT_DATE, buf, len);
+}
+
+bool target_manuf_url_get(void *buf, size_t len)
+{
+	return copy_data(SYSTEM_ATTR_MANUFACT_URL, buf, len);
+}
+
+bool target_manuf_abbr_get(void *buf, size_t len)
+{
+	return copy_data(SYSTEM_ATTR_MANUF_ABBR, buf, len);
+}
+
+bool target_ref_design_get(void *buf, size_t len)
+{
+	return copy_data(SYSTEM_ATTR_REF_DESIGN, buf, len);
+}
+
+bool target_cert_region_get(void *buf, size_t len)
+{
+	return copy_data(SYSTEM_ATTR_CERT_REGION, buf, len);
+}
+
+bool target_mac_addr_get(void *buf, size_t len)
+{
+	return copy_data(SYSTEM_ATTR_MAC_ADDR, buf, len);
+}
+
 bool target_device_config_register(void *awlan_cb)
 {
 	struct schema_AWLAN_Node awlan;

feeds/wlan-ap/wlan-ap-config/files/etc/uci-defaults/99-tip-data

@@ -2,22 +2,120 @@
 
 . /lib/functions.sh
 
+SKU="unknown"
+MODEL=""
+PLATFORM="unknown"
+SERIAL=""
+MODEL_REV="unknown"
+MODEL_DESCR="unknown"
+MANUF_NAME="unknown"
+MANUF_DATE="unknown"
+MANUF_URL="unknown"
+MANUF_DESIGN="unknown"
+REF_DESIGN="unknown"
+CERT_REGION="unknown"
+ID=""
+
 case "$(board_name)" in
 edgecore,ecw5211|\
 edgecore,ecw5410)
-	MODEL=$(cat /tmp/sysinfo/board_name | sed "s/edgecore,//" | tr [a-z] [A-Z])
-	SERIAL=$(cat /sys/class/net/eth0/address | tr -d :)
 	PLATFORM=$(cat /tmp/sysinfo/model)
+	SERIAL=$(cat /dev/mtd5 | grep serial_number | cut -d "=" -f2)
+	MODEL=$(cat /dev/mtd5 | grep "model=" | cut -d "=" -f2)
+	if [ ! $MODEL ]; then
+		MODEL=$(cat /tmp/sysinfo/board_name | sed "s/edgecore,//" | tr [a-z] [A-Z])
+	fi
+	SKU=$(cat /dev/mtd5 | grep sku | cut -d "=" -f2)
+	CERT_REGION=$(cat /dev/mtd5 | grep certification_region | cut -d "=" -f2)
+	ID=$(cat /dev/mtd5 | grep mac_address | cut -d "=" -f2)
+	MANUF_DATE=$(cat /dev/mtd5 | grep manufacturer_date | cut -d "=" -f2)
+	MANUF_NAME=$(cat /dev/mtd5 | grep manufacturer_name | cut -d "=" -f2)
+	if [ ! $MANUF_NAME ]; then
+		MANUF_NAME="Edge-Core"
+	fi
+	MANUF_ABBR="EC"
+	MANUF_URL=$(cat /dev/mtd5 | grep manufacturer_url | cut -d "=" -f2)
+	MODEL_DESCR=$(cat /dev/mtd5 | grep model_description | cut -d "=" -f2)
+	MODEL_REV=$(cat /dev/mtd5 | grep model_revision | cut -d "=" -f2)
+	REF_DESIGN=$(cat /dev/mtd5 | grep reference_design | cut -d "=" -f2)
 	;;
 cig,wf194c)
-	MODEL=$(cat /tmp/sysinfo/board_name)
-	SERIAL=$(cat cat /dev/mtd14 | grep BaseMacAddress | cut -dx -f2 | tr -d '\r\n')
 	PLATFORM=$(cat /tmp/sysinfo/model)
+	SERIAL=$(cat /dev/mtd14 | grep serial_number | cut -d "=" -f2)
+	if [ ! $SERIAL ]; then
+		SERIAL=$(cat /dev/mtd14 | grep BaseMacAddress | cut -dx -f2)
+	fi
+	MODEL=$(cat /dev/mtd14 | grep "model=" | cut -d "=" -f2)
+	SKU=$(cat /dev/mtd14 | grep sku | cut -d "=" -f2)
+	CERT_REGION=$(cat /dev/mtd14 | grep certification_region | cut -d "=" -f2)
+	ID=$(cat /dev/mtd14 | grep mac_address | cut -d "=" -f2)
+	MANUF_DATE=$(cat /dev/mtd14 | grep manufacturer_date | cut -d "=" -f2)
+	MANUF_NAME=$(cat /dev/mtd14 | grep manufacturer_name | cut -d "=" -f2)
+	if [ ! $MANUF_NAME ]; then
+		MANUF_NAME="CIG"
+	fi
+	MANUF_ABBR="CIG"
+	MANUF_URL=$(cat /dev/mtd14 | grep manufacturer_url | cut -d "=" -f2)
+	MODEL_DESCR=$(cat /dev/mtd14 | grep model_description | cut -d "=" -f2)
+	MODEL_REV=$(cat /dev/mtd14 | grep model_revision | cut -d "=" -f2)
+	REF_DESIGN=$(cat /dev/mtd14 | grep reference_design | cut -d "=" -f2)
+	;;
+cig,wf188n)
+	PLATFORM=$(cat /tmp/sysinfo/model)
+	SERIAL=$(cat /dev/mtd12 | grep serial_number | cut -d "=" -f2)
+	MODEL=$(cat /dev/mtd12 | grep "model=" | cut -d "=" -f2)
+	SKU=$(cat /dev/mtd12 | grep sku | cut -d "=" -f2)
+	CERT_REGION=$(cat /dev/mtd12 | grep certification_region | cut -d "=" -f2)
+	ID=$(cat /dev/mtd12 | grep mac_address | cut -d "=" -f2)
+	MANUF_DATE=$(cat /dev/mtd12 | grep manufacturer_date | cut -d "=" -f2)
+	MANUF_NAME=$(cat /dev/mtd12 | grep manufacturer_name | cut -d "=" -f2)
+	if [ ! $MANUF_NAME ]; then
+		MANUF_NAME="CIG"
+	fi
+	MANUF_ABBR="CIG"
+	MANUF_URL=$(cat /dev/mtd12 | grep manufacturer_url | cut -d "=" -f2)
+	MODEL_DESCR=$(cat /dev/mtd12 | grep model_description | cut -d "=" -f2)
+	MODEL_REV=$(cat /dev/mtd12 | grep model_revision | cut -d "=" -f2)
+	REF_DESIGN=$(cat /dev/mtd12 | grep reference_design | cut -d "=" -f2)
 	;;
 linksys,ea8300)
 	MODEL=$(grep modelNumber= /dev/mtd9 | tr -d '\r\n' | sed "s/modelNumber=//")
 	SERIAL=$(grep serial_number= /dev/mtd9 | tr -d '\r\n' | sed "s/serial_number=//")
-	PLATFORM=OPENWRT_EA8300
+	PLATFORM="OPENWRT_EA8300"
+	MODEL_REV=$(cat /dev/mtd9 | grep hw_revision | cut -d "=" -f2 | tr -d '\r\n')
+	MODEL_DESCR=$(cat /dev/mtd9 | grep modelDescription | cut -d "=" -f2 | tr -d '\r\n')
+	MANUF_URL=$(cat /dev/mtd9 | grep manufacturerURL | cut -d "=" -f2 | tr -d '\r\n')
+	CERT_REGION=$(cat /dev/mtd9 | grep cert_region | cut -d "=" -f2 | tr -d '\r\n')
+	ID=$(cat /dev/mtd9 | grep hw_mac_addr | cut -d "=" -f2 | tr -d '\r\n')
+	MANUF_NAME=$(cat /dev/mtd9 | grep "manufacturer=" | cut -d "=" -f2 | tr -d '\r\n')
+	if [ ! $MANUF_NAME ]; then
+		MANUF_NAME="Linksys"
+	fi
+	MANUF_ABBR="LS"
+
+	MANUF_DATE=$(cat /dev/mtd9 | grep manufacturer_date | cut -d "=" -f2 | tr -d '\r\n')
+	YEAR=$(echo "$MANUF_DATE" | cut -d "/" -f1)
+	MONTH=$(echo "$MANUF_DATE" | cut -d "/" -f2)
+	DAY=$(echo "$MANUF_DATE" | cut -d "/" -f3)
+	MANUF_DATE="$DAY-$MONTH-$YEAR"
+	;;
+tp-link,ec420-g1)
+	PLATFORM=$(cat /tmp/sysinfo/model)
+	SERIAL=$(cat /dev/mtd9 | grep serial_number | cut -d "=" -f2)
+	MODEL=$(cat /dev/mtd9 | grep "model=" | cut -d "=" -f2)
+	SKU=$(cat /dev/mtd9 | grep sku | cut -d "=" -f2)
+	CERT_REGION=$(cat /dev/mtd9 | grep certification_region | cut -d "=" -f2)
+	ID=$(cat /dev/mtd9 | grep mac_address | cut -d "=" -f2)
+	MANUF_DATE=$(cat /dev/mtd9 | grep manufacturer_date | cut -d "=" -f2)
+	MANUF_NAME=$(cat /dev/mtd9 | grep manufacturer_name | cut -d "=" -f2)
+	if [ ! $MANUF_NAME ]; then
+		MANUF_NAME="Proware (TP-Link)"
+	fi
+	MANUF_ABBR="PW"
+	MANUF_URL=$(cat /dev/mtd9 | grep manufacturer_url | cut -d "=" -f2)
+	MODEL_DESCR=$(cat /dev/mtd9 | grep model_description | cut -d "=" -f2)
+	MODEL_REV=$(cat /dev/mtd9 | grep model_revision | cut -d "=" -f2)
+	REF_DESIGN=$(cat /dev/mtd9 | grep reference_design | cut -d "=" -f2)
 	;;
 *)
 	MODEL=$(cat /tmp/sysinfo/board_name)
@@ -28,9 +126,41 @@ esac
 
 MODEL=$(echo $MODEL | sed "s/.*,//" | tr [a-z] [A-Z])
 
+# fallback check to get the serial number from mac address if flash does not contain this info.
+if [ ! $SERIAL ]; then
+	SERIAL=$(cat /sys/class/net/eth0/address | tr -d :)
+fi
+
+# fallback check to get the id from mac address if flash does not contain this info.
+if [ ! $ID ]; then
+	ID=$(cat /sys/class/net/eth0/address)
+fi
+
+# fallback check to get the model if flash does not contain this info.
+if [ ! $MODEL ]; then
+	MODEL=$(cat /tmp/sysinfo/board_name)
+fi
+
+# Read the active firmware version info
+FIRMWARE=$(cat /usr/opensync/.versions | grep FW_IMAGE_ACTIVE | grep -o '[^-]*$')
+if [ ! $FIRMWARE ]; then
+	FIRMWARE=$(cat /usr/opensync/.versions | grep FW_VERSION | cut -d ":" -f2)
+fi
+
 uci set system.tip=tip
 uci set system.tip.serial="${SERIAL}"
 uci set system.tip.model="${MODEL}"
 uci set system.tip.platform="${PLATFORM}"
-uci set system.tip.firmware='0.1.0'
+uci set system.tip.firmware="${FIRMWARE}"
+uci set system.tip.sku_number="${SKU}"
+uci set system.tip.revision="${MODEL_REV}"
+uci set system.tip.model_description="${MODEL_DESCR}"
+uci set system.tip.manufacturer_name="${MANUF_NAME}"
+uci set system.tip.manufacturer_date="${MANUF_DATE}"
+uci set system.tip.manufacturer_url="${MANUF_URL}"
+uci set system.tip.reference_design="${REF_DESIGN}"
+uci set system.tip.certification_region="${CERT_REGION}"
+uci set system.tip.id="${ID}"
+uci set system.tip.manuf_abbr="${MANUF_ABBR}"
+
 uci commit

patches/0027-ipq807x-add-the-Qualcomm-AX-target-support.patch

@@ -5666,7 +5666,7 @@ index 0000000000..858d7e1aee
 +# CONFIG_SW_SYNC is not set
 +# CONFIG_FSL_MC_BUS is not set
 +# CONFIG_ALLOC_BUFFERS_IN_4K_CHUNKS is not set
-+# CONFIG_ALLOC_SKB_PAGE_FRAG_DISABLE is not set
++CONFIG_ALLOC_SKB_PAGE_FRAG_DISABLE=y
 +# CONFIG_MMAP_ALLOW_UNINITIALIZED is not set
 +# CONFIG_MAILBOX is not set
 +# CONFIG_MAILBOX_TEST is not set
@@ -5718,7 +5718,7 @@ index 0000000000..858d7e1aee
 +CONFIG_BRIDGE_VLAN_FILTERING=y
 +CONFIG_LEDS_GPIO=y
 +# CONFIG_ARCH_IPQ256M is not set
-+# CONFIG_SKB_FIXED_SIZE_2K is not set
++CONFIG_SKB_FIXED_SIZE_2K=y
 +CONFIG_IPQ_MEM_PROFILE=0
 +# CONFIG_VIRTIO_NET is not set
 +# CONFIG_QCA_85XX_SWITCH is not set

patches/0044-ipq807x-add-512MB-profile.patch

@@ -0,0 +1,57 @@
+From a2ed0a77926c6fdca45677ee7698ceb04ab00eba Mon Sep 17 00:00:00 2001
+From: John Crispin <john@phrozen.org>
+Date: Wed, 3 Mar 2021 10:31:57 +0100
+Subject: [PATCH] ipq807x: add 512MB profile
+
+Signed-off-by: John Crispin <john@phrozen.org>
+---
+ config/Config-kernel.in | 8 ++++++++
+ include/image.mk        | 6 +++++-
+ 2 files changed, 13 insertions(+), 1 deletion(-)
+
+diff --git a/config/Config-kernel.in b/config/Config-kernel.in
+index eb61db542f..9197186b87 100644
+--- a/config/Config-kernel.in
++++ b/config/Config-kernel.in
+@@ -4,6 +4,14 @@
+ # See /LICENSE for more information.
+ #
+ 
++config KERNEL_IPQ_MEM_PROFILE
++	int "Different memory profile "
++	range 0 1024
++	default 0
++	help
++	  This option select memory profile to be used,which defines
++	  the reserved memory configuration used in device tree.
++
+ config KERNEL_BUILD_USER
+ 	string "Custom Kernel Build User Name"
+ 	default "builder" if BUILDBOT
+diff --git a/include/image.mk b/include/image.mk
+index a13f37f886..1d11387ec7 100644
+--- a/include/image.mk
++++ b/include/image.mk
+@@ -178,6 +178,10 @@ ifeq ($(strip $(call kernel_patchver_ge,4.18.0)),1)
+ 	-Wno-unique_unit_address
+ endif
+ 
++ifeq ($(CONFIG_IPQ_MEM_PROFILE),512)
++DTC_CFLAGS = -D __IPQ_MEM_PROFILE_512_MB__
++endif
++
+ # $(1) source dts file
+ # $(2) target dtb file
+ # $(3) extra CPP flags
+@@ -187,7 +191,7 @@ define Image/BuildDTB
+ 		-I$(DTS_DIR) \
+ 		-I$(DTS_DIR)/include \
+ 		-I$(LINUX_DIR)/include/ \
+-		-undef -D__DTS__ $(3) \
++		-undef -D__DTS__ $(DTC_CFLAGS) $(3) \
+ 		-o $(2).tmp $(1)
+ 	$(LINUX_DIR)/scripts/dtc/dtc -O dtb \
+ 		-i$(dir $(1)) $(DTC_FLAGS) $(4) \
+-- 
+2.25.1
+

patches/0045-tp-link-ex447-ex227-factory-Nand-images.patch

@@ -0,0 +1,70 @@
+From 57a733a35f7727d2e1b786e4270de7d593d90614 Mon Sep 17 00:00:00 2001
+From: Chaitanya Godavarthi <chaitanya.kiran@netexperience.com>
+Date: Fri, 12 Mar 2021 15:39:20 -0500
+Subject: [PATCH] openwrt: Generate factory Nand images for tp-link EX447 and
+ EX227
+
+Generate factory nand images for tp-link ex447 and ex227.
+This image is used to flash for migrating from stock qsdk
+image to tip openwrt image using the nand flash.
+---
+ target/linux/ipq807x/base-files/lib/upgrade/platform.sh | 8 ++++----
+ target/linux/ipq807x/image/ipq807x.mk                   | 6 ++++--
+ 2 files changed, 8 insertions(+), 6 deletions(-)
+
+diff --git a/target/linux/ipq807x/base-files/lib/upgrade/platform.sh b/target/linux/ipq807x/base-files/lib/upgrade/platform.sh
+index 9a5538aee3..59d1578925 100755
+--- a/target/linux/ipq807x/base-files/lib/upgrade/platform.sh
++++ b/target/linux/ipq807x/base-files/lib/upgrade/platform.sh
+@@ -43,9 +43,7 @@ platform_do_upgrade() {
+ 
+ 	board=$(board_name)
+ 	case $board in
+-	cig,wf188|\
+-	tplink,ex227|\
+-	tplink,ex447)
++	cig,wf188)
+ 		qca_do_upgrade $1
+ 		;;
+ 	cig,wf188n|\
+@@ -53,7 +51,9 @@ platform_do_upgrade() {
+ 	edgecore,eap102|\
+ 	qcom,ipq6018-cp01|\
+ 	qcom,ipq807x-hk01|\
+-	sercomm,wallaby)
++	sercomm,wallaby|\
++	tplink,ex447|\
++	tplink,ex227)
+ 		nand_upgrade_tar "$1"
+ 		;;
+ 	edgecore,eap101)
+diff --git a/target/linux/ipq807x/image/ipq807x.mk b/target/linux/ipq807x/image/ipq807x.mk
+index 8f9cda14a3..a41097e08e 100644
+--- a/target/linux/ipq807x/image/ipq807x.mk
++++ b/target/linux/ipq807x/image/ipq807x.mk
+@@ -50,9 +50,10 @@ define Device/tplink_ex227
+   DEVICE_DTS_CONFIG=config@hk07
+   SUPPORTED_DEVICES := tplink,ex227
+   DEVICE_PACKAGES := ath11k-wifi-tplink-ex227
+-  IMAGES := sysupgrade.tar nor-factory.bin
++  IMAGES := sysupgrade.tar nor-factory.bin nand-factory.bin
+   IMAGE/sysupgrade.tar/squashfs := append-rootfs | pad-rootfs | sysupgrade-tar rootfs=$$$$@ | append-metadata
+   IMAGE/nor-factory.bin := qsdk-ipq-factory-nor
++  IMAGE/nand-factory.bin := append-ubi | qsdk-ipq-factory-nand
+ endef
+ TARGET_DEVICES += tplink_ex227
+ 
+@@ -62,8 +63,9 @@ define Device/tplink_ex447
+   DEVICE_DTS_CONFIG=config@hk09
+   SUPPORTED_DEVICES := tplink,ex447
+   DEVICE_PACKAGES := ath11k-wifi-tplink-ex447
+-  IMAGES := sysupgrade.tar nor-factory.bin
++  IMAGES := sysupgrade.tar nor-factory.bin nand-factory.bin
+   IMAGE/sysupgrade.tar/squashfs := append-rootfs | pad-rootfs | sysupgrade-tar rootfs=$$$$@ | append-metadata
+   IMAGE/nor-factory.bin := qsdk-ipq-factory-nor
++  IMAGE/nand-factory.bin := append-ubi | qsdk-ipq-factory-nand
+ endef
+ TARGET_DEVICES += tplink_ex447
+-- 
+2.25.1
+

patches/0046-Remove-NOR-factory-support-for-tplink-ex227.patch

@@ -0,0 +1,41 @@
+From 2db87512962f81c6e6e9482136f0b17867ff0e6c Mon Sep 17 00:00:00 2001
+From: Chaitanya Godavarthi <chaitanya.kiran@netexperience.com>
+Date: Fri, 19 Mar 2021 10:37:11 -0400
+Subject: [PATCH] openwrt: Remove NOR factory support for tplink ex227/ex447
+
+Remove NOR factory support for tplink ex227/ex447
+as now its switched to nand based.
+
+Signed-off-by: Chaitanya Godavarthi <chaitanya.kiran@netexperience.com>
+---
+ target/linux/ipq807x/image/ipq807x.mk | 8 --------
+ 1 file changed, 8 deletions(-)
+
+diff --git a/target/linux/ipq807x/image/ipq807x.mk b/target/linux/ipq807x/image/ipq807x.mk
+index a41097e08e..65bf99dd9c 100644
+--- a/target/linux/ipq807x/image/ipq807x.mk
++++ b/target/linux/ipq807x/image/ipq807x.mk
+@@ -50,10 +50,6 @@ define Device/tplink_ex227
+   DEVICE_DTS_CONFIG=config@hk07
+   SUPPORTED_DEVICES := tplink,ex227
+   DEVICE_PACKAGES := ath11k-wifi-tplink-ex227
+-  IMAGES := sysupgrade.tar nor-factory.bin nand-factory.bin
+-  IMAGE/sysupgrade.tar/squashfs := append-rootfs | pad-rootfs | sysupgrade-tar rootfs=$$$$@ | append-metadata
+-  IMAGE/nor-factory.bin := qsdk-ipq-factory-nor
+-  IMAGE/nand-factory.bin := append-ubi | qsdk-ipq-factory-nand
+ endef
+ TARGET_DEVICES += tplink_ex227
+ 
+@@ -63,9 +59,5 @@ define Device/tplink_ex447
+   DEVICE_DTS_CONFIG=config@hk09
+   SUPPORTED_DEVICES := tplink,ex447
+   DEVICE_PACKAGES := ath11k-wifi-tplink-ex447
+-  IMAGES := sysupgrade.tar nor-factory.bin nand-factory.bin
+-  IMAGE/sysupgrade.tar/squashfs := append-rootfs | pad-rootfs | sysupgrade-tar rootfs=$$$$@ | append-metadata
+-  IMAGE/nor-factory.bin := qsdk-ipq-factory-nor
+-  IMAGE/nand-factory.bin := append-ubi | qsdk-ipq-factory-nand
+ endef
+ TARGET_DEVICES += tplink_ex447
+-- 
+2.25.1
+

patches/0047-openwrt-Revert-UBUS-pending-list-iteration-method.patch

@@ -0,0 +1,47 @@
+From 23be9eda1f87b77a772d24510d7096c565021e16 Mon Sep 17 00:00:00 2001
+From: Chaitanya Godavarthi <chaitanya.kiran@netexperience.com>
+Date: Mon, 29 Mar 2021 19:22:55 -0400
+Subject: [PATCH] openwrt: Revert UBUS pending list iteration method
+
+This commit partially reverts the earlier patch:
+"workaround possibly false positive uses of memory after it is freed"
+
+This fixed the crash while freeing a list item in
+ubus_process_pending_msg due to a double free.
+
+Signed-off-by: Chaitanya Godavarthi <chaitanya.kiran@netexperience.com>
+---
+ ...revert-pending-list-iteration-method.patch | 21 +++++++++++++++++++
+ 1 file changed, 21 insertions(+)
+ create mode 100644 package/system/ubus/patches/revert-pending-list-iteration-method.patch
+
+diff --git a/package/system/ubus/patches/revert-pending-list-iteration-method.patch b/package/system/ubus/patches/revert-pending-list-iteration-method.patch
+new file mode 100644
+index 0000000000..ccc13fd9f2
+--- /dev/null
++++ b/package/system/ubus/patches/revert-pending-list-iteration-method.patch
+@@ -0,0 +1,21 @@
++Index: ubus-2019-12-27-041c9d1c/libubus.c
++===================================================================
++--- ubus-2019-12-27-041c9d1c.orig/libubus.c
+++++ ubus-2019-12-27-041c9d1c/libubus.c
++@@ -115,12 +115,11 @@ ubus_process_msg(struct ubus_context *ct
++ static void ubus_process_pending_msg(struct uloop_timeout *timeout)
++ {
++ 	struct ubus_context *ctx = container_of(timeout, struct ubus_context, pending_timer);
++-	struct ubus_pending_msg *pending, *tmp;
++-
++-	list_for_each_entry_safe(pending, tmp, &ctx->pending, list) {
++-		if (ctx->stack_depth)
++-			break;
+++
+++	struct ubus_pending_msg *pending;
++
+++	while (!ctx->stack_depth && !list_empty(&ctx->pending)) {
+++		pending = list_first_entry(&ctx->pending, struct ubus_pending_msg, list);
++ 		list_del(&pending->list);
++ 		ubus_process_msg(ctx, &pending->hdr, -1);
++ 		free(pending);
+--
+2.25.1
+

patches/0048-Add-ESMT-nand-support.patch

@@ -0,0 +1,59 @@
+From 71f57ba133f983f059fc4daacb4bec67fb35cc09 Mon Sep 17 00:00:00 2001
+From: Chaitanya Godavarthi <chaitanya.kiran@netexperience.com>
+Date: Tue, 30 Mar 2021 08:59:14 -0400
+Subject: [PATCH] Add ESMT nand support
+
+Add ESMT nand support
+
+Signed-off-by: Chaitanya Godavarthi <chaitanya.kiran@netexperience.com>
+---
+ .../ipq807x/patches/110-add-esmt-nand.patch   | 37 +++++++++++++++++++
+ 1 file changed, 37 insertions(+)
+ create mode 100644 target/linux/ipq807x/patches/110-add-esmt-nand.patch
+
+diff --git a/target/linux/ipq807x/patches/110-add-esmt-nand.patch b/target/linux/ipq807x/patches/110-add-esmt-nand.patch
+new file mode 100644
+index 0000000000..d47a4d0d16
+--- /dev/null
++++ b/target/linux/ipq807x/patches/110-add-esmt-nand.patch
+@@ -0,0 +1,37 @@
++Index: linux-4.4.60-qsdk-10fd7d14853b7020b804acae690c8acec5d954ce/drivers/mtd/nand/nand_ids.c
++===================================================================
++--- linux-4.4.60-qsdk-10fd7d14853b7020b804acae690c8acec5d954ce.orig/drivers/mtd/nand/nand_ids.c
+++++ linux-4.4.60-qsdk-10fd7d14853b7020b804acae690c8acec5d954ce/drivers/mtd/nand/nand_ids.c
++@@ -62,6 +62,12 @@ struct nand_flash_dev nand_flash_ids[] =
++ 	{"TH58NYG3S0H 8G 1.8V 8-bit",
++ 		{ .id = {0x98, 0xa3, 0x91, 0x26} },
++ 		  SZ_4K, SZ_1K, SZ_256K, 0, 4, 256, NAND_ECC_INFO(8, SZ_512) },
+++
+++	{"F59D2G81KA 2G 1.8V 8-bit",
+++		{ .id = {0xc8, 0x5a, 0x90, 0x04} },
+++		SZ_2K, SZ_256, SZ_128K, 0, 4, 128, NAND_ECC_INFO(8, SZ_512) },
+++
+++
++ 	LEGACY_ID_NAND("NAND 4MiB 5V 8-bit",   0x6B, 4, SZ_8K, SP_OPTIONS),
++ 	LEGACY_ID_NAND("NAND 4MiB 3,3V 8-bit", 0xE3, 4, SZ_8K, SP_OPTIONS),
++ 	LEGACY_ID_NAND("NAND 4MiB 3,3V 8-bit", 0xE5, 4, SZ_8K, SP_OPTIONS),
++@@ -190,6 +196,7 @@ struct nand_manufacturers nand_manuf_ids
++ 	{NAND_MFR_SANDISK, "SanDisk"},
++ 	{NAND_MFR_INTEL, "Intel"},
++ 	{NAND_MFR_ATO, "ATO"},
+++	{NAND_MFR_ESMT, "ESMT"},
++ 	{NAND_MFR_GIGA, "GigaDevice"},
++ 	{NAND_MFR_ATO, "ATO"},
++ 	{NAND_MFR_WINBOND, "Winbond"},
++Index: linux-4.4.60-qsdk-10fd7d14853b7020b804acae690c8acec5d954ce/include/linux/mtd/nand.h
++===================================================================
++--- linux-4.4.60-qsdk-10fd7d14853b7020b804acae690c8acec5d954ce.orig/include/linux/mtd/nand.h
+++++ linux-4.4.60-qsdk-10fd7d14853b7020b804acae690c8acec5d954ce/include/linux/mtd/nand.h
++@@ -778,6 +778,7 @@ static inline struct mtd_info *nand_to_m
++ #define NAND_MFR_ATO		0x9b
++ #define NAND_MFR_WINBOND	0xef
++ #define NAND_MFR_FIDELIX	0xe5
+++#define NAND_MFR_ESMT		0xc8
++ 
++ /* The maximum expected count of bytes in the NAND ID sequence */
++ #define NAND_MAX_ID_LEN 8
+-- 
+2.25.1
+

patches/0048-Fix-ssid-ratelimiting-in-wifi6-AP.patch

@@ -0,0 +1,258 @@
+From 22c8d560c380cb3b188d2177c96121b9cd1835bd Mon Sep 17 00:00:00 2001
+From: Chaitanya Godavarthi <chaitanya.kiran@netexperience.com>
+Date: Sun, 4 Apr 2021 15:11:22 -0400
+Subject: [PATCH] Fix ssid ratelimiting in wifi6 AP
+
+This patch backports some fixes in
+netfilter ratelimiting module for linux v4.4.60.
+These fixes are ported from until following commit id
+6e323887565fe8a23c6c85faf9e395a24affd05c in
+the mainline kernel.
+
+Signed-off-by: Chaitanya Godavarthi <chaitanya.kiran@netexperience.com>
+---
+ .../patches/110-nf-ratelimit-fix.patch        | 232 ++++++++++++++++++
+ 1 file changed, 232 insertions(+)
+ create mode 100644 target/linux/ipq807x/patches/110-nf-ratelimit-fix.patch
+
+diff --git a/target/linux/ipq807x/patches/110-nf-ratelimit-fix.patch b/target/linux/ipq807x/patches/110-nf-ratelimit-fix.patch
+new file mode 100644
+index 0000000000..d4506944b8
+--- /dev/null
++++ b/target/linux/ipq807x/patches/110-nf-ratelimit-fix.patch
+@@ -0,0 +1,232 @@
++Index: linux-4.4.60-qsdk-10fd7d14853b7020b804acae690c8acec5d954ce/include/uapi/linux/netfilter/nf_tables.h
++===================================================================
++--- linux-4.4.60-qsdk-10fd7d14853b7020b804acae690c8acec5d954ce.orig/include/uapi/linux/netfilter/nf_tables.h
+++++ linux-4.4.60-qsdk-10fd7d14853b7020b804acae690c8acec5d954ce/include/uapi/linux/netfilter/nf_tables.h
++@@ -761,6 +761,10 @@ enum nft_limit_type {
++ 	NFT_LIMIT_PKT_BYTES
++ };
++ 
+++enum nft_limit_flags {
+++        NFT_LIMIT_F_INV = (1 << 0),
+++};
+++
++ /**
++  * enum nft_limit_attributes - nf_tables limit expression netlink attributes
++  *
++@@ -768,6 +772,7 @@ enum nft_limit_type {
++  * @NFTA_LIMIT_UNIT: refill unit (NLA_U64)
++  * @NFTA_LIMIT_BURST: burst (NLA_U32)
++  * @NFTA_LIMIT_TYPE: type of limit (NLA_U32: enum nft_limit_type)
+++ * @NFTA_LIMIT_FLAGS: flags (NLA_U32: enum nft_limit_flags)
++  */
++ enum nft_limit_attributes {
++ 	NFTA_LIMIT_UNSPEC,
++@@ -775,6 +780,8 @@ enum nft_limit_attributes {
++ 	NFTA_LIMIT_UNIT,
++ 	NFTA_LIMIT_BURST,
++ 	NFTA_LIMIT_TYPE,
+++	NFTA_LIMIT_FLAGS,
+++	NFTA_LIMIT_PAD,
++ 	__NFTA_LIMIT_MAX
++ };
++ #define NFTA_LIMIT_MAX		(__NFTA_LIMIT_MAX - 1)
++Index: linux-4.4.60-qsdk-10fd7d14853b7020b804acae690c8acec5d954ce/net/netfilter/nft_limit.c
++===================================================================
++--- linux-4.4.60-qsdk-10fd7d14853b7020b804acae690c8acec5d954ce.orig/net/netfilter/nft_limit.c
+++++ linux-4.4.60-qsdk-10fd7d14853b7020b804acae690c8acec5d954ce/net/netfilter/nft_limit.c
++@@ -17,15 +17,15 @@
++ #include <linux/netfilter/nf_tables.h>
++ #include <net/netfilter/nf_tables.h>
++ 
++-static DEFINE_SPINLOCK(limit_lock);
++-
++ struct nft_limit {
+++	spinlock_t	lock;
++ 	u64		last;
++ 	u64		tokens;
++ 	u64		tokens_max;
++ 	u64		rate;
++ 	u64		nsecs;
++ 	u32		burst;
+++	bool		invert;
++ };
++ 
++ static inline bool nft_limit_eval(struct nft_limit *limit, u64 cost)
++@@ -33,7 +33,7 @@ static inline bool nft_limit_eval(struct
++ 	u64 now, tokens;
++ 	s64 delta;
++ 
++-	spin_lock_bh(&limit_lock);
+++	spin_lock_bh(&limit->lock);
++ 	now = ktime_get_ns();
++ 	tokens = limit->tokens + now - limit->last;
++ 	if (tokens > limit->tokens_max)
++@@ -43,12 +43,12 @@ static inline bool nft_limit_eval(struct
++ 	delta = tokens - cost;
++ 	if (delta >= 0) {
++ 		limit->tokens = delta;
++-		spin_unlock_bh(&limit_lock);
++-		return false;
+++		spin_unlock_bh(&limit->lock);
+++		return limit->invert;
++ 	}
++ 	limit->tokens = tokens;
++-	spin_unlock_bh(&limit_lock);
++-	return true;
+++	spin_unlock_bh(&limit->lock);
+++	return !limit->invert;
++ }
++ 
++ static int nft_limit_init(struct nft_limit *limit,
++@@ -65,20 +65,31 @@ static int nft_limit_init(struct nft_lim
++ 	limit->nsecs = unit * NSEC_PER_SEC;
++ 	if (limit->rate == 0 || limit->nsecs < unit)
++ 		return -EOVERFLOW;
++-	limit->tokens = limit->tokens_max = limit->nsecs;
++-
++-	if (tb[NFTA_LIMIT_BURST]) {
++-		u64 rate;
++ 
+++	if (tb[NFTA_LIMIT_BURST])
++ 		limit->burst = ntohl(nla_get_be32(tb[NFTA_LIMIT_BURST]));
+++	else
+++		limit->burst = 0;
+++
+++	if (limit->rate + limit->burst < limit->rate)
+++		return -EOVERFLOW;
+++
+++	/* The token bucket size limits the number of tokens can be
+++	 * accumulated. tokens_max specifies the bucket size.
+++	 * tokens_max = unit * (rate + burst) / rate.
+++	 */
+++	limit->tokens = div_u64(limit->nsecs * (limit->rate + limit->burst),
+++				limit->rate);
+++	limit->tokens_max = limit->tokens;
++ 
++-		rate = limit->rate + limit->burst;
++-		if (rate < limit->rate)
++-			return -EOVERFLOW;
+++	if (tb[NFTA_LIMIT_FLAGS]) {
+++		u32 flags = ntohl(nla_get_be32(tb[NFTA_LIMIT_FLAGS]));
++ 
++-		limit->rate = rate;
+++		if (flags & NFT_LIMIT_F_INV)
+++			limit->invert = true;
++ 	}
++ 	limit->last = ktime_get_ns();
+++	spin_lock_init(&limit->lock);
++ 
++ 	return 0;
++ }
++@@ -86,13 +97,14 @@ static int nft_limit_init(struct nft_lim
++ static int nft_limit_dump(struct sk_buff *skb, const struct nft_limit *limit,
++ 			  enum nft_limit_type type)
++ {
+++	u32 flags = limit->invert ? NFT_LIMIT_F_INV : 0;
++ 	u64 secs = div_u64(limit->nsecs, NSEC_PER_SEC);
++-	u64 rate = limit->rate - limit->burst;
++ 
++-	if (nla_put_be64(skb, NFTA_LIMIT_RATE, cpu_to_be64(rate)) ||
+++	if (nla_put_be64(skb, NFTA_LIMIT_RATE, cpu_to_be64(limit->rate)) ||
++ 	    nla_put_be64(skb, NFTA_LIMIT_UNIT, cpu_to_be64(secs)) ||
++ 	    nla_put_be32(skb, NFTA_LIMIT_BURST, htonl(limit->burst)) ||
++-	    nla_put_be32(skb, NFTA_LIMIT_TYPE, htonl(type)))
+++	    nla_put_be32(skb, NFTA_LIMIT_TYPE, htonl(type)) ||
+++	    nla_put_be32(skb, NFTA_LIMIT_FLAGS, htonl(flags)))
++ 		goto nla_put_failure;
++ 	return 0;
++ 
++@@ -120,6 +132,7 @@ static const struct nla_policy nft_limit
++ 	[NFTA_LIMIT_UNIT]	= { .type = NLA_U64 },
++ 	[NFTA_LIMIT_BURST]	= { .type = NLA_U32 },
++ 	[NFTA_LIMIT_TYPE]	= { .type = NLA_U32 },
+++	[NFTA_LIMIT_FLAGS]	= { .type = NLA_U32 },
++ };
++ 
++ static int nft_limit_pkts_init(const struct nft_ctx *ctx,
++@@ -133,7 +146,7 @@ static int nft_limit_pkts_init(const str
++ 	if (err < 0)
++ 		return err;
++ 
++-	priv->cost = div_u64(priv->limit.nsecs, priv->limit.rate);
+++	priv->cost = div64_u64(priv->limit.nsecs, priv->limit.rate);
++ 	return 0;
++ }
++ 
++@@ -153,40 +166,40 @@ static const struct nft_expr_ops nft_lim
++ 	.dump		= nft_limit_pkts_dump,
++ };
++ 
++-static void nft_limit_pkt_bytes_eval(const struct nft_expr *expr,
++-				     struct nft_regs *regs,
++-				     const struct nft_pktinfo *pkt)
+++static void nft_limit_bytes_eval(const struct nft_expr *expr,
+++				 struct nft_regs *regs,
+++				 const struct nft_pktinfo *pkt)
++ {
++ 	struct nft_limit *priv = nft_expr_priv(expr);
++-	u64 cost = div_u64(priv->nsecs * pkt->skb->len, priv->rate);
+++	u64 cost = div64_u64(priv->nsecs * pkt->skb->len, priv->rate);
++ 
++ 	if (nft_limit_eval(priv, cost))
++ 		regs->verdict.code = NFT_BREAK;
++ }
++ 
++-static int nft_limit_pkt_bytes_init(const struct nft_ctx *ctx,
++-				    const struct nft_expr *expr,
++-				    const struct nlattr * const tb[])
+++static int nft_limit_bytes_init(const struct nft_ctx *ctx,
+++				const struct nft_expr *expr,
+++				const struct nlattr * const tb[])
++ {
++ 	struct nft_limit *priv = nft_expr_priv(expr);
++ 
++ 	return nft_limit_init(priv, tb);
++ }
++ 
++-static int nft_limit_pkt_bytes_dump(struct sk_buff *skb,
++-				    const struct nft_expr *expr)
+++static int nft_limit_bytes_dump(struct sk_buff *skb,
+++				const struct nft_expr *expr)
++ {
++ 	const struct nft_limit *priv = nft_expr_priv(expr);
++ 
++ 	return nft_limit_dump(skb, priv, NFT_LIMIT_PKT_BYTES);
++ }
++ 
++-static const struct nft_expr_ops nft_limit_pkt_bytes_ops = {
+++static const struct nft_expr_ops nft_limit_bytes_ops = {
++ 	.type		= &nft_limit_type,
++ 	.size		= NFT_EXPR_SIZE(sizeof(struct nft_limit)),
++-	.eval		= nft_limit_pkt_bytes_eval,
++-	.init		= nft_limit_pkt_bytes_init,
++-	.dump		= nft_limit_pkt_bytes_dump,
+++	.eval		= nft_limit_bytes_eval,
+++	.init		= nft_limit_bytes_init,
+++	.dump		= nft_limit_bytes_dump,
++ };
++ 
++ static const struct nft_expr_ops *
++@@ -200,7 +213,7 @@ nft_limit_select_ops(const struct nft_ct
++ 	case NFT_LIMIT_PKTS:
++ 		return &nft_limit_pkts_ops;
++ 	case NFT_LIMIT_PKT_BYTES:
++-		return &nft_limit_pkt_bytes_ops;
+++		return &nft_limit_bytes_ops;
++ 	}
++ 	return ERR_PTR(-EOPNOTSUPP);
++ }
++Index: linux-4.4.60-qsdk-10fd7d14853b7020b804acae690c8acec5d954ce/net/bridge/br_private.h
++===================================================================
++--- linux-4.4.60-qsdk-10fd7d14853b7020b804acae690c8acec5d954ce.orig/net/bridge/br_private.h
+++++ linux-4.4.60-qsdk-10fd7d14853b7020b804acae690c8acec5d954ce/net/bridge/br_private.h
++@@ -926,9 +926,6 @@ BR_HOOK(uint8_t pf, unsigned int hook, s
++ 	struct sk_buff *skb, struct net_device *in, struct net_device *out,
++ 	int (*okfn)(struct net *, struct sock *, struct sk_buff *))
++ {
++-	if (!br_netfilter_run_hooks())
++-		return okfn(net, sk, skb);
++-
++ 	return NF_HOOK(pf, hook, net, sk, skb, in, out, okfn);
++ }
++ 
+-- 
+2.25.1
+