diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile index 7005476a41..0493bcd02f 100644 --- a/.devcontainer/Dockerfile +++ b/.devcontainer/Dockerfile @@ -13,13 +13,13 @@ RUN apt-get update \ # Install C++ tools && apt-get -y install build-essential cmake cppcheck valgrind \ # Libraries - libjson-c-dev python-yaml libzmq3-dev libssl-dev \ + libjson-c-dev python-yaml python3-yaml libzmq3-dev libssl-dev \ libncurses-dev libreadline-dev libnl-3-dev libnl-route-3-dev libnl-genl-3-dev \ # Install Helper tools bash-completion locales ninja-build pkg-config shellcheck \ flake8 clang-format vim \ # Network capturing - tcpdump openssh-server + tcpdump tshark wireshark-common openssh-server # Install podman RUN echo "deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/xUbuntu_$(lsb_release -sr)/ /" \ diff --git a/.mergify.yml b/.mergify.yml index 06b02b686b..e71849589b 100644 --- a/.mergify.yml +++ b/.mergify.yml @@ -5,7 +5,6 @@ pull_request_rules: - "#changes-requested-reviews-by=0" # Changes requested blocks the merge - "label=ready for merge" # Must have ready for merge label - "label!=don't merge" # Don't merge label blocks the merge - - "#status-failure=0" # Just to be sure that we don't consider it as passed when the status checks haven't even # started yet. - "#status-success>=3" diff --git a/.vscode/launch.json b/.vscode/launch.json index 2781aaaa6d..beff1b83f6 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -53,10 +53,10 @@ } }, { - "name": "(gdb) GATEWAY - Attach to beerocks_monitor", + "name": "(gdb) GATEWAY - Attach to beerocks_fronthaul", "type": "cppdbg", "request": "attach", - "program": "${workspaceFolder}/build/install/bin/beerocks_monitor", + "program": "${workspaceFolder}/build/install/bin/beerocks_fronthaul", "processId": "${command:pickRemoteProcess}", "pipeTransport": { "pipeCwd": "${workspaceRoot}", @@ -125,10 +125,10 @@ } }, { - "name": "(gdb) REPEATER #1 - Attach to beerocks_monitor", + "name": "(gdb) REPEATER #1 - Attach to beerocks_fronthaul", "type": "cppdbg", "request": "attach", - "program": "${workspaceFolder}/build/install/bin/beerocks_monitor", + "program": "${workspaceFolder}/build/install/bin/beerocks_fronthaul", "processId": "${command:pickRemoteProcess}", "pipeTransport": { "pipeCwd": "${workspaceRoot}", @@ -173,10 +173,10 @@ } }, { - "name": "(gdb) REPEATER #2 - Attach to beerocks_monitor", + "name": "(gdb) REPEATER #2 - Attach to beerocks_fronthaul", "type": "cppdbg", "request": "attach", - "program": "${workspaceFolder}/build/install/bin/beerocks_monitor", + "program": "${workspaceFolder}/build/install/bin/beerocks_fronthaul", "processId": "${command:pickRemoteProcess}", "pipeTransport": { "pipeCwd": "${workspaceRoot}", diff --git a/agent/src/beerocks/slave/CMakeLists.txt b/agent/src/beerocks/slave/CMakeLists.txt index 72d6752d78..eda458d175 100644 --- a/agent/src/beerocks/slave/CMakeLists.txt +++ b/agent/src/beerocks/slave/CMakeLists.txt @@ -11,6 +11,7 @@ file(GLOB beerocks_agent_sources ${MODULE_PATH}/link_metrics/*.c* ${MODULE_PATH}/platform_manager/*.c* ${MODULE_PATH}/gate/*.c* + ${MODULE_PATH}/backhaul_manager/internal/*.c* ${MODULE_PATH}/*.c* ) diff --git a/agent/src/beerocks/slave/backhaul_manager/backhaul_manager_thread.cpp b/agent/src/beerocks/slave/backhaul_manager/backhaul_manager_thread.cpp index 7a57169f5e..20d7f24dbf 100644 --- a/agent/src/beerocks/slave/backhaul_manager/backhaul_manager_thread.cpp +++ b/agent/src/beerocks/slave/backhaul_manager/backhaul_manager_thread.cpp @@ -29,19 +29,17 @@ */ #include "backhaul_manager_thread.h" - #include "../link_metrics/ieee802_11_link_metrics_collector.h" #include "../link_metrics/ieee802_3_link_metrics_collector.h" #include "../tlvf_utils.h" - +#include "internal/expected_ap_metrics_response.h" #include #include -#include - #include #include #include #include +#include /* * TODO: @@ -50,7 +48,7 @@ */ #include #include -#include +#include #include #include #include @@ -523,7 +521,7 @@ void backhaul_manager::after_select(bool timeout) // and send a Topology Notification message. bool neighbors_list_changed = false; for (auto it = m_1905_neighbor_devices.begin(); it != m_1905_neighbor_devices.end();) { - const auto &last_topology_discovery = it->second; + const auto &last_topology_discovery = it->second.timestamp; if (last_topology_discovery + std::chrono::seconds(DISCOVERY_NEIGHBOUR_REMOVAL_TIMEOUT) < std::chrono::steady_clock::now()) { const auto &device_al_mac = it->first; @@ -1025,21 +1023,16 @@ bool backhaul_manager::backhaul_fsm_main(bool &skip_select) for (const auto &socket : slaves_sockets) { if (socket) { for (int i = 0; i < beerocks::IFACE_TOTAL_VAPS; ++i) { - if (socket->vaps_list.vaps[i].mac != network_utils::ZERO_MAC) { + if ((socket->vaps_list.vaps[i].mac != network_utils::ZERO_MAC) && + (socket->vaps_list.vaps[i].ssid[0] != '\0')) { bssid_list.push_back(socket->vaps_list.vaps[i].mac); } } } } - // We must generate a new MID for the periodic AP Metrics Response messages that - // do not correspond to an AP Metrics Query message. - // We cannot set MID to 0 here because we must also differentiate periodic - // AP Metrics Response messages and messages received from monitor thread - // due to channel utilization crossed configured threshold value. - // As a temporary solution, set MID to UINT16_MAX here. - // TODO: to be fixed as part of #1328 + if (!bssid_list.empty()) { - send_slave_ap_metric_query_message(UINT16_MAX, bssid_list); + send_slave_ap_metric_query_message(0, bssid_list); } else { LOG(DEBUG) << "Skipping AP_METRICS_QUERY for slave, empty BSSID list"; } @@ -1120,26 +1113,59 @@ bool backhaul_manager::backhaul_fsm_main(bool &skip_select) bool backhaul_manager::send_1905_topology_discovery_message() { + // TODO: get the list of interfaces that are up_and_running using the event-driven mechanism + // to be implemented in #866 + + /** + * Transmission type of Topology Discovery message is 'neighbor multicast'. + * That is, the CMDU must be transmitted once on each and every of its 1905.1 interfaces. + * Also, according to IEEE1905.1, the message should include a MAC Address TLV which contains + * the address of the interface on which the message is sent. Thus, a different message should + * be sent on each interface. + */ + auto ifaces = network_utils::linux_get_iface_list_from_bridge(m_sConfig.bridge_iface); + for (const auto &iface_name : ifaces) { + if (!network_utils::linux_iface_is_up_and_running(iface_name)) { + continue; + } + + send_1905_topology_discovery_message(iface_name); + } + + return true; +} + +bool backhaul_manager::send_1905_topology_discovery_message(const std::string &iface_name) +{ + sMacAddr iface_mac; + if (!get_iface_mac(iface_name, iface_mac)) { + return false; + } + auto cmdu_hdr = cmdu_tx.create(0, ieee1905_1::eMessageType::TOPOLOGY_DISCOVERY_MESSAGE); if (!cmdu_hdr) { LOG(ERROR) << "Failed to create TOPOLOGY_DISCOVERY_MESSAGE cmdu"; return false; } - auto tlvAlMac = cmdu_tx.addClass(); - if (!tlvAlMac) { - LOG(ERROR) << "Failed to create tlvAlMacAddressType tlv"; + + auto tlvAlMacAddress = cmdu_tx.addClass(); + if (!tlvAlMacAddress) { + LOG(ERROR) << "Failed to create tlvAlMacAddress tlv"; return false; } - tlvAlMac->mac() = tlvf::mac_from_string(bridge_info.mac); - auto tlvMac = cmdu_tx.addClass(); - if (!tlvMac) { + tlvAlMacAddress->mac() = tlvf::mac_from_string(bridge_info.mac); + + auto tlvMacAddress = cmdu_tx.addClass(); + if (!tlvMacAddress) { LOG(ERROR) << "Failed to create tlvMacAddress tlv"; return false; } - tlvMac->mac() = tlvf::mac_from_string(bridge_info.mac); + tlvMacAddress->mac() = iface_mac; - LOG(DEBUG) << "send_1905_topology_discovery_message, bridge_mac=" << bridge_info.mac; - return send_cmdu_to_bus(cmdu_tx, network_utils::MULTICAST_1905_MAC_ADDR, bridge_info.mac); + LOG(DEBUG) << "send_1905_topology_discovery_message, bridge_mac=" << bridge_info.mac + << ", iface=" << iface_name; + return send_cmdu_to_bus(cmdu_tx, network_utils::MULTICAST_1905_MAC_ADDR, bridge_info.mac, + iface_name); } bool backhaul_manager::send_autoconfig_search_message(std::shared_ptr soc) @@ -1162,12 +1188,12 @@ bool backhaul_manager::send_autoconfig_search_message(std::shared_ptr(); - if (!tlvAlMacAddressType) { - LOG(ERROR) << "addClass ieee1905_1::tlvAlMacAddressType failed"; + auto tlvAlMacAddress = cmdu_tx.addClass(); + if (!tlvAlMacAddress) { + LOG(ERROR) << "addClass ieee1905_1::tlvAlMacAddress failed"; return false; } - tlvf::mac_from_string(tlvAlMacAddressType->mac().oct, bridge_info.mac); + tlvf::mac_from_string(tlvAlMacAddress->mac().oct, bridge_info.mac); auto tlvSearchedRole = cmdu_tx.addClass(); if (!tlvSearchedRole) { @@ -1235,51 +1261,101 @@ bool backhaul_manager::send_autoconfig_search_message(std::shared_ptr &bssid_list) { - bool ret = false; + // save mid and clear previous query + m_expected_ap_metrics_response.reset_to_new_mid(mid); + + // compare two mac addresses using thier hash values + auto mac_comp = [](const sMacAddr &addr1, const sMacAddr &addr2) -> bool { + return std::hash()(addr1) < std::hash()(addr2); + }; + + // sort the given bssid list + std::vector given_bssid_list = bssid_list; + std::sort(given_bssid_list.begin(), given_bssid_list.end(), mac_comp); + + // debug + LOG(DEBUG) << "given bssid list for current socket, " << given_bssid_list.size() + << " bssids:" << '\n'; + for (auto &bssid : given_bssid_list) { + LOG(DEBUG) << bssid << '\n'; + } + // end debug + + // for each socket - send only relevant bssids + auto ret = false; for (auto socket : slaves_sockets) { - for (const auto &mac : bssid_list) { - int i = 0; - if (mac == socket->vaps_list.vaps[i].mac) { - LOG(DEBUG) << "Forwarding AP_METRICS_QUERY_MESSAGE message to son_slave, bssid: " - << std::hex << tlvf::mac_to_string(mac); - - auto forward = - cmdu_tx.create(mid, ieee1905_1::eMessageType::AP_METRICS_QUERY_MESSAGE); - if (!forward) { - LOG(ERROR) << "Failed to create AP_METRICS_QUERY_MESSAGE"; - return false; - } - auto query = cmdu_tx.addClass(); - if (!query) { - LOG(ERROR) << "Failed addClass"; - return false; - } + // create the message to forward to current slaves + auto forward = cmdu_tx.create(mid, ieee1905_1::eMessageType::AP_METRICS_QUERY_MESSAGE); + if (!forward) { + LOG(ERROR) << "Failed to create AP_METRICS_QUERY_MESSAGE"; + return false; + } - if (!query->alloc_bssid_list(1)) { - LOG(ERROR) << "Failed allocate memory for bssid_list"; - return false; - } + // copy current vaps bssid + std::vector current_socket_bssids; + std::transform(socket->vaps_list.vaps, socket->vaps_list.vaps + beerocks::IFACE_TOTAL_VAPS, + std::back_inserter(current_socket_bssids), + [](const beerocks_message::sVapInfo &vap_info) { return vap_info.mac; }); - auto list = query->bssid_list(0); - std::get<0>(list) = true; - std::get<1>(list) = mac; + // sort current vaps bssid + std::sort(current_socket_bssids.begin(), current_socket_bssids.end(), mac_comp); - if (!message_com::send_cmdu(socket->slave, cmdu_tx)) { - LOG(ERROR) << "Failed forwarding AP_METRICS_QUERY_MESSAGE message to son_slave"; - ret = false; - continue; - } else { - ret = true; - // Fill a query vector - m_ap_metric_query.push_back({socket->slave, mac}); - } - } + // fill a list of the common bssids: given list with current vaps + std::vector required_bssids; + std::set_intersection(given_bssid_list.begin(), given_bssid_list.end(), + current_socket_bssids.begin(), current_socket_bssids.end(), + std::back_inserter(required_bssids), mac_comp); + + // debug + LOG(DEBUG) << "bssid list for current socket, " << required_bssids.size() + << " bssids:" << '\n'; + for (auto &bssid : required_bssids) { + LOG(DEBUG) << bssid << '\n'; + } + // end debug + + if (required_bssids.empty()) { + // skip if there is nothing to do + LOG(DEBUG) << "empty required bssid list, skipping"; + continue; + } + + // add metric query tlv + auto query = cmdu_tx.addClass(); + if (!query) { + LOG(ERROR) << "Failed addClass"; + return false; + } + + // alocate memory + if (!query->alloc_bssid_list(required_bssids.size())) { + LOG(ERROR) << "Failed allocate memory for bssid_list, size: " << bssid_list.size(); + return false; + } + + int i = 0; + for (const auto &mac : required_bssids) { + auto list = query->bssid_list(i); + std::get<0>(list) = true; + std::get<1>(list) = mac; i++; } + + // save the required list + m_expected_ap_metrics_response.add_expected_bssid(required_bssids.begin(), + required_bssids.end()); + + if (!message_com::send_cmdu(socket->slave, cmdu_tx)) { + LOG(ERROR) << "Failed forwarding AP_METRICS_QUERY_MESSAGE message to son_slave"; + ret = false; + } else { + ret = true; + } } + return ret; -} +} // namespace beerocks bool backhaul_manager::backhaul_fsm_wireless(bool &skip_select) { @@ -2212,6 +2288,7 @@ bool backhaul_manager::handle_1905_1_message(ieee1905_1::CmduMessageRx &cmdu_rx, } case ieee1905_1::eMessageType::MULTI_AP_POLICY_CONFIG_REQUEST_MESSAGE: { return handle_multi_ap_policy_config_request(cmdu_rx, src_mac); + } case ieee1905_1::eMessageType::AP_METRICS_QUERY_MESSAGE: { return handle_ap_metrics_query(cmdu_rx, src_mac); } @@ -2227,7 +2304,6 @@ bool backhaul_manager::handle_1905_1_message(ieee1905_1::CmduMessageRx &cmdu_rx, return false; } } - } } bool backhaul_manager::handle_slave_1905_1_message(ieee1905_1::CmduMessageRx &cmdu_rx, const std::string &src_mac) @@ -2539,8 +2615,12 @@ bool backhaul_manager::handle_ap_capability_query(ieee1905_1::CmduMessageRx &cmd bool backhaul_manager::handle_ap_metrics_query(ieee1905_1::CmduMessageRx &cmdu_rx, const std::string &src_mac) { - std::vector bssid; - const auto mid = cmdu_rx.getMessageId(); + + const auto mid = cmdu_rx.getMessageId(); + + // save mid and erase data for previous query and response + m_expected_ap_metrics_response.reset_to_new_mid(mid); + auto ap_metric_query_tlv = cmdu_rx.getClass(); if (!ap_metric_query_tlv) { LOG(ERROR) << "AP Metrics Query CMDU mid=" << mid << " does not have AP Metric Query TLV"; @@ -2552,14 +2632,22 @@ bool backhaul_manager::handle_ap_metrics_query(ieee1905_1::CmduMessageRx &cmdu_r LOG(ERROR) << "Failed to get bssid " << bssid_idx << " from AP_METRICS_QUERY"; return false; } - bssid.push_back(std::get<1>(bssid_tuple)); + + // #1421 implementation + m_expected_ap_metrics_response.add_expected_bssid(std::get<1>(bssid_tuple)); + LOG(DEBUG) << "Received AP_METRICS_QUERY_MESSAGE, mid=" << std::hex << int(mid) << " bssid " << std::get<1>(bssid_tuple); } - if (!send_slave_ap_metric_query_message(mid, bssid)) { - LOG(ERROR) << "Failed to forward AP_METRICS_RESPONSE to the son_slave_thread"; - return false; + LOG(DEBUG) << "Forwarding AP_METRICS_QUERY_MESSAGE to all slaves, mid=" << std::hex << int(mid); + uint16_t length = message_com::get_uds_header(cmdu_rx)->length; + cmdu_rx.swap(); // swap back before forwarding + for (const auto &soc : slaves_sockets) { + if (!message_com::forward_cmdu_to_uds(soc->slave, cmdu_rx, length)) { + LOG(ERROR) << "Failed forwarding AP_METRICS_QUERY_MESSAGE message to slave: " + << tlvf::mac_to_string(soc->radio_mac); + } } return true; @@ -2569,33 +2657,23 @@ bool backhaul_manager::handle_slave_ap_metrics_response(ieee1905_1::CmduMessageR const std::string &src_mac) { auto mid = cmdu_rx.getMessageId(); - LOG(DEBUG) << "Received AP_METRICS_RESPONSE_MESSAGE, mid=" << std::hex << int(mid); - /** - * If AP Metrics Response message does not correspond to a previously received and forwarded - * AP Metrics Query message (which we know because message id is not set), then forward message - * to controller. - * This might happen when channel utilization value has crossed configured threshold or when - * periodic metrics reporting interval has elapsed. - */ - if (0 == mid) { - uint16_t length = message_com::get_uds_header(cmdu_rx)->length; - cmdu_rx.swap(); //swap back before forwarding - return send_cmdu_to_bus(cmdu_rx, controller_bridge_mac, bridge_info.mac, length); + if (m_expected_ap_metrics_response.get_mid() != mid) { + LOG(ERROR) << "Received AP_METRICS_RESPONSE_MESSAGE with bad mid: existing:" << std::hex + << m_expected_ap_metrics_response.get_mid() << " received: " << int(mid); + return false; } - /** - * When periodic metrics reporting interval has elapsed, we emulate that we have received an - * AP Metrics Query message from controller. To differentiate real queries from emulated ones, - * we use a "special" mid value. - * Note that this design is flaw as a real query might also have this special mid value. This - * is just a quick and dirty fix to pass 4.7.5 and 4.7.6 for M1 - * TODO: to be fixed as part of #1328 - */ - if (UINT16_MAX == mid) { - mid = 0; + if (mid == 0) { + LOG(DEBUG) << "AP_METRICS_RESPONSE_MESSAGE. mid is zero (0), forwarding to controller " + "unconditionaly."; + cmdu_rx.swap(); + return send_cmdu_to_bus(cmdu_rx, controller_bridge_mac, bridge_info.mac, + cmdu_rx.getMessageLength()); } + LOG(DEBUG) << "Received AP_METRICS_RESPONSE_MESSAGE, mid=" << std::hex << int(mid); + auto ap_metrics_tlv = cmdu_rx.getClass(); if (!ap_metrics_tlv) { LOG(ERROR) << "Failed cmdu_rx.getClass(), mid=" << std::hex @@ -2603,44 +2681,64 @@ bool backhaul_manager::handle_slave_ap_metrics_response(ieee1905_1::CmduMessageR return false; } - auto bssid_tlv = ap_metrics_tlv->bssid(); - auto mac = std::find_if( - m_ap_metric_query.begin(), m_ap_metric_query.end(), - [&bssid_tlv](sApMetricsQuery const &query) { return query.bssid == bssid_tlv; }); - - if (mac == m_ap_metric_query.end()) { - LOG(ERROR) << "Failed search in ap_metric_query for bssid: " << bssid_tlv + if (!m_expected_ap_metrics_response.find_expected_bssid(ap_metrics_tlv->bssid())) { + LOG(ERROR) << "Failed search in ap_metric_query for bssid: " << ap_metrics_tlv->bssid() << " from mid=" << std::hex << int(mid); return false; } - sApMetrics metric; - // Copy data to the response vector - metric.bssid = ap_metrics_tlv->bssid(); - metric.channel_utilization = ap_metrics_tlv->channel_utilization(); - metric.number_of_stas_currently_associated = + // prepare ap metrics tlv + auto &ap_metrics_tx_message = m_expected_ap_metrics_response.create_tx_message(); + auto ap_metrics_response_tlv = ap_metrics_tx_message.addClass(); + if (!ap_metrics_response_tlv) { + LOG(ERROR) << "Failed addClass"; + return false; + } + ap_metrics_response_tlv->bssid() = ap_metrics_tlv->bssid(); + ap_metrics_response_tlv->channel_utilization() = ap_metrics_tlv->channel_utilization(); + ap_metrics_response_tlv->number_of_stas_currently_associated() = ap_metrics_tlv->number_of_stas_currently_associated(); - metric.estimated_service_parameters = ap_metrics_tlv->estimated_service_parameters(); - auto info = ap_metrics_tlv->estimated_service_info_field(); + ap_metrics_response_tlv->estimated_service_parameters() = + ap_metrics_tlv->estimated_service_parameters(); + + if (!ap_metrics_response_tlv->alloc_estimated_service_info_field( + ap_metrics_tlv->estimated_service_info_field_length())) { + LOG(ERROR) << "Couldn't allocate " + "ap_metrics_response_tlv->alloc_estimated_service_info_field"; + return false; + } + auto rx_info = ap_metrics_tlv->estimated_service_info_field(); + auto tx_info = ap_metrics_response_tlv->estimated_service_info_field(); for (size_t i = 0; i < ap_metrics_tlv->estimated_service_info_field_length(); i++) { - metric.estimated_service_info_field.push_back(info[i]); + tx_info[i] = rx_info[i]; } - std::vector traffic_stats_response; + // Prepare STA Traffic Stats TLV's for (auto &sta_traffic : cmdu_rx.getClassList()) { if (!sta_traffic) { LOG(ERROR) << "Failed to get class list for tlvAssociatedStaTrafficStats"; continue; } - traffic_stats_response.push_back( - {sta_traffic->sta_mac(), sta_traffic->byte_sent(), sta_traffic->byte_recived(), - sta_traffic->packets_sent(), sta_traffic->packets_recived(), - sta_traffic->tx_packets_error(), sta_traffic->rx_packets_error(), - sta_traffic->retransmission_count()}); + auto sta_traffic_response_tlv = + ap_metrics_tx_message.addClass(); + + if (!sta_traffic_response_tlv) { + LOG(ERROR) << "Failed addClass"; + continue; + } + + sta_traffic_response_tlv->sta_mac() = sta_traffic->sta_mac(); + sta_traffic_response_tlv->byte_sent() = sta_traffic->byte_sent(); + sta_traffic_response_tlv->byte_recived() = sta_traffic->byte_recived(); + sta_traffic_response_tlv->packets_sent() = sta_traffic->packets_sent(); + sta_traffic_response_tlv->packets_recived() = sta_traffic->packets_recived(); + sta_traffic_response_tlv->tx_packets_error() = sta_traffic->tx_packets_error(); + sta_traffic_response_tlv->rx_packets_error() = sta_traffic->rx_packets_error(); + sta_traffic_response_tlv->retransmission_count() = sta_traffic->retransmission_count(); } - std::vector link_metrics_response; + // Prepare STA Link Metrics TLV's for (auto &sta_link_metric : cmdu_rx.getClassList()) { if (!sta_link_metric) { LOG(ERROR) << "Failed getClassList"; @@ -2651,98 +2749,35 @@ bool backhaul_manager::handle_slave_ap_metrics_response(ieee1905_1::CmduMessageR continue; } auto response_list = sta_link_metric->bssid_info_list(0); - link_metrics_response.push_back({sta_link_metric->sta_mac(), std::get<1>(response_list)}); - } - // Fill a response vector - m_ap_metric_response.push_back({metric, traffic_stats_response, link_metrics_response}); + auto sta_link_metric_response_tlv = + ap_metrics_tx_message.addClass(); - // Remove an entry from the processed query - m_ap_metric_query.erase( - std::remove_if(m_ap_metric_query.begin(), m_ap_metric_query.end(), - [&](sApMetricsQuery const &query) { return mac->bssid == query.bssid; }), - m_ap_metric_query.end()); - - if (!m_ap_metric_query.empty()) { - return true; - } - - // We received all responses - prepare and send response message to the controller - auto cmdu_header = cmdu_tx.create(mid, ieee1905_1::eMessageType::AP_METRICS_RESPONSE_MESSAGE); - - if (!cmdu_header) { - LOG(ERROR) << "Failed building IEEE1905 AP_METRICS_RESPONSE_MESSAGE"; - return false; - } - - // Prepare tlvApMetrics for each processed query - for (const auto &response : m_ap_metric_response) { - auto ap_metrics_response_tlv = cmdu_tx.addClass(); - if (!ap_metrics_response_tlv) { - LOG(ERROR) << "Failed addClass"; - return false; - } - - ap_metrics_response_tlv->bssid() = response.metric.bssid; - ap_metrics_response_tlv->channel_utilization() = response.metric.channel_utilization; - ap_metrics_response_tlv->number_of_stas_currently_associated() = - response.metric.number_of_stas_currently_associated; - ap_metrics_response_tlv->estimated_service_parameters() = - response.metric.estimated_service_parameters; - if (!ap_metrics_response_tlv->alloc_estimated_service_info_field( - response.metric.estimated_service_info_field.size())) { - LOG(ERROR) << "Couldn't allocate " - "ap_metrics_response_tlv->alloc_estimated_service_info_field"; - return false; + if (!sta_link_metric_response_tlv) { + LOG(ERROR) << "Failed addClass"; + continue; } - std::copy_n(response.metric.estimated_service_info_field.begin(), - response.metric.estimated_service_info_field.size(), - ap_metrics_response_tlv->estimated_service_info_field()); - - for (auto &stat : response.sta_traffic_stats) { - auto sta_traffic_response_tlv = - cmdu_tx.addClass(); - - if (!sta_traffic_response_tlv) { - LOG(ERROR) << "Failed addClass"; - continue; - } - sta_traffic_response_tlv->sta_mac() = stat.sta_mac; - sta_traffic_response_tlv->byte_sent() = stat.byte_sent; - sta_traffic_response_tlv->byte_recived() = stat.byte_recived; - sta_traffic_response_tlv->packets_sent() = stat.packets_sent; - sta_traffic_response_tlv->packets_recived() = stat.packets_recived; - sta_traffic_response_tlv->tx_packets_error() = stat.tx_packets_error; - sta_traffic_response_tlv->rx_packets_error() = stat.rx_packets_error; - sta_traffic_response_tlv->retransmission_count() = stat.retransmission_count; + sta_link_metric_response_tlv->sta_mac() = sta_link_metric->sta_mac(); + if (!sta_link_metric_response_tlv->alloc_bssid_info_list(1)) { + LOG(ERROR) << "Failed alloc_bssid_info_list"; + continue; } + auto &sta_link_metric_response = + std::get<1>(sta_link_metric_response_tlv->bssid_info_list(0)); + sta_link_metric_response = std::get<1>(response_list); + } - for (auto &link_metric : response.sta_link_metrics) { - auto sta_link_metric_response_tlv = - cmdu_tx.addClass(); - - if (!sta_link_metric_response_tlv) { - LOG(ERROR) << "Failed addClass"; - continue; - } + // remove an entry from the processed query + m_expected_ap_metrics_response.remove_expected_bssid(ap_metrics_tlv->bssid()); - sta_link_metric_response_tlv->sta_mac() = link_metric.sta_mac; - if (!sta_link_metric_response_tlv->alloc_bssid_info_list(1)) { - LOG(ERROR) << "Failed alloc_bssid_info_list"; - continue; - } - auto &sta_link_metric_response = - std::get<1>(sta_link_metric_response_tlv->bssid_info_list(0)); - sta_link_metric_response = link_metric.bssid_info; - } + // waiting for all responses before sending the response + if (!m_expected_ap_metrics_response.is_expected_bssid_empty()) { + return true; } - // Clear the m_ap_metric_response vector after preparing response to the controller - m_ap_metric_response.clear(); - LOG(DEBUG) << "Sending AP_METRICS_RESPONSE_MESSAGE, mid=" << std::hex << int(mid); - return send_cmdu_to_bus(cmdu_tx, controller_bridge_mac, bridge_info.mac); + return send_cmdu_to_bus(ap_metrics_tx_message, controller_bridge_mac, bridge_info.mac); } /** @@ -3275,9 +3310,9 @@ bool backhaul_manager::handle_1905_combined_infrastructure_metrics( bool backhaul_manager::handle_1905_topology_discovery(const std::string &src_mac, ieee1905_1::CmduMessageRx &cmdu_rx) { - auto tlvAlMac = cmdu_rx.getClass(); + auto tlvAlMac = cmdu_rx.getClass(); if (!tlvAlMac) { - LOG(ERROR) << "getClass tlvAlMacAddressType failed"; + LOG(ERROR) << "getClass tlvAlMacAddress failed"; return false; } @@ -3290,11 +3325,23 @@ bool backhaul_manager::handle_1905_topology_discovery(const std::string &src_mac LOG(INFO) << "Received TOPOLOGY_DISCOVERY_MESSAGE from AL MAC=" << tlvAlMac->mac() << ", mid=" << std::hex << int(mid); + auto tlvMac = cmdu_rx.getClass(); + if (!tlvMac) { + LOG(ERROR) << "getClass tlvMacAddress failed"; + return false; + } + auto new_device = m_1905_neighbor_devices.find(tlvAlMac->mac()) == m_1905_neighbor_devices.end(); // Add/Update the device on our list. - m_1905_neighbor_devices[tlvAlMac->mac()] = std::chrono::steady_clock::now(); + sNeighborDevice neighbor_device; + neighbor_device.al_mac = tlvAlMac->mac(); + neighbor_device.mac = tlvMac->mac(); + neighbor_device.if_index = message_com::get_uds_header(cmdu_rx)->if_index; + neighbor_device.timestamp = std::chrono::steady_clock::now(); + + m_1905_neighbor_devices[tlvAlMac->mac()] = neighbor_device; // If it is a new device, then our 1905.1 neighbors list has changed and we are required to send // Topology Notification Message. diff --git a/agent/src/beerocks/slave/backhaul_manager/backhaul_manager_thread.h b/agent/src/beerocks/slave/backhaul_manager/backhaul_manager_thread.h index e44fbc8c86..16d07988ae 100644 --- a/agent/src/beerocks/slave/backhaul_manager/backhaul_manager_thread.h +++ b/agent/src/beerocks/slave/backhaul_manager/backhaul_manager_thread.h @@ -9,6 +9,7 @@ #ifndef _BACKHAUL_MANAGER_THREAD_H #define _BACKHAUL_MANAGER_THREAD_H +#include "internal/expected_ap_metrics_response.h" #include "wan_monitor.h" #include @@ -24,6 +25,7 @@ #include #include +#include #include #include #include @@ -91,6 +93,15 @@ class backhaul_manager : public btl::transport_socket_thread { bool send_autoconfig_search_message(std::shared_ptr soc); bool send_1905_topology_discovery_message(); + + /** + * @brief Sends Topology Discovery message on given interface. + * + * @param iface_name Name of the network interface on which the message is transmitted. + * @return True on success and false otherwise + */ + bool send_1905_topology_discovery_message(const std::string &iface_name); + bool send_slave_ap_metric_query_message(uint16_t mid, std::vector const &bssid_list); // cmdu handlers @@ -454,16 +465,32 @@ class backhaul_manager : public btl::transport_socket_thread { get_neighbor_links(const sMacAddr &neighbor_mac_filter, std::map> &neighbor_links_map); + /** + * @brief 1905.1 Neighbor device information + * + * Information gathered from a neighbor device upon reception of a Topology Discovery message. + */ + struct sNeighborDevice { + sMacAddr al_mac = beerocks::net::network_utils:: + ZERO_MAC; /**< 1905.1 AL MAC address of the Topology Discovery message transmitting device. */ + sMacAddr mac = beerocks::net::network_utils:: + ZERO_MAC; /**< MAC address of the interface on which the Topology Discovery message is transmitted. */ + uint32_t if_index = + 0; /**< Index of the network interface the Topology Discovery message was received on */ + std::chrono::steady_clock::time_point + timestamp; /**< Timestamp of the last Topology Discovery message received from this neighbor device. */ + }; + /* * @brief List of known 1905 neighbor devices * * key: 1905.1 device AL-MAC - * value: Last timestamp receiving discovery message from AL-MAC + * value: 1905.1 device information * Devices are being added to the list when receiving a 1905.1 Topology Discovery message from * an unknown 1905.1 device. Every 1905.1 device shall send this message every 60 seconds, and * we update the time stamp in which the message is received. */ - std::unordered_map m_1905_neighbor_devices; + std::unordered_map m_1905_neighbor_devices; /** * @brief Adds an AP HT Capabilities TLV to AP Capability Report message. @@ -519,43 +546,7 @@ class backhaul_manager : public btl::transport_socket_thread { const sLinkNeighbor &link_neighbor, const sLinkMetrics &link_metrics, ieee1905_1::eLinkMetricsType link_metrics_type); - struct sStaTrafficStats { - sMacAddr sta_mac; - uint32_t byte_sent; - uint32_t byte_recived; - uint32_t packets_sent; - uint32_t packets_recived; - uint32_t tx_packets_error; - uint32_t rx_packets_error; - uint32_t retransmission_count; - }; - - struct sStaLinkMetrics { - sMacAddr sta_mac; - wfa_map::tlvAssociatedStaLinkMetrics::sBssidInfo bssid_info; - }; - - struct sApMetricsQuery { - Socket *soc; - sMacAddr bssid; - }; - - struct sApMetrics { - sMacAddr bssid; - uint8_t channel_utilization; - uint16_t number_of_stas_currently_associated; - wfa_map::tlvApMetrics::sEstimatedService estimated_service_parameters; - std::vector estimated_service_info_field; - }; - - struct sApMetricsResponse { - sApMetrics metric; - std::vector sta_traffic_stats; - std::vector sta_link_metrics; - }; - - std::vector m_ap_metric_query; - std::vector m_ap_metric_response; + ExpectedApMetricsResponse m_expected_ap_metrics_response; struct sChannelSelectionResponse { sMacAddr radio_mac; diff --git a/agent/src/beerocks/slave/backhaul_manager/internal/expected_ap_metrics_response.cpp b/agent/src/beerocks/slave/backhaul_manager/internal/expected_ap_metrics_response.cpp new file mode 100644 index 0000000000..940361d952 --- /dev/null +++ b/agent/src/beerocks/slave/backhaul_manager/internal/expected_ap_metrics_response.cpp @@ -0,0 +1,42 @@ + +#include "expected_ap_metrics_response.h" + +// mid +void ExpectedApMetricsResponse::reset_to_new_mid(uint16_t mid) +{ + _mid = mid; + _expected_bssid_list.clear(); + _response.reset(); + memset(_response_buffer, 0, sizeof(_response_buffer)); +} + +uint16_t ExpectedApMetricsResponse::get_mid() const { return _mid; } + +// bssid +void ExpectedApMetricsResponse::add_expected_bssid(const sMacAddr &bssid) +{ + _expected_bssid_list.insert(bssid); +} + +void ExpectedApMetricsResponse::remove_expected_bssid(const sMacAddr &bssid) +{ + _expected_bssid_list.erase(bssid); +} + +bool ExpectedApMetricsResponse::is_expected_bssid_empty() const +{ + return _expected_bssid_list.empty(); +} + +bool ExpectedApMetricsResponse::find_expected_bssid(const sMacAddr &bssid) const +{ + return _expected_bssid_list.find(bssid) != _expected_bssid_list.end(); +} + +// cmdu message +ieee1905_1::CmduMessageTx &ExpectedApMetricsResponse::create_tx_message() +{ + _response.create(_mid, ieee1905_1::eMessageType::AP_METRICS_RESPONSE_MESSAGE); + + return _response; +} diff --git a/agent/src/beerocks/slave/backhaul_manager/internal/expected_ap_metrics_response.h b/agent/src/beerocks/slave/backhaul_manager/internal/expected_ap_metrics_response.h new file mode 100644 index 0000000000..5541e4359c --- /dev/null +++ b/agent/src/beerocks/slave/backhaul_manager/internal/expected_ap_metrics_response.h @@ -0,0 +1,54 @@ +/* SPDX-License-Identifier: BSD-2-Clause-Patent + * + * SPDX-FileCopyrightText: 2016-2020 the prplMesh contributors (see AUTHORS.md) + * + * This code is subject to the terms of the BSD+Patent license. + * See LICENSE file for more details. + */ + +#ifndef _EXPECTED_AP_METRICS_RESPONSE_H +#define _EXPECTED_AP_METRICS_RESPONSE_H + +#include +#include +#include +#include +#include + +class ExpectedApMetricsResponse { +public: + /** + * @brief resets this object with a new mid + * @details resets all members of this object to its empty initial state except for the mid + * that is set as was given bt the parameter (mid default value is zero (0)) + * @param mid - the new mid value + * @return radio mac of the found slave if found, otherwise empty string + */ + void reset_to_new_mid(uint16_t mid = 0); + uint16_t get_mid() const; + ieee1905_1::CmduMessageTx &create_tx_message(); + + // bssid related operations +public: + template void add_expected_bssid(FirstIt first, LastIt last); + void add_expected_bssid(const sMacAddr &bssid); + void remove_expected_bssid(const sMacAddr &); + bool find_expected_bssid(const sMacAddr &) const; + bool is_expected_bssid_empty() const; + +private: + uint16_t _mid = 0; + std::unordered_set _expected_bssid_list; + +private: + uint8_t _response_buffer[beerocks::message::MESSAGE_BUFFER_LENGTH] = {0}; + ieee1905_1::CmduMessageTx _response = {_response_buffer, sizeof(_response_buffer)}; +}; + +template +void ExpectedApMetricsResponse::add_expected_bssid(FirstIt first, LastIt last) +{ + _expected_bssid_list.insert(first, last); +} + +#endif diff --git a/agent/src/beerocks/slave/son_slave_thread.cpp b/agent/src/beerocks/slave/son_slave_thread.cpp index 79298fe5ea..d3a6297977 100644 --- a/agent/src/beerocks/slave/son_slave_thread.cpp +++ b/agent/src/beerocks/slave/son_slave_thread.cpp @@ -24,7 +24,7 @@ #include #include -#include +#include #include #include #include @@ -3990,7 +3990,7 @@ bool slave_thread::handle_autoconfiguration_renew(Socket *sd, ieee1905_1::CmduMe { LOG(INFO) << "received autoconfig renew message"; - auto tlvAlMac = cmdu_rx.getClass(); + auto tlvAlMac = cmdu_rx.getClass(); if (tlvAlMac) { LOG(DEBUG) << "tlvAlMac=" << tlvAlMac->mac(); // TODO register/update mapping of AL-MAC to interface, cfr. #81 diff --git a/common/beerocks/bcl/include/bcl/beerocks_message_structs.h b/common/beerocks/bcl/include/bcl/beerocks_message_structs.h index 7533dfc8cf..119f5fe218 100644 --- a/common/beerocks/bcl/include/bcl/beerocks_message_structs.h +++ b/common/beerocks/bcl/include/bcl/beerocks_message_structs.h @@ -17,6 +17,7 @@ namespace beerocks { namespace message { typedef struct { + uint32_t if_index = 0; // index of the network interface the message was received on uint8_t dst_bridge_mac[net::MAC_ADDR_LEN] = {}; uint8_t src_bridge_mac[net::MAC_ADDR_LEN] = {}; uint16_t length = 0; diff --git a/common/beerocks/bcl/include/bcl/network/network_utils.h b/common/beerocks/bcl/include/bcl/network/network_utils.h index ce81205ddd..939a516a89 100644 --- a/common/beerocks/bcl/include/bcl/network/network_utils.h +++ b/common/beerocks/bcl/include/bcl/network/network_utils.h @@ -111,7 +111,14 @@ class network_utils { static std::string get_mac_from_arp_table(const std::string &ipv4); static std::vector linux_get_iface_list_from_bridge(const std::string &bridge); - static int linux_get_iface_index(const std::string &iface); + + /** + * @brief Gets the interface index corresponding to a particular name. + * + * @param iface_name The name of the network interface. + * @return interface index or 0 if no interface exists with the name given. + */ + static uint32_t linux_get_iface_index(const std::string &iface_name); static bool linux_add_iface_to_bridge(const std::string &bridge, const std::string &iface); static bool linux_remove_iface_from_bridge(const std::string &bridge, const std::string &iface); static bool linux_iface_ctrl(const std::string &iface, bool up, std::string ip = "", diff --git a/common/beerocks/bcl/source/network/network_utils.cpp b/common/beerocks/bcl/source/network/network_utils.cpp index abcacc250d..3e4277633a 100644 --- a/common/beerocks/bcl/source/network/network_utils.cpp +++ b/common/beerocks/bcl/source/network/network_utils.cpp @@ -525,9 +525,12 @@ std::vector network_utils::linux_get_iface_list_from_bridge(const s return ifs; } -int network_utils::linux_get_iface_index(const std::string &iface) +uint32_t network_utils::linux_get_iface_index(const std::string &iface_name) { - return if_nametoindex(iface.c_str()); + uint32_t iface_index = if_nametoindex(iface_name.c_str()); + LOG_IF(!iface_index, ERROR) << "Failed to read the index of interface " << iface_name << ": " + << strerror(errno); + return iface_index; } bool network_utils::linux_add_iface_to_bridge(const std::string &bridge, const std::string &iface) diff --git a/common/beerocks/btl/btl.cpp b/common/beerocks/btl/btl.cpp index 87dfc5e331..4275cb0787 100644 --- a/common/beerocks/btl/btl.cpp +++ b/common/beerocks/btl/btl.cpp @@ -40,19 +40,21 @@ void transport_socket_thread::set_select_timeout(unsigned msec) { poll_timeout_m bool transport_socket_thread::send_cmdu_to_bus(ieee1905_1::CmduMessageTx &cmdu_tx, const std::string &dst_mac, - const std::string &src_mac) + const std::string &src_mac, + const std::string &iface_name) { if (!cmdu_tx.finalize()) { THREAD_LOG(ERROR) << "finalize failed"; return false; } - return send_cmdu_to_bus(cmdu_tx, dst_mac, src_mac, cmdu_tx.getMessageLength()); + return send_cmdu_to_bus(cmdu_tx, dst_mac, src_mac, cmdu_tx.getMessageLength(), iface_name); } bool transport_socket_thread::send_cmdu_to_bus(ieee1905_1::CmduMessage &cmdu, const std::string &dst_mac, - const std::string &src_mac, uint16_t length) + const std::string &src_mac, uint16_t length, + const std::string &iface_name) { // This method should be used by Message Routers only. It is used to forward CMDU messages from UDS socket to the BUS. LOG_IF(!bus, FATAL) << "Bus is not allocated!"; @@ -68,5 +70,5 @@ bool transport_socket_thread::send_cmdu_to_bus(ieee1905_1::CmduMessage &cmdu, return false; } - return bus_send(cmdu, dst_mac, src_mac, length); + return bus_send(cmdu, iface_name, dst_mac, src_mac, length); } diff --git a/common/beerocks/btl/btl_local_bus.cpp b/common/beerocks/btl/btl_local_bus.cpp index 0bd71b308c..6ef31c595b 100644 --- a/common/beerocks/btl/btl_local_bus.cpp +++ b/common/beerocks/btl/btl_local_bus.cpp @@ -200,6 +200,7 @@ bool transport_socket_thread::handle_cmdu_message_bus() // fill UDS Header message::sUdsHeader *uds_header = (message::sUdsHeader *)rx_buffer; + uds_header->if_index = cmdu_rx_msg->metadata()->if_index; std::copy_n((uint8_t *)cmdu_rx_msg->metadata()->src, sizeof(mapf::CmduRxMessage::Metadata::src), uds_header->src_bridge_mac); std::copy_n((uint8_t *)cmdu_rx_msg->metadata()->dst, sizeof(mapf::CmduRxMessage::Metadata::dst), @@ -224,8 +225,9 @@ bool transport_socket_thread::handle_cmdu_message_bus() return true; } -bool transport_socket_thread::bus_send(ieee1905_1::CmduMessage &cmdu, const std::string &dst_mac, - const std::string &src_mac, uint16_t length) +bool transport_socket_thread::bus_send(ieee1905_1::CmduMessage &cmdu, const std::string &iface_name, + const std::string &dst_mac, const std::string &src_mac, + uint16_t length) { mapf::CmduTxMessage msg; @@ -236,6 +238,7 @@ bool transport_socket_thread::bus_send(ieee1905_1::CmduMessage &cmdu, const std: msg.metadata()->length = length; msg.metadata()->msg_type = static_cast(cmdu.getMessageType()); msg.metadata()->preset_message_id = cmdu.getMessageId() ? 1 : 0; + msg.metadata()->if_index = if_nametoindex(iface_name.c_str()); std::copy_n((uint8_t *)cmdu.getMessageBuff(), msg.metadata()->length, (uint8_t *)msg.data()); return bus->publisher().Send(msg); diff --git a/common/beerocks/btl/btl_uds.cpp b/common/beerocks/btl/btl_uds.cpp index ab2931e14f..54e327d048 100644 --- a/common/beerocks/btl/btl_uds.cpp +++ b/common/beerocks/btl/btl_uds.cpp @@ -108,8 +108,10 @@ void transport_socket_thread::bus_connected(Socket *sd) add_socket(bus); } -bool transport_socket_thread::bus_send(ieee1905_1::CmduMessage &cmdu, const std::string &dst_mac, - const std::string &src_mac, uint16_t length) +bool transport_socket_thread::bus_send(ieee1905_1::CmduMessage &cmdu, + [[gnu::unused]] const std::string &iface_name, + const std::string &dst_mac, const std::string &src_mac, + uint16_t length) { auto uds_header = message_com::get_uds_header(cmdu); if (!uds_header) { diff --git a/common/beerocks/btl/include/btl/btl.h b/common/beerocks/btl/include/btl/btl.h index 544d402ccd..6fcb9ed484 100644 --- a/common/beerocks/btl/include/btl/btl.h +++ b/common/beerocks/btl/include/btl/btl.h @@ -35,8 +35,18 @@ class transport_socket_thread : public socket_thread { virtual void set_select_timeout(unsigned msec) override; virtual bool work() override; + /** + * @brief Sends CDMU to transport for dispatching. + * + * @param cmdu Control Message Data Unit to send. + * @param dst_mac Destination MAC address. + * @param src_mac Source MAC address. + * @param iface_name Name of the network interface to use (set to empty string to send on all + * available interfaces). + * @return True on success and false otherwise. + */ bool send_cmdu_to_bus(ieee1905_1::CmduMessageTx &cmdu, const std::string &dst_mac, - const std::string &src_mac); + const std::string &src_mac, const std::string &iface_name = ""); protected: void add_socket(Socket *s, bool add_to_vector = true) override; @@ -50,13 +60,25 @@ class transport_socket_thread : public socket_thread { bool bus_connect(const std::string &beerocks_temp_path, const bool local_master); void bus_connected(Socket *sd); + /** + * @brief Sends CDMU to transport for dispatching. + * + * @param cmdu Control Message Data Unit to send. + * @param dst_mac Destination MAC address. + * @param src_mac Source MAC address. + * @param length Message length. + * @param iface_name Name of the network interface to use (set to empty string to send on all + * available interfaces). + * @return True on success and false otherwise. + */ bool send_cmdu_to_bus(ieee1905_1::CmduMessage &cmdu, const std::string &dst_mac, - const std::string &src_mac, uint16_t length); + const std::string &src_mac, uint16_t length, + const std::string &iface_name = ""); private: bool bus_init(); - bool bus_send(ieee1905_1::CmduMessage &cmdu, const std::string &dst_mac, - const std::string &src_mac, uint16_t length); + bool bus_send(ieee1905_1::CmduMessage &cmdu, const std::string &iface_name, + const std::string &dst_mac, const std::string &src_mac, uint16_t length); bool handle_cmdu_message_bus(); int poll_timeout_ms = 500; diff --git a/common/beerocks/bwl/dwpal/mon_wlan_hal_dwpal.cpp b/common/beerocks/bwl/dwpal/mon_wlan_hal_dwpal.cpp index 940f9fb61e..d38f60eace 100644 --- a/common/beerocks/bwl/dwpal/mon_wlan_hal_dwpal.cpp +++ b/common/beerocks/bwl/dwpal/mon_wlan_hal_dwpal.cpp @@ -689,9 +689,9 @@ bool mon_wlan_hal_dwpal::update_stations_stats(const std::string &vap_iface_name size_t numOfValidArgs[10] = {0}, replyLen = strnlen(reply, HOSTAPD_TO_DWPAL_MSG_LENGTH); uint64_t BytesSent = 0, BytesReceived = 0, PacketsSent = 0, PacketsReceived = 0, LastDataDownlinkRate = 0, LastDataUplinkRate = 0, Active = 0; - char ShortTermRSSIAverage[32][HOSTAPD_TO_DWPAL_VALUE_STRING_LENGTH] = {'\0'}; - char SNR[32][HOSTAPD_TO_DWPAL_VALUE_STRING_LENGTH] = {'\0'}; - FieldsToParse fieldsToParse[] = { + char ShortTermRSSIAverage[32] = {'\0'}; + char SNR[32] = {'\0'}; + FieldsToParse fieldsToParse[] = { {(void *)&BytesSent, &numOfValidArgs[0], DWPAL_LONG_LONG_INT_PARAM, "BytesSent=", 0}, {(void *)&BytesReceived, &numOfValidArgs[1], DWPAL_LONG_LONG_INT_PARAM, "BytesReceived=", 0}, @@ -699,9 +699,9 @@ bool mon_wlan_hal_dwpal::update_stations_stats(const std::string &vap_iface_name {(void *)&PacketsReceived, &numOfValidArgs[3], DWPAL_LONG_LONG_INT_PARAM, "PacketsReceived=", 0}, {(void *)&sta_stats.retrans_count, &numOfValidArgs[4], DWPAL_INT_PARAM, "RetransCount=", 0}, - {(void *)ShortTermRSSIAverage, &numOfValidArgs[5], DWPAL_STR_ARRAY_PARAM, + {(void *)ShortTermRSSIAverage, &numOfValidArgs[5], DWPAL_STR_PARAM, "ShortTermRSSIAverage=", sizeof(ShortTermRSSIAverage)}, - {(void *)SNR, &numOfValidArgs[6], DWPAL_STR_ARRAY_PARAM, "SNR=", sizeof(SNR)}, + {(void *)SNR, &numOfValidArgs[6], DWPAL_STR_PARAM, "SNR=", sizeof(SNR)}, {(void *)&Active, &numOfValidArgs[7], DWPAL_LONG_LONG_INT_PARAM, "Active=", 0}, {(void *)&LastDataDownlinkRate, &numOfValidArgs[8], DWPAL_LONG_LONG_INT_PARAM, "LastDataDownlinkRate=", 0}, @@ -738,18 +738,20 @@ bool mon_wlan_hal_dwpal::update_stations_stats(const std::string &vap_iface_name } } - //save avarage RSSI in watt - for (uint8_t i = 0; i < numOfValidArgs[5]; i++) { - float s_float = float(beerocks::string_utils::stoi(std::string(ShortTermRSSIAverage[i]))); + //save average RSSI in watt + // ShortTermRSSIAverage values are space-separated: + for (const auto &rssi : beerocks::string_utils::str_split(ShortTermRSSIAverage, ' ')) { + float s_float = float(beerocks::string_utils::stoi(std::string(rssi))); if (s_float > beerocks::RSSI_MIN) { sta_stats.rx_rssi_watt += std::pow(10, s_float / float(10)); sta_stats.rx_rssi_watt_samples_cnt++; } } - //save avarage SNR in watt - for (uint8_t i = 0; i < numOfValidArgs[6]; i++) { - float s_float = float(beerocks::string_utils::stoi(std::string(SNR[i]))); + //save average SNR in watt + // SNR values are space-separated: + for (const auto &snr : beerocks::string_utils::str_split(SNR, ' ')) { + float s_float = float(beerocks::string_utils::stoi(std::string(snr))); if (s_float > beerocks::SNR_MIN) { sta_stats.rx_snr_watt += std::pow(10, s_float / float(10)); sta_stats.rx_snr_watt_samples_cnt++; diff --git a/common/beerocks/bwl/include/bwl/mon_wlan_hal_types.h b/common/beerocks/bwl/include/bwl/mon_wlan_hal_types.h index 906e9d33c6..ea078a0b85 100644 --- a/common/beerocks/bwl/include/bwl/mon_wlan_hal_types.h +++ b/common/beerocks/bwl/include/bwl/mon_wlan_hal_types.h @@ -64,29 +64,29 @@ struct SVapStats { }; struct SStaStats { - float rx_rssi_watt; - uint8_t rx_rssi_watt_samples_cnt; - float rx_snr_watt; - uint8_t rx_snr_watt_samples_cnt; + float rx_rssi_watt = 0; + uint8_t rx_rssi_watt_samples_cnt = 0; + float rx_snr_watt = 0; + uint8_t rx_snr_watt_samples_cnt = 0; // int8_t rx_rssi_prev=beerocks::RSSI_INVALID; // int8_t rx_rssi_curr=beerocks::RSSI_INVALID; - uint16_t tx_phy_rate_100kb; + uint16_t tx_phy_rate_100kb = 0; // uint16_t tx_phy_rate_100kb_avg; // uint16_t tx_phy_rate_100kb_min; // uint16_t tx_phy_rate_100kb_acc; - uint16_t rx_phy_rate_100kb; + uint16_t rx_phy_rate_100kb = 0; // uint16_t rx_phy_rate_100kb_avg; // uint16_t rx_phy_rate_100kb_min; // uint16_t rx_phy_rate_100kb_acc; - uint64_t tx_bytes_cnt; - uint64_t rx_bytes_cnt; - uint64_t tx_packets_cnt; - uint64_t rx_packets_cnt; - uint32_t tx_packets; - uint32_t tx_bytes; - uint32_t rx_packets; - uint32_t rx_bytes; - uint32_t retrans_count; + uint64_t tx_bytes_cnt = 0; + uint64_t rx_bytes_cnt = 0; + uint64_t tx_packets_cnt = 0; + uint64_t rx_packets_cnt = 0; + uint32_t tx_packets = 0; + uint32_t tx_bytes = 0; + uint32_t rx_packets = 0; + uint32_t rx_bytes = 0; + uint32_t retrans_count = 0; // uint8_t tx_load_percent_curr=0; // uint8_t tx_load_percent_prev=0; // uint8_t rx_load_percent_curr=0; diff --git a/common/beerocks/scripts/prplmesh_utils.sh.in b/common/beerocks/scripts/prplmesh_utils.sh.in index a1d73839fb..432111949c 100755 --- a/common/beerocks/scripts/prplmesh_utils.sh.in +++ b/common/beerocks/scripts/prplmesh_utils.sh.in @@ -27,7 +27,7 @@ run() { killall_program() { PROGRAM_NAME=$1 - KILL_SIG=${2:-KILL} + KILL_SIG=${2:-TERM} echo "killing $PROGRAM_NAME ($KILL_SIG)" start-stop-daemon -K -s "$KILL_SIG" -x "$PRPLMESH_BIN_DIR"/"$PROGRAM_NAME" > /dev/null 2>&1 } @@ -246,6 +246,18 @@ stop_function() { [ "$DELETE_LOGS" = "true" ] && prplmesh_delete_logs } +execute_beerocks_command() { + dbg "Executing beerocks cli command: $*" + if [ -e $PRPLMESH_BIN_DIR/beerocks_cli ]; then + output=$(${PRPLMESH_BIN_DIR}/beerocks_cli -c "$@") + return $? + else + err "BML CLI not found" + output="" + return 1 + fi +} + # Note: Apparently on some Linux version space is added to the process name. # Therefore added "($|[[:blank:]])" to the end of the regex expression which means the end of the # line ($) or blank character ([[:blank:]]) @@ -276,21 +288,45 @@ status_function() { pgrep -l ieee1905_transport pgrep -l local_bus - # check for operational status - LOGS_PATH=@BEEROCKS_LOG_FILES_PATH@ + bridge_mac="$(ip link show dev @BEEROCKS_BRIDGE_IFACE@ | awk '/^ *link\/ether / {print $2}')" + bml_cmd="bml_get_device_operational_radios $bridge_mac" + + if pgrep -l beerocks_cont ; then + if execute_beerocks_command "$bml_cmd" ; then + # Expecting + # > OK Main radio agent operational + # > OK wlan0 radio agent operational + # > OK wlan2 radio agent operational + OK_Count=$(echo "$output" | grep -c -e "OK.*operational") + if [ "$OK_Count" -eq 3 ]; then + success "operational test success!" + exit 0 + else + err "operational test failed!" + err "$output" + exit 1 + fi + else + err "Beerocks command failed to execute!" + exit 1 + fi + else + # check for operational status + LOGS_PATH=@BEEROCKS_LOG_FILES_PATH@ - error=0 - report "Main agent operational" main_agent_operational $LOGS_PATH - report "@BEEROCKS_WLAN1_IFACE@ radio agent operational" radio_agent_operational $LOGS_PATH @BEEROCKS_WLAN1_IFACE@ - report "@BEEROCKS_WLAN2_IFACE@ radio agent operational" radio_agent_operational $LOGS_PATH @BEEROCKS_WLAN2_IFACE@ + error=0 + report "Main agent operational" main_agent_operational $LOGS_PATH + report "@BEEROCKS_WLAN1_IFACE@ radio agent operational" radio_agent_operational $LOGS_PATH @BEEROCKS_WLAN1_IFACE@ + report "@BEEROCKS_WLAN2_IFACE@ radio agent operational" radio_agent_operational $LOGS_PATH @BEEROCKS_WLAN2_IFACE@ - [ "$VERBOSE" = "true" ] && [ $error = 1 ] && { - cat $LOGS_PATH/beerocks_agent@BEEROCKS_LOG_FILES_SUFFIX@ - cat $LOGS_PATH/beerocks_agent_@BEEROCKS_WLAN1_IFACE@@BEEROCKS_LOG_FILES_SUFFIX@ - cat $LOGS_PATH/beerocks_agent_@BEEROCKS_WLAN2_IFACE@@BEEROCKS_LOG_FILES_SUFFIX@ - } + [ "$VERBOSE" = "true" ] && [ $error = 1 ] && { + cat $LOGS_PATH/beerocks_agent@BEEROCKS_LOG_FILES_SUFFIX@ + cat $LOGS_PATH/beerocks_agent_@BEEROCKS_WLAN1_IFACE@@BEEROCKS_LOG_FILES_SUFFIX@ + cat $LOGS_PATH/beerocks_agent_@BEEROCKS_WLAN2_IFACE@@BEEROCKS_LOG_FILES_SUFFIX@ + } - exit $error + exit $error + fi } usage() { diff --git a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_1905_vs.yaml b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_1905_vs.yaml index 845bc2ba34..01b3ccf0ab 100755 --- a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_1905_vs.yaml +++ b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_1905_vs.yaml @@ -1,9 +1,7 @@ # --- -_include: { - bcl/beerocks_message_structs.h, - beerocks/tlvf/beerocks_message_action.h, -} +_include: + { bcl/beerocks_message_structs.h, beerocks/tlvf/beerocks_message_action.h } _namespace: beerocks_message @@ -11,7 +9,7 @@ _multi_class: True _multi_class_auto_insert: action_op: _type: eActionOp_1905_VS - _value_const: ACTION_TLV_VENDOR_SPECIFIC + _value_const: ACTION_TLV_VENDOR_SPECIFIC _class_const: True ################################################# @@ -23,15 +21,15 @@ tlvVsClientAssociationEvent: mac: sMacAddr bssid: sMacAddr vap_id: int8_t - capabilities: + capabilities: _type: beerocks::message::sRadioCapabilities _comment: relevant only on connect event - disconnect_reason: + disconnect_reason: _type: uint8_t _comment: relevant only on disconnect event - disconnect_source: + disconnect_source: _type: uint8_t _comment: relevant only on disconnect event - disconnect_type: + disconnect_type: _type: uint8_t _comment: relevant only on disconnect event diff --git a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_action.yaml b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_action.yaml index e793c314b5..3cd129fdf0 100755 --- a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_action.yaml +++ b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_action.yaml @@ -48,7 +48,7 @@ eActionOp_CONTROL: ACTION_CONTROL_BACKHAUL_ROAM_REQUEST: 30 ACTION_CONTROL_BACKHAUL_DL_RSSI_REPORT_NOTIFICATION: 31 ACTION_CONTROL_BACKHAUL_RESET: 32 - + ACTION_CONTROL_HOSTAP_CHANNEL_SWITCH_REQUEST: 53 ACTION_CONTROL_HOSTAP_CSA_ERROR_NOTIFICATION: 54 ACTION_CONTROL_HOSTAP_CSA_NOTIFICATION: 55 @@ -79,7 +79,7 @@ eActionOp_CONTROL: ACTION_CONTROL_CLIENT_RX_RSSI_MEASUREMENT_NOTIFICATION: 106 ACTION_CONTROL_CLIENT_NO_RESPONSE_NOTIFICATION: 107 ACTION_CONTROL_CLIENT_NEW_IP_ADDRESS_NOTIFICATION: 108 - + ACTION_CONTROL_CLIENT_DISCONNECT_REQUEST: 111 ACTION_CONTROL_CLIENT_DISCONNECT_RESPONSE: 112 ACTION_CONTROL_CLIENT_DHCP_COMPLETE_NOTIFICATION: 115 @@ -98,19 +98,19 @@ eActionOp_CONTROL: ACTION_CONTROL_STEERING_CLIENT_SET_GROUP_RESPONSE: 128 ACTION_CONTROL_STEERING_CLIENT_SET_REQUEST: 129 ACTION_CONTROL_STEERING_CLIENT_SET_RESPONSE: 130 - ACTION_CONTROL_STEERING_EVENT_CLIENT_ACTIVITY_NOTIFICATION : 131 - ACTION_CONTROL_STEERING_EVENT_SNR_XING_NOTIFICATION : 132 - ACTION_CONTROL_STEERING_EVENT_PROBE_REQ_NOTIFICATION : 133 - ACTION_CONTROL_STEERING_EVENT_AUTH_FAIL_NOTIFICATION : 134 + ACTION_CONTROL_STEERING_EVENT_CLIENT_ACTIVITY_NOTIFICATION: 131 + ACTION_CONTROL_STEERING_EVENT_SNR_XING_NOTIFICATION: 132 + ACTION_CONTROL_STEERING_EVENT_PROBE_REQ_NOTIFICATION: 133 + ACTION_CONTROL_STEERING_EVENT_AUTH_FAIL_NOTIFICATION: 134 - ACTION_CONTROL_CHANNEL_SCAN_TRIGGER_SCAN_REQUEST : 140 - ACTION_CONTROL_CHANNEL_SCAN_TRIGGER_SCAN_RESPONSE : 141 + ACTION_CONTROL_CHANNEL_SCAN_TRIGGER_SCAN_REQUEST: 140 + ACTION_CONTROL_CHANNEL_SCAN_TRIGGER_SCAN_RESPONSE: 141 ACTION_CONTROL_CHANNEL_SCAN_DUMP_RESULTS_REQUEST: 142 ACTION_CONTROL_CHANNEL_SCAN_DUMP_RESULTS_RESPONSE: 143 - ACTION_CONTROL_CHANNEL_SCAN_TRIGGERED_NOTIFICATION : 144 - ACTION_CONTROL_CHANNEL_SCAN_RESULTS_NOTIFICATION : 145 - ACTION_CONTROL_CHANNEL_SCAN_ABORT_NOTIFICATION : 146 - ACTION_CONTROL_CHANNEL_SCAN_FINISHED_NOTIFICATION : 147 + ACTION_CONTROL_CHANNEL_SCAN_TRIGGERED_NOTIFICATION: 144 + ACTION_CONTROL_CHANNEL_SCAN_RESULTS_NOTIFICATION: 145 + ACTION_CONTROL_CHANNEL_SCAN_ABORT_NOTIFICATION: 146 + ACTION_CONTROL_CHANNEL_SCAN_FINISHED_NOTIFICATION: 147 ACTION_CONTROL_ENUM_END: 148 @@ -291,9 +291,9 @@ eActionOp_MONITOR: ACTION_MONITOR_HOSTAP_LOAD_MEASUREMENT_NOTIFICATION: 52 ACTION_MONITOR_HOSTAP_ACTIVITY_NOTIFICATION: 53 ACTION_MONITOR_HOSTAP_STATUS_CHANGED_NOTIFICATION: 54 - - ACTION_MONITOR_CHANNEL_SCAN_TRIGGER_SCAN_REQUEST : 60 - ACTION_MONITOR_CHANNEL_SCAN_TRIGGER_SCAN_RESPONSE : 61 + + ACTION_MONITOR_CHANNEL_SCAN_TRIGGER_SCAN_REQUEST: 60 + ACTION_MONITOR_CHANNEL_SCAN_TRIGGER_SCAN_RESPONSE: 61 ACTION_MONITOR_CHANNEL_SCAN_TRIGGERED_NOTIFICATION: 62 ACTION_MONITOR_CHANNEL_SCAN_DUMP_RESULTS_REQUEST: 63 ACTION_MONITOR_CHANNEL_SCAN_DUMP_RESULTS_RESPONSE: 64 @@ -310,7 +310,6 @@ eActionOp_MONITOR: ACTION_MONITOR_ENUM_END: 86 - #################################################### #################################################### eActionOp_CLI: @@ -343,12 +342,12 @@ eActionOp_CLI: ACTION_CLI_CLIENT_CHANNEL_LOAD_11K_REQUEST: 85 ACTION_CLI_CLIENT_BEACON_11K_REQUEST: 86 ACTION_CLI_CLIENT_STATISTICS_11K_REQUEST: 87 - + ACTION_CLI_HOSTAP_CHANNEL_SWITCH_REQUEST: 122 ACTION_CLI_HOSTAP_SET_NEIGHBOR_11K_REQUEST: 123 ACTION_CLI_HOSTAP_REMOVE_NEIGHBOR_11K_REQUEST: 124 ACTION_CLI_HOSTAP_STATS_MEASUREMENT: 125 - + ACTION_CLI_ENUM_END: 126 #################################################### @@ -404,12 +403,12 @@ eActionOp_BML: ACTION_BML_SET_SERVICE_FAIRNESS_RESPONSE: 77 ACTION_BML_GET_SERVICE_FAIRNESS_REQUEST: 78 ACTION_BML_GET_SERVICE_FAIRNESS_RESPONSE: 79 - + ACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST: 80 ACTION_BML_SET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE: 81 ACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_REQUEST: 82 ACTION_BML_GET_CLIENT_ROAMING_PREFER_SIGNAL_STRENGTH_RESPONSE: 83 - + ACTION_BML_SET_DFS_REENTRY_REQUEST: 84 ACTION_BML_SET_DFS_REENTRY_RESPONSE: 85 ACTION_BML_GET_DFS_REENTRY_REQUEST: 86 @@ -434,7 +433,7 @@ eActionOp_BML: ACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_REQUEST: 140 ACTION_BML_CHANGE_MODULE_LOGGING_LEVEL_RESPONSE: 141 - + ACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST: 150 ACTION_BML_SET_VAP_LIST_CREDENTIALS_RESPONSE: 151 ACTION_BML_GET_VAP_LIST_CREDENTIALS_REQUEST: 152 @@ -448,8 +447,8 @@ eActionOp_BML: ACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_RESPONSE: 168 ACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST: 169 ACTION_BML_STEERING_CLIENT_DISCONNECT_RESPONSE: 170 - ACTION_BML_STEERING_CLIENT_MEASURE_REQUEST : 171 - ACTION_BML_STEERING_CLIENT_MEASURE_RESPONSE : 172 + ACTION_BML_STEERING_CLIENT_MEASURE_REQUEST: 171 + ACTION_BML_STEERING_CLIENT_MEASURE_RESPONSE: 172 ACTION_BML_STEERING_EVENT_PROBE_REQ_NOTIFICATION: 178 ACTION_BML_STEERING_EVENT_CLIENT_CONNECT_NOTIFICATION: 179 @@ -458,7 +457,7 @@ eActionOp_BML: ACTION_BML_STEERING_EVENT_SNR_XING_NOTIFICATION: 182 ACTION_BML_STEERING_EVENT_SNR_NOTIFICATION: 183 ACTION_BML_STEERING_EVENT_AUTH_FAIL_NOTIFICATION: 184 - ACTION_BML_STEERING_EVENTS_UPDATE : 185 + ACTION_BML_STEERING_EVENTS_UPDATE: 185 ACTION_BML_TRIGGER_CHANNEL_SELECTION_REQUEST: 190 ACTION_BML_TRIGGER_TOPOLOGY_QUERY: 191 @@ -466,19 +465,19 @@ eActionOp_BML: ACTION_BML_REGISTER_TOPOLOGY_QUERY: 193 ACTION_BML_UNREGISTER_TOPOLOGY_QUERY: 194 - ACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_REQUEST : 200 - ACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_RESPONSE : 201 - ACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_REQUEST : 202 - ACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_RESPONSE : 203 - ACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_REQUEST : 204 - ACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_RESPONSE : 205 - ACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_REQUEST : 206 - ACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_RESPONSE : 207 - ACTION_BML_CHANNEL_SCAN_START_SCAN_REQUEST : 208 - ACTION_BML_CHANNEL_SCAN_START_SCAN_RESPONSE : 209 - ACTION_BML_CHANNEL_SCAN_GET_RESULTS_REQUEST : 210 - ACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE : 211 - ACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_REQUEST : 212 - ACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_RESPONSE : 213 + ACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_REQUEST: 200 + ACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_PARAMS_RESPONSE: 201 + ACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_REQUEST: 202 + ACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_PARAMS_RESPONSE: 203 + ACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_REQUEST: 204 + ACTION_BML_CHANNEL_SCAN_SET_CONTINUOUS_ENABLE_RESPONSE: 205 + ACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_REQUEST: 206 + ACTION_BML_CHANNEL_SCAN_GET_CONTINUOUS_ENABLE_RESPONSE: 207 + ACTION_BML_CHANNEL_SCAN_START_SCAN_REQUEST: 208 + ACTION_BML_CHANNEL_SCAN_START_SCAN_RESPONSE: 209 + ACTION_BML_CHANNEL_SCAN_GET_RESULTS_REQUEST: 210 + ACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE: 211 + ACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_REQUEST: 212 + ACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_RESPONSE: 213 ACTION_BML_ENUM_END: 214 diff --git a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_apmanager.yaml b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_apmanager.yaml index a92dbdeabd..7b0940678a 100755 --- a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_apmanager.yaml +++ b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_apmanager.yaml @@ -1,21 +1,18 @@ # --- -_include: { - beerocks/tlvf/beerocks_message_common.h, - tlvf/WSC/WSC_Attributes.h, -} +_include: { beerocks/tlvf/beerocks_message_common.h, tlvf/WSC/WSC_Attributes.h } _namespace: beerocks_message _multi_class: True _multi_class_auto_insert: action_op: _type: eActionOp_APMANAGER - _value_const: [_auto_value_by_name, 1] + _value_const: [_auto_value_by_name, 1] _class_const: True ################################################# ################################################# - + cACTION_APMANAGER_UP_NOTIFICATION: _type: class iface_name_length: @@ -38,13 +35,13 @@ cACTION_APMANAGER_JOINED_NOTIFICATION: _length_var: True preferred_channels: _type: beerocks::message::sWifiChannel - _length: [ preferred_channels_size ] + _length: [preferred_channels_size] supported_channels_size: _type: uint8_t _length_var: True supported_channels: _type: beerocks::message::sWifiChannel - _length: [ supported_channels_size ] + _length: [supported_channels_size] cACTION_APMANAGER_ENABLE_APS_REQUEST: _type: class @@ -109,7 +106,7 @@ cACTION_APMANAGER_HOSTAP_ACS_NOTIFICATION: _length_var: True preferred_channels: _type: beerocks::message::sWifiChannel - _length: [ preferred_channels_size ] + _length: [preferred_channels_size] cACTION_APMANAGER_HOSTAP_DFS_CAC_COMPLETED_NOTIFICATION: _type: class @@ -143,7 +140,7 @@ cACTION_APMANAGER_CLIENT_ASSOCIATED_NOTIFICATION: vap_id: int8_t association_frame: _type: uint8_t - _length: [] + _length: [] cACTION_APMANAGER_CLIENT_DISCONNECTED_NOTIFICATION: _type: class @@ -219,7 +216,7 @@ cACTION_APMANAGER_WIFI_CREDENTIALS_UPDATE_REQUEST: _length_var: True wifi_credentials: _type: WSC::cConfigData - _length: [ wifi_credentials_size ] + _length: [wifi_credentials_size] cACTION_APMANAGER_START_WPS_PBC_REQUEST: _type: class @@ -237,5 +234,4 @@ cACTION_APMANAGER_READ_ACS_REPORT_RESPONSE: _length_var: True preferred_channels: _type: beerocks::message::sWifiChannel - _length: [ preferred_channels_size ] - + _length: [preferred_channels_size] diff --git a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_backhaul.yaml b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_backhaul.yaml index 42257e6ced..0d1cf6b5da 100755 --- a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_backhaul.yaml +++ b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_backhaul.yaml @@ -6,7 +6,7 @@ _multi_class: True _multi_class_auto_insert: action_op: _type: eActionOp_BACKHAUL - _value_const: [_auto_value_by_name, 1] + _value_const: [_auto_value_by_name, 1] _class_const: True ################################################# @@ -16,10 +16,10 @@ cACTION_BACKHAUL_REGISTER_REQUEST: _type: class sta_iface: _type: char - _length: [ "beerocks::message::IFACE_NAME_LENGTH" ] + _length: ["beerocks::message::IFACE_NAME_LENGTH"] hostap_iface: _type: char - _length: [ "beerocks::message::IFACE_NAME_LENGTH" ] + _length: ["beerocks::message::IFACE_NAME_LENGTH"] local_master: uint8_t local_gw: uint8_t sta_iface_filter_low: uint8_t @@ -38,40 +38,40 @@ cACTION_BACKHAUL_ENABLE: iface_mac: sMacAddr wire_iface: _type: char - _length: [ "beerocks::message::IFACE_NAME_LENGTH" ] + _length: ["beerocks::message::IFACE_NAME_LENGTH"] sta_iface: _type: char - _length: [ "beerocks::message::IFACE_NAME_LENGTH" ] + _length: ["beerocks::message::IFACE_NAME_LENGTH"] ssid: _type: char - _length: [ "beerocks::message::WIFI_SSID_MAX_LENGTH" ] + _length: ["beerocks::message::WIFI_SSID_MAX_LENGTH"] pass: _type: char - _length: [ "beerocks::message::WIFI_PASS_MAX_LENGTH" ] + _length: ["beerocks::message::WIFI_PASS_MAX_LENGTH"] security_type: uint32_t # bwl::sta_wlan_hal::Security preferred_bssid: sMacAddr - wire_iface_type: uint8_t - wireless_iface_type: uint8_t + wire_iface_type: uint8_t + wireless_iface_type: uint8_t mem_only_psk: uint8_t backhaul_preferred_radio_band: uint8_t frequency_band: beerocks::eFreqType - max_bandwidth: beerocks::eWiFiBandwidth + max_bandwidth: beerocks::eWiFiBandwidth ht_supported: uint8_t #bool ht_capability: uint16_t ht_mcs_set: _type: uint8_t - _length: [ "beerocks::message::HT_MCS_SET_SIZE" ] + _length: ["beerocks::message::HT_MCS_SET_SIZE"] vht_supported: uint8_t #bool vht_capability: uint32_t vht_mcs_set: _type: uint8_t - _length: [ "beerocks::message::VHT_MCS_SET_SIZE" ] + _length: ["beerocks::message::VHT_MCS_SET_SIZE"] preferred_channels_size: _type: uint8_t _length_var: True preferred_channels: _type: beerocks::message::sWifiChannel - _length: [ preferred_channels_size ] + _length: [preferred_channels_size] cACTION_BACKHAUL_CONNECTED_NOTIFICATION: _type: class @@ -93,7 +93,7 @@ cACTION_BACKHAUL_ROAM_REQUEST: cACTION_BACKHAUL_ROAM_RESPONSE: _type: class - connected: uint8_t + connected: uint8_t cACTION_BACKHAUL_RESET: _type: class @@ -134,8 +134,8 @@ cACTION_BACKHAUL_CLIENT_ASSOCIATED_NOTIFICATION: client_mac: sMacAddr bssid: sMacAddr association_frame: - _type: uint8_t - _length: [] + _type: uint8_t + _length: [] cACTION_BACKHAUL_CLIENT_DISCONNECTED_NOTIFICATION: _type: class @@ -149,7 +149,7 @@ cACTION_BACKHAUL_ASSOCIATED_STA_LINK_METRICS_REQUEST: cACTION_BACKHAUL_ASSOCIATED_STA_LINK_METRICS_RESPONSE: _type: class - _is_tlv_class : True + _is_tlv_class: True length: uint16_t sta_mac: sMacAddr bssid_info_list_length: @@ -157,7 +157,7 @@ cACTION_BACKHAUL_ASSOCIATED_STA_LINK_METRICS_RESPONSE: _length_var: True bssid_info_list: _type: sBssidInfo - _length: [ bssid_info_list_length ] + _length: [bssid_info_list_length] cACTION_BACKHAUL_START_WPS_PBC_REQUEST: _type: class diff --git a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_bml.yaml b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_bml.yaml index 864163a033..065e0d05f6 100755 --- a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_bml.yaml +++ b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_bml.yaml @@ -6,14 +6,14 @@ _multi_class: True _multi_class_auto_insert: action_op: _type: eActionOp_BML - _value_const: [_auto_value_by_name, 1] + _value_const: [_auto_value_by_name, 1] _class_const: True ################################################# ################################################# cACTION_BML_PING_REQUEST: - _type: class + _type: class cACTION_BML_PING_RESPONSE: _type: class @@ -27,9 +27,9 @@ cACTION_BML_NW_MAP_RESPONSE: buffer_size: _type: uint32_t _length_var: True - buffer: + buffer: _type: char - _length: [ buffer_size ] + _length: [buffer_size] cACTION_BML_NW_MAP_UPDATE: _type: class @@ -37,9 +37,9 @@ cACTION_BML_NW_MAP_UPDATE: buffer_size: _type: uint32_t _length_var: True - buffer: + buffer: _type: char - _length: [ buffer_size ] + _length: [buffer_size] cACTION_BML_STATS_UPDATE: _type: class @@ -47,18 +47,18 @@ cACTION_BML_STATS_UPDATE: buffer_size: _type: uint32_t _length_var: True - buffer: + buffer: _type: char - _length: [ buffer_size ] + _length: [buffer_size] cACTION_BML_EVENTS_UPDATE: _type: class buffer_size: _type: uint32_t _length_var: True - buffer: + buffer: _type: char - _length: [ buffer_size ] + _length: [buffer_size] cACTION_BML_REGISTER_TO_NW_MAP_UPDATES_REQUEST: _type: class @@ -79,28 +79,28 @@ cACTION_BML_GET_LEGACY_CLIENT_ROAMING_REQUEST: _type: class cACTION_BML_REGISTER_TO_EVENTS_UPDATES_REQUEST: - _type: class + _type: class cACTION_BML_REGISTER_TO_EVENTS_UPDATES_RESPONSE: - _type: class + _type: class cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_REQUEST: - _type: class + _type: class cACTION_BML_UNREGISTER_FROM_EVENTS_UPDATES_RESPONSE: - _type: class + _type: class cACTION_BML_REGISTER_TO_STATS_UPDATES_REQUEST: - _type: class + _type: class cACTION_BML_REGISTER_TO_STATS_UPDATES_RESPONSE: - _type: class + _type: class cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_REQUEST: - _type: class + _type: class cACTION_BML_UNREGISTER_FROM_STATS_UPDATES_RESPONSE: - _type: class + _type: class cACTION_BML_SET_LEGACY_CLIENT_ROAMING_REQUEST: _type: class @@ -109,16 +109,16 @@ cACTION_BML_SET_LEGACY_CLIENT_ROAMING_REQUEST: cACTION_BML_GET_LEGACY_CLIENT_ROAMING_RESPONSE: _type: class isEnable: uint8_t - + cACTION_BML_SET_CLIENT_ROAMING_REQUEST: _type: class isEnable: uint8_t cACTION_BML_SET_CLIENT_ROAMING_RESPONSE: _type: class - + cACTION_BML_GET_CLIENT_ROAMING_REQUEST: - _type: class + _type: class cACTION_BML_GET_CLIENT_ROAMING_RESPONSE: _type: class @@ -130,9 +130,9 @@ cACTION_BML_SET_DFS_REENTRY_REQUEST: cACTION_BML_SET_DFS_REENTRY_RESPONSE: _type: class - + cACTION_BML_GET_DFS_REENTRY_REQUEST: - _type: class + _type: class cACTION_BML_GET_DFS_REENTRY_RESPONSE: _type: class @@ -227,19 +227,19 @@ cACTION_BML_WIFI_CREDENTIALS_SET_REQUEST: _length_var: True ssid: _type: char - _length: [ ssid_size ] + _length: [ssid_size] network_key_size: _type: uint8_t _length_var: True network_key: _type: char - _length: [ network_key_size ] + _length: [network_key_size] operating_classes_size: _type: uint8_t _length_var: True operating_classes: _type: uint8_t - _length: [ operating_classes_size ] + _length: [operating_classes_size] cACTION_BML_WIFI_CREDENTIALS_SET_RESPONSE: _type: class @@ -276,37 +276,37 @@ cACTION_BML_GET_CERTIFICATION_MODE_RESPONSE: isEnable: uint8_t cACTION_BML_SET_VAP_LIST_CREDENTIALS_REQUEST: - _type: class + _type: class result: _type: uint32_t - _comment: # 0 - Failure, 1 - Success + _comment: # 0 - Failure, 1 - Success vap_list_size: _type: uint8_t _length_var: True vap_list: _type: sConfigVapInfo - _length: [ vap_list_size ] + _length: [vap_list_size] cACTION_BML_SET_VAP_LIST_CREDENTIALS_RESPONSE: - _type: class + _type: class result: _type: uint32_t - _comment: # 0 - Failure, 1 - Success - + _comment: # 0 - Failure, 1 - Success + cACTION_BML_GET_VAP_LIST_CREDENTIALS_RESPONSE: - _type: class + _type: class result: _type: uint32_t - _comment: # 0 - Failure, 1 - Success + _comment: # 0 - Failure, 1 - Success vap_list_size: _type: uint8_t _length_var: True vap_list: _type: sConfigVapInfo - _length: [ vap_list_size ] - + _length: [vap_list_size] + cACTION_BML_GET_VAP_LIST_CREDENTIALS_REQUEST: - _type: class + _type: class result: _type: uint32_t _comment: # 0 - Failure, 1 - Success @@ -320,7 +320,7 @@ cACTION_BML_STEERING_SET_GROUP_REQUEST: cACTION_BML_STEERING_SET_GROUP_RESPONSE: _type: class - error_code: int32_t + error_code: int32_t cACTION_BML_STEERING_CLIENT_SET_REQUEST: _type: class @@ -339,7 +339,7 @@ cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_REQUEST: unregister: uint8_t cACTION_BML_STEERING_EVENT_REGISTER_UNREGISTER_RESPONSE: - _type: class + _type: class error_code: int32_t cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST: @@ -351,7 +351,7 @@ cACTION_BML_STEERING_CLIENT_DISCONNECT_REQUEST: reason: uint32_t cACTION_BML_STEERING_CLIENT_DISCONNECT_RESPONSE: - _type: class + _type: class error_code: int32_t cACTION_BML_STEERING_CLIENT_MEASURE_REQUEST: @@ -361,7 +361,7 @@ cACTION_BML_STEERING_CLIENT_MEASURE_REQUEST: client_mac: sMacAddr cACTION_BML_STEERING_CLIENT_MEASURE_RESPONSE: - _type: class + _type: class error_code: int32_t ################################################ @@ -372,9 +372,9 @@ cACTION_BML_STEERING_EVENTS_UPDATE: buffer_size: _type: uint32_t _length_var: True - buffer: + buffer: _type: char - _length: [ buffer_size ] + _length: [buffer_size] cACTION_BML_TRIGGER_TOPOLOGY_QUERY: _type: class @@ -385,7 +385,7 @@ cACTION_BML_TOPOLOGY_RESPONSE: device_data: sDeviceData result: _type: uint32_t - _comment: # 0 - Failure, 1 - Success + _comment: # 0 - Failure, 1 - Success cACTION_BML_REGISTER_TOPOLOGY_QUERY: _type: class @@ -469,7 +469,7 @@ cACTION_BML_CHANNEL_SCAN_GET_RESULTS_RESPONSE: _length_var: True results: _type: sChannelScanResults - _length: [ results_size ] + _length: [results_size] cACTION_BML_CHANNEL_SCAN_DUMP_RESULTS_REQUEST: _type: class diff --git a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_cli.yaml b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_cli.yaml index a4d9261105..b27cc65e4f 100755 --- a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_cli.yaml +++ b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_cli.yaml @@ -1,15 +1,16 @@ # --- -_include: { - beerocks/tlvf/beerocks_message_common.h, - beerocks/tlvf/beerocks_message_cli_net_map.h, -} +_include: + { + beerocks/tlvf/beerocks_message_common.h, + beerocks/tlvf/beerocks_message_cli_net_map.h, + } _namespace: beerocks_message _multi_class: True _multi_class_auto_insert: action_op: _type: eActionOp_CLI - _value_const: [_auto_value_by_name, 1] + _value_const: [_auto_value_by_name, 1] _class_const: True ################################################# @@ -41,9 +42,9 @@ cACTION_CLI_RESPONSE_STR: buffer_size: _type: uint32_t _length_var: True - buffer: + buffer: _type: char - _length: [ buffer_size ] + _length: [buffer_size] cACTION_CLI_CROSS_RX_RSSI_MEASUREMENT: _type: class @@ -127,22 +128,22 @@ cACTION_CLI_CLIENT_CHANNEL_LOAD_11K_REQUEST: cACTION_CLI_CLIENT_BEACON_11K_REQUEST: _type: class - client_mac: sMacAddr - bssid: sMacAddr + client_mac: sMacAddr + bssid: sMacAddr ssid: - _type: uint8_t - _length: [ "beerocks::message::WIFI_SSID_MAX_LENGTH" ] - use_optional_ssid: uint8_t - channel: uint8_t - measurement_mode: uint8_t - duration: uint16_t - rand_ival: uint16_t - repeats: uint16_t - op_class: int16_t + _type: uint8_t + _length: ["beerocks::message::WIFI_SSID_MAX_LENGTH"] + use_optional_ssid: uint8_t + channel: uint8_t + measurement_mode: uint8_t + duration: uint16_t + rand_ival: uint16_t + repeats: uint16_t + op_class: int16_t cACTION_CLI_CLIENT_STATISTICS_11K_REQUEST: _type: class - hostap_mac: sMacAddr + hostap_mac: sMacAddr client_mac: sMacAddr peer_mac: sMacAddr group_identity: uint8_t diff --git a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_cli_net_map.yaml b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_cli_net_map.yaml index 37db87c93f..c04cff6c27 100755 --- a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_cli_net_map.yaml +++ b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_cli_net_map.yaml @@ -17,23 +17,23 @@ sCliNetworkMapNodeSta: sCliNetworkMapsNodeInfo: _type: struct - mac: sMacAddr - ipv4: beerocks::net::sIpv4Addr + mac: sMacAddr + ipv4: beerocks::net::sIpv4Addr name: - _type: char - _length: [ "beerocks::message::NODE_NAME_LENGTH" ] - type: uint8_t - state: uint8_t - channel: uint8_t - bandwidth: uint8_t #beerocks::eWiFiBandwidth - channel_ext_above_secondary: uint8_t - is_dfs: uint8_t - cac_completed: uint8_t - tx_bytes: uint32_t - rx_bytes: uint32_t - stats_delta_ms: uint16_t - tx_load_percent: uint8_t # for HOSTAP it is the total sta tx_load - rx_load_percent: uint8_t # for HOSTAP it is the total sta rx_load - channel_load_percent: uint8_t # only for HOSTAP - iface_type: uint8_t #eIfaceType - vap_id: int8_t + _type: char + _length: ["beerocks::message::NODE_NAME_LENGTH"] + type: uint8_t + state: uint8_t + channel: uint8_t + bandwidth: uint8_t #beerocks::eWiFiBandwidth + channel_ext_above_secondary: uint8_t + is_dfs: uint8_t + cac_completed: uint8_t + tx_bytes: uint32_t + rx_bytes: uint32_t + stats_delta_ms: uint16_t + tx_load_percent: uint8_t # for HOSTAP it is the total sta tx_load + rx_load_percent: uint8_t # for HOSTAP it is the total sta rx_load + channel_load_percent: uint8_t # only for HOSTAP + iface_type: uint8_t #eIfaceType + vap_id: int8_t diff --git a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_control.yaml b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_control.yaml index f2525acc42..ada2ccef08 100755 --- a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_control.yaml +++ b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_control.yaml @@ -6,7 +6,7 @@ _multi_class: True _multi_class_auto_insert: action_op: _type: eActionOp_CONTROL - _value_const: [_auto_value_by_name, 1] + _value_const: [_auto_value_by_name, 1] _class_const: True ################################################# @@ -17,59 +17,59 @@ _multi_class_auto_insert: ################################################# cACTION_CONTROL_SLAVE_HANDSHAKE_REQUEST: - _type: class + _type: class cACTION_CONTROL_SLAVE_HANDSHAKE_RESPONSE: - _type: class + _type: class cACTION_CONTROL_SLAVE_JOINED_NOTIFICATION: _type: class slave_version: _type: char - _length: [ "beerocks::message::VERSION_LENGTH" ] + _length: ["beerocks::message::VERSION_LENGTH"] platform_settings: sPlatformSettings - wlan_settings: sWlanSettings - backhaul_params: sBackhaulParams - hostap: sNodeHostap - cs_params: sApChannelSwitch - low_pass_filter_on: uint8_t # configuration - enable_repeater_mode: uint8_t + wlan_settings: sWlanSettings + backhaul_params: sBackhaulParams + hostap: sNodeHostap + cs_params: sApChannelSwitch + low_pass_filter_on: uint8_t # configuration + enable_repeater_mode: uint8_t radio_identifier: sMacAddr is_slave_reconf: uint8_t cACTION_CONTROL_SLAVE_JOINED_RESPONSE: _type: class master_version: - _type: char - _length: [ "beerocks::message::VERSION_LENGTH" ] - err_code: uint8_t #beerocks::eSlaveJoinResponseErrCode - config: sSonConfig + _type: char + _length: ["beerocks::message::VERSION_LENGTH"] + err_code: uint8_t #beerocks::eSlaveJoinResponseErrCode + config: sSonConfig cACTION_CONTROL_SLAVE_JOINED_4ADDR_MODE_NOTIFICATION: _type: class - backhaul_iface_mac: sMacAddr - backhaul_ipv4: beerocks::net::sIpv4Addr - bridge_iface_mac: sMacAddr - bridge_ipv4: beerocks::net::sIpv4Addr - hostap: sNodeHostap + backhaul_iface_mac: sMacAddr + backhaul_ipv4: beerocks::net::sIpv4Addr + bridge_iface_mac: sMacAddr + bridge_ipv4: beerocks::net::sIpv4Addr + hostap: sNodeHostap cACTION_CONTROL_SON_CONFIG_UPDATE: _type: class - config: sSonConfig + config: sSonConfig cACTION_CONTROL_CONTROLLER_PING_REQUEST: _type: class - total: uint16_t - seq: uint16_t - size: uint16_t + total: uint16_t + seq: uint16_t + size: uint16_t data: _type: uint8_t _length: [] cACTION_CONTROL_CONTROLLER_PING_RESPONSE: _type: class - total: uint16_t - seq: uint16_t + total: uint16_t + seq: uint16_t size: uint16_t data: _type: uint8_t @@ -77,17 +77,17 @@ cACTION_CONTROL_CONTROLLER_PING_RESPONSE: cACTION_CONTROL_AGENT_PING_REQUEST: _type: class - total: uint16_t - seq: uint16_t - size: uint16_t + total: uint16_t + seq: uint16_t + size: uint16_t data: _type: uint8_t _length: [] cACTION_CONTROL_AGENT_PING_RESPONSE: _type: class - total: uint16_t - seq: uint16_t + total: uint16_t + seq: uint16_t size: uint16_t data: _type: uint8_t @@ -95,31 +95,31 @@ cACTION_CONTROL_AGENT_PING_RESPONSE: cACTION_CONTROL_ARP_QUERY_REQUEST: _type: class - params: sArpQuery + params: sArpQuery cACTION_CONTROL_ARP_QUERY_RESPONSE: _type: class - params: sArpMonitorData + params: sArpMonitorData cACTION_CONTROL_PLATFORM_OPERATIONAL_NOTIFICATION: _type: class - bridge_mac: sMacAddr - operational: uint8_t + bridge_mac: sMacAddr + operational: uint8_t cACTION_CONTROL_BACKHAUL_DL_RSSI_REPORT_NOTIFICATION: _type: class - params: sBackhaulRssi + params: sBackhaulRssi cACTION_CONTROL_BACKHAUL_RESET: _type: class cACTION_CONTROL_BACKHAUL_ROAM_REQUEST: _type: class - params: sBackhaulRoam + params: sBackhaulRoam cACTION_CONTROL_CHANGE_MODULE_LOGGING_LEVEL: _type: class - params: sLoggingLevelChange + params: sLoggingLevelChange ################################################# # HOSTAP @@ -127,95 +127,95 @@ cACTION_CONTROL_CHANGE_MODULE_LOGGING_LEVEL: cACTION_CONTROL_HOSTAP_CSA_ERROR_NOTIFICATION: _type: class - cs_params: sApChannelSwitch + cs_params: sApChannelSwitch cACTION_CONTROL_HOSTAP_CSA_NOTIFICATION: _type: class - cs_params: sApChannelSwitch + cs_params: sApChannelSwitch cACTION_CONTROL_HOSTAP_ACS_ERROR_NOTIFICATION: _type: class - cs_params: sApChannelSwitch + cs_params: sApChannelSwitch cACTION_CONTROL_HOSTAP_ACS_NOTIFICATION: _type: class - cs_params: sApChannelSwitch + cs_params: sApChannelSwitch preferred_channels_size: _type: uint8_t _length_var: True preferred_channels: _type: beerocks::message::sWifiChannel - _length: [ preferred_channels_size ] + _length: [preferred_channels_size] cACTION_CONTROL_HOSTAP_DFS_CAC_COMPLETED_NOTIFICATION: _type: class - params: sDfsCacCompleted + params: sDfsCacCompleted cACTION_CONTROL_HOSTAP_DFS_CHANNEL_AVAILABLE_NOTIFICATION: _type: class - params: sDfsChannelAvailable + params: sDfsChannelAvailable cACTION_CONTROL_HOSTAP_SET_RESTRICTED_FAILSAFE_CHANNEL_REQUEST: _type: class - params: sApSetRestrictedFailsafe + params: sApSetRestrictedFailsafe cACTION_CONTROL_HOSTAP_SET_RESTRICTED_FAILSAFE_CHANNEL_RESPONSE: _type: class - success: uint8_t + success: uint8_t cACTION_CONTROL_HOSTAP_CHANNEL_SWITCH_ACS_START: _type: class - cs_params: sApChannelSwitch + cs_params: sApChannelSwitch cACTION_CONTROL_HOSTAP_UPDATE_STOP_ON_FAILURE_ATTEMPTS_REQUEST: _type: class - attempts: uint32_t + attempts: uint32_t cACTION_CONTROL_HOSTAP_DISABLED_BY_MASTER: _type: class cACTION_CONTROL_HOSTAP_CHANNEL_SWITCH_REQUEST: _type: class - cs_params: sApChannelSwitch + cs_params: sApChannelSwitch cACTION_CONTROL_HOSTAP_STATS_MEASUREMENT_REQUEST: _type: class - sync: uint8_t + sync: uint8_t cACTION_CONTROL_HOSTAP_STATS_MEASUREMENT_RESPONSE: _type: class ap_stats_size: _type: uint8_t _length_var: True - ap_stats: + ap_stats: _type: sApStatsParams - _length: [ ap_stats_size ] + _length: [ap_stats_size] sta_stats_size: _type: uint8_t _length_var: True sta_stats: _type: sStaStatsParams - _length: [ sta_stats_size ] + _length: [sta_stats_size] cACTION_CONTROL_HOSTAP_LOAD_MEASUREMENT_NOTIFICATION: _type: class - params: sApLoadNotificationParams + params: sApLoadNotificationParams cACTION_CONTROL_HOSTAP_SET_NEIGHBOR_11K_REQUEST: _type: class - params: sNeighborSetParams11k + params: sNeighborSetParams11k cACTION_CONTROL_HOSTAP_REMOVE_NEIGHBOR_11K_REQUEST: _type: class - params: sNeighborRemoveParams11k + params: sNeighborRemoveParams11k cACTION_CONTROL_HOSTAP_ACTIVITY_NOTIFICATION: _type: class - params: sApActivityNotificationParams + params: sApActivityNotificationParams cACTION_CONTROL_HOSTAP_VAPS_LIST_UPDATE_NOTIFICATION: _type: class - params: sVapsList + params: sVapsList cACTION_CONTROL_HOSTAP_AP_DISABLED_NOTIFICATION: _type: class @@ -226,26 +226,24 @@ cACTION_CONTROL_HOSTAP_AP_ENABLED_NOTIFICATION: vap_id: int8_t vap_info: sVapInfo - ################################################# # CLIENT ################################################# cACTION_CONTROL_CLIENT_START_MONITORING_REQUEST: _type: class - params: sClientMonitoringParams + params: sClientMonitoringParams - cACTION_CONTROL_CLIENT_START_MONITORING_RESPONSE: _type: class success: uint8_t cACTION_CONTROL_CLIENT_RX_RSSI_MEASUREMENT_REQUEST: _type: class - params: sNodeRssiMeasurementRequest + params: sNodeRssiMeasurementRequest cACTION_CONTROL_CLIENT_RX_RSSI_MEASUREMENT_RESPONSE: _type: class - params: sNodeRssiMeasurement + params: sNodeRssiMeasurement cACTION_CONTROL_CLIENT_RX_RSSI_MEASUREMENT_START_NOTIFICATION: _type: class @@ -253,28 +251,28 @@ cACTION_CONTROL_CLIENT_RX_RSSI_MEASUREMENT_START_NOTIFICATION: cACTION_CONTROL_CLIENT_RX_RSSI_MEASUREMENT_CMD_RESPONSE: _type: class - mac: sMacAddr + mac: sMacAddr cACTION_CONTROL_CLIENT_RX_RSSI_MEASUREMENT_NOTIFICATION: _type: class - params: sNodeRssiMeasurement + params: sNodeRssiMeasurement cACTION_CONTROL_CLIENT_NO_ACTIVITY_NOTIFICATION: _type: class - mac: sMacAddr + mac: sMacAddr cACTION_CONTROL_CLIENT_NO_RESPONSE_NOTIFICATION: _type: class - mac: sMacAddr + mac: sMacAddr cACTION_CONTROL_CLIENT_NEW_IP_ADDRESS_NOTIFICATION: _type: class mac: sMacAddr - ipv4: beerocks::net::sIpv4Addr + ipv4: beerocks::net::sIpv4Addr cACTION_CONTROL_CLIENT_DISCONNECT_REQUEST: _type: class - mac: sMacAddr + mac: sMacAddr vap_id: int8_t type: eDisconnectType reason: uint32_t @@ -285,43 +283,43 @@ cACTION_CONTROL_CLIENT_DISCONNECT_RESPONSE: cACTION_CONTROL_CLIENT_DHCP_COMPLETE_NOTIFICATION: _type: class - mac: sMacAddr - ipv4: beerocks::net::sIpv4Addr - name: - _type: char - _length: [ "beerocks::message::NODE_NAME_LENGTH" ] + mac: sMacAddr + ipv4: beerocks::net::sIpv4Addr + name: + _type: char + _length: ["beerocks::message::NODE_NAME_LENGTH"] cACTION_CONTROL_CLIENT_ARP_MONITOR_NOTIFICATION: _type: class - params: sArpMonitorData + params: sArpMonitorData cACTION_CONTROL_CLIENT_BEACON_11K_REQUEST: _type: class - params: sBeaconRequest11k + params: sBeaconRequest11k cACTION_CONTROL_CLIENT_BEACON_11K_RESPONSE: _type: class - params: sBeaconResponse11k + params: sBeaconResponse11k cACTION_CONTROL_CLIENT_CHANNEL_LOAD_11K_REQUEST: _type: class - params: sStaChannelLoadRequest11k + params: sStaChannelLoadRequest11k cACTION_CONTROL_CLIENT_CHANNEL_LOAD_11K_RESPONSE: _type: class - params: sStaChannelLoadResponse11k + params: sStaChannelLoadResponse11k cACTION_CONTROL_CLIENT_STATISTICS_11K_REQUEST: _type: class - params: sStatisticsRequest11k + params: sStatisticsRequest11k cACTION_CONTROL_CLIENT_STATISTICS_11K_RESPONSE: _type: class - params: sStatisticsResponse11k + params: sStatisticsResponse11k cACTION_CONTROL_CLIENT_LINK_MEASUREMENT_11K_REQUEST: _type: class - mac: sMacAddr + mac: sMacAddr cACTION_CONTROL_CLIENT_LINK_MEASUREMENTS_11K_RESPONSE: _type: class @@ -330,19 +328,19 @@ cACTION_CONTROL_CLIENT_LINK_MEASUREMENTS_11K_RESPONSE: ################################################# # MONITOR RDKB CONFIGURATIONS ################################################# -cACTION_CONTROL_STEERING_CLIENT_SET_GROUP_REQUEST: +cACTION_CONTROL_STEERING_CLIENT_SET_GROUP_REQUEST: _type: class params: sSteeringSetGroupRequest -cACTION_CONTROL_STEERING_CLIENT_SET_GROUP_RESPONSE: +cACTION_CONTROL_STEERING_CLIENT_SET_GROUP_RESPONSE: _type: class params: sSteeringSetGroupResponse -cACTION_CONTROL_STEERING_CLIENT_SET_REQUEST: +cACTION_CONTROL_STEERING_CLIENT_SET_REQUEST: _type: class params: sSteeringClientSetRequest -cACTION_CONTROL_STEERING_CLIENT_SET_RESPONSE: +cACTION_CONTROL_STEERING_CLIENT_SET_RESPONSE: _type: class params: sSteeringClientSetResponse ################################################ @@ -353,18 +351,18 @@ cACTION_CONTROL_STEERING_EVENT_CLIENT_ACTIVITY_NOTIFICATION: params: sSteeringEvActivity cACTION_CONTROL_STEERING_EVENT_SNR_XING_NOTIFICATION: - _type: class + _type: class params: sSteeringEvSnrXing ################################################ # AP_MANAGER RDKB NOTIFICATIONS(softblock) ################################################# cACTION_CONTROL_STEERING_EVENT_PROBE_REQ_NOTIFICATION: - _type: class + _type: class params: sSteeringEvProbeReq cACTION_CONTROL_STEERING_EVENT_AUTH_FAIL_NOTIFICATION: - _type: class + _type: class params: sSteeringEvAuthFail ################################################ diff --git a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_header.yaml b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_header.yaml index 1fb66d6ca7..9c163da338 100755 --- a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_header.yaml +++ b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_header.yaml @@ -1,10 +1,11 @@ # --- _namespace: beerocks_message -_include: { - beerocks/tlvf/beerocks_message_common.h, - beerocks/tlvf/beerocks_message_action.h, -} +_include: + { + beerocks/tlvf/beerocks_message_common.h, + beerocks/tlvf/beerocks_message_action.h, + } cACTION_HEADER: _type: class @@ -14,11 +15,11 @@ cACTION_HEADER: version: _type: uint8_t _value_const: "beerocks::message::MESSAGE_VERSION" - action: eAction + action: eAction action_op: _type: uint8_t _comment: need to cast eActionOp_XXXX to uint8_t - direction: + direction: _type: uint8_t _value: 1 #BEEROCKS_DIRECTION_AGENT radio_mac: sMacAddr diff --git a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_monitor.yaml b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_monitor.yaml index 4ff77ec5ef..55c1ce0db5 100755 --- a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_monitor.yaml +++ b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_monitor.yaml @@ -6,7 +6,7 @@ _multi_class: True _multi_class_auto_insert: action_op: _type: eActionOp_MONITOR - _value_const: [_auto_value_by_name, 1] + _value_const: [_auto_value_by_name, 1] _class_const: True ################################################# @@ -20,15 +20,15 @@ cACTION_MONITOR_JOINED_NOTIFICATION: cACTION_MONITOR_SON_CONFIG_UPDATE: _type: class - config: sSonConfig + config: sSonConfig cACTION_MONITOR_CHANGE_MODULE_LOGGING_LEVEL: _type: class - params: sLoggingLevelChange + params: sLoggingLevelChange cACTION_MONITOR_ERROR_NOTIFICATION: _type: class - error_code: uint32_t + error_code: uint32_t cACTION_MONITOR_ERROR_NOTIFICATION_ACK: _type: class @@ -42,7 +42,7 @@ cACTION_MONITOR_HEARTBEAT_NOTIFICATION: cACTION_MONITOR_CLIENT_START_MONITORING_REQUEST: _type: class - params: sClientMonitoringParams + params: sClientMonitoringParams cACTION_MONITOR_CLIENT_START_MONITORING_RESPONSE: _type: class @@ -50,41 +50,41 @@ cACTION_MONITOR_CLIENT_START_MONITORING_RESPONSE: cACTION_MONITOR_CLIENT_RX_RSSI_MEASUREMENT_REQUEST: _type: class - params: sNodeRssiMeasurementRequest + params: sNodeRssiMeasurementRequest cACTION_MONITOR_CLIENT_DISCONNECT_REQUEST: _type: class - mac: sMacAddr - ipv4: beerocks::net::sIpv4Addr - channel: uint8_t + mac: sMacAddr + ipv4: beerocks::net::sIpv4Addr + channel: uint8_t cACTION_MONITOR_CLIENT_RX_RSSI_MEASUREMENT_NOTIFICATION: _type: class - params: sNodeRssiMeasurement - + params: sNodeRssiMeasurement + cACTION_MONITOR_CLIENT_RX_RSSI_MEASUREMENT_RESPONSE: _type: class - params: sNodeRssiMeasurement + params: sNodeRssiMeasurement cACTION_MONITOR_CLIENT_NO_RESPONSE_NOTIFICATION: _type: class - mac: sMacAddr + mac: sMacAddr cACTION_MONITOR_CLIENT_RX_RSSI_MEASUREMENT_START_NOTIFICATION: _type: class - mac: sMacAddr - + mac: sMacAddr + cACTION_MONITOR_CLIENT_RX_RSSI_MEASUREMENT_CMD_RESPONSE: _type: class - mac: sMacAddr + mac: sMacAddr cACTION_MONITOR_CLIENT_NO_ACTIVITY_NOTIFICATION: _type: class - mac: sMacAddr + mac: sMacAddr cACTION_MONITOR_HOSTAP_ACTIVITY_NOTIFICATION: _type: class - params: sApActivityNotificationParams + params: sApActivityNotificationParams cACTION_MONITOR_CLIENT_ASSOCIATED_STA_LINK_METRIC_REQUEST: _type: class @@ -93,7 +93,7 @@ cACTION_MONITOR_CLIENT_ASSOCIATED_STA_LINK_METRIC_REQUEST: cACTION_MONITOR_CLIENT_ASSOCIATED_STA_LINK_METRIC_RESPONSE: _type: class - _is_tlv_class : True + _is_tlv_class: True length: uint16_t sta_mac: sMacAddr bssid_info_list_length: @@ -101,7 +101,7 @@ cACTION_MONITOR_CLIENT_ASSOCIATED_STA_LINK_METRIC_RESPONSE: _length_var: True bssid_info_list: _type: sBssidInfo - _length: [ bssid_info_list_length ] + _length: [bssid_info_list_length] ################################################# # HOSTAP @@ -109,7 +109,7 @@ cACTION_MONITOR_CLIENT_ASSOCIATED_STA_LINK_METRIC_RESPONSE: cACTION_MONITOR_HOSTAP_STATS_MEASUREMENT_REQUEST: _type: class - sync: uint8_t + sync: uint8_t cACTION_MONITOR_HOSTAP_STATUS_CHANGED_NOTIFICATION: _type: class @@ -121,76 +121,76 @@ cACTION_MONITOR_HOSTAP_STATS_MEASUREMENT_RESPONSE: ap_stats_size: _type: uint8_t _length_var: True - ap_stats: + ap_stats: _type: sApStatsParams - _length: [ ap_stats_size ] + _length: [ap_stats_size] sta_stats_size: _type: uint8_t _length_var: True sta_stats: _type: sStaStatsParams - _length: [ sta_stats_size ] + _length: [sta_stats_size] cACTION_MONITOR_HOSTAP_LOAD_MEASUREMENT_NOTIFICATION: _type: class - params: sApLoadNotificationParams + params: sApLoadNotificationParams cACTION_MONITOR_CLIENT_BEACON_11K_REQUEST: _type: class - params: sBeaconRequest11k + params: sBeaconRequest11k cACTION_MONITOR_CLIENT_BEACON_11K_RESPONSE: _type: class - params: sBeaconResponse11k + params: sBeaconResponse11k cACTION_MONITOR_CLIENT_CHANNEL_LOAD_11K_REQUEST: _type: class - params: sStaChannelLoadRequest11k + params: sStaChannelLoadRequest11k cACTION_MONITOR_CLIENT_CHANNEL_LOAD_11K_RESPONSE: _type: class - params: sStaChannelLoadResponse11k + params: sStaChannelLoadResponse11k cACTION_MONITOR_CLIENT_STATISTICS_11K_REQUEST: _type: class - params: sStatisticsRequest11k + params: sStatisticsRequest11k cACTION_MONITOR_CLIENT_STATISTICS_11K_RESPONSE: _type: class - params: sStatisticsResponse11k + params: sStatisticsResponse11k cACTION_MONITOR_CLIENT_LINK_MEASUREMENT_11K_REQUEST: _type: class - mac: sMacAddr + mac: sMacAddr cACTION_MONITOR_CLIENT_LINK_MEASUREMENTS_11K_RESPONSE: _type: class - params: sLinkMeasurementsResponse11k + params: sLinkMeasurementsResponse11k cACTION_MONITOR_CLIENT_NEW_IP_ADDRESS_NOTIFICATION: _type: class mac: sMacAddr - ipv4: beerocks::net::sIpv4Addr + ipv4: beerocks::net::sIpv4Addr ################################################# # CLIENT MONITOR RDKB HAL ################################################# -cACTION_MONITOR_STEERING_CLIENT_SET_GROUP_REQUEST: +cACTION_MONITOR_STEERING_CLIENT_SET_GROUP_REQUEST: _type: class params: sSteeringSetGroupRequest -cACTION_MONITOR_STEERING_CLIENT_SET_GROUP_RESPONSE: +cACTION_MONITOR_STEERING_CLIENT_SET_GROUP_RESPONSE: _type: class params: sSteeringSetGroupResponse -cACTION_MONITOR_STEERING_CLIENT_SET_REQUEST: +cACTION_MONITOR_STEERING_CLIENT_SET_REQUEST: _type: class params: sSteeringClientSetRequest -cACTION_MONITOR_STEERING_CLIENT_SET_RESPONSE: +cACTION_MONITOR_STEERING_CLIENT_SET_RESPONSE: _type: class params: sSteeringClientSetResponse - + cACTION_MONITOR_STEERING_EVENT_CLIENT_ACTIVITY_NOTIFICATION: _type: class params: sSteeringEvActivity @@ -231,4 +231,3 @@ cACTION_MONITOR_CHANNEL_SCAN_ABORT_NOTIFICATION: cACTION_MONITOR_CHANNEL_SCAN_FINISHED_NOTIFICATION: _type: class - diff --git a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_platform.yaml b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_platform.yaml index 1714cd2df6..b45ffa1bc3 100755 --- a/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_platform.yaml +++ b/common/beerocks/tlvf/yaml/beerocks/tlvf/beerocks_message_platform.yaml @@ -6,7 +6,7 @@ _multi_class: True _multi_class_auto_insert: action_op: _type: eActionOp_PLATFORM - _value_const: [_auto_value_by_name, 1] + _value_const: [_auto_value_by_name, 1] _class_const: True ################################################# @@ -19,72 +19,72 @@ cACTION_PLATFORM_SON_SLAVE_BACKHAUL_CONNECTION_COMPLETE_NOTIFICATION: cACTION_PLATFORM_SON_SLAVE_REGISTER_REQUEST: _type: class iface_name: - _type: char - _length: [ "beerocks::message::IFACE_NAME_LENGTH" ] + _type: char + _length: ["beerocks::message::IFACE_NAME_LENGTH"] cACTION_PLATFORM_SON_SLAVE_REGISTER_RESPONSE: _type: class - platform_settings: sPlatformSettings - wlan_settings: sWlanSettings + platform_settings: sPlatformSettings + wlan_settings: sWlanSettings valid: _type: uint32_t _comment: #Marks whether the settings are valid cACTION_PLATFORM_ARP_MONITOR_NOTIFICATION: _type: class - params: sArpMonitorData + params: sArpMonitorData cACTION_PLATFORM_WLAN_PARAMS_CHANGED_NOTIFICATION: _type: class - wlan_settings: sWlanSettings + wlan_settings: sWlanSettings cACTION_PLATFORM_DHCP_MONITOR_NOTIFICATION: _type: class dhcp_op: eDHCPOp - op: uint32_t - mac: sMacAddr - ipv4: beerocks::net::sIpv4Addr - hostname: - _type: char - _length: [ "beerocks::message::NODE_NAME_LENGTH" ] + op: uint32_t + mac: sMacAddr + ipv4: beerocks::net::sIpv4Addr + hostname: + _type: char + _length: ["beerocks::message::NODE_NAME_LENGTH"] cACTION_PLATFORM_CHANGE_MODULE_LOGGING_LEVEL: _type: class - params: sLoggingLevelChange + params: sLoggingLevelChange cACTION_PLATFORM_ARP_QUERY_REQUEST: _type: class - params: sArpQuery + params: sArpQuery cACTION_PLATFORM_ARP_QUERY_RESPONSE: _type: class - params: sArpMonitorData + params: sArpMonitorData cACTION_PLATFORM_ONBOARD_QUERY_REQUEST: _type: class cACTION_PLATFORM_ONBOARD_QUERY_RESPONSE: _type: class - params: sOnboarding + params: sOnboarding cACTION_PLATFORM_ONBOARD_SET_REQUEST: _type: class - params: sOnboarding + params: sOnboarding cACTION_PLATFORM_WPS_ONBOARDING_REQUEST: _type: class - iface_name: - _type: char - _length: [ "beerocks::message::IFACE_NAME_LENGTH" ] + iface_name: + _type: char + _length: ["beerocks::message::IFACE_NAME_LENGTH"] cACTION_PLATFORM_WIFI_CREDENTIALS_GET_REQUEST: _type: class - vap_id: uint8_t + vap_id: uint8_t cACTION_PLATFORM_WIFI_CREDENTIALS_GET_RESPONSE: _type: class - front_params: sWifiCredentials - back_params: sWifiCredentials + front_params: sWifiCredentials + back_params: sWifiCredentials result: _type: uint32_t _comment: # 0 - Failure, 1 - Success @@ -94,7 +94,7 @@ cACTION_PLATFORM_ADMIN_CREDENTIALS_GET_REQUEST: cACTION_PLATFORM_ADMIN_CREDENTIALS_GET_RESPONSE: _type: class - params: sAdminCredentials + params: sAdminCredentials result: _type: uint32_t _comment: # 0 - Failure, 1 - Success @@ -104,7 +104,7 @@ cACTION_PLATFORM_DEVICE_INFO_GET_REQUEST: cACTION_PLATFORM_DEVICE_INFO_GET_RESPONSE: _type: class - params: sDeviceInfo + params: sDeviceInfo result: _type: uint32_t _comment: # 0 - Failure, 1 - Success @@ -114,31 +114,31 @@ cACTION_PLATFORM_LOCAL_MASTER_GET_REQUEST: cACTION_PLATFORM_LOCAL_MASTER_GET_RESPONSE: _type: class - local_master: uint8_t + local_master: uint8_t cACTION_PLATFORM_VERSION_MISMATCH_NOTIFICATION: _type: class - versions: sVersions + versions: sVersions cACTION_PLATFORM_MASTER_SLAVE_VERSIONS_NOTIFICATION: _type: class - versions: sVersions + versions: sVersions cACTION_PLATFORM_GET_MASTER_SLAVE_VERSIONS_REQUEST: _type: class cACTION_PLATFORM_GET_MASTER_SLAVE_VERSIONS_RESPONSE: _type: class - versions: sVersions + versions: sVersions result: _type: uint32_t _comment: # 0 - Failure, 1 - Success cACTION_PLATFORM_ERROR_NOTIFICATION: _type: class - code: uint32_t - data: - _type: char - _length: [ 256 ] + code: uint32_t + data: + _type: char + _length: [256] _comment: # Must match BPL_ERROR_STRING_LEN diff --git a/controller/src/beerocks/master/son_actions.cpp b/controller/src/beerocks/master/son_actions.cpp index babe5e49ec..4896823aaa 100644 --- a/controller/src/beerocks/master/son_actions.cpp +++ b/controller/src/beerocks/master/son_actions.cpp @@ -467,9 +467,9 @@ bool son_actions::send_ap_config_renew_msg(ieee1905_1::CmduMessageTx &cmdu_tx, d LOG(ERROR) << "Failed building IEEE1905 AP_AUTOCONFIGURATION_RENEW_MESSAGE"; } - auto tlvAlMac = cmdu_tx.addClass(); + auto tlvAlMac = cmdu_tx.addClass(); if (!tlvAlMac) { - LOG(ERROR) << "Failed addClass ieee1905_1::tlvAlMacAddressType"; + LOG(ERROR) << "Failed addClass ieee1905_1::tlvAlMacAddress"; result = false; } diff --git a/controller/src/beerocks/master/son_actions.h b/controller/src/beerocks/master/son_actions.h index 024dc42f80..fba85f867b 100644 --- a/controller/src/beerocks/master/son_actions.h +++ b/controller/src/beerocks/master/son_actions.h @@ -14,7 +14,7 @@ #include #include -#include +#include #include #include #include diff --git a/controller/src/beerocks/master/son_master_thread.cpp b/controller/src/beerocks/master/son_master_thread.cpp index 1a5e6970b0..9e0e1e7805 100644 --- a/controller/src/beerocks/master/son_master_thread.cpp +++ b/controller/src/beerocks/master/son_master_thread.cpp @@ -38,7 +38,7 @@ #include #include #include -#include +#include #include #include #include @@ -326,9 +326,9 @@ bool master_thread::handle_cmdu_1905_autoconfiguration_search(const std::string { LOG(DEBUG) << "Received AP_AUTOCONFIGURATION_SEARCH_MESSAGE"; - auto tlvAlMacAddressType = cmdu_rx.getClass(); - if (!tlvAlMacAddressType) { - LOG(ERROR) << "getClass failed"; + auto tlvAlMacAddress = cmdu_rx.getClass(); + if (!tlvAlMacAddress) { + LOG(ERROR) << "getClass failed"; return false; } auto tlvSearchedRole = cmdu_rx.getClass(); @@ -352,7 +352,7 @@ bool master_thread::handle_cmdu_1905_autoconfiguration_search(const std::string return false; } - auto al_mac = tlvf::mac_to_string((const unsigned char *)tlvAlMacAddressType->mac().oct); + auto al_mac = tlvf::mac_to_string((const unsigned char *)tlvAlMacAddress->mac().oct); LOG(DEBUG) << "mac=" << al_mac; LOG(DEBUG) << "searched_role=" << int(tlvSearchedRole->value()); diff --git a/documentation/images/plantuml/agent/flows/bh_sta_steering.png b/documentation/images/plantuml/agent/flows/bh_sta_steering.png new file mode 100644 index 0000000000..a4b9f7e837 Binary files /dev/null and b/documentation/images/plantuml/agent/flows/bh_sta_steering.png differ diff --git a/documentation/images/plantuml/agent/flows/bh_sta_steering.puml b/documentation/images/plantuml/agent/flows/bh_sta_steering.puml new file mode 100644 index 0000000000..a30c371ac3 --- /dev/null +++ b/documentation/images/plantuml/agent/flows/bh_sta_steering.puml @@ -0,0 +1,19 @@ +@startuml +->controller: dev_reset_default +->controller: Prepare setup( execute 4.1.2 test) +controller->backhaul_manager: send_cmdu(Backhaul Steering Request with correct data) +backhaul_manager->backhaul_manager: handle_1905_msg(\n Backhaul Steering Request message,\n Backhaul Steering Request TLV(0x9E)) +backhaul_manager->controller: send_cmdu(ACK) +backhaul_manager->backhaul_manager: sta_wlan_hal->connect(bssid,channel) +backhaul_manager->wpa_supplicant: NETWORK_ENABLE +wpa_supplicant->ctt_agent_2: Association Request +ctt_agent_2->wpa_supplicant: Association Response +wpa_supplicant->backhaul_manager: ENABLED +backhaul_manager->controller: send_cmdu(Backhaul Steering Response message) +controller->controller: handle_1905_msg(Backhaul Steering Response message) +controller->backhaul_manager: send_cmdu(Backhaul Steering Request with bogus channel number) +backhaul_manager->backhaul_manager: handle_1905_msg(\n Backhaul Steering Request message,\n Backhaul Steering Request TLV(0x9E)) +backhaul_manager->controller: send_cmdu(ACK) +backhaul_manager->controller: send_cmdu(Backhaul Steering Response message) +controller->controller: handle_1905_msg(Backhaul Steering Response message) +@enduml diff --git a/framework/tlvf/AutoGenerated/include/tlvf/ieee_1905_1/eTlvType.h b/framework/tlvf/AutoGenerated/include/tlvf/ieee_1905_1/eTlvType.h index fd14a9497a..c5b6f6d168 100644 --- a/framework/tlvf/AutoGenerated/include/tlvf/ieee_1905_1/eTlvType.h +++ b/framework/tlvf/AutoGenerated/include/tlvf/ieee_1905_1/eTlvType.h @@ -21,7 +21,7 @@ namespace ieee1905_1 { enum class eTlvType : uint8_t { TLV_END_OF_MESSAGE = 0x0, - TLV_AL_MAC_ADDRESS_TYPE = 0x1, + TLV_AL_MAC_ADDRESS = 0x1, TLV_MAC_ADDRESS = 0x2, TLV_DEVICE_INFORMATION = 0x3, TLV_DEVICE_BRIDGING_CAPABILITY = 0x4, diff --git a/framework/tlvf/AutoGenerated/include/tlvf/ieee_1905_1/tlvAlMacAddress.h b/framework/tlvf/AutoGenerated/include/tlvf/ieee_1905_1/tlvAlMacAddress.h new file mode 100644 index 0000000000..0544c3bc15 --- /dev/null +++ b/framework/tlvf/AutoGenerated/include/tlvf/ieee_1905_1/tlvAlMacAddress.h @@ -0,0 +1,52 @@ +/////////////////////////////////////// +// AUTO GENERATED FILE - DO NOT EDIT // +/////////////////////////////////////// + +/* SPDX-License-Identifier: BSD-2-Clause-Patent + * + * SPDX-FileCopyrightText: 2016-2020 the prplMesh contributors (see AUTHORS.md) + * + * This code is subject to the terms of the BSD+Patent license. + * See LICENSE file for more details. + */ + +#ifndef _TLVF_IEEE_1905_1_TLVALMACADDRESS_H_ +#define _TLVF_IEEE_1905_1_TLVALMACADDRESS_H_ + +#include +#include +#include +#include +#include +#include +#include +#include "tlvf/ieee_1905_1/eTlvType.h" +#include "tlvf/common/sMacAddr.h" + +namespace ieee1905_1 { + + +class tlvAlMacAddress : public BaseClass +{ + public: + tlvAlMacAddress(uint8_t* buff, size_t buff_len, bool parse = false); + explicit tlvAlMacAddress(std::shared_ptr base, bool parse = false); + ~tlvAlMacAddress(); + + const eTlvType& type(); + const uint16_t& length(); + sMacAddr& mac(); + void class_swap() override; + bool finalize() override; + static size_t get_initial_size(); + + private: + bool init(); + eTlvType* m_type = nullptr; + uint16_t* m_length = nullptr; + sMacAddr* m_mac = nullptr; +}; + +}; // close namespace: ieee1905_1 + +#endif //_TLVF/IEEE_1905_1_TLVALMACADDRESS_H_ diff --git a/framework/tlvf/AutoGenerated/include/tlvf/wfa_map/tlvBackhaulSteeringRequest.h b/framework/tlvf/AutoGenerated/include/tlvf/wfa_map/tlvBackhaulSteeringRequest.h new file mode 100644 index 0000000000..4298516803 --- /dev/null +++ b/framework/tlvf/AutoGenerated/include/tlvf/wfa_map/tlvBackhaulSteeringRequest.h @@ -0,0 +1,58 @@ +/////////////////////////////////////// +// AUTO GENERATED FILE - DO NOT EDIT // +/////////////////////////////////////// + +/* SPDX-License-Identifier: BSD-2-Clause-Patent + * + * SPDX-FileCopyrightText: 2016-2020 the prplMesh contributors (see AUTHORS.md) + * + * This code is subject to the terms of the BSD+Patent license. + * See LICENSE file for more details. + */ + +#ifndef _TLVF_WFA_MAP_TLVBACKHAULSTEERINGREQUEST_H_ +#define _TLVF_WFA_MAP_TLVBACKHAULSTEERINGREQUEST_H_ + +#include +#include +#include +#include +#include +#include +#include +#include "tlvf/wfa_map/eTlvTypeMap.h" +#include "tlvf/common/sMacAddr.h" + +namespace wfa_map { + + +class tlvBackhaulSteeringRequest : public BaseClass +{ + public: + tlvBackhaulSteeringRequest(uint8_t* buff, size_t buff_len, bool parse = false); + explicit tlvBackhaulSteeringRequest(std::shared_ptr base, bool parse = false); + ~tlvBackhaulSteeringRequest(); + + const eTlvTypeMap& type(); + const uint16_t& length(); + sMacAddr& backhaul_station_mac(); + sMacAddr& target_bssid(); + uint8_t& operating_class(); + uint8_t& target_channel_number(); + void class_swap() override; + bool finalize() override; + static size_t get_initial_size(); + + private: + bool init(); + eTlvTypeMap* m_type = nullptr; + uint16_t* m_length = nullptr; + sMacAddr* m_backhaul_station_mac = nullptr; + sMacAddr* m_target_bssid = nullptr; + uint8_t* m_operating_class = nullptr; + uint8_t* m_target_channel_number = nullptr; +}; + +}; // close namespace: wfa_map + +#endif //_TLVF/WFA_MAP_TLVBACKHAULSTEERINGREQUEST_H_ diff --git a/framework/tlvf/AutoGenerated/include/tlvf/wfa_map/tlvBackhaulSteeringResponse.h b/framework/tlvf/AutoGenerated/include/tlvf/wfa_map/tlvBackhaulSteeringResponse.h new file mode 100644 index 0000000000..c3536d1dc0 --- /dev/null +++ b/framework/tlvf/AutoGenerated/include/tlvf/wfa_map/tlvBackhaulSteeringResponse.h @@ -0,0 +1,61 @@ +/////////////////////////////////////// +// AUTO GENERATED FILE - DO NOT EDIT // +/////////////////////////////////////// + +/* SPDX-License-Identifier: BSD-2-Clause-Patent + * + * SPDX-FileCopyrightText: 2016-2020 the prplMesh contributors (see AUTHORS.md) + * + * This code is subject to the terms of the BSD+Patent license. + * See LICENSE file for more details. + */ + +#ifndef _TLVF_WFA_MAP_TLVBACKHAULSTEERINGRESPONSE_H_ +#define _TLVF_WFA_MAP_TLVBACKHAULSTEERINGRESPONSE_H_ + +#include +#include +#include +#include +#include +#include +#include +#include "tlvf/wfa_map/eTlvTypeMap.h" +#include "tlvf/common/sMacAddr.h" + +namespace wfa_map { + + +class tlvBackhaulSteeringResponse : public BaseClass +{ + public: + tlvBackhaulSteeringResponse(uint8_t* buff, size_t buff_len, bool parse = false); + explicit tlvBackhaulSteeringResponse(std::shared_ptr base, bool parse = false); + ~tlvBackhaulSteeringResponse(); + + enum eResultCode: uint8_t { + SUCCESS = 0x0, + FAILURE = 0x1, + }; + + const eTlvTypeMap& type(); + const uint16_t& length(); + sMacAddr& backhaul_station_mac(); + sMacAddr& target_bssid(); + eResultCode& result_code(); + void class_swap() override; + bool finalize() override; + static size_t get_initial_size(); + + private: + bool init(); + eTlvTypeMap* m_type = nullptr; + uint16_t* m_length = nullptr; + sMacAddr* m_backhaul_station_mac = nullptr; + sMacAddr* m_target_bssid = nullptr; + eResultCode* m_result_code = nullptr; +}; + +}; // close namespace: wfa_map + +#endif //_TLVF/WFA_MAP_TLVBACKHAULSTEERINGRESPONSE_H_ diff --git a/framework/tlvf/AutoGenerated/src/tlvf/ieee_1905_1/tlvAlMacAddress.cpp b/framework/tlvf/AutoGenerated/src/tlvf/ieee_1905_1/tlvAlMacAddress.cpp new file mode 100644 index 0000000000..165c28e51c --- /dev/null +++ b/framework/tlvf/AutoGenerated/src/tlvf/ieee_1905_1/tlvAlMacAddress.cpp @@ -0,0 +1,118 @@ +/////////////////////////////////////// +// AUTO GENERATED FILE - DO NOT EDIT // +/////////////////////////////////////// + +/* SPDX-License-Identifier: BSD-2-Clause-Patent + * + * SPDX-FileCopyrightText: 2016-2020 the prplMesh contributors (see AUTHORS.md) + * + * This code is subject to the terms of the BSD+Patent license. + * See LICENSE file for more details. + */ + +#include +#include + +using namespace ieee1905_1; + +tlvAlMacAddress::tlvAlMacAddress(uint8_t* buff, size_t buff_len, bool parse) : + BaseClass(buff, buff_len, parse) { + m_init_succeeded = init(); +} +tlvAlMacAddress::tlvAlMacAddress(std::shared_ptr base, bool parse) : +BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){ + m_init_succeeded = init(); +} +tlvAlMacAddress::~tlvAlMacAddress() { +} +const eTlvType& tlvAlMacAddress::type() { + return (const eTlvType&)(*m_type); +} + +const uint16_t& tlvAlMacAddress::length() { + return (const uint16_t&)(*m_length); +} + +sMacAddr& tlvAlMacAddress::mac() { + return (sMacAddr&)(*m_mac); +} + +void tlvAlMacAddress::class_swap() +{ + tlvf_swap(16, reinterpret_cast(m_length)); + m_mac->struct_swap(); +} + +bool tlvAlMacAddress::finalize() +{ + if (m_parse__) { + TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set"; + return true; + } + if (m_finalized__) { + TLVF_LOG(DEBUG) << "finalize() called for already finalized class"; + return true; + } + if (!isPostInitSucceeded()) { + TLVF_LOG(ERROR) << "post init check failed"; + return false; + } + if (m_inner__) { + if (!m_inner__->finalize()) { + TLVF_LOG(ERROR) << "m_inner__->finalize() failed"; + return false; + } + auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength(); + m_buff_ptr__ -= tailroom; + *m_length -= tailroom; + } + class_swap(); + m_finalized__ = true; + return true; +} + +size_t tlvAlMacAddress::get_initial_size() +{ + size_t class_size = 0; + class_size += sizeof(eTlvType); // type + class_size += sizeof(uint16_t); // length + class_size += sizeof(sMacAddr); // mac + return class_size; +} + +bool tlvAlMacAddress::init() +{ + if (getBuffRemainingBytes() < get_initial_size()) { + TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed"; + return false; + } + m_type = reinterpret_cast(m_buff_ptr__); + if (!m_parse__) *m_type = eTlvType::TLV_AL_MAC_ADDRESS; + if (!buffPtrIncrementSafe(sizeof(eTlvType))) { + LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(eTlvType) << ") Failed!"; + return false; + } + m_length = reinterpret_cast(m_buff_ptr__); + if (!m_parse__) *m_length = 0; + if (!buffPtrIncrementSafe(sizeof(uint16_t))) { + LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint16_t) << ") Failed!"; + return false; + } + m_mac = reinterpret_cast(m_buff_ptr__); + if (!buffPtrIncrementSafe(sizeof(sMacAddr))) { + LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!"; + return false; + } + if(m_length && !m_parse__){ (*m_length) += sizeof(sMacAddr); } + if (!m_parse__) { m_mac->struct_init(); } + if (m_parse__) { class_swap(); } + if (m_parse__) { + if (*m_type != eTlvType::TLV_AL_MAC_ADDRESS) { + TLVF_LOG(ERROR) << "TLV type mismatch. Expected value: " << int(eTlvType::TLV_AL_MAC_ADDRESS) << ", received value: " << int(*m_type); + return false; + } + } + return true; +} + + diff --git a/framework/tlvf/AutoGenerated/src/tlvf/wfa_map/tlvBackhaulSteeringRequest.cpp b/framework/tlvf/AutoGenerated/src/tlvf/wfa_map/tlvBackhaulSteeringRequest.cpp new file mode 100644 index 0000000000..f8d211cd5f --- /dev/null +++ b/framework/tlvf/AutoGenerated/src/tlvf/wfa_map/tlvBackhaulSteeringRequest.cpp @@ -0,0 +1,153 @@ +/////////////////////////////////////// +// AUTO GENERATED FILE - DO NOT EDIT // +/////////////////////////////////////// + +/* SPDX-License-Identifier: BSD-2-Clause-Patent + * + * SPDX-FileCopyrightText: 2016-2020 the prplMesh contributors (see AUTHORS.md) + * + * This code is subject to the terms of the BSD+Patent license. + * See LICENSE file for more details. + */ + +#include +#include + +using namespace wfa_map; + +tlvBackhaulSteeringRequest::tlvBackhaulSteeringRequest(uint8_t* buff, size_t buff_len, bool parse) : + BaseClass(buff, buff_len, parse) { + m_init_succeeded = init(); +} +tlvBackhaulSteeringRequest::tlvBackhaulSteeringRequest(std::shared_ptr base, bool parse) : +BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){ + m_init_succeeded = init(); +} +tlvBackhaulSteeringRequest::~tlvBackhaulSteeringRequest() { +} +const eTlvTypeMap& tlvBackhaulSteeringRequest::type() { + return (const eTlvTypeMap&)(*m_type); +} + +const uint16_t& tlvBackhaulSteeringRequest::length() { + return (const uint16_t&)(*m_length); +} + +sMacAddr& tlvBackhaulSteeringRequest::backhaul_station_mac() { + return (sMacAddr&)(*m_backhaul_station_mac); +} + +sMacAddr& tlvBackhaulSteeringRequest::target_bssid() { + return (sMacAddr&)(*m_target_bssid); +} + +uint8_t& tlvBackhaulSteeringRequest::operating_class() { + return (uint8_t&)(*m_operating_class); +} + +uint8_t& tlvBackhaulSteeringRequest::target_channel_number() { + return (uint8_t&)(*m_target_channel_number); +} + +void tlvBackhaulSteeringRequest::class_swap() +{ + tlvf_swap(16, reinterpret_cast(m_length)); + m_backhaul_station_mac->struct_swap(); + m_target_bssid->struct_swap(); +} + +bool tlvBackhaulSteeringRequest::finalize() +{ + if (m_parse__) { + TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set"; + return true; + } + if (m_finalized__) { + TLVF_LOG(DEBUG) << "finalize() called for already finalized class"; + return true; + } + if (!isPostInitSucceeded()) { + TLVF_LOG(ERROR) << "post init check failed"; + return false; + } + if (m_inner__) { + if (!m_inner__->finalize()) { + TLVF_LOG(ERROR) << "m_inner__->finalize() failed"; + return false; + } + auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength(); + m_buff_ptr__ -= tailroom; + *m_length -= tailroom; + } + class_swap(); + m_finalized__ = true; + return true; +} + +size_t tlvBackhaulSteeringRequest::get_initial_size() +{ + size_t class_size = 0; + class_size += sizeof(eTlvTypeMap); // type + class_size += sizeof(uint16_t); // length + class_size += sizeof(sMacAddr); // backhaul_station_mac + class_size += sizeof(sMacAddr); // target_bssid + class_size += sizeof(uint8_t); // operating_class + class_size += sizeof(uint8_t); // target_channel_number + return class_size; +} + +bool tlvBackhaulSteeringRequest::init() +{ + if (getBuffRemainingBytes() < get_initial_size()) { + TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed"; + return false; + } + m_type = reinterpret_cast(m_buff_ptr__); + if (!m_parse__) *m_type = eTlvTypeMap::TLV_BACKHAUL_STEERING_REQUEST; + if (!buffPtrIncrementSafe(sizeof(eTlvTypeMap))) { + LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(eTlvTypeMap) << ") Failed!"; + return false; + } + m_length = reinterpret_cast(m_buff_ptr__); + if (!m_parse__) *m_length = 0; + if (!buffPtrIncrementSafe(sizeof(uint16_t))) { + LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint16_t) << ") Failed!"; + return false; + } + m_backhaul_station_mac = reinterpret_cast(m_buff_ptr__); + if (!buffPtrIncrementSafe(sizeof(sMacAddr))) { + LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!"; + return false; + } + if(m_length && !m_parse__){ (*m_length) += sizeof(sMacAddr); } + if (!m_parse__) { m_backhaul_station_mac->struct_init(); } + m_target_bssid = reinterpret_cast(m_buff_ptr__); + if (!buffPtrIncrementSafe(sizeof(sMacAddr))) { + LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!"; + return false; + } + if(m_length && !m_parse__){ (*m_length) += sizeof(sMacAddr); } + if (!m_parse__) { m_target_bssid->struct_init(); } + m_operating_class = reinterpret_cast(m_buff_ptr__); + if (!buffPtrIncrementSafe(sizeof(uint8_t))) { + LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!"; + return false; + } + if(m_length && !m_parse__){ (*m_length) += sizeof(uint8_t); } + m_target_channel_number = reinterpret_cast(m_buff_ptr__); + if (!buffPtrIncrementSafe(sizeof(uint8_t))) { + LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint8_t) << ") Failed!"; + return false; + } + if(m_length && !m_parse__){ (*m_length) += sizeof(uint8_t); } + if (m_parse__) { class_swap(); } + if (m_parse__) { + if (*m_type != eTlvTypeMap::TLV_BACKHAUL_STEERING_REQUEST) { + TLVF_LOG(ERROR) << "TLV type mismatch. Expected value: " << int(eTlvTypeMap::TLV_BACKHAUL_STEERING_REQUEST) << ", received value: " << int(*m_type); + return false; + } + } + return true; +} + + diff --git a/framework/tlvf/AutoGenerated/src/tlvf/wfa_map/tlvBackhaulSteeringResponse.cpp b/framework/tlvf/AutoGenerated/src/tlvf/wfa_map/tlvBackhaulSteeringResponse.cpp new file mode 100644 index 0000000000..9d3b307777 --- /dev/null +++ b/framework/tlvf/AutoGenerated/src/tlvf/wfa_map/tlvBackhaulSteeringResponse.cpp @@ -0,0 +1,143 @@ +/////////////////////////////////////// +// AUTO GENERATED FILE - DO NOT EDIT // +/////////////////////////////////////// + +/* SPDX-License-Identifier: BSD-2-Clause-Patent + * + * SPDX-FileCopyrightText: 2016-2020 the prplMesh contributors (see AUTHORS.md) + * + * This code is subject to the terms of the BSD+Patent license. + * See LICENSE file for more details. + */ + +#include +#include + +using namespace wfa_map; + +tlvBackhaulSteeringResponse::tlvBackhaulSteeringResponse(uint8_t* buff, size_t buff_len, bool parse) : + BaseClass(buff, buff_len, parse) { + m_init_succeeded = init(); +} +tlvBackhaulSteeringResponse::tlvBackhaulSteeringResponse(std::shared_ptr base, bool parse) : +BaseClass(base->getBuffPtr(), base->getBuffRemainingBytes(), parse){ + m_init_succeeded = init(); +} +tlvBackhaulSteeringResponse::~tlvBackhaulSteeringResponse() { +} +const eTlvTypeMap& tlvBackhaulSteeringResponse::type() { + return (const eTlvTypeMap&)(*m_type); +} + +const uint16_t& tlvBackhaulSteeringResponse::length() { + return (const uint16_t&)(*m_length); +} + +sMacAddr& tlvBackhaulSteeringResponse::backhaul_station_mac() { + return (sMacAddr&)(*m_backhaul_station_mac); +} + +sMacAddr& tlvBackhaulSteeringResponse::target_bssid() { + return (sMacAddr&)(*m_target_bssid); +} + +tlvBackhaulSteeringResponse::eResultCode& tlvBackhaulSteeringResponse::result_code() { + return (eResultCode&)(*m_result_code); +} + +void tlvBackhaulSteeringResponse::class_swap() +{ + tlvf_swap(16, reinterpret_cast(m_length)); + m_backhaul_station_mac->struct_swap(); + m_target_bssid->struct_swap(); + tlvf_swap(8*sizeof(eResultCode), reinterpret_cast(m_result_code)); +} + +bool tlvBackhaulSteeringResponse::finalize() +{ + if (m_parse__) { + TLVF_LOG(DEBUG) << "finalize() called but m_parse__ is set"; + return true; + } + if (m_finalized__) { + TLVF_LOG(DEBUG) << "finalize() called for already finalized class"; + return true; + } + if (!isPostInitSucceeded()) { + TLVF_LOG(ERROR) << "post init check failed"; + return false; + } + if (m_inner__) { + if (!m_inner__->finalize()) { + TLVF_LOG(ERROR) << "m_inner__->finalize() failed"; + return false; + } + auto tailroom = m_inner__->getMessageBuffLength() - m_inner__->getMessageLength(); + m_buff_ptr__ -= tailroom; + *m_length -= tailroom; + } + class_swap(); + m_finalized__ = true; + return true; +} + +size_t tlvBackhaulSteeringResponse::get_initial_size() +{ + size_t class_size = 0; + class_size += sizeof(eTlvTypeMap); // type + class_size += sizeof(uint16_t); // length + class_size += sizeof(sMacAddr); // backhaul_station_mac + class_size += sizeof(sMacAddr); // target_bssid + class_size += sizeof(eResultCode); // result_code + return class_size; +} + +bool tlvBackhaulSteeringResponse::init() +{ + if (getBuffRemainingBytes() < get_initial_size()) { + TLVF_LOG(ERROR) << "Not enough available space on buffer. Class init failed"; + return false; + } + m_type = reinterpret_cast(m_buff_ptr__); + if (!m_parse__) *m_type = eTlvTypeMap::TLV_BACKHAUL_STEERING_RESPONSE; + if (!buffPtrIncrementSafe(sizeof(eTlvTypeMap))) { + LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(eTlvTypeMap) << ") Failed!"; + return false; + } + m_length = reinterpret_cast(m_buff_ptr__); + if (!m_parse__) *m_length = 0; + if (!buffPtrIncrementSafe(sizeof(uint16_t))) { + LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(uint16_t) << ") Failed!"; + return false; + } + m_backhaul_station_mac = reinterpret_cast(m_buff_ptr__); + if (!buffPtrIncrementSafe(sizeof(sMacAddr))) { + LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!"; + return false; + } + if(m_length && !m_parse__){ (*m_length) += sizeof(sMacAddr); } + if (!m_parse__) { m_backhaul_station_mac->struct_init(); } + m_target_bssid = reinterpret_cast(m_buff_ptr__); + if (!buffPtrIncrementSafe(sizeof(sMacAddr))) { + LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(sMacAddr) << ") Failed!"; + return false; + } + if(m_length && !m_parse__){ (*m_length) += sizeof(sMacAddr); } + if (!m_parse__) { m_target_bssid->struct_init(); } + m_result_code = reinterpret_cast(m_buff_ptr__); + if (!buffPtrIncrementSafe(sizeof(eResultCode))) { + LOG(ERROR) << "buffPtrIncrementSafe(" << std::dec << sizeof(eResultCode) << ") Failed!"; + return false; + } + if(m_length && !m_parse__){ (*m_length) += sizeof(eResultCode); } + if (m_parse__) { class_swap(); } + if (m_parse__) { + if (*m_type != eTlvTypeMap::TLV_BACKHAUL_STEERING_RESPONSE) { + TLVF_LOG(ERROR) << "TLV type mismatch. Expected value: " << int(eTlvTypeMap::TLV_BACKHAUL_STEERING_RESPONSE) << ", received value: " << int(*m_type); + return false; + } + } + return true; +} + + diff --git a/framework/tlvf/src/src/CmduMessageRx.cpp b/framework/tlvf/src/src/CmduMessageRx.cpp index ea730cc5e9..db43454d90 100644 --- a/framework/tlvf/src/src/CmduMessageRx.cpp +++ b/framework/tlvf/src/src/CmduMessageRx.cpp @@ -9,7 +9,7 @@ #include #include #include -#include +#include #include #include #include @@ -35,6 +35,8 @@ #include #include #include +#include +#include #include #include #include @@ -88,7 +90,7 @@ std::shared_ptr CmduMessageRx::parseNextTlv() return msg.addClass(); } case (1): { - return msg.addClass(); + return msg.addClass(); } case (2): { return msg.addClass(); @@ -230,6 +232,12 @@ std::shared_ptr CmduMessageRx::parseNextTlv() case (157): { return msg.addClass(); } + case (158): { + return msg.addClass(); + } + case (159): { + return msg.addClass(); + } case (160): { return msg.addClass(); } diff --git a/framework/tlvf/tlvf_conf.yaml b/framework/tlvf/tlvf_conf.yaml index 702c5ca15a..4c936eaf83 100644 --- a/framework/tlvf/tlvf_conf.yaml +++ b/framework/tlvf/tlvf_conf.yaml @@ -46,6 +46,8 @@ include_yaml_path: { "tlvf/wfa_map/tlvSupportedService.yaml", "tlvf/wfa_map/tlvTimestamp.yaml", "tlvf/wfa_map/tlvTransmitPowerLimit.yaml", + "tlvf/wfa_map/tlvBackhaulSteeringRequest.yaml", + "tlvf/wfa_map/tlvBackhaulSteeringResponse.yaml", } # Relative to tlvf.py src_path variable diff --git a/framework/tlvf/yaml/tlvf/ieee_1905_1/eTlvType.yaml b/framework/tlvf/yaml/tlvf/ieee_1905_1/eTlvType.yaml index cf445c9edf..32a76b42af 100644 --- a/framework/tlvf/yaml/tlvf/ieee_1905_1/eTlvType.yaml +++ b/framework/tlvf/yaml/tlvf/ieee_1905_1/eTlvType.yaml @@ -6,7 +6,7 @@ eTlvType: _type: enum_class _enum_storage: uint8_t TLV_END_OF_MESSAGE: 0x00 - TLV_AL_MAC_ADDRESS_TYPE: 0x01 + TLV_AL_MAC_ADDRESS: 0x01 TLV_MAC_ADDRESS: 0x02 TLV_DEVICE_INFORMATION: 0x03 TLV_DEVICE_BRIDGING_CAPABILITY: 0x04 diff --git a/framework/tlvf/yaml/tlvf/ieee_1905_1/tlvAlMacAddressType.yaml b/framework/tlvf/yaml/tlvf/ieee_1905_1/tlvAlMacAddress.yaml similarity index 67% rename from framework/tlvf/yaml/tlvf/ieee_1905_1/tlvAlMacAddressType.yaml rename to framework/tlvf/yaml/tlvf/ieee_1905_1/tlvAlMacAddress.yaml index 1ed526a3b5..df7450587c 100755 --- a/framework/tlvf/yaml/tlvf/ieee_1905_1/tlvAlMacAddressType.yaml +++ b/framework/tlvf/yaml/tlvf/ieee_1905_1/tlvAlMacAddress.yaml @@ -2,11 +2,11 @@ --- _namespace: ieee1905_1 -tlvAlMacAddressType: +tlvAlMacAddress: _type: class _is_tlv_class: True type: _type: eTlvType - _value_const: TLV_AL_MAC_ADDRESS_TYPE + _value_const: TLV_AL_MAC_ADDRESS length: uint16_t mac: sMacAddr diff --git a/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgApAutoConfigurationRenew.yaml b/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgApAutoConfigurationRenew.yaml index 4d39c26107..2400f483ac 100644 --- a/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgApAutoConfigurationRenew.yaml +++ b/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgApAutoConfigurationRenew.yaml @@ -7,7 +7,7 @@ msgApAutoConfigurationRenew: header: _type: cmduHeader _setValue: { "messageType" : AP_AUTOCONFIGURATION_RENEW_MESSAGE } - tlv_al_mac_tlv: tlvAlMacAddressType + tlv_al_mac_tlv: tlvAlMacAddress tlv_supported_role: tlvSupportedRole tlv_supported_freq_band: tlvSupportedFreqBand tlv_eof: tlvEndOfMessage \ No newline at end of file diff --git a/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgApAutoConfigurationSearch.yaml b/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgApAutoConfigurationSearch.yaml index c52087c503..c93b28e73c 100644 --- a/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgApAutoConfigurationSearch.yaml +++ b/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgApAutoConfigurationSearch.yaml @@ -7,7 +7,7 @@ msgApAutoConfigurationSearch: header: _type: cmduHeader _setValue: { "messageType" : AP_AUTOCONFIGURATION_SEARCH_MESSAGE } - tlv_al_mac_tlv: tlvAlMacAddressType + tlv_al_mac_tlv: tlvAlMacAddress tlv_searched_role: tlvSearchedRole tlv_auto_conf_freq_band: tlvAutoconfigFreqBand tlv_eof: tlvEndOfMessage \ No newline at end of file diff --git a/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgPushButtonEventNotification.yaml b/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgPushButtonEventNotification.yaml index 5e4264e544..09ed65658a 100644 --- a/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgPushButtonEventNotification.yaml +++ b/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgPushButtonEventNotification.yaml @@ -7,6 +7,6 @@ msgPushButtonEventNotification: header: _type: cmduHeader _setValue: { "messageType" : PUSH_BUTTON_EVENT_NOTIFICATION_MESSAGE } - tlv_al_mac_tlv: tlvAlMacAddressType + tlv_al_mac_tlv: tlvAlMacAddress tlv_push_butt_event_notif: tlvPushButtonEventNotification tlv_eof: tlvEndOfMessage \ No newline at end of file diff --git a/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgPushButtonJoinNotification.yaml b/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgPushButtonJoinNotification.yaml index 5f8ccd82be..f2ccf9d12b 100644 --- a/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgPushButtonJoinNotification.yaml +++ b/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgPushButtonJoinNotification.yaml @@ -7,6 +7,6 @@ msgPushButtonJoinNotification: header: _type: cmduHeader _setValue: { "messageType" : PUSH_BUTTON_JOIN_NOTIFICATION_MESSAGE } - tlv_al_mac_tlv: tlvAlMacAddressType + tlv_al_mac_tlv: tlvAlMacAddress tlv_push_butt_join_notif: tlvPushButtonJoinNotification tlv_eof: tlvEndOfMessage \ No newline at end of file diff --git a/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgTopologyDiscovery.yaml b/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgTopologyDiscovery.yaml index 4445a61c20..90c011dbac 100644 --- a/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgTopologyDiscovery.yaml +++ b/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgTopologyDiscovery.yaml @@ -7,7 +7,7 @@ msgTopologyDiscovery: header: _type: cmduHeader _setValue: { "messageType" : TOPOLOGY_DISCOVERY_MESSAGE } - tlv_al_mac_tlv: tlvAlMacAddressType - tlv_mac_tlv: tlvAlMacAddressType + tlv_al_mac_tlv: tlvAlMacAddress + tlv_mac_tlv: tlvMacAddress tlv_eof: tlvEndOfMessage \ No newline at end of file diff --git a/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgTopologyNotification.yaml b/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgTopologyNotification.yaml index e870ec7d22..aae39736c6 100644 --- a/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgTopologyNotification.yaml +++ b/framework/tlvf/yaml/tlvf/ieee_1905_1_msg/msgTopologyNotification.yaml @@ -7,5 +7,5 @@ msgTopologyNotification: header: _type: cmduHeader _setValue: { "messageType" : TOPOLOGY_NOTIFICATION_MESSAGE } - tlv_al_mac_tlv: tlvAlMacAddressType + tlv_al_mac_tlv: tlvAlMacAddress tlv_eof: tlvEndOfMessage \ No newline at end of file diff --git a/tests/boardfarm_plugins/boardfarm_prplmesh/devices/prplmesh_docker.py b/tests/boardfarm_plugins/boardfarm_prplmesh/devices/prplmesh_docker.py index aa41f53691..d4f9870d3c 100644 --- a/tests/boardfarm_plugins/boardfarm_prplmesh/devices/prplmesh_docker.py +++ b/tests/boardfarm_plugins/boardfarm_prplmesh/devices/prplmesh_docker.py @@ -51,14 +51,14 @@ def __init__(self, *args, **kwargs): self._run_shell_cmd(docker_cmd, docker_args) time.sleep(self.delay) - self.controller_entity = ALEntityDocker(self.name, is_controller=True) + self.controller_entity = ALEntityDocker(self.name, device=self, is_controller=True) else: # Spawn dockerized agent docker_args.append("start-agent") self._run_shell_cmd(docker_cmd, docker_args) time.sleep(self.delay) - self.agent_entity = ALEntityDocker(self.name, is_controller=False) + self.agent_entity = ALEntityDocker(self.name, device=self, is_controller=False) self.wired_sniffer = Sniffer(_get_bridge_interface(self.docker_network), boardfarm.config.output_dir) @@ -83,3 +83,10 @@ def isalive(self): States that device is operational and its consoles are accessible. """ return True + + def prprlmesh_status_check(self) -> bool: + """Check prplMesh status by executing status command to initd service. + Return True if operational. + """ + self.check_status() + return True diff --git a/tests/boardfarm_plugins/boardfarm_prplmesh/devices/prplmesh_prplwrt.py b/tests/boardfarm_plugins/boardfarm_prplmesh/devices/prplmesh_prplwrt.py index 877373aadf..b8e9120c6c 100644 --- a/tests/boardfarm_plugins/boardfarm_prplmesh/devices/prplmesh_prplwrt.py +++ b/tests/boardfarm_plugins/boardfarm_prplmesh/devices/prplmesh_prplwrt.py @@ -6,9 +6,19 @@ ############################################################### import boardfarm -from boardfarm.devices import OpenWrtRouter -from environment import ALEntityPrplWrt, _get_bridge_interface +import json +import os +import pexpect +import signal +import subprocess +import sys +import time + from .prplmesh_base import PrplMeshBase +from boardfarm.devices import connection_decider +from boardfarm.devices.openwrt_router import OpenWrtRouter +from environment import ALEntityPrplWrt, _get_bridge_interface +from ipaddress import IPv4Network, IPv4Address from sniffer import Sniffer @@ -16,9 +26,10 @@ class PrplMeshPrplWRT(OpenWrtRouter, PrplMeshBase): """prplWRT burned device with prplMesh installed.""" model = "prplWRT" - prompt = ['root\\@OpenWrt:/#', '/#', '@OpenWrt:/#'] + prompt = ['root\\@OpenWrt:/#', '/#', '@OpenWrt:/#', "@OpenWrt:~#"] wan_iface = "eth1" uboot_eth = "eth0_1" + linesep = "\r" agent_entity = None controller_entity = None @@ -27,17 +38,74 @@ def __init__(self, *args, **kwargs): self.args = args self.kwargs = kwargs config = kwargs.get("config", kwargs) + + self.unique_id = os.getenv("SUDO_USER", os.getenv("USER", "")) self.docker_network = config.get("docker_network", "prplMesh-net-{}".format(self.unique_id)) self.role = config.get("role", "agent") - if self.role == "controller": - self.controller_entity = ALEntityPrplWrt(self.name, is_controller=True) - else: - self.agent_entity = ALEntityPrplWrt(self.name, is_controller=False) + self.connection_type = config.get("connection_type", None) + self.conn_cmd = config.get("conn_cmd", None) + self.wan_ip = config.get("wan_ip", None) + self.username = config.get("username", "root") + + self.name = "-".join((config.get("name", "netgear-rax40"), self.unique_id)) + + # If no WAN IP is set in config file retrieve IP from docker network set in config + # X.X.X.245 IP will be selected from docker network + if not self.wan_ip: + self.connection = connection_decider.connection(device=self, + conn_type="local_serial", + **kwargs) + self.connection.connect() + self.consoles = [self] + self.logfile_read = sys.stdout + self.wan_network = self.get_docker_subnet() + self.wan_ip = self.wan_network[+245] + self.set_iface_ip("br-lan", self.wan_ip, self.wan_network.prefixlen) + self.connection.close() + self.kill(signal.SIGTERM) + # Removal of PID is required by pexpect in order to spawn a new process + # serial connection should be terminated by 2 commands above + self.pid = None self.wired_sniffer = Sniffer(_get_bridge_interface(self.docker_network), boardfarm.config.output_dir) - self.check_status() + self.connection = connection_decider.connection(device=self, + conn_type="ssh", + conn_cmd="ssh {}@{}".format( + self.username, self.wan_ip)) + self.connection.connect() + # Append active connection to the general array for logging + self.consoles = [self] + # Point what to log as data read from child process of pexpect + # Result: boardfarm will log communication in separate file + self.logfile_read = sys.stdout + self.add_iface_to_bridge(self.wan_iface, "br-lan") + + if self.role == "controller": + self.controller_entity = ALEntityPrplWrt(self, is_controller=True) + else: + self.agent_entity = ALEntityPrplWrt(self, is_controller=False) + self.prplmesh_start_agent() + + def _prplMesh_exec(self, mode: str): + """Send line to prplmesh initd script.""" + self.sendline("/etc/init.d/prplmesh {}".format(mode)) + + def _prplmesh_status_poll(self, timeout: int = 120) -> bool: + """Poll prplMesh status for timeout time. + + Main agent and wlan0, wlan2 radios should be operational. + Return True if status is operational and timeout not reached. + """ + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + if self.get_prplMesh_status(): + break + time.sleep(5) + else: + return False + return True def check_status(self) -> bool: """Check status of device, return bool to indicate state. @@ -45,11 +113,17 @@ def check_status(self) -> bool: It is used by boardfarm to indicate that spawned device instance is ready for test and also after test - to insure that device still operational. """ + return True + + def get_prplMesh_status(self) -> bool: + """ Check prplMesh status. Return True if operational.""" self.sendline("/etc/init.d/prplmesh status") - match = self.expect( - ["OPERATIONAL", self.device.pexpect.EOF, self.device.pexpect.TIMEOUT], - timeout=10) - if match == 1: + self.expect( + ["(?POK) Main agent.+" + "(?POK) wlan0.+" + "(?POK) wlan2", pexpect.TIMEOUT], + timeout=5) + if self.match is not pexpect.TIMEOUT: return True else: return False @@ -67,3 +141,42 @@ def touch(self): Purpose is to keep consoles active, so they don't disconnect for long running activities. """ pass + + def get_docker_subnet(self) -> IPv4Network: + """Get subnet used by docker network.""" + docker_network_inspect_cmd = ('docker', 'network', 'inspect', self.docker_network) + inspect_raw = subprocess.run(docker_network_inspect_cmd, stdout=subprocess.PIPE) + if inspect_raw.returncode != 0: + # Assume network doesn't exist yet. Create it. + # Raise an exception if it fails (check=True). + subprocess.run(('docker', 'network', 'create', self.docker_network), check=True, + stdout=subprocess.DEVNULL) + # Inspect again, now raise if it fails (check=True). + inspect_raw = subprocess.run(docker_network_inspect_cmd, check=True, + stdout=subprocess.PIPE) + inspect_json = json.loads(inspect_raw.stdout) + + return IPv4Network(inspect_json[0]["IPAM"]["Config"][0]["Subnet"]) + + def add_iface_to_bridge(self, iface: str, bridge: str) -> bool: + """Add specified interface to the specified bridge.""" + ip_command = ("ip link set {} master {}".format(iface, bridge)) + self.sendline(ip_command) + self.expect(self.prompt, timeout=10) + + def set_iface_ip(self, iface: str, ip: IPv4Address, prefixlen: int) -> bool: + """Set interface IPv4 address.""" + self.sendline("ip a add {}/{} dev {}".format(ip, prefixlen, iface)) + self.expect(self.prompt, timeout=10) + + def prplmesh_start_agent(self) -> bool: + """Start prplMesh in certification_mode agent. Return true if done.""" + self._prplMesh_exec("certification_mode agent") + self.expect(self.prompt) + return True + + def prprlmesh_status_check(self) -> bool: + """Check prplMesh status by executing status command to initd service. + Return True if operational. + """ + return self._prplmesh_status_poll() diff --git a/tests/boardfarm_plugins/boardfarm_prplmesh/prplmesh_config.json b/tests/boardfarm_plugins/boardfarm_prplmesh/prplmesh_config.json index b8114775c1..7a55f651c2 100644 --- a/tests/boardfarm_plugins/boardfarm_prplmesh/prplmesh_config.json +++ b/tests/boardfarm_plugins/boardfarm_prplmesh/prplmesh_config.json @@ -16,5 +16,21 @@ "conn_cmd": "" } ] + }, + "netgear-rax40-1": { + "name": "agent-rax40", + "board_type": "prplWRT", + "role": "agent", + "docker_network": "prplMesh-net-rax40-1", + "conn_cmd": "cu -s 115200 -l /dev/ttyUSB0", + "devices": [ + { + "name": "controller", + "type": "prplmesh_docker", + "role": "controller", + "docker_network": "prplMesh-net-rax40-1", + "conn_cmd": "" + } + ] } } diff --git a/tests/boardfarm_plugins/boardfarm_prplmesh/tests/initial_ap_config.py b/tests/boardfarm_plugins/boardfarm_prplmesh/tests/initial_ap_config.py index d8432cf1ba..c959dadb21 100644 --- a/tests/boardfarm_plugins/boardfarm_prplmesh/tests/initial_ap_config.py +++ b/tests/boardfarm_plugins/boardfarm_prplmesh/tests/initial_ap_config.py @@ -14,6 +14,11 @@ def runTest(self): if dev.agent_entity: dev.wired_sniffer.start(self.__class__.__name__ + "-" + dev.name) + self.prplmesh_status_check(dev.agent_entity) + self.check_log(dev.agent_entity.radios[0], + r"\(WSC M2 Encrypted Settings\)") + self.check_log(dev.agent_entity.radios[1], + r"\(WSC M2 Encrypted Settings\)") self.check_log(dev.agent_entity.radios[0], r"WSC Global authentication success") self.check_log(dev.agent_entity.radios[1], @@ -22,13 +27,18 @@ def runTest(self): r"KWA \(Key Wrap Auth\) success") self.check_log(dev.agent_entity.radios[1], r"KWA \(Key Wrap Auth\) success") - self.check_log(dev.agent_entity.radios[0], - r".* Controller configuration \(WSC M2 Encrypted Settings\)") - self.check_log(dev.agent_entity.radios[1], - r".* Controller configuration \(WSC M2 Encrypted Settings\)") - - dev.wired_sniffer.stop() @classmethod def teardown_class(cls): """Teardown method, optional for boardfarm tests.""" + test = cls.test_obj + for dev in test.dev: + if dev.agent_entity: + print("Sniffer - stop") + # Send Ctrl+C to the device to terminate "tail -f" + # Which is used to read log from device. Required only for tests on HW + try: + dev.agent_entity.device.send('\003') + except AttributeError: + pass + dev.wired_sniffer.stop() diff --git a/tests/boardfarm_plugins/boardfarm_prplmesh/tests/prplmesh_base_test.py b/tests/boardfarm_plugins/boardfarm_prplmesh/tests/prplmesh_base_test.py index 9a9f32ef9f..5e03247c77 100644 --- a/tests/boardfarm_plugins/boardfarm_prplmesh/tests/prplmesh_base_test.py +++ b/tests/boardfarm_plugins/boardfarm_prplmesh/tests/prplmesh_base_test.py @@ -16,8 +16,17 @@ class PrplMeshBaseTest(bft_base_test.BftBaseTest): """ def check_log(self, entity_or_radio: Union[env.ALEntity, env.Radio], regex: str, - start_line: int = 0, timeout: float = 0.3) -> bool: + start_line: int = 0, timeout: float = 0.6) -> bool: result, line, match = entity_or_radio.wait_for_log(regex, start_line, timeout) if not result: raise Exception return result, line, match + + def prplmesh_status_check(self, entity_or_radio: Union[env.ALEntity, env.Radio]) -> bool: + """Check prplMesh status by executing status command to initd service. + Return True if operational. + """ + result = entity_or_radio.prprlmesh_status_check() + if not result: + raise Exception + return result diff --git a/tests/environment.py b/tests/environment.py index 155436df41..675397d33f 100644 --- a/tests/environment.py +++ b/tests/environment.py @@ -225,16 +225,23 @@ def logfilename(program): def _device_wait_for_log(device: None, log_path: str, regex: str, - start_line: int, timeout: int) -> bool: - """Waits for log mathing regex expression to show up.""" - device.sendline("tail -n10 -f {}".format(log_path)) - match = device.expect( - pattern=[regex, device.pexpect.EOF, device.pexpect.TIMEOUT], - timeout=timeout) - if match == 1: - return True + timeout: int, start_line: int = 0): + """Waits for log matching regex expression to show up.""" + device.sendline("tail -f -n +{:d} {}".format(start_line + 1, log_path)) + device.expect(regex, timeout=timeout) + match = device.match.group(0) + # Send Ctrl-C to interrupt tail -f + device.send('\003') + device.expect(device.prompt) + if match: + device.sendline("tail -n +{:d} {} | grep -n \"{}\"".format(start_line, log_path, match)) + # Typical output of grep -n from log: "line_num:severity" + # this regex has to capture just number of line in log + device.expect(r"(?P[0-9]+):[A-Z]+\s[0-9]", timeout=timeout) + matched_line = int(device.match.group('line_number')) + start_line + return (True, matched_line, match) else: - return False + return (False, start_line, None) class ALEntityDocker(ALEntity): @@ -242,10 +249,13 @@ class ALEntityDocker(ALEntity): The entity is defined from the name of the container, the rest is derived from that. ''' - - def __init__(self, name: str, is_controller: bool = False): + # NOTE: name arg can be also extracted from the device class itself, but test_flows.py + # don't have it. We can remove this arg as soon, as we drop test_flows.py + def __init__(self, name: str, device: None = None, is_controller: bool = False): self.name = name self.bridge_name = 'br-lan' + if device: + self.device = device # First, get the UCC port from the config file if is_controller: @@ -254,7 +264,8 @@ def __init__(self, name: str, is_controller: bool = False): config_file_name = 'beerocks_agent.conf' with open(os.path.join(installdir, 'config', config_file_name)) as config_file: ucc_port = \ - re.search(r'ucc_listener_port=(?P[0-9]+)', config_file.read()).group('port') + re.search(r'ucc_listener_port=(?P[0-9]+)', + config_file.read()).group('port') # On WSL, connect to the locally exposed container port if on_wsl: @@ -265,8 +276,8 @@ def __init__(self, name: str, is_controller: bool = False): else: device_ip_output = self.command( 'ip', '-f', 'inet', 'addr', 'show', self.bridge_name) - device_ip = re.search( - r'inet (?P[0-9.]+)', device_ip_output.decode('utf-8')).group('ip') + device_ip = re.search(r'inet (?P[0-9.]+)', + device_ip_output.decode('utf-8')).group('ip') ucc_socket = UCCSocket(device_ip, ucc_port) mac = ucc_socket.dev_get_parameter('ALid') @@ -286,14 +297,17 @@ def wait_for_log(self, regex: str, start_line: int, timeout: float) -> bool: program = "controller" if self.is_controller else "agent" return _docker_wait_for_log(self.name, [program], regex, start_line, timeout) + def prprlmesh_status_check(self): + return self.device.prprlmesh_status_check() + class RadioDocker(Radio): '''Docker implementation of a radio.''' - def __init__(self, agent: ALEntityDocker, iface_name: str): self.iface_name = iface_name ip_output = agent.command("ip", "-o", "link", "list", "dev", self.iface_name).decode() - mac = re.search(r"link/ether (([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2})", ip_output).group(1) + mac = re.search(r"link/ether (([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2})", + ip_output).group(1) super().__init__(agent, mac) # Since dummy bwl always uses the first VAP, in practice we always have a single VAP with @@ -389,8 +403,8 @@ def launch_environment_docker(unique_id: str, skip_init: bool = False, tag: str wired_sniffer.stop() global controller, agents - controller = ALEntityDocker(gateway, True) - agents = (ALEntityDocker(repeater1), ALEntityDocker(repeater2)) + controller = ALEntityDocker(name=gateway, is_controller=True) + agents = (ALEntityDocker(name=repeater1), ALEntityDocker(name=repeater2)) debug('controller: {}'.format(controller.mac)) debug('agent1: {}'.format(agents[0].mac)) @@ -404,66 +418,72 @@ def launch_environment_docker(unique_id: str, skip_init: bool = False, tag: str class ALEntityPrplWrt(ALEntity): """Abstraction of ALEntity in real device.""" - def __init__(self, name: str, device: None, is_controller: bool = False): + def __init__(self, device: None, is_controller: bool = False): self.device = device - self.name = name - self.bridge_name = 'br-lan' + self.name = device.name if is_controller: self.config_file_name = '/opt/prplmesh/config/beerocks_controller.conf' else: self.config_file_name = '/opt/prplmesh/config/beerocks_agent.conf' - ucc_port = self.command(("grep \"ucc_listener_port\" {} " - "| cut -d'=' -f2 | cut -d\" \" -f 1").format(self.config_file_name)) - - device_ip_output = self.command( - "ip -f inet addr show {} | head -n 2".format(self.bridge_name)) - device_ip = re.search( - r'inet (?P[0-9.]+)', device_ip_output.decode('utf-8')).group('ip') - self.log_folder = self.command( - "grep log_files_path {} | cut -d=\'=\' -f2".format(self.config_file_name)) - - ucc_socket = UCCSocket(device_ip, ucc_port) + ucc_port_raw = self.command("grep \"ucc_listener_port\" {}".format(self.config_file_name)) + ucc_port = int(re.search(r'ucc_listener_port=(?P[0-9]+)', + ucc_port_raw).group('port')) + bridge_name_raw = self.command("grep \"bridge_iface\" {}".format(self.config_file_name)) + self.bridge_name = re.search(r'bridge_iface=(?P.+)\r\n', + bridge_name_raw).group('bridge') + log_folder_raw = self.command( + "grep log_files_path {}".format(self.config_file_name)) + self.log_folder = re.search(r'log_files_path=(?P[a-zA-Z0-9_\/]+)', + log_folder_raw).group('log_path') + ucc_socket = UCCSocket(str(self.device.wan_ip), int(ucc_port)) mac = ucc_socket.dev_get_parameter('ALid') super().__init__(mac, ucc_socket, installdir, is_controller) # We always have two radios, wlan0 and wlan2 - RadioHostapd(self, "wlan0", device=self) - RadioHostapd(self, "wlan2", device=self) + RadioHostapd(self, "wlan0") + RadioHostapd(self, "wlan2") def command(self, *command: str) -> bytes: """Execute `command` in device and return its output.""" - self.device.sendline(command) - return self.device.read() + self.device.sendline(" ".join(command)) + self.device.expect(self.device.prompt, timeout=10) + return self.device.before def wait_for_log(self, regex: str, start_line: int, timeout: float) -> bool: """Poll the entity's logfile until it contains "regex" or times out.""" program = "controller" if self.is_controller else "agent" + # Multiply timeout by 100, as test sets it in float. return _device_wait_for_log(self.device, "{}/beerocks_{}.log".format(self.log_folder, program), - regex, start_line, timeout) + regex, start_line, timeout*100) + + def prprlmesh_status_check(self): + return self.device.prprlmesh_status_check() class RadioHostapd(Radio): """Abstraction of real Radio in prplWRT device.""" - def __init__(self, agent: ALEntityPrplWrt, bssid: str, device: None): - self.iface_name = bssid - ip_output = agent.command("ip -o link list dev {}".format(self.iface_name)) - mac = re.search(r"link/ether (([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2})", ip_output).group(1) - self.log_folder = self.command( - "grep log_files_path {} | cut -d=\'=\' -f2".format(self.config_file_name)) + def __init__(self, agent: ALEntityPrplWrt, iface_name: str): + self.iface_name = iface_name + self.agent = agent + ip_raw = self.agent.command("ip link list dev {}".format(self.iface_name)) + mac = re.search(r"link/ether (([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2})", + ip_raw).group(1) + self.log_folder = agent.log_folder super().__init__(agent, mac) VirtualAPHostapd(self, mac) VirtualAPHostapd(self, mac) - def wait_for_log(self, regex: str, start_line: int, timeout: float) -> bool: + def wait_for_log(self, regex: str, start_line: int, timeout: float): ''' Poll the Radio's logfile until it match regular expression ''' - return _device_wait_for_log(self.device, "{}/beerocks_agent_{}.log".format( - self.log_folder, self.iface_name), regex, start_line, timeout) + # Multiply timeout by 100, as test sets it in float. + return _device_wait_for_log(self.agent.device, "{}/beerocks_agent_{}.log".format( + self.log_folder, self.iface_name), regex, timeout*100, start_line) class VirtualAPHostapd(VirtualAP): @@ -475,7 +495,9 @@ def __init__(self, radio: RadioHostapd, bssid: str): def associate(self, sta: Station) -> bool: ''' Associate "sta" with this VAP ''' # TODO: complete this stub + return True def disassociate(self, sta: Station) -> bool: ''' Disassociate "sta" from this VAP.''' # TODO: complete this stub + return True diff --git a/tests/test_flows.py b/tests/test_flows.py index 065e806d22..9f8e897bfe 100755 --- a/tests/test_flows.py +++ b/tests/test_flows.py @@ -1189,6 +1189,68 @@ def test_beacon_report_query(self): # r"inserting 1 RRM_EVENT_BEACON_REP_RXED event(s) to the pending list") env.agents[0].radios[0].vaps[0].disassociate(sta) + def test_ap_metrics_interval_response(self): + # Trigger( + # DEV_SEND_1905,DestAL id, + # WTS_REPLACE_DEST_A LID, + # MessageTypeValue,0x8003, + # tlv_type,0x8A, + # tlv_length,0x000C, + # tlv_value,{0x05 0x01 {WTS_REPLACE_MAUT_RUID 0x00 0x00 0x00 0xC0}) + + # set vaps for both agents + for agent in range(0, 2): + env.beerocks_cli_command('bml_clear_wifi_credentials {}'.format(env.agents[agent].mac)) + env.beerocks_cli_command('bml_set_wifi_credentials {} {} {} {} {}' + .format(env.agents[agent].mac, + "Multi-AP-24G-3-cli", "maprocks1", "24g", "fronthaul")) + env.beerocks_cli_command('bml_update_wifi_credentials {}'.format(env.agents[agent].mac)) + + # create and associate stations + + sta1 = env.Station.create() + debug("Connect dummy STA (" + sta1.mac + ") to wlan0") + env.agents[0].radios[0].vaps[0].associate(sta1) + + sta2 = env.Station.create() + debug("Connect dummy STA (" + sta2.mac + ") to wlan2") + env.agents[1].radios[1].vaps[0].associate(sta2) + + debug("sending multi-ap policy config request") + + # in seconds + interval_time = 5 + tlv_value = '0x{:02} 0x01 0x{ruid} 0x00 0x00 0x00 0xC0'.format( + interval_time, ruid=env.agents[0].radios[0].mac.replace(':', '')) + + debug(tlv_value) + + # sending two commands to the controller, for each agent + env.controller.dev_send_1905(env.agents[0].mac, 0x8003, + tlv(0x8A, 0x000C, "{" + tlv_value + "}")) + + env.controller.dev_send_1905(env.agents[1].mac, 0x8003, + tlv(0x8A, 0x000C, "{" + tlv_value + "}")) + + # wait for ACK + time.sleep(1) + self.check_cmdu_type_single("ACK", 0x8000, env.agents[0].mac, env.controller.mac) + self.check_cmdu_type_single("ACK", 0x8000, env.agents[1].mac, env.controller.mac) + + # wait for report + # since it is a periodic report and we want to verify that + # we have only _one_ response, we wait for a time correlated with the request itself + time.sleep(interval_time + interval_time/2) + + # expect two single reports + self.check_cmdu_type_single("ap metrics response agent1", 0x800C, + env.agents[0].mac, env.controller.mac) + self.check_cmdu_type_single("ap metrics response agent2", 0x800C, + env.agents[1].mac, env.controller.mac) + + env.agents[0].radios[0].vaps[0].disassociate(sta1) + env.agents[0].radios[0].vaps[0].disassociate(sta2) + if __name__ == '__main__': t = TestFlows()