Create wifi backend abstraction

internal/wifi/iwd/backend.go

@@ -0,0 +1,255 @@
+package iwd
+
+import (
+	"fmt"
+
+	"github.com/godbus/dbus/v5"
+	"github.com/nemunaire/repeater/internal/wifi/backend"
+)
+
+const (
+	AgentPath = "/com/github/nemunaire/repeater/agent"
+)
+
+// IWDBackend implements the WiFiBackend interface for iwd (Intel Wireless Daemon)
+type IWDBackend struct {
+	conn          *dbus.Conn
+	manager       *Manager
+	station       *Station
+	agent         *Agent
+	agentManager  *AgentManager
+	signalMonitor *SignalMonitor
+	interfaceName string
+	callbacks     backend.EventCallbacks
+}
+
+// NewIWDBackend creates a new IWD backend instance
+func NewIWDBackend() *IWDBackend {
+	return &IWDBackend{}
+}
+
+// Initialize initializes the iwd backend with the given interface name
+func (b *IWDBackend) Initialize(interfaceName string) error {
+	b.interfaceName = interfaceName
+	var err error
+
+	// Connect to D-Bus
+	b.conn, err = dbus.SystemBus()
+	if err != nil {
+		return fmt.Errorf("échec de connexion à D-Bus: %v", err)
+	}
+
+	// Find station for interface
+	b.manager = NewManager(b.conn)
+	b.station, err = b.manager.FindStation(interfaceName)
+	if err != nil {
+		return fmt.Errorf("impossible de trouver la station pour %s: %v", interfaceName, err)
+	}
+
+	// Create and register agent for credential callbacks
+	b.agent = NewAgent(b.conn, dbus.ObjectPath(AgentPath))
+	if err := b.agent.Export(); err != nil {
+		return fmt.Errorf("échec de l'export de l'agent: %v", err)
+	}
+
+	b.agentManager = NewAgentManager(b.conn)
+	if err := b.agentManager.RegisterAgent(dbus.ObjectPath(AgentPath)); err != nil {
+		b.agent.Unexport()
+		return fmt.Errorf("échec de l'enregistrement de l'agent: %v", err)
+	}
+
+	return nil
+}
+
+// Close closes the D-Bus connection and unregisters the agent
+func (b *IWDBackend) Close() error {
+	if b.agentManager != nil && b.agent != nil {
+		b.agentManager.UnregisterAgent(dbus.ObjectPath(AgentPath))
+		b.agent.Unexport()
+	}
+	if b.conn != nil {
+		b.conn.Close()
+	}
+	return nil
+}
+
+// ScanNetworks triggers a network scan
+func (b *IWDBackend) ScanNetworks() error {
+	err := b.station.Scan()
+	if err != nil {
+		return fmt.Errorf("erreur lors du scan: %v", err)
+	}
+	return nil
+}
+
+// GetOrderedNetworks returns networks sorted by signal strength in backend-agnostic format
+func (b *IWDBackend) GetOrderedNetworks() ([]backend.BackendNetwork, error) {
+	networkInfos, err := b.station.GetOrderedNetworks()
+	if err != nil {
+		return nil, fmt.Errorf("erreur lors de la récupération des réseaux: %v", err)
+	}
+
+	var networks []backend.BackendNetwork
+	seenSSIDs := make(map[string]bool)
+
+	for _, netInfo := range networkInfos {
+		network := NewNetwork(b.conn, netInfo.Path)
+		props, err := network.GetProperties()
+		if err != nil {
+			continue
+		}
+
+		if props.Name == "" || seenSSIDs[props.Name] {
+			continue
+		}
+		seenSSIDs[props.Name] = true
+
+		// Convert iwd network to backend-agnostic format
+		backendNet := backend.BackendNetwork{
+			SSID:         props.Name,
+			SignalDBm:    netInfo.Signal / 100, // iwd provides 100*dBm, convert to dBm
+			SecurityType: props.Type,
+			BSSID:        generateSyntheticBSSID(props.Name), // iwd doesn't expose BSSID
+			Frequency:    0,                                  // iwd doesn't expose frequency in GetOrderedNetworks
+		}
+
+		networks = append(networks, backendNet)
+	}
+
+	return networks, nil
+}
+
+// IsScanning checks if a scan is currently in progress
+func (b *IWDBackend) IsScanning() (bool, error) {
+	return b.station.IsScanning()
+}
+
+// Connect connects to a WiFi network
+func (b *IWDBackend) Connect(ssid, password string) error {
+	// Store passphrase in agent for callback
+	if password != "" {
+		b.agent.SetPassphrase(ssid, password)
+	}
+
+	// Ensure passphrase is cleared after connection attempt
+	defer func() {
+		if password != "" {
+			b.agent.ClearPassphrase(ssid)
+		}
+	}()
+
+	// Get network object
+	network, err := b.station.GetNetwork(ssid)
+	if err != nil {
+		return fmt.Errorf("réseau '%s' non trouvé: %v", ssid, err)
+	}
+
+	// Connect - iwd will call agent.RequestPassphrase() if needed
+	if err := network.Connect(); err != nil {
+		return fmt.Errorf("erreur lors de la connexion: %v", err)
+	}
+
+	return nil
+}
+
+// Disconnect disconnects from the current WiFi network
+func (b *IWDBackend) Disconnect() error {
+	if err := b.station.Disconnect(); err != nil {
+		return fmt.Errorf("erreur lors de la déconnexion: %v", err)
+	}
+	return nil
+}
+
+// GetConnectionState returns the current WiFi connection state
+func (b *IWDBackend) GetConnectionState() (backend.ConnectionState, error) {
+	state, err := b.station.GetState()
+	if err != nil {
+		return backend.StateDisconnected, err
+	}
+	return mapIWDState(state), nil
+}
+
+// GetConnectedSSID returns the SSID of the currently connected network
+func (b *IWDBackend) GetConnectedSSID() string {
+	network, err := b.station.GetConnectedNetwork()
+	if err != nil {
+		return ""
+	}
+
+	props, err := network.GetProperties()
+	if err != nil {
+		return ""
+	}
+
+	return props.Name
+}
+
+// StartEventMonitoring starts monitoring WiFi events
+func (b *IWDBackend) StartEventMonitoring(callbacks backend.EventCallbacks) error {
+	b.callbacks = callbacks
+
+	// Create signal monitor
+	b.signalMonitor = NewSignalMonitor(b.conn, b.station)
+
+	// Register callbacks - wrap to convert iwd types to backend types
+	b.signalMonitor.OnStateChange(func(state StationState, ssid string) {
+		if b.callbacks.OnStateChange != nil {
+			b.callbacks.OnStateChange(mapIWDState(state), ssid)
+		}
+	})
+
+	b.signalMonitor.OnScanComplete(func() {
+		if b.callbacks.OnScanComplete != nil {
+			b.callbacks.OnScanComplete()
+		}
+	})
+
+	// Start monitoring
+	return b.signalMonitor.Start()
+}
+
+// StopEventMonitoring stops monitoring WiFi events
+func (b *IWDBackend) StopEventMonitoring() {
+	if b.signalMonitor != nil {
+		b.signalMonitor.Stop()
+	}
+}
+
+// mapIWDState maps iwd-specific states to backend-agnostic states
+func mapIWDState(state StationState) backend.ConnectionState {
+	switch state {
+	case StateConnected:
+		return backend.StateConnected
+	case StateConnecting:
+		return backend.StateConnecting
+	case StateDisconnecting:
+		return backend.StateDisconnecting
+	case StateDisconnected:
+		return backend.StateDisconnected
+	case StateRoaming:
+		// Map roaming to connected since we're still connected during roaming
+		return backend.StateConnected
+	default:
+		return backend.StateDisconnected
+	}
+}
+
+// generateSyntheticBSSID generates a consistent fake BSSID from SSID
+// (iwd doesn't expose real BSSID)
+func generateSyntheticBSSID(ssid string) string {
+	// Use a simple hash approach - consistent per SSID
+	hash := 0
+	for _, c := range ssid {
+		hash = ((hash << 5) - hash) + int(c)
+	}
+
+	// Generate 6 bytes for MAC address
+	b1 := byte((hash >> 0) & 0xff)
+	b2 := byte((hash >> 8) & 0xff)
+	b3 := byte((hash >> 16) & 0xff)
+	b4 := byte((hash >> 24) & 0xff)
+	b5 := byte(len(ssid) & 0xff)
+	b6 := byte((len(ssid) >> 8) & 0xff)
+
+	return fmt.Sprintf("%02x:%02x:%02x:%02x:%02x:%02x", b1, b2, b3, b4, b5, b6)
+}