added cleaner script (#25)

* added  cleaner script

* updated based on recommendation

---------

Co-authored-by: Don Johnson <[email protected]>

Author: Don Johnson

bitswing/.gitignore

@@ -0,0 +1 @@
+/target

bitswing/Cargo.toml

@@ -0,0 +1,11 @@
+[workspace]
+members = ["bpf", "user"]
+
+[package]
+name = "bitswing-workspace"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "bitswing_workspace"
+path = "src/lib.rs"

bitswing/Config.toml

@@ -0,0 +1,11 @@
+[general]
+interface = "eth0"
+default_rate_limit_bps = 500000
+
+[[rules]]
+port = 80
+rate_limit_bps = 1000000
+
+[[rules]]
+port = 443
+rate_limit_bps = 1500000

bitswing/Makefile

@@ -0,0 +1,55 @@
+# Makefile for BitSwing
+
+# Project directories
+BPF_DIR        := bpf
+USER_DIR       := user
+
+# BPF build output (assuming a release build)
+BPF_TARGET     := $(BPF_DIR)/target/bpfel-unknown-none/release/bitswing-bpf
+
+# User-space binary (release build)
+USER_TARGET    := $(USER_DIR)/target/release/bitswing-user
+
+# If you need a special Docker image to cross-compile eBPF, set it here:
+AYA_BUILDER_IMAGE := ghcr.io/aya-rs/aya-builder-x86_64-unknown-linux-gnu:latest
+
+# Phony targets don't correspond to actual files
+.PHONY: all bpf user clean run install
+
+## Default target: build everything
+all: bpf user
+
+## Build the BPF crate
+bpf:
+	# Option 1: Native build (requires rustup target add bpfel-unknown-none)
+	# cd $(BPF_DIR) && cargo build --release --target bpfel-unknown-none
+	#
+	# Option 2: Use Docker-based builder (uncomment if you use aya-builder)
+	# docker run --rm -v $(shell pwd):/workdir -w /workdir/$(BPF_DIR) \
+	#     $(AYA_BUILDER_IMAGE) cargo build --release --target bpfel-unknown-none
+	#
+	# For now, we'll assume local native build:
+	cd $(BPF_DIR) && cargo build --release --target bpfel-unknown-none
+
+## Build the user-space crate
+user:
+	cd $(USER_DIR) && cargo build --release
+
+## Clean all build artifacts
+clean:
+	cd $(BPF_DIR) && cargo clean
+	cd $(USER_DIR) && cargo clean
+
+## Run the user-space binary (requires sudo if attaching XDP)
+run: all
+	@echo "Running BitSwing user-space daemon..."
+	sudo $(USER_TARGET)
+
+## Optional: Install the user binary (and optionally the BPF bytecode) to /usr/local/bin
+install: all
+	@echo "Installing user binary to /usr/local/bin..."
+	sudo cp $(USER_TARGET) /usr/local/bin/bitswing
+	@echo "Installing BPF bytecode to /usr/local/lib/bitswing/..."
+	sudo mkdir -p /usr/local/lib/bitswing
+	sudo cp $(BPF_TARGET) /usr/local/lib/bitswing/bitswing-bpf
+	@echo "Install complete."

bitswing/README.md

@@ -0,0 +1,10 @@
+[package]
+name = "bitswing-bpf"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+aya-bpf = "0.15.1"
+
+[lib]
+crate-type = ["cdylib"]

bitswing/bpf/src/Cargo.toml

@@ -0,0 +1,44 @@
+#![no_std]
+#![no_main]
+
+use aya_bpf::{
+    bindings::xdp_action::XDP_PASS,
+    macros::{map, xdp},
+    maps::HashMap,
+    programs::XdpContext,
+};
+use core::mem;
+
+#[repr(C)]
+pub struct RateLimit {
+    pub bps: u32,
+}
+
+#[map(name = "RATE_LIMIT_MAP")]
+static mut RATE_LIMIT_MAP: HashMap<u16, RateLimit> = HashMap::with_max_entries(1024, 0);
+
+#[xdp(name = "shaper")]
+pub fn shaper(ctx: XdpContext) -> u32 {
+    if try_shaper(&ctx).is_err() {
+        XDP_PASS
+    } else {
+        XDP_PASS
+    }
+}
+
+fn try_shaper(ctx: &XdpContext) -> Result<(), i64> {
+    let data = ctx.data();
+    let data_end = ctx.data_end();
+
+    // Check length for at least an Ethernet header
+    if data + mem::size_of::<aya_bpf::bindings::ethhdr>() > data_end {
+        return Ok(());
+    }
+
+    // Hard-coded example: port = 80
+    if let Some(limit) = unsafe { RATE_LIMIT_MAP.get(&80u16) } {
+        let _bps = limit.bps;
+        // Real shaping logic would track usage & drop/mark packets as needed
+    }
+    Ok(())
+}

bitswing/bpf/src/shaper.rs

@@ -0,0 +1,57 @@
+#!/bin/bash
+
+# Output file for the snapshot
+output_file="filesystem_snapshot_$(date +%Y%m%d_%H%M%S).txt"
+
+# Function to process files
+process_file() {
+    local file="$1"
+    
+    # Skip files ending with .sum
+    if [[ "$file" == *.sum ]]; then
+        return
+    fi
+    
+    # Add file separator and path to output
+    echo -e "\n=== File: $file ===" >> "$output_file"
+    
+    # Check if file is binary
+    if [[ -f "$file" ]] && ! [[ -x "$file" ]] && file "$file" | grep -q "text"; then
+        # For text files, add content
+        echo -e "\n--- Content ---" >> "$output_file"
+        cat "$file" >> "$output_file"
+    else
+        # For binary files, just note that it's binary
+        echo -e "\n[Binary file]" >> "$output_file"
+    fi
+}
+
+# Main function to traverse directory
+traverse_directory() {
+    local dir="$1"
+    
+    # Find all files and directories, excluding specified patterns
+    find "$dir" \
+        -not \( -path "*/target/*" -o -path "*/target" \) \
+        -not \( -path "*/.git/*" -o -path "*/.git" \) \
+        -not \( -path "*/.cargo/*" -o -path "*/.cargo" \) \
+        -not \( -path "*/.rustup/*" -o -path "*/.rustup" \) \
+        -type f -o -type d | while read -r item; do
+        
+        if [[ -f "$item" ]]; then
+            process_file "$item"
+        elif [[ -d "$item" ]]; then
+            echo -e "\n=== Directory: $item ===" >> "$output_file"
+        fi
+    done
+}
+
+# Initialize output file with header
+echo "File System Snapshot - Generated on $(date)" > "$output_file"
+echo "Current working directory: $(pwd)" >> "$output_file"
+echo -e "\n----------------------------------------" >> "$output_file"
+
+# Start traversal from current directory
+traverse_directory "."
+
+echo "Snapshot has been generated in: $output_file"

bitswing/snap.sh

@@ -0,0 +1,5 @@
+#![allow(dead_code)]
+
+pub fn placeholder() {
+    // No-op function, just to have a valid library target.
+}

bitswing/src/lib.rs

@@ -0,0 +1,9 @@
+[package]
+name = "bitswing-user"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+aya = "0.13.1"
+serde = { version = "1.0", features = ["derive"] }
+toml = "0.8"

bitswing/user/Cargo.toml

@@ -0,0 +1,66 @@
+use aya::{Bpf, include_bytes_aligned, maps::HashMap, programs::Xdp};
+use aya::programs::xdp::XdpFlags;
+use serde::Deserialize;
+use std::fs;
+
+#[derive(Deserialize)]
+struct General {
+    interface: String,
+    default_rate_limit_bps: u32,
+}
+
+#[derive(Deserialize)]
+struct Rule {
+    port: u16,
+    rate_limit_bps: u32,
+}
+
+#[derive(Deserialize)]
+struct Config {
+    general: General,
+    rules: Vec<Rule>,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct RateLimit {
+    pub bps: u32,
+}
+
+static BPF_BYTES: &[u8] = include_bytes_aligned!(concat!(env!("OUT_DIR"), "/bitswing-bpf"));
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Read TOML config
+    let config_str = fs::read_to_string("Config.toml")?;
+    let config: Config = toml::from_str(&config_str)?;
+
+    // Load BPF bytecode
+    let mut bpf = Bpf::load(BPF_BYTES)?;
+    let mut shaper = bpf.program_mut("shaper").ok_or("program not found")?;
+    shaper.load()?;
+    if let Some(xdp) = shaper.try_into_xdp() {
+        xdp.attach(&config.general.interface, XdpFlags::SKB_MODE)?;
+    }
+
+    // Populate BPF map
+    let mut rate_map = HashMap::<u16, RateLimit>::try_from(bpf.map_mut("RATE_LIMIT_MAP")?)?;
+    let default_limit = RateLimit {
+        bps: config.general.default_rate_limit_bps,
+    };
+    // Use port=0 as a "catch-all" or fallback
+    rate_map.insert(&0, &default_limit, 0)?;
+
+    // Insert per-port rules
+    for rule in &config.rules {
+        let limit = RateLimit { bps: rule.rate_limit_bps };
+        rate_map.insert(&rule.port, &limit, 0)?;
+    }
+
+    println!(
+        "BitSwing running on {}. Press Ctrl+C to stop.",
+        config.general.interface
+    );
+    loop {
+        std::thread::park();
+    }
+}