[sonic-dhcp4relay] Smart switch support

Signed-off-by: Shivashankar CR <[email protected]>

Author: cshivashgit

dhcp4relay/src/dhcp4relay.cpp

@@ -11,6 +11,7 @@
 #include <pcapplusplus/UdpLayer.h>
 #include <signal.h>
 #include <unistd.h>
+#include <fstream>
 
 #include "configdb.h"
 #include "dhcp4_sender.h"
@@ -430,9 +431,22 @@ uint8_t encode_tlv(uint8_t *buf, uint8_t t, uint8_t l, uint8_t *v) {
     return (l + DHCP_SUB_OPT_TLV_HEADER_LEN);
 }
 
+std::string get_mac_address(const std::string &ifname) {
+    std::string path = "/sys/class/net/" + ifname + "/address";
+    std::ifstream file(path);
+    if (!file.is_open()) {
+        syslog(LOG_ERR, "Fetching mac address for interface %s", ifname.c_str());
+        return "";
+    }
+    std::string mac;
+    std::getline(file, mac);
+    return mac;
+}
+
 void encode_relay_option(pcpp::DhcpLayer *dhcp_pkt, relay_config *config) {
     uint8_t buf[256] = {0};
     uint8_t buf_offset = 0;
+    std::string bm_mac;
 
     auto vrf = vlan_vrf_map[config->vlan.c_str()];
 
@@ -454,11 +468,22 @@ void encode_relay_option(pcpp::DhcpLayer *dhcp_pkt, relay_config *config) {
                              (uint8_t *)circuit_id.c_str());
     buf_offset += offset;
 
+    if (!m_config.midplane_bridge.empty()) {
+        bm_mac = get_mac_address(m_config.midplane_bridge);
+    }
+
     /* Encode remote ID sub-option */
     /* | 2 | 6 | my_mac| */
-    offset = encode_tlv((buf + buf_offset), OPTION82_SUBOPT_REMOTE_ID,
-                        MAC_ADDR_STR_LEN, (uint8_t *)(m_config.host_mac_addr.c_str()));
-    buf_offset += offset;
+    /* if its SmartSwitch we need to fetch mac of bridge-midplane */
+    if ((m_config.is_SmartSwitch) && (!bm_mac.empty())) {
+        offset = encode_tlv((buf + buf_offset), OPTION82_SUBOPT_REMOTE_ID,
+                            MAC_ADDR_STR_LEN, (uint8_t *)(bm_mac.c_str()));
+        buf_offset += offset;
+    } else {
+        offset = encode_tlv((buf + buf_offset), OPTION82_SUBOPT_REMOTE_ID,
+                            MAC_ADDR_STR_LEN, (uint8_t *)(m_config.host_mac_addr.c_str()));
+        buf_offset += offset;
+    }
 
     /* TODO: this sub-option should be set if source interface selection is enabled */
     /* | 5 | 4 | ipv4 | */
@@ -914,6 +939,9 @@ void pkt_in_callback(evutil_socket_t fd, short event, void *arg) {
             if (vlan == vlan_map.end()) {
                 if (intf.find(CLIENT_IF_PREFIX) != std::string::npos) {
                     syslog(LOG_WARNING, "[DHCPV4_RELAY] Invalid input interface %s\n", interface_name);
+                } else if ((m_config.is_SmartSwitch) && (intf.rfind("dpu", 0) == 0) && !m_config.midplane_bridge.empty()) {
+                    // if its SmartSwitch, we need to check for bridge_midplane interface
+                    vlan_str = m_config.midplane_bridge;
                 }
             } else {
                 vlan_str = vlan->second;

dhcp4relay/src/dhcp4relay.h

@@ -162,6 +162,8 @@ struct metadata_config {
     std::string hostname = "sonic";
     uint32_t deployment_id;
     bool is_dualTor;
+    bool is_SmartSwitch;
+    std::string midplane_bridge;
 };
 
 /**

dhcp4relay/src/dhcp4relay_mgr.cpp

@@ -64,6 +64,7 @@ void DHCPMgr::handle_swss_notification() {
     config_db_dhcp_server_ipv4_ptr = std::make_shared<swss::SubscriberStateTable>(config_db_ptr.get(), "DHCP_SERVER_IPV4");
     state_db_dhcp_server_ipv4_ip_ptr = std::make_shared<swss::SubscriberStateTable>(state_db_ptr.get(), "DHCP_SERVER_IPV4_SERVER_IP");
     swss::SubscriberStateTable config_db_port_table(config_db_ptr.get(), "PORT");
+    swss::SubscriberStateTable config_db_dpu_table(config_db_ptr.get(), "DPUS");
     swss::SubscriberStateTable state_db_interface_table(state_db_ptr.get(), "INTERFACE_TABLE");
 
     std::deque<swss::KeyOpFieldsValuesTuple> entries;
@@ -79,6 +80,7 @@ void DHCPMgr::handle_swss_notification() {
     swss_select.addSelectable(config_db_dhcp_server_ipv4_ptr.get());
     swss_select.addSelectable(state_db_dhcp_server_ipv4_ip_ptr.get());
     swss_select.addSelectable(&config_db_port_table);
+    swss_select.addSelectable(&config_db_dpu_table);
     swss_select.addSelectable(&state_db_interface_table);
 
     while (!stop_thread) {
@@ -137,6 +139,9 @@ void DHCPMgr::handle_swss_notification() {
 	} else if (selectable == static_cast<swss::Selectable *>(&config_db_port_table)) {
             config_db_port_table.pops(entries);
             process_port_notification(entries);
+	} else if (selectable == static_cast<swss::Selectable *>(&config_db_dpu_table)) {
+            config_db_dpu_table.pops(entries);
+            process_port_notification(entries);
 	}
     }
 }
@@ -157,6 +162,8 @@ void DHCPMgr::process_device_metadata_notification(std::deque<swss::KeyOpFieldsV
         std::string key = kfvKey(entry);
         std::vector<swss::FieldValueTuple> field_values = kfvFieldsValues(entry);
         std::string operation = kfvOp(entry);
+        std::shared_ptr<swss::DBConnector> config_db = std::make_shared<swss::DBConnector>("CONFIG_DB", 0);
+        swss::Table midplane_tbl(config_db.get(), "MID_PLANE_BRIDGE");
 
         if (key != "localhost") {
             continue;
@@ -191,6 +198,20 @@ void DHCPMgr::process_device_metadata_notification(std::deque<swss::KeyOpFieldsV
                 send_dualTor_event = true;
             }
 
+            // Handle is_SmartSwitch logic
+            if (subtype_found && subtype_value == "SmartSwitch") {
+                m_config.is_SmartSwitch = true;
+                std::string bridge_name;
+                bool ok = midplane_tbl.hget("GLOBAL", "bridge", bridge_name);
+                if (ok) {
+                    m_config.midplane_bridge = bridge_name;
+                } else {
+                    syslog(LOG_ERR, "Failed to read midplane bridge name\n");
+                }
+            } else if (m_config.is_SmartSwitch) {
+                m_config.is_SmartSwitch = false;
+            }
+
             if (send_dualTor_event) {
                 relay_config *relay_msg = nullptr;
                 try {
@@ -724,8 +745,10 @@ void DHCPMgr::process_dhcp_server_ipv4_notification(std::deque<swss::KeyOpFields
 	}
 
 	/*Validation to check vlan is present in VLAN table or not */
+	/*If its a smartswitch, we are checking midplane_bridge details */
 	std::string value;
-        if (!vlan_tbl.hget(vlan, "vlanid", value)) {
+        if ((!vlan_tbl.hget(vlan, "vlanid", value))
+              && (!m_config.is_SmartSwitch || (!m_config.midplane_bridge.empty() && m_config.midplane_bridge != vlan))) {
             delete relay_msg;
             continue;
         }
@@ -812,6 +835,9 @@ void DHCPMgr::process_port_notification(std::deque<swss::KeyOpFieldsValuesTuple>
                  if (fvField(fv) == "alias") {
                      port_msg->alias = fvValue(fv);
                      break;
+                 } else if (fvField(fv) == "midplane_interface") {
+                     port_msg->alias = fvValue(fv);
+                     break;
                  }
             }
         } else {