diff options
Diffstat (limited to 'data-ipa-cfg-mgr/ipacm/src/IPACM_Wlan.cpp')
| -rw-r--r-- | data-ipa-cfg-mgr/ipacm/src/IPACM_Wlan.cpp | 2228 |
1 files changed, 2228 insertions, 0 deletions
diff --git a/data-ipa-cfg-mgr/ipacm/src/IPACM_Wlan.cpp b/data-ipa-cfg-mgr/ipacm/src/IPACM_Wlan.cpp new file mode 100644 index 0000000..c912a6e --- /dev/null +++ b/data-ipa-cfg-mgr/ipacm/src/IPACM_Wlan.cpp @@ -0,0 +1,2228 @@ +/* +Copyright (c) 2013-2017, The Linux Foundation. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: +* Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. +* Neither the name of The Linux Foundation nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS +BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR +BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN +IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +/*! +@file +IPACM_Wlan.cpp + +@brief +This file implements the WLAN iface functionality. + +@Author +Skylar Chang + +*/ + +#include <string.h> +#include <unistd.h> +#include <sys/ioctl.h> +#include <IPACM_Wlan.h> +#include <IPACM_Netlink.h> +#include <fcntl.h> +#include <sys/inotify.h> +#include <IPACM_Wan.h> +#include <IPACM_Lan.h> +#include <IPACM_IfaceManager.h> +#include <IPACM_ConntrackListener.h> + + +/* static member to store the number of total wifi clients within all APs*/ +int IPACM_Wlan::total_num_wifi_clients = 0; + +int IPACM_Wlan::num_wlan_ap_iface = 0; + +IPACM_Wlan::IPACM_Wlan(int iface_index) : IPACM_Lan(iface_index) +{ +#define WLAN_AMPDU_DEFAULT_FILTER_RULES 3 + + wlan_ap_index = IPACM_Wlan::num_wlan_ap_iface; + if(wlan_ap_index < 0 || wlan_ap_index > 1) + { + IPACMERR("Wlan_ap_index is not correct: %d, not creating instance.\n", wlan_ap_index); + if (tx_prop != NULL) + { + free(tx_prop); + } + if (rx_prop != NULL) + { + free(rx_prop); + } + if (iface_query != NULL) + { + free(iface_query); + } + delete this; + return; + } + + num_wifi_client = 0; + header_name_count = 0; + wlan_client = NULL; + wlan_client_len = 0; + + if(iface_query != NULL) + { + wlan_client_len = (sizeof(ipa_wlan_client)) + (iface_query->num_tx_props * sizeof(wlan_client_rt_hdl)); + wlan_client = (ipa_wlan_client *)calloc(IPA_MAX_NUM_WIFI_CLIENTS, wlan_client_len); + if (wlan_client == NULL) + { + IPACMERR("unable to allocate memory\n"); + return; + } + IPACMDBG_H("index:%d constructor: Tx properties:%d\n", iface_index, iface_query->num_tx_props); + } + Nat_App = NatApp::GetInstance(); + if (Nat_App == NULL) + { + IPACMERR("unable to get Nat App instance \n"); + return; + } + + IPACM_Wlan::num_wlan_ap_iface++; + IPACMDBG_H("Now the number of wlan AP iface is %d\n", IPACM_Wlan::num_wlan_ap_iface); + + m_is_guest_ap = false; + if (IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].wlan_mode == INTERNET) + { + m_is_guest_ap = true; + } + IPACMDBG_H("%s: guest ap enable: %d \n", + IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].iface_name, m_is_guest_ap); + +#ifdef FEATURE_IPA_ANDROID + /* set the IPA-client pipe enum */ + if(ipa_if_cate == WLAN_IF) + { +#ifdef FEATURE_IPACM_HAL + handle_tethering_client(false, IPACM_CLIENT_MAX); +#else + handle_tethering_client(false, IPACM_CLIENT_WLAN); +#endif + } +#endif + return; +} + + +IPACM_Wlan::~IPACM_Wlan() +{ + IPACM_EvtDispatcher::deregistr(this); + IPACM_IfaceManager::deregistr(this); + return; +} + +void IPACM_Wlan::event_callback(ipa_cm_event_id event, void *param) +{ + if(is_active == false && event != IPA_LAN_DELETE_SELF) + { + IPACMDBG_H("The interface is no longer active, return.\n"); + return; + } + + int ipa_interface_index; + int wlan_index; + ipacm_ext_prop* ext_prop; + ipacm_event_iface_up_tehter* data_wan_tether; + + switch (event) + { + + case IPA_WLAN_LINK_DOWN_EVENT: + { + ipacm_event_data_fid *data = (ipacm_event_data_fid *)param; + ipa_interface_index = iface_ipa_index_query(data->if_index); + if (ipa_interface_index == ipa_if_num) + { + IPACMDBG_H("Received IPA_WLAN_LINK_DOWN_EVENT\n"); + handle_down_evt(); + /* reset the AP-iface category to unknown */ + IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].if_cat = UNKNOWN_IF; + IPACM_Iface::ipacmcfg->DelNatIfaces(dev_name); // delete NAT-iface + IPACM_Wlan::total_num_wifi_clients = (IPACM_Wlan::total_num_wifi_clients) - \ + (num_wifi_client); + return; + } + } + break; + + case IPA_PRIVATE_SUBNET_CHANGE_EVENT: + { + ipacm_event_data_fid *data = (ipacm_event_data_fid *)param; + /* internel event: data->if_index is ipa_if_index */ + if (data->if_index == ipa_if_num) + { + IPACMDBG_H("Received IPA_PRIVATE_SUBNET_CHANGE_EVENT from itself posting, ignore\n"); + return; + } + else + { + IPACMDBG_H("Received IPA_PRIVATE_SUBNET_CHANGE_EVENT from other LAN iface \n"); +#ifdef FEATURE_IPA_ANDROID + handle_private_subnet_android(IPA_IP_v4); +#endif + IPACMDBG_H(" delete old private subnet rules, use new sets \n"); + return; + } + } + break; + + case IPA_LAN_DELETE_SELF: + { + ipacm_event_data_fid *data = (ipacm_event_data_fid *)param; + if(data->if_index == ipa_if_num) + { + IPACM_Wlan::num_wlan_ap_iface--; + IPACMDBG_H("Now the number of wlan AP iface is %d\n", IPACM_Wlan::num_wlan_ap_iface); + + IPACMDBG_H("Received IPA_LAN_DELETE_SELF event.\n"); + IPACMDBG_H("ipa_WLAN (%s):ipa_index (%d) instance close \n", IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].iface_name, ipa_if_num); + delete this; + } + break; + } + + case IPA_ADDR_ADD_EVENT: + { + ipacm_event_data_addr *data = (ipacm_event_data_addr *)param; + ipa_interface_index = iface_ipa_index_query(data->if_index); + + if ( (data->iptype == IPA_IP_v4 && data->ipv4_addr == 0) || + (data->iptype == IPA_IP_v6 && + data->ipv6_addr[0] == 0 && data->ipv6_addr[1] == 0 && + data->ipv6_addr[2] == 0 && data->ipv6_addr[3] == 0) ) + { + IPACMDBG_H("Invalid address, ignore IPA_ADDR_ADD_EVENT event\n"); + return; + } + + if (ipa_interface_index == ipa_if_num) + { + /* check v4 not setup before, v6 can have 2 iface ip */ + if( ((data->iptype != ip_type) && (ip_type != IPA_IP_MAX)) + || ((data->iptype==IPA_IP_v6) && (num_dft_rt_v6!=MAX_DEFAULT_v6_ROUTE_RULES))) + { + IPACMDBG_H("Got IPA_ADDR_ADD_EVENT ip-family:%d, v6 num %d: \n",data->iptype,num_dft_rt_v6); + /* Post event to NAT */ + if (data->iptype == IPA_IP_v4) + { + ipacm_cmd_q_data evt_data; + ipacm_event_iface_up *info; + + info = (ipacm_event_iface_up *) + malloc(sizeof(ipacm_event_iface_up)); + if (info == NULL) + { + IPACMERR("Unable to allocate memory\n"); + return; + } + + memcpy(info->ifname, dev_name, IF_NAME_LEN); + info->ipv4_addr = data->ipv4_addr; + info->addr_mask = IPACM_Iface::ipacmcfg->private_subnet_table[0].subnet_mask; + + evt_data.event = IPA_HANDLE_WLAN_UP; + evt_data.evt_data = (void *)info; + + /* Insert IPA_HANDLE_WLAN_UP to command queue */ + IPACMDBG_H("posting IPA_HANDLE_WLAN_UP for IPv4 with below information\n"); + IPACMDBG_H("IPv4 address:0x%x, IPv4 address mask:0x%x\n", + info->ipv4_addr, info->addr_mask); + IPACM_EvtDispatcher::PostEvt(&evt_data); + } + + if(handle_addr_evt(data) == IPACM_FAILURE) + { + return; + } + +#ifdef FEATURE_IPA_ANDROID + add_dummy_private_subnet_flt_rule(data->iptype); + handle_private_subnet_android(data->iptype); +#else + handle_private_subnet(data->iptype); +#endif + +#ifndef FEATURE_IPACM_HAL + if (IPACM_Wan::isWanUP(ipa_if_num)) + { + if(data->iptype == IPA_IP_v4 || data->iptype == IPA_IP_MAX) + { + if(IPACM_Wan::backhaul_is_sta_mode == false) + { + ext_prop = IPACM_Iface::ipacmcfg->GetExtProp(IPA_IP_v4); + IPACM_Lan::handle_wan_up_ex(ext_prop, IPA_IP_v4, + IPACM_Wan::getXlat_Mux_Id()); + } + else + { + IPACM_Lan::handle_wan_up(IPA_IP_v4); + } + } + IPACMDBG_H("Finished checking wan_up\n"); + } else { + IPACMDBG_H("Wan_V4 haven't up yet \n"); + } + + if(IPACM_Wan::isWanUP_V6(ipa_if_num)) + { + if((data->iptype == IPA_IP_v6 || data->iptype == IPA_IP_MAX) && num_dft_rt_v6 == 1) + { + memcpy(ipv6_prefix, IPACM_Wan::backhaul_ipv6_prefix, sizeof(ipv6_prefix)); + install_ipv6_prefix_flt_rule(IPACM_Wan::backhaul_ipv6_prefix); + + if(IPACM_Wan::backhaul_is_sta_mode == false) + { + ext_prop = IPACM_Iface::ipacmcfg->GetExtProp(IPA_IP_v6); + IPACM_Lan::handle_wan_up_ex(ext_prop, IPA_IP_v6, 0); + } + else + { + IPACM_Lan::handle_wan_up(IPA_IP_v6); + } + } + IPACMDBG_H("Finished checking wan_up_v6\n"); + } else { + IPACMDBG_H("Wan_V6 haven't up yet \n"); + } +#endif + /* checking if SW-RT_enable */ + if (IPACM_Iface::ipacmcfg->ipa_sw_rt_enable == true) + { + /* handle software routing enable event*/ + IPACMDBG_H("IPA_SW_ROUTING_ENABLE for iface: %s \n",IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].iface_name); + handle_software_routing_enable(); + } + } + } + } + break; +#ifdef FEATURE_IPA_ANDROID + case IPA_HANDLE_WAN_UP_TETHER: + IPACMDBG_H("Received IPA_HANDLE_WAN_UP_TETHER event\n"); + + data_wan_tether = (ipacm_event_iface_up_tehter*)param; + if(data_wan_tether == NULL) + { + IPACMERR("No event data is found.\n"); + return; + } + IPACMDBG_H("Backhaul is sta mode?%d, if_index_tether:%d tether_if_name:%s\n", data_wan_tether->is_sta, + data_wan_tether->if_index_tether, + IPACM_Iface::ipacmcfg->iface_table[data_wan_tether->if_index_tether].iface_name); +#ifndef FEATURE_IPACM_HAL + if (data_wan_tether->if_index_tether != ipa_if_num) + { + IPACMERR("IPA_HANDLE_WAN_UP_TETHER tether_if(%d), not valid (%d) ignore\n", data_wan_tether->if_index_tether, ipa_if_num); + return; + } +#endif + if(ip_type == IPA_IP_v4 || ip_type == IPA_IP_MAX) + { +#ifdef FEATURE_IPACM_HAL + if(is_upstream_set[IPA_IP_v4] == false) + { + IPACMDBG_H("Add upstream for IPv4.\n"); + is_upstream_set[IPA_IP_v4] = true; + if(is_downstream_set[IPA_IP_v4] == true) + { + IPACMDBG_H("Downstream was set before, adding UL rules.\n"); + if(data_wan_tether->is_sta == false) + { + ext_prop = IPACM_Iface::ipacmcfg->GetExtProp(IPA_IP_v4); + handle_wan_up_ex(ext_prop, IPA_IP_v4, 0); + } else { + handle_wan_up(IPA_IP_v4); + } + } + } +#else + if(data_wan_tether->is_sta == false) + { + ext_prop = IPACM_Iface::ipacmcfg->GetExtProp(IPA_IP_v4); + handle_wan_up_ex(ext_prop, IPA_IP_v4, 0); + } else { + handle_wan_up(IPA_IP_v4); + } +#endif + } + break; + + case IPA_HANDLE_WAN_UP_V6_TETHER: + IPACMDBG_H("Received IPA_HANDLE_WAN_UP_V6_TETHER event\n"); + + data_wan_tether = (ipacm_event_iface_up_tehter*)param; + if(data_wan_tether == NULL) + { + IPACMERR("No event data is found.\n"); + return; + } + IPACMDBG_H("Backhaul is sta mode?%d, if_index_tether:%d tether_if_name:%s\n", data_wan_tether->is_sta, + data_wan_tether->if_index_tether, + IPACM_Iface::ipacmcfg->iface_table[data_wan_tether->if_index_tether].iface_name); +#ifndef FEATURE_IPACM_HAL + if (data_wan_tether->if_index_tether != ipa_if_num) + { + IPACMERR("IPA_HANDLE_WAN_UP_V6_TETHER tether_if(%d), not valid (%d) ignore\n", data_wan_tether->if_index_tether, ipa_if_num); + return; + } +#endif + if(ip_type == IPA_IP_v6 || ip_type == IPA_IP_MAX) + { +#ifdef FEATURE_IPACM_HAL + if(is_upstream_set[IPA_IP_v6] == false) + { + IPACMDBG_H("Add upstream for IPv6.\n"); + is_upstream_set[IPA_IP_v6] = true; + + if(is_downstream_set[IPA_IP_v6] == true) + { + IPACMDBG_H("Downstream was set before, adding UL rules.\n"); + memcpy(ipv6_prefix, data_wan_tether->ipv6_prefix, sizeof(ipv6_prefix)); + install_ipv6_prefix_flt_rule(data_wan_tether->ipv6_prefix); + if(data_wan_tether->is_sta == false) + { + ext_prop = IPACM_Iface::ipacmcfg->GetExtProp(IPA_IP_v6); + handle_wan_up_ex(ext_prop, IPA_IP_v6, 0); + } + else + { + handle_wan_up(IPA_IP_v6); + } + } + } +#else + if(data_wan_tether->is_sta == false) + { + ext_prop = IPACM_Iface::ipacmcfg->GetExtProp(IPA_IP_v6); + handle_wan_up_ex(ext_prop, IPA_IP_v6, 0); + } + else + { + handle_wan_up(IPA_IP_v6); + } +#endif + } + break; + + case IPA_HANDLE_WAN_DOWN_TETHER: + IPACMDBG_H("Received IPA_HANDLE_WAN_DOWN_TETHER event\n"); + data_wan_tether = (ipacm_event_iface_up_tehter*)param; + if(data_wan_tether == NULL) + { + IPACMERR("No event data is found.\n"); + return; + } + if(rx_prop == NULL) + { + IPACMERR("No rx prop.\n"); + return; + } + IPACMDBG_H("Backhaul is sta mode?%d, if_index_tether:%d tether_if_name:%s\n", data_wan_tether->is_sta, + data_wan_tether->if_index_tether, + IPACM_Iface::ipacmcfg->iface_table[data_wan_tether->if_index_tether].iface_name); +#ifndef FEATURE_IPACM_HAL + if (data_wan_tether->if_index_tether != ipa_if_num) + { + IPACMERR("IPA_HANDLE_WAN_DOWN_TETHER tether_if(%d), not valid (%d) ignore\n", data_wan_tether->if_index_tether, ipa_if_num); + return; + } +#endif + if(ip_type == IPA_IP_v4 || ip_type == IPA_IP_MAX) + { +#ifdef FEATURE_IPACM_HAL + if(is_upstream_set[IPA_IP_v4] == true) + { + IPACMDBG_H("Del upstream for IPv4.\n"); + is_upstream_set[IPA_IP_v4] = false; + if(is_downstream_set[IPA_IP_v4] == true) + { + IPACMDBG_H("Downstream was set before, deleting UL rules.\n"); + handle_wan_down(data_wan_tether->is_sta); + } + } +#else + handle_wan_down(data_wan_tether->is_sta); +#endif + } + break; + + case IPA_HANDLE_WAN_DOWN_V6_TETHER: + IPACMDBG_H("Received IPA_HANDLE_WAN_DOWN_V6_TETHER event\n"); + data_wan_tether = (ipacm_event_iface_up_tehter*)param; + if(data_wan_tether == NULL) + { + IPACMERR("No event data is found.\n"); + return; + } + if(rx_prop == NULL) + { + IPACMERR("No rx prop.\n"); + return; + } + IPACMDBG_H("Backhaul is sta mode?%d, if_index_tether:%d tether_if_name:%s\n", data_wan_tether->is_sta, + data_wan_tether->if_index_tether, + IPACM_Iface::ipacmcfg->iface_table[data_wan_tether->if_index_tether].iface_name); +#ifndef FEATURE_IPACM_HAL + if (data_wan_tether->if_index_tether != ipa_if_num) + { + IPACMERR("IPA_HANDLE_WAN_DOWN_V6_TETHER tether_if(%d), not valid (%d) ignore\n", data_wan_tether->if_index_tether, ipa_if_num); + return; + } +#endif + if(ip_type == IPA_IP_v6 || ip_type == IPA_IP_MAX) + { +#ifdef FEATURE_IPACM_HAL + if(is_upstream_set[IPA_IP_v6] == true) + { + IPACMDBG_H("Del upstream for IPv6.\n"); + is_upstream_set[IPA_IP_v6] = false; + if(is_downstream_set[IPA_IP_v6] == true) + { + IPACMDBG_H("Downstream was set before, deleting UL rules.\n"); + /* reset usb-client ipv6 rt-rules */ + handle_wlan_client_reset_rt(IPA_IP_v6); + handle_wan_down_v6(data_wan_tether->is_sta); + } + } +#else + /* reset usb-client ipv6 rt-rules */ + handle_wlan_client_reset_rt(IPA_IP_v6); + handle_wan_down_v6(data_wan_tether->is_sta); +#endif + } + break; + + case IPA_DOWNSTREAM_ADD: + { + ipacm_event_ipahal_stream *data = (ipacm_event_ipahal_stream *)param; + ipa_interface_index = iface_ipa_index_query(data->if_index); + if(ipa_interface_index == ipa_if_num) + { + IPACMDBG_H("Received IPA_DOWNSTREAM_ADD event.\n"); + if(is_downstream_set[data->prefix.iptype] == false) + { + IPACMDBG_H("Add downstream for IP iptype %d.\n", data->prefix.iptype); + is_downstream_set[data->prefix.iptype] = true; + memcpy(&prefix[data->prefix.iptype], &data->prefix, + sizeof(prefix[data->prefix.iptype])); + + if(is_upstream_set[data->prefix.iptype] == true) + { + IPACMDBG_H("Upstream was set before, adding modem UL rules.\n"); + if(ip_type == IPA_IP_MAX || ip_type == data->prefix.iptype) + { + if (data->prefix.iptype == IPA_IP_v6) /* ipv6 only */ + { + /* Only offload clients has same prefix as Android gave */ + ipv6_prefix[0] = data->prefix.v6Addr[0]; + ipv6_prefix[1] = data->prefix.v6Addr[1]; + IPACMDBG_H("ipv6_prefix0x%x:%x\n", ipv6_prefix[0], ipv6_prefix[1]); + install_ipv6_prefix_flt_rule(ipv6_prefix); + } + + if (IPACM_Wan::backhaul_is_sta_mode == false) /* LTE */ + { + ext_prop = IPACM_Iface::ipacmcfg->GetExtProp(data->prefix.iptype); + handle_wan_up_ex(ext_prop, data->prefix.iptype, 0); + } else { + handle_wan_up(data->prefix.iptype); /* STA */ + } + } + } + } + } + break; + } + + case IPA_DOWNSTREAM_DEL: + { + ipacm_event_ipahal_stream *data = (ipacm_event_ipahal_stream *)param; + ipa_interface_index = iface_ipa_index_query(data->if_index); + if(ipa_interface_index == ipa_if_num) + { + IPACMDBG_H("Received IPA_DOWNSTREAM_DEL event.\n"); + if(is_downstream_set[data->prefix.iptype] == true) + { + IPACMDBG_H("Del downstream for IP iptype %d.\n", data->prefix.iptype); + is_downstream_set[data->prefix.iptype] = false; + + if(is_upstream_set[data->prefix.iptype] == true) + { + IPACMDBG_H("Upstream was set before, deleting UL rules.\n"); + if (data->prefix.iptype == IPA_IP_v4) + { + handle_wan_down(IPACM_Wan::backhaul_is_sta_mode); /* LTE STA */ + } else { + handle_wlan_client_reset_rt(IPA_IP_v6); + handle_wan_down_v6(IPACM_Wan::backhaul_is_sta_mode); /* LTE STA */ + } + } + } + } + break; + } +#else + case IPA_HANDLE_WAN_UP: + IPACMDBG_H("Received IPA_HANDLE_WAN_UP event\n"); + + ipacm_event_iface_up* data_wan = (ipacm_event_iface_up*)param; + if(data_wan == NULL) + { + IPACMERR("No event data is found.\n"); + return; + } + IPACMDBG_H("Backhaul is sta mode?%d\n", data_wan->is_sta); + if(ip_type == IPA_IP_v4 || ip_type == IPA_IP_MAX) + { + if(data_wan->is_sta == false) + { + ext_prop = IPACM_Iface::ipacmcfg->GetExtProp(IPA_IP_v4); + IPACM_Lan::handle_wan_up_ex(ext_prop, IPA_IP_v4, data_wan->xlat_mux_id); + } + else + { + IPACM_Lan::handle_wan_up(IPA_IP_v4); + } + } + break; + + case IPA_HANDLE_WAN_UP_V6: + IPACMDBG_H("Received IPA_HANDLE_WAN_UP_V6 event\n"); + + data_wan = (ipacm_event_iface_up*)param; + if(data_wan == NULL) + { + IPACMERR("No event data is found.\n"); + return; + } + IPACMDBG_H("Backhaul is sta mode?%d\n", data_wan->is_sta); + if(ip_type == IPA_IP_v6 || ip_type == IPA_IP_MAX) + { + memcpy(ipv6_prefix, data_wan->ipv6_prefix, sizeof(ipv6_prefix)); + install_ipv6_prefix_flt_rule(data_wan->ipv6_prefix); + + if(data_wan->is_sta == false) + { + ext_prop = IPACM_Iface::ipacmcfg->GetExtProp(IPA_IP_v6); + IPACM_Lan::handle_wan_up_ex(ext_prop, IPA_IP_v6, 0); + } + else + { + IPACM_Lan::handle_wan_up(IPA_IP_v6); + } + } + break; + + case IPA_HANDLE_WAN_DOWN: + IPACMDBG_H("Received IPA_HANDLE_WAN_DOWN event\n"); + data_wan = (ipacm_event_iface_up*)param; + if(data_wan == NULL) + { + IPACMERR("No event data is found.\n"); + return; + } + IPACMDBG_H("Backhaul is sta mode?%d\n", data_wan->is_sta); + if (rx_prop != NULL) + { + if(ip_type == IPA_IP_v4 || ip_type == IPA_IP_MAX) + { + handle_wan_down(data_wan->is_sta); + } + } + break; + + case IPA_HANDLE_WAN_DOWN_V6: + IPACMDBG_H("Received IPA_HANDLE_WAN_DOWN_V6 event\n"); + data_wan = (ipacm_event_iface_up*)param; + if(data_wan == NULL) + { + IPACMERR("No event data is found.\n"); + return; + } + /* clean up v6 RT rules*/ + IPACMDBG_H("Received IPA_WAN_V6_DOWN in WLAN-instance and need clean up client IPv6 address \n"); + /* reset wifi-client ipv6 rt-rules */ + handle_wlan_client_reset_rt(IPA_IP_v6); + IPACMDBG_H("Backhaul is sta mode ? %d\n", data_wan->is_sta); + if (rx_prop != NULL) + { + if(ip_type == IPA_IP_v6 || ip_type == IPA_IP_MAX) + { + handle_wan_down_v6(data_wan->is_sta); + } + } + break; +#endif + + case IPA_WLAN_CLIENT_ADD_EVENT_EX: + { + ipacm_event_data_wlan_ex *data = (ipacm_event_data_wlan_ex *)param; + ipa_interface_index = iface_ipa_index_query(data->if_index); + if (ipa_interface_index == ipa_if_num) + { + int i; + for(i=0; i<data->num_of_attribs; i++) + { + if(data->attribs[i].attrib_type == WLAN_HDR_ATTRIB_MAC_ADDR) + { + eth_bridge_post_event(IPA_ETH_BRIDGE_CLIENT_ADD, IPA_IP_MAX, data->attribs[i].u.mac_addr, NULL, NULL); + break; + } + } + IPACMDBG_H("Received IPA_WLAN_CLIENT_ADD_EVENT\n"); + handle_wlan_client_init_ex(data); + } + } + break; + + case IPA_WLAN_CLIENT_DEL_EVENT: + { + ipacm_event_data_mac *data = (ipacm_event_data_mac *)param; + ipa_interface_index = iface_ipa_index_query(data->if_index); + if (ipa_interface_index == ipa_if_num) + { + IPACMDBG_H("Received IPA_WLAN_CLIENT_DEL_EVENT\n"); + eth_bridge_post_event(IPA_ETH_BRIDGE_CLIENT_DEL, IPA_IP_MAX, data->mac_addr, NULL, NULL); + handle_wlan_client_down_evt(data->mac_addr); + } + } + break; + + case IPA_WLAN_CLIENT_POWER_SAVE_EVENT: + { + ipacm_event_data_mac *data = (ipacm_event_data_mac *)param; + ipa_interface_index = iface_ipa_index_query(data->if_index); + if (ipa_interface_index == ipa_if_num) + { + IPACMDBG_H("Received IPA_WLAN_CLIENT_POWER_SAVE_EVENT\n"); + handle_wlan_client_pwrsave(data->mac_addr); + } + } + break; + + case IPA_WLAN_CLIENT_RECOVER_EVENT: + { + ipacm_event_data_mac *data = (ipacm_event_data_mac *)param; + ipa_interface_index = iface_ipa_index_query(data->if_index); + if (ipa_interface_index == ipa_if_num) + { + IPACMDBG_H("Received IPA_WLAN_CLIENT_RECOVER_EVENT\n"); + + wlan_index = get_wlan_client_index(data->mac_addr); + if ((wlan_index != IPACM_INVALID_INDEX) && + (get_client_memptr(wlan_client, wlan_index)->power_save_set == true)) + { + + IPACMDBG_H("change wlan client out of power safe mode \n"); + get_client_memptr(wlan_client, wlan_index)->power_save_set = false; + + /* First add route rules and then nat rules */ + if(get_client_memptr(wlan_client, wlan_index)->ipv4_set == true) /* for ipv4 */ + { + IPACMDBG_H("recover client index(%d):ipv4 address: 0x%x\n", + wlan_index, + get_client_memptr(wlan_client, wlan_index)->v4_addr); + + IPACMDBG_H("Adding Route Rules\n"); + handle_wlan_client_route_rule(data->mac_addr, IPA_IP_v4); + IPACMDBG_H("Adding Nat Rules\n"); + Nat_App->ResetPwrSaveIf(get_client_memptr(wlan_client, wlan_index)->v4_addr); + } + + if(get_client_memptr(wlan_client, wlan_index)->ipv6_set != 0) /* for ipv6 */ + { + handle_wlan_client_route_rule(data->mac_addr, IPA_IP_v6); + } + } + } + } + break; + + case IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT: + { + ipacm_event_data_all *data = (ipacm_event_data_all *)param; + ipa_interface_index = iface_ipa_index_query(data->if_index); + if (ipa_interface_index == ipa_if_num) + { + IPACMDBG_H("Received IPA_NEIGH_CLIENT_IP_ADDR_ADD_EVENT\n"); + if (handle_wlan_client_ipaddr(data) == IPACM_FAILURE) + { + return; + } + + handle_wlan_client_route_rule(data->mac_addr, data->iptype); + if (data->iptype == IPA_IP_v4) + { + /* Add NAT rules after ipv4 RT rules are set */ + CtList->HandleNeighIpAddrAddEvt(data); + //Nat_App->ResetPwrSaveIf(data->ipv4_addr); + } + } + } + break; + + /* handle software routing enable event, iface will update softwarerouting_act to true*/ + case IPA_SW_ROUTING_ENABLE: + IPACMDBG_H("Received IPA_SW_ROUTING_ENABLE\n"); + IPACM_Iface::handle_software_routing_enable(); + break; + + /* handle software routing disable event, iface will update softwarerouting_act to false*/ + case IPA_SW_ROUTING_DISABLE: + IPACMDBG_H("Received IPA_SW_ROUTING_DISABLE\n"); + IPACM_Iface::handle_software_routing_disable(); + break; + + case IPA_WLAN_SWITCH_TO_SCC: + IPACMDBG_H("Received IPA_WLAN_SWITCH_TO_SCC\n"); + if(ip_type == IPA_IP_MAX) + { + handle_SCC_MCC_switch(IPA_IP_v4); + handle_SCC_MCC_switch(IPA_IP_v6); + } + else + { + handle_SCC_MCC_switch(ip_type); + } + eth_bridge_post_event(IPA_ETH_BRIDGE_WLAN_SCC_MCC_SWITCH, IPA_IP_MAX, NULL, NULL, NULL); + break; + + case IPA_WLAN_SWITCH_TO_MCC: + IPACMDBG_H("Received IPA_WLAN_SWITCH_TO_MCC\n"); + if(ip_type == IPA_IP_MAX) + { + handle_SCC_MCC_switch(IPA_IP_v4); + handle_SCC_MCC_switch(IPA_IP_v6); + } + else + { + handle_SCC_MCC_switch(ip_type); + } + eth_bridge_post_event(IPA_ETH_BRIDGE_WLAN_SCC_MCC_SWITCH, IPA_IP_MAX, NULL, NULL, NULL); + break; + + case IPA_CRADLE_WAN_MODE_SWITCH: + { + IPACMDBG_H("Received IPA_CRADLE_WAN_MODE_SWITCH event.\n"); + ipacm_event_cradle_wan_mode* wan_mode = (ipacm_event_cradle_wan_mode*)param; + if(wan_mode == NULL) + { + IPACMERR("Event data is empty.\n"); + return; + } + + if(wan_mode->cradle_wan_mode == BRIDGE) + { + handle_cradle_wan_mode_switch(true); + } + else + { + handle_cradle_wan_mode_switch(false); + } + } + break; + case IPA_CFG_CHANGE_EVENT: + { + IPACMDBG_H("Received IPA_CFG_CHANGE_EVENT event for %s with new wlan-mode: %s old wlan-mode: %s\n", + IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].iface_name, + (IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].wlan_mode == 0) ? "full" : "internet", + (m_is_guest_ap == true) ? "internet" : "full"); + /* Add Natting iface to IPACM_Config if there is Rx/Tx property */ + if (rx_prop != NULL || tx_prop != NULL) + { + IPACMDBG_H(" Has rx/tx properties registered for iface %s, add for NATTING \n", dev_name); + IPACM_Iface::ipacmcfg->AddNatIfaces(dev_name); + } + + if (m_is_guest_ap == true && (IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].wlan_mode == FULL)) + { + m_is_guest_ap = false; + IPACMDBG_H("wlan mode is switched to full access mode. \n"); + eth_bridge_handle_wlan_mode_switch(); + } + else if (m_is_guest_ap == false && (IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].wlan_mode == INTERNET)) + { + m_is_guest_ap = true; + IPACMDBG_H("wlan mode is switched to internet only access mode. \n"); + eth_bridge_handle_wlan_mode_switch(); + } + else + { + IPACMDBG_H("No change in %s access mode. \n", + IPACM_Iface::ipacmcfg->iface_table[ipa_if_num].iface_name); + } + } + break; + case IPA_TETHERING_STATS_UPDATE_EVENT: + { + IPACMDBG_H("Received IPA_TETHERING_STATS_UPDATE_EVENT event.\n"); + if (IPACM_Wan::isWanUP(ipa_if_num) || IPACM_Wan::isWanUP_V6(ipa_if_num)) + { + if(IPACM_Wan::backhaul_is_sta_mode == false) /* LTE */ + { + ipa_get_data_stats_resp_msg_v01 *data = (ipa_get_data_stats_resp_msg_v01 *)param; + if (data->ipa_stats_type != QMI_IPA_STATS_TYPE_PIPE_V01) + { + IPACMERR("not valid pipe stats\n"); + return; + } + handle_tethering_stats_event(data); + }; + } + } + break; +#ifdef FEATURE_IPACM_HAL + /* WA for WLAN to clean up NAT instance during SSR */ + case IPA_SSR_NOTICE: + { + IPACMDBG_H("Received IPA_SSR_NOTICE event.\n"); + IPACM_Iface::ipacmcfg->DelNatIfaces(dev_name); // delete NAT-iface + } + break; +#endif + default: + break; + } + return; +} + +/* handle wifi client initial,copy all partial headers (tx property) */ +int IPACM_Wlan::handle_wlan_client_init_ex(ipacm_event_data_wlan_ex *data) +{ + +#define WLAN_IFACE_INDEX_LEN 2 + + int res = IPACM_SUCCESS, len = 0, i, evt_size; + char index[WLAN_IFACE_INDEX_LEN]; + struct ipa_ioc_copy_hdr sCopyHeader; + struct ipa_ioc_add_hdr *pHeaderDescriptor = NULL; + uint32_t cnt; + + /* start of adding header */ + IPACMDBG_H("Wifi client number for this iface: %d & total number of wlan clients: %d\n", + num_wifi_client,IPACM_Wlan::total_num_wifi_clients); + + if ((num_wifi_client >= IPA_MAX_NUM_WIFI_CLIENTS) || + (IPACM_Wlan::total_num_wifi_clients >= IPA_MAX_NUM_WIFI_CLIENTS)) + { + IPACMERR("Reached maximum number of wlan clients\n"); + return IPACM_FAILURE; + } + + IPACMDBG_H("Wifi client number: %d\n", num_wifi_client); + + /* add header to IPA */ + if(tx_prop != NULL) + { + len = sizeof(struct ipa_ioc_add_hdr) + (1 * sizeof(struct ipa_hdr_add)); + pHeaderDescriptor = (struct ipa_ioc_add_hdr *)calloc(1, len); + if (pHeaderDescriptor == NULL) + { + IPACMERR("calloc failed to allocate pHeaderDescriptor\n"); + return IPACM_FAILURE; + } + + evt_size = sizeof(ipacm_event_data_wlan_ex) + data->num_of_attribs * sizeof(struct ipa_wlan_hdr_attrib_val); + get_client_memptr(wlan_client, num_wifi_client)->p_hdr_info = (ipacm_event_data_wlan_ex*)malloc(evt_size); + memcpy(get_client_memptr(wlan_client, num_wifi_client)->p_hdr_info, data, evt_size); + + /* copy partial header for v4*/ + for (cnt=0; cnt<tx_prop->num_tx_props; cnt++) + { + if(tx_prop->tx[cnt].ip==IPA_IP_v4) + { + IPACMDBG_H("Got partial v4-header name from %d tx props\n", cnt); + memset(&sCopyHeader, 0, sizeof(sCopyHeader)); + memcpy(sCopyHeader.name, + tx_prop->tx[cnt].hdr_name, + sizeof(sCopyHeader.name)); + + IPACMDBG_H("header name: %s in tx:%d\n", sCopyHeader.name,cnt); + if (m_header.CopyHeader(&sCopyHeader) == false) + { + PERROR("ioctl copy header failed"); + res = IPACM_FAILURE; + goto fail; + } + + IPACMDBG_H("header length: %d, paritial: %d\n", sCopyHeader.hdr_len, sCopyHeader.is_partial); + if (sCopyHeader.hdr_len > IPA_HDR_MAX_SIZE) + { + IPACMERR("header oversize\n"); + res = IPACM_FAILURE; + goto fail; + } + else + { + memcpy(pHeaderDescriptor->hdr[0].hdr, + sCopyHeader.hdr, + sCopyHeader.hdr_len); + } + + for(i = 0; i < data->num_of_attribs; i++) + { + if(data->attribs[i].attrib_type == WLAN_HDR_ATTRIB_MAC_ADDR) + { + memcpy(get_client_memptr(wlan_client, num_wifi_client)->mac, + data->attribs[i].u.mac_addr, + sizeof(get_client_memptr(wlan_client, num_wifi_client)->mac)); + + /* copy client mac_addr to partial header */ + memcpy(&pHeaderDescriptor->hdr[0].hdr[data->attribs[i].offset], + get_client_memptr(wlan_client, num_wifi_client)->mac, + IPA_MAC_ADDR_SIZE); + /* replace src mac to bridge mac_addr if any */ + if (IPACM_Iface::ipacmcfg->ipa_bridge_enable) + { + memcpy(&pHeaderDescriptor->hdr[0].hdr[data->attribs[i].offset+IPA_MAC_ADDR_SIZE], + IPACM_Iface::ipacmcfg->bridge_mac, + IPA_MAC_ADDR_SIZE); + IPACMDBG_H("device is in bridge mode \n"); + } + + } + else if(data->attribs[i].attrib_type == WLAN_HDR_ATTRIB_STA_ID) + { + /* copy client id to header */ + memcpy(&pHeaderDescriptor->hdr[0].hdr[data->attribs[i].offset], + &data->attribs[i].u.sta_id, sizeof(data->attribs[i].u.sta_id)); + } + else + { + IPACMDBG_H("The attribute type is not expected!\n"); + } + } + + pHeaderDescriptor->commit = true; + pHeaderDescriptor->num_hdrs = 1; + + memset(pHeaderDescriptor->hdr[0].name, 0, + sizeof(pHeaderDescriptor->hdr[0].name)); + + snprintf(index,sizeof(index), "%d", ipa_if_num); + strlcpy(pHeaderDescriptor->hdr[0].name, index, sizeof(pHeaderDescriptor->hdr[0].name)); + pHeaderDescriptor->hdr[0].name[IPA_RESOURCE_NAME_MAX-1] = '\0'; + + if (strlcat(pHeaderDescriptor->hdr[0].name, IPA_WLAN_PARTIAL_HDR_NAME_v4, sizeof(pHeaderDescriptor->hdr[0].name)) > IPA_RESOURCE_NAME_MAX) + { + IPACMERR(" header name construction failed exceed length (%zu)\n", strlen(pHeaderDescriptor->hdr[0].name)); + res = IPACM_FAILURE; + goto fail; + } + snprintf(index,sizeof(index), "%d", header_name_count); + if (strlcat(pHeaderDescriptor->hdr[0].name, index, sizeof(pHeaderDescriptor->hdr[0].name)) > IPA_RESOURCE_NAME_MAX) + { + IPACMERR(" header name construction failed exceed length (%zu)\n", strlen(pHeaderDescriptor->hdr[0].name)); + res = IPACM_FAILURE; + goto fail; + } + + + pHeaderDescriptor->hdr[0].hdr_len = sCopyHeader.hdr_len; + pHeaderDescriptor->hdr[0].hdr_hdl = -1; + pHeaderDescriptor->hdr[0].is_partial = 0; + pHeaderDescriptor->hdr[0].status = -1; + + if (m_header.AddHeader(pHeaderDescriptor) == false || + pHeaderDescriptor->hdr[0].status != 0) + { + IPACMERR("ioctl IPA_IOC_ADD_HDR failed: %d\n", pHeaderDescriptor->hdr[0].status); + res = IPACM_FAILURE; + goto fail; + } + + get_client_memptr(wlan_client, num_wifi_client)->hdr_hdl_v4 = pHeaderDescriptor->hdr[0].hdr_hdl; + IPACMDBG_H("client(%d) v4 full header name:%s header handle:(0x%x)\n", + num_wifi_client, + pHeaderDescriptor->hdr[0].name, + get_client_memptr(wlan_client, num_wifi_client)->hdr_hdl_v4); + get_client_memptr(wlan_client, num_wifi_client)->ipv4_header_set=true; + break; + } + } + + /* copy partial header for v6*/ + for (cnt=0; cnt<tx_prop->num_tx_props; cnt++) + { + if(tx_prop->tx[cnt].ip==IPA_IP_v6) + { + IPACMDBG_H("Got partial v6-header name from %d tx props\n", cnt); + memset(&sCopyHeader, 0, sizeof(sCopyHeader)); + memcpy(sCopyHeader.name, + tx_prop->tx[cnt].hdr_name, + sizeof(sCopyHeader.name)); + + IPACMDBG_H("header name: %s in tx:%d\n", sCopyHeader.name,cnt); + if (m_header.CopyHeader(&sCopyHeader) == false) + { + PERROR("ioctl copy header failed"); + res = IPACM_FAILURE; + goto fail; + } + + IPACMDBG_H("header length: %d, paritial: %d\n", sCopyHeader.hdr_len, sCopyHeader.is_partial); + if (sCopyHeader.hdr_len > IPA_HDR_MAX_SIZE) + { + IPACMERR("header oversize\n"); + res = IPACM_FAILURE; + goto fail; + } + else + { + memcpy(pHeaderDescriptor->hdr[0].hdr, + sCopyHeader.hdr, + sCopyHeader.hdr_len); + } + + for(i = 0; i < data->num_of_attribs; i++) + { + if(data->attribs[i].attrib_type == WLAN_HDR_ATTRIB_MAC_ADDR) + { + memcpy(get_client_memptr(wlan_client, num_wifi_client)->mac, + data->attribs[i].u.mac_addr, + sizeof(get_client_memptr(wlan_client, num_wifi_client)->mac)); + + /* copy client mac_addr to partial header */ + memcpy(&pHeaderDescriptor->hdr[0].hdr[data->attribs[i].offset], + get_client_memptr(wlan_client, num_wifi_client)->mac, + IPA_MAC_ADDR_SIZE); + + /* replace src mac to bridge mac_addr if any */ + if (IPACM_Iface::ipacmcfg->ipa_bridge_enable) + { + memcpy(&pHeaderDescriptor->hdr[0].hdr[data->attribs[i].offset+IPA_MAC_ADDR_SIZE], + IPACM_Iface::ipacmcfg->bridge_mac, + IPA_MAC_ADDR_SIZE); + IPACMDBG_H("device is in bridge mode \n"); + } + } + else if (data->attribs[i].attrib_type == WLAN_HDR_ATTRIB_STA_ID) + { + /* copy client id to header */ + memcpy(&pHeaderDescriptor->hdr[0].hdr[data->attribs[i].offset], + &data->attribs[i].u.sta_id, sizeof(data->attribs[i].u.sta_id)); + } + else + { + IPACMDBG_H("The attribute type is not expected!\n"); + } + } + + pHeaderDescriptor->commit = true; + pHeaderDescriptor->num_hdrs = 1; + + memset(pHeaderDescriptor->hdr[0].name, 0, + sizeof(pHeaderDescriptor->hdr[0].name)); + + snprintf(index,sizeof(index), "%d", ipa_if_num); + strlcpy(pHeaderDescriptor->hdr[0].name, index, sizeof(pHeaderDescriptor->hdr[0].name)); + pHeaderDescriptor->hdr[0].name[IPA_RESOURCE_NAME_MAX-1] = '\0'; + if (strlcat(pHeaderDescriptor->hdr[0].name, IPA_WLAN_PARTIAL_HDR_NAME_v6, sizeof(pHeaderDescriptor->hdr[0].name)) > IPA_RESOURCE_NAME_MAX) + { + IPACMERR(" header name construction failed exceed length (%zu)\n", strlen(pHeaderDescriptor->hdr[0].name)); + res = IPACM_FAILURE; + goto fail; + } + + snprintf(index,sizeof(index), "%d", header_name_count); + if (strlcat(pHeaderDescriptor->hdr[0].name, index, sizeof(pHeaderDescriptor->hdr[0].name)) > IPA_RESOURCE_NAME_MAX) + { + IPACMERR(" header name construction failed exceed length (%zu)\n", strlen(pHeaderDescriptor->hdr[0].name)); + res = IPACM_FAILURE; + goto fail; + } + + pHeaderDescriptor->hdr[0].hdr_len = sCopyHeader.hdr_len; + pHeaderDescriptor->hdr[0].hdr_hdl = -1; + pHeaderDescriptor->hdr[0].is_partial = 0; + pHeaderDescriptor->hdr[0].status = -1; + + if (m_header.AddHeader(pHeaderDescriptor) == false || + pHeaderDescriptor->hdr[0].status != 0) + { + IPACMERR("ioctl IPA_IOC_ADD_HDR failed: %d\n", pHeaderDescriptor->hdr[0].status); + res = IPACM_FAILURE; + goto fail; + } + + get_client_memptr(wlan_client, num_wifi_client)->hdr_hdl_v6 = pHeaderDescriptor->hdr[0].hdr_hdl; + IPACMDBG_H("client(%d) v6 full header name:%s header handle:(0x%x)\n", + num_wifi_client, + pHeaderDescriptor->hdr[0].name, + get_client_memptr(wlan_client, num_wifi_client)->hdr_hdl_v6); + + get_client_memptr(wlan_client, num_wifi_client)->ipv6_header_set=true; + break; + } + } + + /* initialize wifi client*/ + get_client_memptr(wlan_client, num_wifi_client)->route_rule_set_v4 = false; + get_client_memptr(wlan_client, num_wifi_client)->route_rule_set_v6 = 0; + get_client_memptr(wlan_client, num_wifi_client)->ipv4_set = false; + get_client_memptr(wlan_client, num_wifi_client)->ipv6_set = 0; + get_client_memptr(wlan_client, num_wifi_client)->power_save_set=false; + num_wifi_client++; + header_name_count++; //keep increasing header_name_count + IPACM_Wlan::total_num_wifi_clients++; + res = IPACM_SUCCESS; + IPACMDBG_H("Wifi client number: %d\n", num_wifi_client); + } + else + { + return res; + } + +fail: + free(pHeaderDescriptor); + return res; +} + +/*handle wifi client */ +int IPACM_Wlan::handle_wlan_client_ipaddr(ipacm_event_data_all *data) +{ + int clnt_indx; + int v6_num; + uint32_t ipv6_link_local_prefix = 0xFE800000; + uint32_t ipv6_link_local_prefix_mask = 0xFFC00000; + + IPACMDBG_H("number of wifi clients: %d\n", num_wifi_client); + IPACMDBG_H(" event MAC %02x:%02x:%02x:%02x:%02x:%02x\n", + data->mac_addr[0], + data->mac_addr[1], + data->mac_addr[2], + data->mac_addr[3], + data->mac_addr[4], + data->mac_addr[5]); + + clnt_indx = get_wlan_client_index(data->mac_addr); + + if (clnt_indx == IPACM_INVALID_INDEX) + { + IPACMERR("wlan client not found/attached \n"); + return IPACM_FAILURE; + } + + IPACMDBG_H("Ip-type received %d\n", data->iptype); + if (data->iptype == IPA_IP_v4) + { + IPACMDBG_H("ipv4 address: 0x%x\n", data->ipv4_addr); + if (data->ipv4_addr != 0) /* not 0.0.0.0 */ + { + if (get_client_memptr(wlan_client, clnt_indx)->ipv4_set == false) + { + get_client_memptr(wlan_client, clnt_indx)->v4_addr = data->ipv4_addr; + get_client_memptr(wlan_client, clnt_indx)->ipv4_set = true; + } + else + { + /* check if client got new IPv4 address*/ + if(data->ipv4_addr == get_client_memptr(wlan_client, clnt_indx)->v4_addr) + { + IPACMDBG_H("Already setup ipv4 addr for client:%d, ipv4 address didn't change\n", clnt_indx); + return IPACM_FAILURE; + } + else + { + IPACMDBG_H("ipv4 addr for client:%d is changed \n", clnt_indx); + /* delete NAT rules first */ + CtList->HandleNeighIpAddrDelEvt(get_client_memptr(wlan_client, clnt_indx)->v4_addr); + delete_default_qos_rtrules(clnt_indx,IPA_IP_v4); + get_client_memptr(wlan_client, clnt_indx)->route_rule_set_v4 = false; + get_client_memptr(wlan_client, clnt_indx)->v4_addr = data->ipv4_addr; + } + } + } + else + { + IPACMDBG_H("Invalid client IPv4 address \n"); + return IPACM_FAILURE; + } + } + else + { + if ((data->ipv6_addr[0] != 0) || (data->ipv6_addr[1] != 0) || + (data->ipv6_addr[2] != 0) || (data->ipv6_addr[3] != 0)) /* check if all 0 not valid ipv6 address */ + { + IPACMDBG_H("ipv6 address: 0x%x:%x:%x:%x\n", data->ipv6_addr[0], data->ipv6_addr[1], data->ipv6_addr[2], data->ipv6_addr[3]); + if( (data->ipv6_addr[0] & ipv6_link_local_prefix_mask) != (ipv6_link_local_prefix & ipv6_link_local_prefix_mask) && + memcmp(ipv6_prefix, data->ipv6_addr, sizeof(ipv6_prefix)) != 0) + { + IPACMDBG_H("This IPv6 address is not global IPv6 address with correct prefix, ignore.\n"); + IPACMDBG_H("ipv6 address: 0x%x:%x ipv6_prefix0x%x:%x\n", data->ipv6_addr[0], data->ipv6_addr[1], ipv6_prefix[0], ipv6_prefix[1]); + return IPACM_FAILURE; + } + + if(get_client_memptr(wlan_client, clnt_indx)->ipv6_set < IPV6_NUM_ADDR) + { + + for(v6_num=0;v6_num < get_client_memptr(wlan_client, clnt_indx)->ipv6_set;v6_num++) + { + if( data->ipv6_addr[0] == get_client_memptr(wlan_client, clnt_indx)->v6_addr[v6_num][0] && + data->ipv6_addr[1] == get_client_memptr(wlan_client, clnt_indx)->v6_addr[v6_num][1] && + data->ipv6_addr[2]== get_client_memptr(wlan_client, clnt_indx)->v6_addr[v6_num][2] && + data->ipv6_addr[3] == get_client_memptr(wlan_client, clnt_indx)->v6_addr[v6_num][3]) + { + IPACMDBG_H("Already see this ipv6 addr for client:%d\n", clnt_indx); + return IPACM_FAILURE; /* not setup the RT rules*/ + break; + } + } + + /* not see this ipv6 before for wifi client*/ + get_client_memptr(wlan_client, clnt_indx)->v6_addr[get_client_memptr(wlan_client, clnt_indx)->ipv6_set][0] = data->ipv6_addr[0]; + get_client_memptr(wlan_client, clnt_indx)->v6_addr[get_client_memptr(wlan_client, clnt_indx)->ipv6_set][1] = data->ipv6_addr[1]; + get_client_memptr(wlan_client, clnt_indx)->v6_addr[get_client_memptr(wlan_client, clnt_indx)->ipv6_set][2] = data->ipv6_addr[2]; + get_client_memptr(wlan_client, clnt_indx)->v6_addr[get_client_memptr(wlan_client, clnt_indx)->ipv6_set][3] = data->ipv6_addr[3]; + get_client_memptr(wlan_client, clnt_indx)->ipv6_set++; + } + else + { + IPACMDBG_H("Already got %d ipv6 addr for client:%d\n", IPV6_NUM_ADDR, clnt_indx); + return IPACM_FAILURE; /* not setup the RT rules*/ + } + } + else + { + IPACMDBG_H("IPV6 address is invalid\n"); + return IPACM_FAILURE; + } + } + + return IPACM_SUCCESS; +} + +/*handle wifi client routing rule*/ +int IPACM_Wlan::handle_wlan_client_route_rule(uint8_t *mac_addr, ipa_ip_type iptype) +{ + struct ipa_ioc_add_rt_rule *rt_rule; + struct ipa_rt_rule_add *rt_rule_entry; + uint32_t tx_index; + int wlan_index,v6_num; + const int NUM = 1; + + if(tx_prop == NULL) + { + IPACMDBG_H("No rx properties registered for iface %s\n", dev_name); + return IPACM_SUCCESS; + } + + IPACMDBG_H("Received mac_addr MAC %02x:%02x:%02x:%02x:%02x:%02x\n", + mac_addr[0], mac_addr[1], mac_addr[2], + mac_addr[3], mac_addr[4], mac_addr[5]); + + wlan_index = get_wlan_client_index(mac_addr); + if (wlan_index == IPACM_INVALID_INDEX) + { + IPACMDBG_H("wlan client not found/attached \n"); + return IPACM_SUCCESS; + } + + /* during power_save mode, even receive IP_ADDR_ADD, not setting RT rules*/ + if (get_client_memptr(wlan_client, wlan_index)->power_save_set == true) + { + IPACMDBG_H("wlan client is in power safe mode \n"); + return IPACM_SUCCESS; + } + + if (iptype==IPA_IP_v4) + { + IPACMDBG_H("wlan client index: %d, ip-type: %d, ipv4_set:%d, ipv4_rule_set:%d \n", wlan_index, iptype, + get_client_memptr(wlan_client, wlan_index)->ipv4_set, + get_client_memptr(wlan_client, wlan_index)->route_rule_set_v4); + } + else + { + IPACMDBG_H("wlan client index: %d, ip-type: %d, ipv6_set:%d, ipv6_rule_num:%d \n", wlan_index, iptype, + get_client_memptr(wlan_client, wlan_index)->ipv6_set, + get_client_memptr(wlan_client, wlan_index)->route_rule_set_v6); + } + + + /* Add default Qos routing rules if not set yet */ + if ((iptype == IPA_IP_v4 + && get_client_memptr(wlan_client, wlan_index)->route_rule_set_v4 == false + && get_client_memptr(wlan_client, wlan_index)->ipv4_set == true) + || (iptype == IPA_IP_v6 + && get_client_memptr(wlan_client, wlan_index)->route_rule_set_v6 < get_client_memptr(wlan_client, wlan_index)->ipv6_set + )) + { + rt_rule = (struct ipa_ioc_add_rt_rule *) + calloc(1, sizeof(struct ipa_ioc_add_rt_rule) + + NUM * sizeof(struct ipa_rt_rule_add)); + + if (rt_rule == NULL) + { + PERROR("Error Locate ipa_ioc_add_rt_rule memory...\n"); + return IPACM_FAILURE; + } + + rt_rule->commit = 1; + rt_rule->num_rules = (uint8_t)NUM; + rt_rule->ip = iptype; + + + for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++) + { + + if(iptype != tx_prop->tx[tx_index].ip) + { + IPACMDBG_H("Tx:%d, ip-type: %d conflict ip-type: %d no RT-rule added\n", + tx_index, tx_prop->tx[tx_index].ip,iptype); + continue; + } + + rt_rule_entry = &rt_rule->rules[0]; + rt_rule_entry->at_rear = 0; + + if (iptype == IPA_IP_v4) + { + IPACMDBG_H("client index(%d):ipv4 address: 0x%x\n", wlan_index, + get_client_memptr(wlan_client, wlan_index)->v4_addr); + + IPACMDBG_H("client(%d): v4 header handle:(0x%x)\n", + wlan_index, + get_client_memptr(wlan_client, wlan_index)->hdr_hdl_v4); + strlcpy(rt_rule->rt_tbl_name, + IPACM_Iface::ipacmcfg->rt_tbl_lan_v4.name, + sizeof(rt_rule->rt_tbl_name)); + rt_rule->rt_tbl_name[IPA_RESOURCE_NAME_MAX-1] = '\0'; + + if(IPACM_Iface::ipacmcfg->isMCC_Mode) + { + IPACMDBG_H("In MCC mode, use alt dst pipe: %d\n", + tx_prop->tx[tx_index].alt_dst_pipe); + rt_rule_entry->rule.dst = tx_prop->tx[tx_index].alt_dst_pipe; + } + else + { + rt_rule_entry->rule.dst = tx_prop->tx[tx_index].dst_pipe; + } + + memcpy(&rt_rule_entry->rule.attrib, + &tx_prop->tx[tx_index].attrib, + sizeof(rt_rule_entry->rule.attrib)); + rt_rule_entry->rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR; + rt_rule_entry->rule.hdr_hdl = get_client_memptr(wlan_client, wlan_index)->hdr_hdl_v4; + rt_rule_entry->rule.attrib.u.v4.dst_addr = get_client_memptr(wlan_client, wlan_index)->v4_addr; + rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF; +#ifdef FEATURE_IPA_V3 + rt_rule_entry->rule.hashable = false; +#endif + if (false == m_routing.AddRoutingRule(rt_rule)) + { + IPACMERR("Routing rule addition failed!\n"); + free(rt_rule); + return IPACM_FAILURE; + } + + /* copy ipv4 RT hdl */ + get_client_memptr(wlan_client, wlan_index)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v4 = + rt_rule->rules[0].rt_rule_hdl; + IPACMDBG_H("tx:%d, rt rule hdl=%x ip-type: %d\n", tx_index, + get_client_memptr(wlan_client, wlan_index)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v4, iptype); + } + else + { + for(v6_num = get_client_memptr(wlan_client, wlan_index)->route_rule_set_v6;v6_num < get_client_memptr(wlan_client, wlan_index)->ipv6_set;v6_num++) + { + IPACMDBG_H("client(%d): v6 header handle:(0x%x)\n", + wlan_index, + get_client_memptr(wlan_client, wlan_index)->hdr_hdl_v6); + + /* v6 LAN_RT_TBL */ + strlcpy(rt_rule->rt_tbl_name, + IPACM_Iface::ipacmcfg->rt_tbl_v6.name, + sizeof(rt_rule->rt_tbl_name)); + rt_rule->rt_tbl_name[IPA_RESOURCE_NAME_MAX-1] = '\0'; + /* Support QCMAP LAN traffic feature, send to A5 */ + rt_rule_entry->rule.dst = iface_query->excp_pipe; + memset(&rt_rule_entry->rule.attrib, 0, sizeof(rt_rule_entry->rule.attrib)); + rt_rule_entry->rule.hdr_hdl = 0; + rt_rule_entry->rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR; + rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = get_client_memptr(wlan_client, wlan_index)->v6_addr[v6_num][0]; + rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = get_client_memptr(wlan_client, wlan_index)->v6_addr[v6_num][1]; + rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = get_client_memptr(wlan_client, wlan_index)->v6_addr[v6_num][2]; + rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = get_client_memptr(wlan_client, wlan_index)->v6_addr[v6_num][3]; + rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF; + rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF; + rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF; + rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF; +#ifdef FEATURE_IPA_V3 + rt_rule_entry->rule.hashable = true; +#endif + if (false == m_routing.AddRoutingRule(rt_rule)) + { + IPACMERR("Routing rule addition failed!\n"); + free(rt_rule); + return IPACM_FAILURE; + } + + get_client_memptr(wlan_client, wlan_index)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6[v6_num] = rt_rule->rules[0].rt_rule_hdl; + IPACMDBG_H("tx:%d, rt rule hdl=%x ip-type: %d\n", tx_index, + get_client_memptr(wlan_client, wlan_index)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6[v6_num], iptype); + + /*Copy same rule to v6 WAN RT TBL*/ + strlcpy(rt_rule->rt_tbl_name, + IPACM_Iface::ipacmcfg->rt_tbl_wan_v6.name, + sizeof(rt_rule->rt_tbl_name)); + rt_rule->rt_tbl_name[IPA_RESOURCE_NAME_MAX-1] = '\0'; + /* Downlink traffic from Wan iface, directly through IPA */ + if(IPACM_Iface::ipacmcfg->isMCC_Mode) + { + IPACMDBG_H("In MCC mode, use alt dst pipe: %d\n", + tx_prop->tx[tx_index].alt_dst_pipe); + rt_rule_entry->rule.dst = tx_prop->tx[tx_index].alt_dst_pipe; + } + else + { + rt_rule_entry->rule.dst = tx_prop->tx[tx_index].dst_pipe; + } + memcpy(&rt_rule_entry->rule.attrib, + &tx_prop->tx[tx_index].attrib, + sizeof(rt_rule_entry->rule.attrib)); + rt_rule_entry->rule.hdr_hdl = get_client_memptr(wlan_client, wlan_index)->hdr_hdl_v6; + rt_rule_entry->rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR; + rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = get_client_memptr(wlan_client, wlan_index)->v6_addr[v6_num][0]; + rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = get_client_memptr(wlan_client, wlan_index)->v6_addr[v6_num][1]; + rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = get_client_memptr(wlan_client, wlan_index)->v6_addr[v6_num][2]; + rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = get_client_memptr(wlan_client, wlan_index)->v6_addr[v6_num][3]; + rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF; + rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF; + rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF; + rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF; +#ifdef FEATURE_IPA_V3 + rt_rule_entry->rule.hashable = true; +#endif + if (false == m_routing.AddRoutingRule(rt_rule)) + { + IPACMERR("Routing rule addition failed!\n"); + free(rt_rule); + return IPACM_FAILURE; + } + + get_client_memptr(wlan_client, wlan_index)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6_wan[v6_num] = rt_rule->rules[0].rt_rule_hdl; + + IPACMDBG_H("tx:%d, rt rule hdl=%x ip-type: %d\n", tx_index, + get_client_memptr(wlan_client, wlan_index)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6_wan[v6_num], iptype); + } + } + + } /* end of for loop */ + + free(rt_rule); + + if (iptype == IPA_IP_v4) + { + get_client_memptr(wlan_client, wlan_index)->route_rule_set_v4 = true; + } + else + { + get_client_memptr(wlan_client, wlan_index)->route_rule_set_v6 = get_client_memptr(wlan_client, wlan_index)->ipv6_set; + } + } + + return IPACM_SUCCESS; +} + +/*handle wifi client power-save mode*/ +int IPACM_Wlan::handle_wlan_client_pwrsave(uint8_t *mac_addr) +{ + int clt_indx; + IPACMDBG_H("wlan->handle_wlan_client_pwrsave();\n"); + + clt_indx = get_wlan_client_index(mac_addr); + if (clt_indx == IPACM_INVALID_INDEX) + { + IPACMDBG_H("wlan client not attached\n"); + return IPACM_SUCCESS; + } + + if (get_client_memptr(wlan_client, clt_indx)->power_save_set == false) + { + /* First reset nat rules and then route rules */ + if(get_client_memptr(wlan_client, clt_indx)->ipv4_set == true) + { + IPACMDBG_H("Deleting Nat Rules\n"); + Nat_App->UpdatePwrSaveIf(get_client_memptr(wlan_client, clt_indx)->v4_addr); + } + + IPACMDBG_H("Deleting default qos Route Rules\n"); + delete_default_qos_rtrules(clt_indx, IPA_IP_v4); + delete_default_qos_rtrules(clt_indx, IPA_IP_v6); + get_client_memptr(wlan_client, clt_indx)->power_save_set = true; + } + else + { + IPACMDBG_H("wlan client already in power-save mode\n"); + } + return IPACM_SUCCESS; +} + +/*handle wifi client del mode*/ +int IPACM_Wlan::handle_wlan_client_down_evt(uint8_t *mac_addr) +{ + int clt_indx; + uint32_t tx_index; + int num_wifi_client_tmp = num_wifi_client; + int num_v6; + + IPACMDBG_H("total client: %d\n", num_wifi_client_tmp); + + clt_indx = get_wlan_client_index(mac_addr); + if (clt_indx == IPACM_INVALID_INDEX) + { + IPACMDBG_H("wlan client not attached\n"); + return IPACM_SUCCESS; + } + + /* First reset nat rules and then route rules */ + if(get_client_memptr(wlan_client, clt_indx)->ipv4_set == true) + { + IPACMDBG_H("Clean Nat Rules for ipv4:0x%x\n", get_client_memptr(wlan_client, clt_indx)->v4_addr); + CtList->HandleNeighIpAddrDelEvt(get_client_memptr(wlan_client, clt_indx)->v4_addr); + } + + if (delete_default_qos_rtrules(clt_indx, IPA_IP_v4)) + { + IPACMERR("unbale to delete v4 default qos route rules for index: %d\n", clt_indx); + return IPACM_FAILURE; + } + + if (delete_default_qos_rtrules(clt_indx, IPA_IP_v6)) + { + IPACMERR("unbale to delete v6 default qos route rules for indexn: %d\n", clt_indx); + return IPACM_FAILURE; + } + + /* Delete wlan client header */ + if(get_client_memptr(wlan_client, clt_indx)->ipv4_header_set == true) + { + if (m_header.DeleteHeaderHdl(get_client_memptr(wlan_client, clt_indx)->hdr_hdl_v4) + == false) + { + return IPACM_FAILURE; + } + get_client_memptr(wlan_client, clt_indx)->ipv4_header_set = false; + } + + if(get_client_memptr(wlan_client, clt_indx)->ipv6_header_set == true) + { + if (m_header.DeleteHeaderHdl(get_client_memptr(wlan_client, clt_indx)->hdr_hdl_v6) + == false) + { + return IPACM_FAILURE; + } + get_client_memptr(wlan_client, clt_indx)->ipv6_header_set = false; + } + + /* Reset ip_set to 0*/ + get_client_memptr(wlan_client, clt_indx)->ipv4_set = false; + get_client_memptr(wlan_client, clt_indx)->ipv6_set = 0; + get_client_memptr(wlan_client, clt_indx)->ipv4_header_set = false; + get_client_memptr(wlan_client, clt_indx)->ipv6_header_set = false; + get_client_memptr(wlan_client, clt_indx)->route_rule_set_v4 = false; + get_client_memptr(wlan_client, clt_indx)->route_rule_set_v6 = 0; + free(get_client_memptr(wlan_client, clt_indx)->p_hdr_info); + + for (; clt_indx < num_wifi_client_tmp - 1; clt_indx++) + { + get_client_memptr(wlan_client, clt_indx)->p_hdr_info = get_client_memptr(wlan_client, (clt_indx + 1))->p_hdr_info; + + memcpy(get_client_memptr(wlan_client, clt_indx)->mac, + get_client_memptr(wlan_client, (clt_indx + 1))->mac, + sizeof(get_client_memptr(wlan_client, clt_indx)->mac)); + + get_client_memptr(wlan_client, clt_indx)->hdr_hdl_v4 = get_client_memptr(wlan_client, (clt_indx + 1))->hdr_hdl_v4; + get_client_memptr(wlan_client, clt_indx)->hdr_hdl_v6 = get_client_memptr(wlan_client, (clt_indx + 1))->hdr_hdl_v6; + get_client_memptr(wlan_client, clt_indx)->v4_addr = get_client_memptr(wlan_client, (clt_indx + 1))->v4_addr; + + get_client_memptr(wlan_client, clt_indx)->ipv4_set = get_client_memptr(wlan_client, (clt_indx + 1))->ipv4_set; + get_client_memptr(wlan_client, clt_indx)->ipv6_set = get_client_memptr(wlan_client, (clt_indx + 1))->ipv6_set; + get_client_memptr(wlan_client, clt_indx)->ipv4_header_set = get_client_memptr(wlan_client, (clt_indx + 1))->ipv4_header_set; + get_client_memptr(wlan_client, clt_indx)->ipv6_header_set = get_client_memptr(wlan_client, (clt_indx + 1))->ipv6_header_set; + + get_client_memptr(wlan_client, clt_indx)->route_rule_set_v4 = get_client_memptr(wlan_client, (clt_indx + 1))->route_rule_set_v4; + get_client_memptr(wlan_client, clt_indx)->route_rule_set_v6 = get_client_memptr(wlan_client, (clt_indx + 1))->route_rule_set_v6; + + for(num_v6=0;num_v6< get_client_memptr(wlan_client, clt_indx)->ipv6_set;num_v6++) + { + get_client_memptr(wlan_client, clt_indx)->v6_addr[num_v6][0] = get_client_memptr(wlan_client, (clt_indx + 1))->v6_addr[num_v6][0]; + get_client_memptr(wlan_client, clt_indx)->v6_addr[num_v6][1] = get_client_memptr(wlan_client, (clt_indx + 1))->v6_addr[num_v6][1]; + get_client_memptr(wlan_client, clt_indx)->v6_addr[num_v6][2] = get_client_memptr(wlan_client, (clt_indx + 1))->v6_addr[num_v6][2]; + get_client_memptr(wlan_client, clt_indx)->v6_addr[num_v6][3] = get_client_memptr(wlan_client, (clt_indx + 1))->v6_addr[num_v6][3]; + } + + for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++) + { + get_client_memptr(wlan_client, clt_indx)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v4 = + get_client_memptr(wlan_client, (clt_indx + 1))->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v4; + + for(num_v6=0;num_v6< get_client_memptr(wlan_client, clt_indx)->route_rule_set_v6;num_v6++) + { + get_client_memptr(wlan_client, clt_indx)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6[num_v6] = + get_client_memptr(wlan_client, (clt_indx + 1))->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6[num_v6]; + get_client_memptr(wlan_client, clt_indx)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6_wan[num_v6] = + get_client_memptr(wlan_client, (clt_indx + 1))->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6_wan[num_v6]; + } + } + } + + IPACMDBG_H(" %d wifi client deleted successfully \n", num_wifi_client); + num_wifi_client = num_wifi_client - 1; + IPACM_Wlan::total_num_wifi_clients = IPACM_Wlan::total_num_wifi_clients - 1; + IPACMDBG_H(" Number of wifi client: %d\n", num_wifi_client); + + return IPACM_SUCCESS; +} + +/*handle wlan iface down event*/ +int IPACM_Wlan::handle_down_evt() +{ + int res = IPACM_SUCCESS, num_private_subnet_fl_rule; + uint32_t i; + num_private_subnet_fl_rule = 0; + + IPACMDBG_H("WLAN ip-type: %d \n", ip_type); + /* no iface address up, directly close iface*/ + if (ip_type == IPACM_IP_NULL) + { + IPACMERR("Invalid iptype: 0x%x\n", ip_type); + goto fail; + } + + /* delete wan filter rule */ + if (IPACM_Wan::isWanUP(ipa_if_num) && rx_prop != NULL) + { + IPACMDBG_H("LAN IF goes down, backhaul type %d\n", IPACM_Wan::backhaul_is_sta_mode); + IPACM_Lan::handle_wan_down(IPACM_Wan::backhaul_is_sta_mode); +#ifdef FEATURE_IPA_ANDROID + /* Clean-up tethered-iface list */ + IPACM_Wan::delete_tether_iface(IPA_IP_v4, ipa_if_num); +#endif + } + + if (IPACM_Wan::isWanUP_V6(ipa_if_num) && rx_prop != NULL) + { + IPACMDBG_H("LAN IF goes down, backhaul type %d\n", IPACM_Wan::backhaul_is_sta_mode); + handle_wan_down_v6(IPACM_Wan::backhaul_is_sta_mode); +#ifdef FEATURE_IPA_ANDROID + /* Clean-up tethered-iface list */ + IPACM_Wan::delete_tether_iface(IPA_IP_v6, ipa_if_num); +#endif + } + IPACMDBG_H("finished deleting wan filtering rules\n "); + + /* Delete v4 filtering rules */ + if (ip_type != IPA_IP_v6 && rx_prop != NULL) + { + /* delete IPv4 icmp filter rules */ + if(m_filtering.DeleteFilteringHdls(ipv4_icmp_flt_rule_hdl, IPA_IP_v4, NUM_IPV4_ICMP_FLT_RULE) == false) + { + IPACMERR("Error Deleting ICMPv4 Filtering Rule, aborting...\n"); + res = IPACM_FAILURE; + goto fail; + } + IPACM_Iface::ipacmcfg->decreaseFltRuleCount(rx_prop->rx[0].src_pipe, IPA_IP_v4, NUM_IPV4_ICMP_FLT_RULE); + if (dft_v4fl_rule_hdl[0] != 0) + { + if (m_filtering.DeleteFilteringHdls(dft_v4fl_rule_hdl, IPA_IP_v4, IPV4_DEFAULT_FILTERTING_RULES) == false) + { + IPACMERR("Error Deleting Filtering Rule, aborting...\n"); + res = IPACM_FAILURE; + goto fail; + } + IPACM_Iface::ipacmcfg->decreaseFltRuleCount(rx_prop->rx[0].src_pipe, IPA_IP_v4, IPV4_DEFAULT_FILTERTING_RULES); + IPACMDBG_H("Deleted default v4 filter rules successfully.\n"); + } + /* delete private-ipv4 filter rules */ +#ifdef FEATURE_IPA_ANDROID + if(m_filtering.DeleteFilteringHdls(private_fl_rule_hdl, IPA_IP_v4, IPA_MAX_PRIVATE_SUBNET_ENTRIES) == false) + { + IPACMERR("Error deleting private subnet IPv4 flt rules.\n"); + res = IPACM_FAILURE; + goto fail; + } + IPACM_Iface::ipacmcfg->decreaseFltRuleCount(rx_prop->rx[0].src_pipe, IPA_IP_v4, IPA_MAX_PRIVATE_SUBNET_ENTRIES); +#else + num_private_subnet_fl_rule = IPACM_Iface::ipacmcfg->ipa_num_private_subnet > IPA_MAX_PRIVATE_SUBNET_ENTRIES? + IPA_MAX_PRIVATE_SUBNET_ENTRIES : IPACM_Iface::ipacmcfg->ipa_num_private_subnet; + if(m_filtering.DeleteFilteringHdls(private_fl_rule_hdl, IPA_IP_v4, num_private_subnet_fl_rule) == false) + { + IPACMERR("Error deleting private subnet flt rules, aborting...\n"); + res = IPACM_FAILURE; + goto fail; + } + IPACM_Iface::ipacmcfg->decreaseFltRuleCount(rx_prop->rx[0].src_pipe, IPA_IP_v4, num_private_subnet_fl_rule); +#endif + IPACMDBG_H("Deleted private subnet v4 filter rules successfully.\n"); + } + + /* Delete v6 filtering rules */ + if (ip_type != IPA_IP_v4 && rx_prop != NULL) + { + /* delete icmp filter rules */ + if(m_filtering.DeleteFilteringHdls(ipv6_icmp_flt_rule_hdl, IPA_IP_v6, NUM_IPV6_ICMP_FLT_RULE) == false) + { + IPACMERR("Error Deleting ICMPv6 Filtering Rule, aborting...\n"); + res = IPACM_FAILURE; + goto fail; + } + IPACM_Iface::ipacmcfg->decreaseFltRuleCount(rx_prop->rx[0].src_pipe, IPA_IP_v6, NUM_IPV6_ICMP_FLT_RULE); + + if (dft_v6fl_rule_hdl[0] != 0) + { + if (m_filtering.DeleteFilteringHdls(dft_v6fl_rule_hdl, IPA_IP_v6, IPV6_DEFAULT_FILTERTING_RULES) == false) + { + IPACMERR("Error Adding RuleTable(1) to Filtering, aborting...\n"); + res = IPACM_FAILURE; + goto fail; + } + IPACM_Iface::ipacmcfg->decreaseFltRuleCount(rx_prop->rx[0].src_pipe, IPA_IP_v6, IPV6_DEFAULT_FILTERTING_RULES); + IPACMDBG_H("Deleted default v6 filter rules successfully.\n"); + } + } + IPACMDBG_H("finished delete filtering rules\n "); + + /* Delete default v4 RT rule */ + if (ip_type != IPA_IP_v6) + { + IPACMDBG_H("Delete default v4 routing rules\n"); + if (m_routing.DeleteRoutingHdl(dft_rt_rule_hdl[0], IPA_IP_v4) + == false) + { + IPACMERR("Routing rule deletion failed!\n"); + res = IPACM_FAILURE; + goto fail; + } + } + + /* Delete default v6 RT rule */ + if (ip_type != IPA_IP_v4) + { + IPACMDBG_H("Delete default v6 routing rules\n"); + /* May have multiple ipv6 iface-RT rules */ + for (i = 0; i < 2*num_dft_rt_v6; i++) + { + if (m_routing.DeleteRoutingHdl(dft_rt_rule_hdl[MAX_DEFAULT_v4_ROUTE_RULES+i], IPA_IP_v6) + == false) + { + IPACMERR("Routing rule deletion failed!\n"); + res = IPACM_FAILURE; + goto fail; + } + } + } + IPACMDBG_H("finished deleting default RT rules\n "); + + eth_bridge_post_event(IPA_ETH_BRIDGE_IFACE_DOWN, IPA_IP_MAX, NULL, NULL, NULL); + + /* free the wlan clients cache */ + IPACMDBG_H("Free wlan clients cache\n"); + + /* Delete private subnet*/ +#ifdef FEATURE_IPA_ANDROID + if (ip_type != IPA_IP_v6) + { + IPACMDBG_H("current IPACM private subnet_addr number(%d)\n", IPACM_Iface::ipacmcfg->ipa_num_private_subnet); + IPACMDBG_H(" Delete IPACM private subnet_addr as: 0x%x \n", if_ipv4_subnet); + if(IPACM_Iface::ipacmcfg->DelPrivateSubnet(if_ipv4_subnet, ipa_if_num) == false) + { + IPACMERR(" can't Delete IPACM private subnet_addr as: 0x%x \n", if_ipv4_subnet); + } + } + /* reset the IPA-client pipe enum */ +#ifdef FEATURE_IPACM_HAL + handle_tethering_client(true, IPACM_CLIENT_MAX); +#else + handle_tethering_client(true, IPACM_CLIENT_WLAN); +#endif +#endif /* defined(FEATURE_IPA_ANDROID)*/ + +fail: + /* clean wifi-client header, routing rules */ + /* clean wifi client rule*/ + IPACMDBG_H("left %d wifi clients need to be deleted \n ", num_wifi_client); + for (i = 0; i < num_wifi_client; i++) + { + /* First reset nat rules and then route rules */ + if(get_client_memptr(wlan_client, i)->ipv4_set == true) + { + IPACMDBG_H("Clean Nat Rules for ipv4:0x%x\n", get_client_memptr(wlan_client, i)->v4_addr); + CtList->HandleNeighIpAddrDelEvt(get_client_memptr(wlan_client, i)->v4_addr); + } + + if (delete_default_qos_rtrules(i, IPA_IP_v4)) + { + IPACMERR("unbale to delete v4 default qos route rules for index: %d\n", i); + res = IPACM_FAILURE; + } + + if (delete_default_qos_rtrules(i, IPA_IP_v6)) + { + IPACMERR("unbale to delete v6 default qos route rules for index: %d\n", i); + res = IPACM_FAILURE; + } + + IPACMDBG_H("Delete %d client header\n", num_wifi_client); + + if(get_client_memptr(wlan_client, i)->ipv4_header_set == true) + { + if (m_header.DeleteHeaderHdl(get_client_memptr(wlan_client, i)->hdr_hdl_v4) + == false) + { + res = IPACM_FAILURE; + } + } + + if(get_client_memptr(wlan_client, i)->ipv6_header_set == true) + { + if (m_header.DeleteHeaderHdl(get_client_memptr(wlan_client, i)->hdr_hdl_v6) + == false) + { + res = IPACM_FAILURE; + } + } + } /* end of for loop */ + + /* check software routing fl rule hdl */ + if (softwarerouting_act == true && rx_prop != NULL ) + { + IPACMDBG_H("Delete sw routing filtering rules\n"); + IPACM_Iface::handle_software_routing_disable(); + } + IPACMDBG_H("finished delete software-routing filtering rules\n "); + + /* Delete corresponding ipa_rm_resource_name of RX-endpoint after delete all IPV4V6 FT-rule */ + if (rx_prop != NULL) + { + IPACMDBG_H("dev %s add producer dependency\n", dev_name); + IPACMDBG_H("depend Got pipe %d rm index : %d \n", rx_prop->rx[0].src_pipe, IPACM_Iface::ipacmcfg->ipa_client_rm_map_tbl[rx_prop->rx[0].src_pipe]); + IPACM_Iface::ipacmcfg->DelRmDepend(IPACM_Iface::ipacmcfg->ipa_client_rm_map_tbl[rx_prop->rx[0].src_pipe]); + free(rx_prop); + } + + for (i = 0; i < num_wifi_client; i++) + { + if(get_client_memptr(wlan_client, i)->p_hdr_info != NULL) + { + free(get_client_memptr(wlan_client, i)->p_hdr_info); + } + } + if(wlan_client != NULL) + { + free(wlan_client); + } + if (tx_prop != NULL) + { + free(tx_prop); + } + + if (iface_query != NULL) + { + free(iface_query); + } + + is_active = false; + post_del_self_evt(); + + return res; +} + +/*handle reset wifi-client rt-rules */ +int IPACM_Wlan::handle_wlan_client_reset_rt(ipa_ip_type iptype) +{ + uint32_t i; + int res = IPACM_SUCCESS; + + /* clean wifi-client routing rules */ + IPACMDBG_H("left %d wifi clients to reset ip-type(%d) rules \n ", num_wifi_client, iptype); + + for (i = 0; i < num_wifi_client; i++) + { + /* Reset RT rules */ + res = delete_default_qos_rtrules(i, iptype); + if (res != IPACM_SUCCESS) + { + IPACMERR("Failed to delete old iptype(%d) rules.\n", iptype); + return res; + } + + /* Reset ip-address */ + if(iptype == IPA_IP_v4) + { + get_client_memptr(wlan_client, i)->ipv4_set = false; + } + else + { + get_client_memptr(wlan_client, i)->ipv6_set = 0; + } + } /* end of for loop */ + return res; +} + +void IPACM_Wlan::handle_SCC_MCC_switch(ipa_ip_type iptype) +{ + struct ipa_ioc_mdfy_rt_rule *rt_rule = NULL; + struct ipa_rt_rule_mdfy *rt_rule_entry; + uint32_t tx_index; + int wlan_index, v6_num; + const int NUM = 1; + int num_wifi_client_tmp = IPACM_Wlan::num_wifi_client; + bool isAdded = false; + + if (tx_prop == NULL) + { + IPACMDBG_H("No rx properties registered for iface %s\n", dev_name); + return; + } + + if (rt_rule == NULL) + { + rt_rule = (struct ipa_ioc_mdfy_rt_rule *) + calloc(1, sizeof(struct ipa_ioc_mdfy_rt_rule) + + NUM * sizeof(struct ipa_rt_rule_mdfy)); + + if (rt_rule == NULL) + { + PERROR("Error Locate ipa_ioc_mdfy_rt_rule memory...\n"); + return; + } + + rt_rule->commit = 0; + rt_rule->num_rules = NUM; + rt_rule->ip = iptype; + } + rt_rule_entry = &rt_rule->rules[0]; + + /* modify ipv4 routing rule */ + if (iptype == IPA_IP_v4) + { + for (wlan_index = 0; wlan_index < num_wifi_client_tmp; wlan_index++) + { + IPACMDBG_H("wlan client index: %d, ip-type: %d, ipv4_set:%d, ipv4_rule_set:%d \n", + wlan_index, iptype, + get_client_memptr(wlan_client, wlan_index)->ipv4_set, + get_client_memptr(wlan_client, wlan_index)->route_rule_set_v4); + + if (get_client_memptr(wlan_client, wlan_index)->power_save_set == true || + get_client_memptr(wlan_client, wlan_index)->route_rule_set_v4 == false) + { + IPACMDBG_H("client %d route rules not set\n", wlan_index); + continue; + } + + IPACMDBG_H("Modify client %d route rule\n", wlan_index); + for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++) + { + if (iptype != tx_prop->tx[tx_index].ip) + { + IPACMDBG_H("Tx:%d, ip-type: %d ip-type not matching: %d ignore\n", + tx_index, tx_prop->tx[tx_index].ip, iptype); + continue; + } + + IPACMDBG_H("client index(%d):ipv4 address: 0x%x\n", wlan_index, + get_client_memptr(wlan_client, wlan_index)->v4_addr); + + IPACMDBG_H("client(%d): v4 header handle:(0x%x)\n", + wlan_index, + get_client_memptr(wlan_client, wlan_index)->hdr_hdl_v4); + + if (IPACM_Iface::ipacmcfg->isMCC_Mode) + { + IPACMDBG_H("In MCC mode, use alt dst pipe: %d\n", + tx_prop->tx[tx_index].alt_dst_pipe); + rt_rule_entry->rule.dst = tx_prop->tx[tx_index].alt_dst_pipe; + } + else + { + rt_rule_entry->rule.dst = tx_prop->tx[tx_index].dst_pipe; + } + + memcpy(&rt_rule_entry->rule.attrib, + &tx_prop->tx[tx_index].attrib, + sizeof(rt_rule_entry->rule.attrib)); + + rt_rule_entry->rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR; + rt_rule_entry->rule.hdr_hdl = get_client_memptr(wlan_client, wlan_index)->hdr_hdl_v4; + + rt_rule_entry->rule.attrib.u.v4.dst_addr = get_client_memptr(wlan_client, wlan_index)->v4_addr; + rt_rule_entry->rule.attrib.u.v4.dst_addr_mask = 0xFFFFFFFF; + + IPACMDBG_H("tx:%d, rt rule hdl=%x ip-type: %d\n", tx_index, + get_client_memptr(wlan_client, wlan_index)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v4, iptype); + + rt_rule_entry->rt_rule_hdl = + get_client_memptr(wlan_client, wlan_index)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v4; + + if (false == m_routing.ModifyRoutingRule(rt_rule)) + { + IPACMERR("Routing rule modify failed!\n"); + free(rt_rule); + return; + } + isAdded = true; + } + + } + } + + /* modify ipv6 routing rule */ + if (iptype == IPA_IP_v6) + { + for (wlan_index = 0; wlan_index < num_wifi_client_tmp; wlan_index++) + { + + IPACMDBG_H("wlan client index: %d, ip-type: %d, ipv6_set:%d, ipv6_rule_num:%d \n", wlan_index, iptype, + get_client_memptr(wlan_client, wlan_index)->ipv6_set, + get_client_memptr(wlan_client, wlan_index)->route_rule_set_v6); + + if (get_client_memptr(wlan_client, wlan_index)->power_save_set == true || + (get_client_memptr(wlan_client, wlan_index)->route_rule_set_v6 < + get_client_memptr(wlan_client, wlan_index)->ipv6_set) ) + { + IPACMDBG_H("client %d route rules not set\n", wlan_index); + continue; + } + + IPACMDBG_H("Modify client %d route rule\n", wlan_index); + for (tx_index = 0; tx_index < iface_query->num_tx_props; tx_index++) + { + if (iptype != tx_prop->tx[tx_index].ip) + { + IPACMDBG_H("Tx:%d, ip-type: %d ip-type not matching: %d Ignore\n", + tx_index, tx_prop->tx[tx_index].ip, iptype); + continue; + } + + for (v6_num = get_client_memptr(wlan_client, wlan_index)->route_rule_set_v6; + v6_num < get_client_memptr(wlan_client, wlan_index)->ipv6_set; + v6_num++) + { + + IPACMDBG_H("client(%d): v6 header handle:(0x%x)\n", + wlan_index, + get_client_memptr(wlan_client, wlan_index)->hdr_hdl_v6); + + if (IPACM_Iface::ipacmcfg->isMCC_Mode) + { + IPACMDBG_H("In MCC mode, use alt dst pipe: %d\n", + tx_prop->tx[tx_index].alt_dst_pipe); + rt_rule_entry->rule.dst = tx_prop->tx[tx_index].alt_dst_pipe; + } + else + { + rt_rule_entry->rule.dst = tx_prop->tx[tx_index].dst_pipe; + } + + memcpy(&rt_rule_entry->rule.attrib, + &tx_prop->tx[tx_index].attrib, + sizeof(rt_rule_entry->rule.attrib)); + + rt_rule_entry->rule.hdr_hdl = get_client_memptr(wlan_client, wlan_index)->hdr_hdl_v6; + rt_rule_entry->rule.attrib.attrib_mask |= IPA_FLT_DST_ADDR; + + rt_rule_entry->rule.attrib.u.v6.dst_addr[0] = get_client_memptr(wlan_client, wlan_index)->v6_addr[v6_num][0]; + rt_rule_entry->rule.attrib.u.v6.dst_addr[1] = get_client_memptr(wlan_client, wlan_index)->v6_addr[v6_num][1]; + rt_rule_entry->rule.attrib.u.v6.dst_addr[2] = get_client_memptr(wlan_client, wlan_index)->v6_addr[v6_num][2]; + rt_rule_entry->rule.attrib.u.v6.dst_addr[3] = get_client_memptr(wlan_client, wlan_index)->v6_addr[v6_num][3]; + rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[0] = 0xFFFFFFFF; + rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[1] = 0xFFFFFFFF; + rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[2] = 0xFFFFFFFF; + rt_rule_entry->rule.attrib.u.v6.dst_addr_mask[3] = 0xFFFFFFFF; + + rt_rule_entry->rt_rule_hdl = + get_client_memptr(wlan_client, wlan_index)->wifi_rt_hdl[tx_index].wifi_rt_rule_hdl_v6_wan[v6_num]; + + if (false == m_routing.ModifyRoutingRule(rt_rule)) + { + IPACMERR("Routing rule modify failed!\n"); + free(rt_rule); + return; + } + isAdded = true; + } + } + + } + } + + + if (isAdded) + { + if (false == m_routing.Commit(iptype)) + { + IPACMERR("Routing rule modify commit failed!\n"); + free(rt_rule); + return; + } + + IPACMDBG("Routing rule modified successfully \n"); + } + + if(rt_rule) + { + free(rt_rule); + } + return; +} + +void IPACM_Wlan::eth_bridge_handle_wlan_mode_switch() +{ + uint32_t i; + + /* ====== post events to mimic WLAN interface goes down/up when AP mode is changing ====== */ + + /* first post IFACE_DOWN event */ + eth_bridge_post_event(IPA_ETH_BRIDGE_IFACE_DOWN, IPA_IP_MAX, NULL, NULL, NULL); + + /* then post IFACE_UP event */ + if(ip_type == IPA_IP_v4 || ip_type == IPA_IP_MAX) + { + eth_bridge_post_event(IPA_ETH_BRIDGE_IFACE_UP, IPA_IP_v4, NULL, NULL, NULL); + } + if(ip_type == IPA_IP_v6 || ip_type == IPA_IP_MAX) + { + eth_bridge_post_event(IPA_ETH_BRIDGE_IFACE_UP, IPA_IP_v6, NULL, NULL, NULL); + } + + /* at last post CLIENT_ADD event */ + for(i = 0; i < num_wifi_client; i++) + { + eth_bridge_post_event(IPA_ETH_BRIDGE_CLIENT_ADD, IPA_IP_MAX, + get_client_memptr(wlan_client, i)->mac, NULL, NULL); + } + + return; +} + +bool IPACM_Wlan::is_guest_ap() +{ + return m_is_guest_ap; +} |