| /* |
| * Copyright (c) 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. |
| */ |
| |
| #include "sync.h" |
| |
| #define LOG_TAG "WifiHAL" |
| |
| #include <utils/Log.h> |
| |
| #include "wifi_hal.h" |
| #include "common.h" |
| #include "cpp_bindings.h" |
| #include "wifihal_vendorcommand.h" |
| |
| //Singleton Static Instance |
| NUDStatsCommand* NUDStatsCommand::mNUDStatsCommandInstance = NULL; |
| |
| // This function implements creation of Vendor command |
| // For NUDStats just call base Vendor command create |
| wifi_error NUDStatsCommand::create() { |
| wifi_error ret = mMsg.create(NL80211_CMD_VENDOR, 0, 0); |
| if (ret != WIFI_SUCCESS) { |
| return ret; |
| } |
| // insert the oui in the msg |
| ret = mMsg.put_u32(NL80211_ATTR_VENDOR_ID, mVendor_id); |
| if (ret != WIFI_SUCCESS) |
| goto out; |
| |
| // insert the subcmd in the msg |
| ret = mMsg.put_u32(NL80211_ATTR_VENDOR_SUBCMD, mSubcmd); |
| if (ret != WIFI_SUCCESS) |
| goto out; |
| |
| out: |
| return ret; |
| } |
| |
| NUDStatsCommand::NUDStatsCommand(wifi_handle handle, int id, u32 vendor_id, u32 subcmd) |
| : WifiVendorCommand(handle, id, vendor_id, subcmd) |
| { |
| memset(&mStats, 0,sizeof(nud_stats)); |
| } |
| |
| NUDStatsCommand::~NUDStatsCommand() |
| { |
| mNUDStatsCommandInstance = NULL; |
| } |
| |
| NUDStatsCommand* NUDStatsCommand::instance(wifi_handle handle) |
| { |
| if (handle == NULL) { |
| ALOGE("Interface Handle is invalid"); |
| return NULL; |
| } |
| if (mNUDStatsCommandInstance == NULL) { |
| mNUDStatsCommandInstance = new NUDStatsCommand(handle, 0, |
| OUI_QCA, |
| QCA_NL80211_VENDOR_SUBCMD_NUD_STATS_SET); |
| return mNUDStatsCommandInstance; |
| } |
| else |
| { |
| if (handle != getWifiHandle(mNUDStatsCommandInstance->mInfo)) |
| { |
| /* upper layer must have cleaned up the handle and reinitialized, |
| so we need to update the same */ |
| ALOGE("Handle different, update the handle"); |
| mNUDStatsCommandInstance->mInfo = (hal_info *)handle; |
| } |
| } |
| return mNUDStatsCommandInstance; |
| } |
| |
| void NUDStatsCommand::setSubCmd(u32 subcmd) |
| { |
| mSubcmd = subcmd; |
| } |
| |
| wifi_error NUDStatsCommand::requestResponse() |
| { |
| return WifiCommand::requestResponse(mMsg); |
| } |
| |
| int NUDStatsCommand::handleResponse(WifiEvent &reply) |
| { |
| int status = WIFI_ERROR_NONE; |
| WifiVendorCommand::handleResponse(reply); |
| |
| // Parse the vendordata and get the attribute |
| |
| switch(mSubcmd) |
| { |
| case QCA_NL80211_VENDOR_SUBCMD_NUD_STATS_GET: |
| { |
| struct nlattr *tb_vendor[QCA_ATTR_NUD_STATS_GET_MAX + 1]; |
| nud_stats *stats = &mStats; |
| |
| memset(stats, 0, sizeof(nud_stats)); |
| nla_parse(tb_vendor, QCA_ATTR_NUD_STATS_GET_MAX, |
| (struct nlattr *)mVendorData, mDataLen, NULL); |
| |
| if (!tb_vendor[QCA_ATTR_NUD_STATS_ARP_REQ_COUNT_FROM_NETDEV]) |
| { |
| ALOGE("%s: QCA_ATTR_NUD_STATS_ARP_REQ_COUNT_FROM_NETDEV" |
| " not found", __FUNCTION__); |
| status = WIFI_ERROR_INVALID_ARGS; |
| goto cleanup; |
| } |
| stats->arp_req_count_from_netdev = nla_get_u16(tb_vendor[ |
| QCA_ATTR_NUD_STATS_ARP_REQ_COUNT_FROM_NETDEV]); |
| |
| if (!tb_vendor[QCA_ATTR_NUD_STATS_ARP_REQ_COUNT_TO_LOWER_MAC]) |
| { |
| ALOGE("%s: QCA_ATTR_NUD_STATS_ARP_REQ_COUNT_TO_LOWER_MAC" |
| " not found", __FUNCTION__); |
| status = WIFI_ERROR_INVALID_ARGS; |
| goto cleanup; |
| } |
| stats->arp_req_count_to_lower_mac = nla_get_u16(tb_vendor[ |
| QCA_ATTR_NUD_STATS_ARP_REQ_COUNT_TO_LOWER_MAC]); |
| |
| if (!tb_vendor[QCA_ATTR_NUD_STATS_ARP_REQ_RX_COUNT_BY_LOWER_MAC]) |
| { |
| ALOGE("%s: QCA_ATTR_NUD_STATS_ARP_REQ_RX_COUNT_BY_LOWER_MAC" |
| " not found", __FUNCTION__); |
| status = WIFI_ERROR_INVALID_ARGS; |
| goto cleanup; |
| } |
| stats->arp_req_rx_count_by_lower_mac = nla_get_u16(tb_vendor[ |
| QCA_ATTR_NUD_STATS_ARP_REQ_RX_COUNT_BY_LOWER_MAC]); |
| |
| if (!tb_vendor[QCA_ATTR_NUD_STATS_ARP_REQ_COUNT_TX_SUCCESS]) |
| { |
| ALOGE("%s: QCA_ATTR_NUD_STATS_ARP_REQ_COUNT_TX_SUCCESS" |
| " not found", __FUNCTION__); |
| status = WIFI_ERROR_INVALID_ARGS; |
| goto cleanup; |
| } |
| stats->arp_req_count_tx_success = nla_get_u16(tb_vendor[ |
| QCA_ATTR_NUD_STATS_ARP_REQ_COUNT_TX_SUCCESS]); |
| |
| if (!tb_vendor[QCA_ATTR_NUD_STATS_ARP_RSP_RX_COUNT_BY_LOWER_MAC]) |
| { |
| ALOGE("%s: QCA_ATTR_NUD_STATS_ARP_RSP_RX_COUNT_BY_LOWER_MAC" |
| " not found", __FUNCTION__); |
| status = WIFI_ERROR_INVALID_ARGS; |
| goto cleanup; |
| } |
| stats->arp_rsp_rx_count_by_lower_mac = nla_get_u16(tb_vendor[ |
| QCA_ATTR_NUD_STATS_ARP_RSP_RX_COUNT_BY_LOWER_MAC]); |
| |
| if (!tb_vendor[QCA_ATTR_NUD_STATS_ARP_RSP_RX_COUNT_BY_UPPER_MAC]) |
| { |
| ALOGE("%s: QCA_ATTR_NUD_STATS_ARP_RSP_RX_COUNT_BY_UPPER_MAC" |
| " not found", __FUNCTION__); |
| status = WIFI_ERROR_INVALID_ARGS; |
| goto cleanup; |
| } |
| stats->arp_rsp_rx_count_by_upper_mac = nla_get_u16(tb_vendor[ |
| QCA_ATTR_NUD_STATS_ARP_RSP_RX_COUNT_BY_UPPER_MAC]); |
| |
| if (!tb_vendor[QCA_ATTR_NUD_STATS_ARP_RSP_COUNT_TO_NETDEV]) |
| { |
| ALOGE("%s: QCA_ATTR_NUD_STATS_ARP_RSP_COUNT_TO_NETDEV" |
| " not found", __FUNCTION__); |
| status = WIFI_ERROR_INVALID_ARGS; |
| goto cleanup; |
| } |
| stats->arp_rsp_count_to_netdev = nla_get_u16(tb_vendor[ |
| QCA_ATTR_NUD_STATS_ARP_RSP_COUNT_TO_NETDEV]); |
| |
| if (!tb_vendor[QCA_ATTR_NUD_STATS_ARP_RSP_COUNT_OUT_OF_ORDER_DROP]) |
| { |
| ALOGE("%s: QCA_ATTR_NUD_STATS_ARP_RSP_COUNT_OUT_OF_ORDER_DROP" |
| " not found", __FUNCTION__); |
| status = WIFI_ERROR_INVALID_ARGS; |
| goto cleanup; |
| } |
| stats->arp_rsp_count_out_of_order_drop = nla_get_u16(tb_vendor[ |
| QCA_ATTR_NUD_STATS_ARP_RSP_COUNT_OUT_OF_ORDER_DROP]); |
| |
| if (tb_vendor[QCA_ATTR_NUD_STATS_AP_LINK_ACTIVE]) |
| stats->ap_link_active = 1; |
| |
| if (tb_vendor[QCA_ATTR_NUD_STATS_IS_DAD]) |
| stats->is_duplicate_addr_detection = 1; |
| |
| ALOGV(" req_from_netdev %d count_to_lower :%d" |
| " count_by_lower :%d" |
| " count_tx_succ :%d rsp_count_lower :%d" |
| " rsp_count_upper :%d rsp_count_netdev :%d" |
| " out_of_order_drop :%d active_aplink %d" |
| " DAD %d ", |
| stats->arp_req_count_from_netdev, |
| stats->arp_req_count_to_lower_mac, |
| stats->arp_req_rx_count_by_lower_mac, |
| stats->arp_req_count_tx_success, |
| stats->arp_rsp_rx_count_by_lower_mac, |
| stats->arp_rsp_rx_count_by_upper_mac, |
| stats->arp_rsp_count_to_netdev, |
| stats->arp_rsp_count_out_of_order_drop, |
| stats->ap_link_active, |
| stats->is_duplicate_addr_detection); |
| } |
| } |
| cleanup: |
| if (status == WIFI_ERROR_INVALID_ARGS) |
| memset(&mStats,0,sizeof(nud_stats)); |
| |
| return status; |
| } |
| |
| void NUDStatsCommand::copyStats(nud_stats *stats) |
| { |
| memcpy(stats, &mStats, sizeof(nud_stats)); |
| } |
| |
| wifi_error wifi_set_nud_stats(wifi_interface_handle iface, u32 gw_addr) |
| { |
| wifi_error ret; |
| NUDStatsCommand *NUDCommand; |
| struct nlattr *nl_data; |
| interface_info *iinfo = getIfaceInfo(iface); |
| wifi_handle handle = getWifiHandle(iface); |
| |
| ALOGV("gw_addr : %x", gw_addr); |
| NUDCommand = NUDStatsCommand::instance(handle); |
| if (NUDCommand == NULL) { |
| ALOGE("%s: Error NUDStatsCommand NULL", __FUNCTION__); |
| return WIFI_ERROR_INVALID_ARGS; |
| } |
| NUDCommand->setSubCmd(QCA_NL80211_VENDOR_SUBCMD_NUD_STATS_SET); |
| |
| /* create the message */ |
| ret = NUDCommand->create(); |
| if (ret != WIFI_SUCCESS) |
| goto cleanup; |
| |
| ret = NUDCommand->set_iface_id(iinfo->name); |
| if (ret != WIFI_SUCCESS) |
| goto cleanup; |
| |
| /*add the attributes*/ |
| nl_data = NUDCommand->attr_start(NL80211_ATTR_VENDOR_DATA); |
| if (!nl_data) |
| goto cleanup; |
| /**/ |
| ret = NUDCommand->put_flag(QCA_ATTR_NUD_STATS_SET_START); |
| |
| ret = NUDCommand->put_u32(QCA_ATTR_NUD_STATS_GW_IPV4, gw_addr); |
| if (ret != WIFI_SUCCESS) |
| goto cleanup; |
| /**/ |
| NUDCommand->attr_end(nl_data); |
| |
| ret = NUDCommand->requestResponse(); |
| if (ret != WIFI_SUCCESS) { |
| ALOGE("%s: requestResponse Error:%d",__FUNCTION__, ret); |
| } |
| |
| cleanup: |
| return ret; |
| } |
| |
| |
| wifi_error wifi_get_nud_stats(wifi_interface_handle iface, |
| nud_stats *stats) |
| { |
| wifi_error ret; |
| NUDStatsCommand *NUDCommand; |
| struct nlattr *nl_data; |
| interface_info *iinfo = getIfaceInfo(iface); |
| wifi_handle handle = getWifiHandle(iface); |
| |
| if (stats == NULL) { |
| ALOGE("%s: Error stats is NULL", __FUNCTION__); |
| return WIFI_ERROR_INVALID_ARGS; |
| } |
| |
| NUDCommand = NUDStatsCommand::instance(handle); |
| if (NUDCommand == NULL) { |
| ALOGE("%s: Error NUDStatsCommand NULL", __FUNCTION__); |
| return WIFI_ERROR_INVALID_ARGS; |
| } |
| NUDCommand->setSubCmd(QCA_NL80211_VENDOR_SUBCMD_NUD_STATS_GET); |
| |
| /* create the message */ |
| ret = NUDCommand->create(); |
| if (ret != WIFI_SUCCESS) |
| goto cleanup; |
| |
| ret = NUDCommand->set_iface_id(iinfo->name); |
| if (ret != WIFI_SUCCESS) |
| goto cleanup; |
| /*add the attributes*/ |
| nl_data = NUDCommand->attr_start(NL80211_ATTR_VENDOR_DATA); |
| if (!nl_data) |
| goto cleanup; |
| /**/ |
| NUDCommand->attr_end(nl_data); |
| |
| ret = NUDCommand->requestResponse(); |
| if (ret != WIFI_SUCCESS) { |
| ALOGE("%s: requestResponse Error:%d",__FUNCTION__, ret); |
| goto cleanup; |
| } |
| |
| NUDCommand->copyStats(stats); |
| |
| cleanup: |
| return ret; |
| } |
| |
| |
| wifi_error wifi_clear_nud_stats(wifi_interface_handle iface) |
| { |
| wifi_error ret; |
| NUDStatsCommand *NUDCommand; |
| struct nlattr *nl_data; |
| interface_info *iinfo = getIfaceInfo(iface); |
| wifi_handle handle = getWifiHandle(iface); |
| |
| NUDCommand = NUDStatsCommand::instance(handle); |
| if (NUDCommand == NULL) { |
| ALOGE("%s: Error NUDStatsCommand NULL", __FUNCTION__); |
| return WIFI_ERROR_INVALID_ARGS; |
| } |
| NUDCommand->setSubCmd(QCA_NL80211_VENDOR_SUBCMD_NUD_STATS_SET); |
| |
| /* create the message */ |
| ret = NUDCommand->create(); |
| if (ret != WIFI_SUCCESS) |
| goto cleanup; |
| |
| ret = NUDCommand->set_iface_id(iinfo->name); |
| if (ret != WIFI_SUCCESS) |
| goto cleanup; |
| |
| /*add the attributes*/ |
| nl_data = NUDCommand->attr_start(NL80211_ATTR_VENDOR_DATA); |
| if (!nl_data) |
| goto cleanup; |
| |
| NUDCommand->attr_end(nl_data); |
| |
| ret = NUDCommand->requestResponse(); |
| if (ret != WIFI_SUCCESS) |
| ALOGE("%s: requestResponse Error:%d",__FUNCTION__, ret); |
| |
| cleanup: |
| return ret; |
| } |
