Start work on dual virtual interfaces

redfast00 · redfast00 · commit 3da45b82cbac · 2024-12-06T11:39:12.000+01:00
diff --git a/components/80211_mac_rust/80211_mac_interface.c b/components/80211_mac_rust/80211_mac_interface.c
@@ -80,7 +80,7 @@ int64_t rs_get_time_us() {
 
 // declaration from IP
 // RX'ed 802.11 packets -> RX queue of MAC stack
-void openmac_netif_receive(void* buffer, size_t len);
+void openmac_netif_receive(rs_mac_interface_type_t interface, void* buffer, size_t len);
 
 /*Called from the Rust MAC stack, to obtain a frame to receive MAC data in and pass it to ESP-NETIF */
 uint8_t* rs_get_mac_rx_frame(size_t size_required) {
@@ -95,8 +95,8 @@ uint8_t* rs_get_mac_rx_frame(size_t size_required) {
 }
 
 /*Called from the Rust MAC stack, to pass a previously obtained data frame buffer to ESP-NETIF. Expects the frame to be in Ethernet format. Does not take ownership of the data*/
-void rs_rx_mac_frame(uint8_t* frame, size_t len) {
-	openmac_netif_receive(frame, len);
+void rs_rx_mac_frame(rs_mac_interface_type_t interface, uint8_t* frame, size_t len) {
+	openmac_netif_receive(interface, frame, len);
 }
 
 /*
@@ -168,15 +168,15 @@ void c_hand_rx_to_mac_stack(dma_list_item* item) {
 	}
 }
 
-void openmac_netif_up();
-void openmac_netif_down();
+void openmac_netif_up(rs_mac_interface_type_t interface);
+void openmac_netif_down(rs_mac_interface_type_t interface);
 
-void rs_mark_iface_up() {
-	openmac_netif_up();
+void rs_mark_iface_up(rs_mac_interface_type_t interface) {
+	openmac_netif_up(interface);
 }
 
-void rs_mark_iface_down() {
-	openmac_netif_down();
+void rs_mark_iface_down(rs_mac_interface_type_t interface) {
+	openmac_netif_down(interface);
 }
 
 void rs_recycle_mac_tx_data(uint8_t* data) {
@@ -202,7 +202,7 @@ void rs_filters_set_client_with_bssid(const uint8_t* addr) {
 
 // Called from the C ESP-NETIF stack to request the Rust MAC stack to TX a frame
 // This function does NOT take ownership of the frame, so you're allowed to reuse the buffer directly after this returns
-void c_transmit_data_frame(uint8_t* frame, size_t len) {
+void c_transmit_data_frame(rs_mac_interface_type_t interface, uint8_t* frame, size_t len) {
 	// TODO make sure we don't flood the stack by sending too much frames
 	// maybe use a counting semaphore?
 	void* queued_buffer = malloc(len);
diff --git a/components/80211_mac_rust/include/80211_mac_interface.h b/components/80211_mac_rust/include/80211_mac_interface.h
@@ -4,6 +4,10 @@
 #include <stdbool.h>
 #include <stddef.h>
 
+// Number of virtual interfaces the hardware supports
+// See https://esp32-open-mac.be/posts/0008-rx-filter/
+#define NUM_VIRTUAL_INTERFACES (2)
+
 #define CONFIG_IDF_TARGET_ESP32 1
 
 /** @brief Received packet radio metadata header, this is the common header at the beginning of all promiscuous mode RX callback buffers */
@@ -78,7 +82,7 @@ typedef enum {
     STA_2_MAC_INTERFACE_TYPE,
     AP_1_MAC_INTERFACE_TYPE,
     AP_2_MAC_INTERFACE_TYPE,
-} mac_interface_type_t;
+} rs_mac_interface_type_t;
 
 typedef enum {
     EVENT_TYPE_MAC_TX_DATA_FRAME,
@@ -117,13 +121,13 @@ rs_smart_frame_t* rs_get_smart_frame(size_t size_hint);
 void rs_tx_smart_frame(rs_smart_frame_t* frame);
 
 /*Called from the Rust MAC stack, to pass a data frame to the IP stack. Expects the frame to be in Ethernet format. Does not take ownership of the data*/
-void rs_rx_mac_frame(uint8_t* frame, size_t len);
+void rs_rx_mac_frame(rs_mac_interface_type_t interface, uint8_t* frame, size_t len);
 
 void rs_recycle_dma_item(dma_list_item* item);
 
 
-void rs_mark_iface_up();
-void rs_mark_iface_down();
+void rs_mark_iface_up(rs_mac_interface_type_t interface);
+void rs_mark_iface_down(rs_mac_interface_type_t interface);
 
 /*
   Called from the hardware stack to recycle a smart frame after it was sent
@@ -137,7 +141,7 @@ void c_hand_rx_to_mac_stack();
 
 int64_t rs_get_time_us();
 
-void c_transmit_data_frame(uint8_t* frame, size_t len);
+void c_transmit_data_frame(rs_mac_interface_type_t interface, uint8_t* frame, size_t len);
 void rs_recycle_mac_tx_data(uint8_t* frame);
 
 uint8_t* rs_get_mac_rx_frame(size_t size_required);
diff --git a/components/80211_mac_rust/rust_crate/build.rs b/components/80211_mac_rust/rust_crate/build.rs
@@ -17,6 +17,7 @@ fn run_bindgen(target: &str, out_dir: &Path) {
         .header(header)
         .allowlist_item(r#"(rs_.*)"#)
         .rustified_enum("rs_event_type_t")
+        .rustified_enum("rs_mac_interface_type_t")
         .allowlist_item("dma_list_item");
     match target {
         "riscv32imc-esp-espidf" => {
diff --git a/components/80211_mac_rust/rust_crate/src/lib.rs b/components/80211_mac_rust/rust_crate/src/lib.rs
@@ -23,8 +23,7 @@ use ieee80211::scroll::{Pread, Pwrite};
 use ieee80211::{element_chain, match_frames, ssid, supported_rates, GenericFrame};
 use llc::SnapLlcFrame;
 use sys::{
-    dma_list_item, rs_event_type_t, rs_get_smart_frame, rs_get_time_us,
-    rs_tx_smart_frame,
+    dma_list_item, rs_event_type_t, rs_get_smart_frame, rs_get_time_us, rs_mac_interface_type_t, rs_tx_smart_frame
 };
 
 use esp_println as _;
@@ -215,6 +214,7 @@ pub fn transmit_hardware_frame<
 }
 
 fn receive_mac_frame(
+    interface: sys::rs_mac_interface_type_t,
     source: MACAddress,
     destination: MACAddress,
     ether_type: EtherType,
@@ -234,7 +234,7 @@ fn receive_mac_frame(
     buffer.pwrite(ether_type.into_bits(), 6 + 6).unwrap();
     buffer.pwrite(payload, 6 + 6 + 2).unwrap();
 
-    unsafe { sys::rs_rx_mac_frame(buffer.as_mut_ptr(), buffer.len()) };
+    unsafe { sys::rs_rx_mac_frame(interface, buffer.as_mut_ptr(), buffer.len()) };
     Ok(())
 }
 
@@ -289,7 +289,10 @@ struct STAState {
 const SEQNO_WINDOW_SIZE: i32 = 32;
 
 fn transition_to_scanning(state: &mut STAState) {
-    unsafe { sys::rs_mark_iface_down() }
+    unsafe {
+        // TODO don't hardcode this to STA 1
+        sys::rs_mark_iface_down(rs_mac_interface_type_t::STA_1_MAC_INTERFACE_TYPE)
+    }
     unsafe { sys::rs_filters_set_scanning() }
     state.state = StaMachineState::Scanning(ScanningS {
         last_channel_change: None,
@@ -357,7 +360,10 @@ fn handle_assoc_resp(state: &mut STAState, assoc_resp_frame: AssociationResponse
         // yay, they accepted our association
         match state.state {
             StaMachineState::Associated => {}
-            _ => unsafe { sys::rs_mark_iface_up() },
+            _ => unsafe {
+                // TODO don't hardcode this to STA 1
+                sys::rs_mark_iface_up(rs_mac_interface_type_t::STA_1_MAC_INTERFACE_TYPE)
+            },
         }
         state.state = StaMachineState::Associated;
     }
@@ -396,7 +402,8 @@ fn handle_data_frame(_state: &mut STAState, data_frame: DataFrame) -> Option<()>
                     let source: MACAddress = data_frame.header.address_3;
                     let ethertype = inner_payload.ether_type;
                     let packet = inner_payload.payload;
-                    if receive_mac_frame(source, destination, ethertype, packet).is_err() {
+                    // TODO make this dynamic instead of hardcofing STA_1
+                    if receive_mac_frame(sys::rs_mac_interface_type_t::STA_1_MAC_INTERFACE_TYPE, source, destination, ethertype, packet).is_err() {
                         println!("Receiving MAC frame failed");
                     }
                 }
diff --git a/main/mac.c b/main/mac.c
@@ -17,17 +17,26 @@ static char* TAG = "mac.c";
 
 typedef struct openmac_netif_driver {
     esp_netif_driver_base_t base;
-    mac_interface_type_t interface_type;
+    rs_mac_interface_type_t interface_type;
 } openmac_netif_driver_t;
 
-static esp_netif_t *netif_openmac_sta = NULL;
+static openmac_netif_driver_t* active_interfaces[NUM_VIRTUAL_INTERFACES] = {0};
 
 static esp_err_t openmac_netif_transmit(void *h, void *buffer, size_t len)
 {
-    uint8_t* eth_data = (uint8_t*) buffer;
-    ESP_LOGI("netif-tx", "Going to transmit a data packet: to "MACSTR" from "MACSTR" type=%02x%02x", MAC2STR(&eth_data[0]), MAC2STR(&eth_data[6]), eth_data[12], eth_data[13]);
-    c_transmit_data_frame(buffer, len);
-    return ESP_OK;
+    openmac_netif_driver_t* driver = (openmac_netif_driver_t*)h;
+
+    for (int i = 0; i < NUM_VIRTUAL_INTERFACES; i++) {
+        if (active_interfaces[i] != NULL && active_interfaces[i] == driver) {
+            uint8_t* eth_data = (uint8_t*) buffer;
+            ESP_LOGI("netif-tx", "Going to transmit a data packet: to "MACSTR" from "MACSTR" type=%02x%02x", MAC2STR(&eth_data[0]), MAC2STR(&eth_data[6]), eth_data[12], eth_data[13]);
+            c_transmit_data_frame(active_interfaces[i]->interface_type, buffer, len);
+            return ESP_OK;
+        }
+    }
+    ESP_LOGE(TAG, "netif_tx: failed to find vif for handle %p", h);
+
+    return ESP_FAIL;
 }
 
 static esp_err_t openmac_netif_transmit_wrap(void *h, void *buffer, size_t len, void *netstack_buf)
@@ -36,18 +45,38 @@ static esp_err_t openmac_netif_transmit_wrap(void *h, void *buffer, size_t len,
 }
 
 
-void openmac_netif_up() {
-    esp_netif_action_connected(netif_openmac_sta, NULL, 0, NULL);
+void openmac_netif_up(rs_mac_interface_type_t interface) {
+    for (int i = 0; i < NUM_VIRTUAL_INTERFACES; i++) {
+        if (active_interfaces[i] != NULL && active_interfaces[i]->interface_type == interface) {
+            esp_netif_action_connected(active_interfaces[i]->base.netif, NULL, 0, NULL);
+            return;
+        }
+    }
+    ESP_LOGE(TAG, "trying to up vif %d but not active", interface);
 }
 
-void openmac_netif_down() {
-    esp_netif_action_disconnected(netif_openmac_sta, NULL, 0, NULL);
+void openmac_netif_down(rs_mac_interface_type_t interface) {
+    for (int i = 0; i < NUM_VIRTUAL_INTERFACES; i++) {
+        if (active_interfaces[i] != NULL && active_interfaces[i]->interface_type == interface) {
+            esp_netif_action_disconnected(active_interfaces[i]->base.netif, NULL, 0, NULL);
+            return;
+        }
+    }
+    ESP_LOGE(TAG, "trying to down vif %d but not active", interface);
 }
 
 // Put Ethernet-formatted frame in MAC stack; does not take ownership of the buffer: after the function returns, you can delete/reuse it.
-void openmac_netif_receive(void* buffer, size_t len) {
+void openmac_netif_receive(rs_mac_interface_type_t interface, void* buffer, size_t len) {
     assert(buffer != NULL);
-    esp_netif_receive(netif_openmac_sta, buffer, len, buffer);
+
+    for (int i = 0; i < NUM_VIRTUAL_INTERFACES; i++) {
+        if (active_interfaces[i] != NULL && active_interfaces[i]->interface_type == interface) {
+            esp_netif_receive(active_interfaces[i]->base.netif, buffer, len, buffer);
+            return;
+        }
+    }
+    // If we get here, the MAC stack passed us a frame that does not have a currently active interface
+    ESP_LOGE(TAG, "received frame for vif %d but not active", interface);
 }
 
 // Free RX buffer
@@ -92,14 +121,19 @@ esp_err_t openmac_netif_start()
             .base = &base_cfg_sta,
             .driver = NULL,
             .stack = ESP_NETIF_NETSTACK_DEFAULT_WIFI_STA };
-    netif_openmac_sta = esp_netif_new(&cfg_sta);
+
+    esp_netif_t* netif_openmac_sta = esp_netif_new(&cfg_sta);
     assert(netif_openmac_sta);
 
     openmac_netif_driver_t* driver = openmac_create_if_driver();
     if (driver == NULL) {
         ESP_LOGE(TAG, "Failed to create wifi interface handle");
         return ESP_FAIL;
     }
+
+    driver->interface_type = STA_1_MAC_INTERFACE_TYPE;
+    active_interfaces[0] = driver;
+
     esp_netif_attach(netif_openmac_sta, driver);
     esp_netif_set_hostname(netif_openmac_sta, "esp32-open-mac");
     esp_netif_set_mac(netif_openmac_sta, module_mac_addr);
