Go NetworkManager

https://github.com/wifx/gonetworkmanager
Admin
Go D-Bus bindings for NetworkManager, providing an interface to interact with NetworkManager...
Tokens:4,901
Snippets:13
Trust Score:6.8
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Monitor Network Connection State Changes in Go

Source: https://context7.com/wifx/gonetworkmanager/llms.txt

This Go example shows how to subscribe to and monitor real-time network connection state changes using gonetworkmanager. It connects to the NetworkManager, gets the first active connection, and sets up a channel to receive state change notifications. The monitoring runs for a specified duration before stopping.

```go
package main

import (
    "fmt"
    "log"
    "time"
    "github.com/Wifx/gonetworkmanager/v3"
)

func main() {
    nm, err := gonetworkmanager.NewNetworkManager()
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }

    activeConns, err := nm.GetPropertyActiveConnections()
    if err != nil {
        log.Fatalf("Failed to get active connections: %v", err)
    }

    if len(activeConns) == 0 {
        log.Fatal("No active connections to monitor")
    }

    conn := activeConns[0]
    connID, _ := conn.GetPropertyID()
    fmt.Printf("Monitoring connection: %s\n", connID)

    stateChanges := make(chan gonetworkmanager.StateChange, 10)
    exit := make(chan struct{})

    err = conn.SubscribeState(stateChanges, exit)
    if err != nil {
        log.Fatalf("Failed to subscribe: %v", err)
    }

    // Monitor for 60 seconds
    go func() {
        time.Sleep(60 * time.Second)
        close(exit)
    }()

    for change := range stateChanges {
        fmt.Printf("State changed to: %s (reason: %s)\n",
            change.State.String(),
            change.Reason.String())
    }

    fmt.Println("Monitoring stopped")
}
```

--------------------------------

### Scan Wi-Fi Access Points in Go

Source: https://context7.com/wifx/gonetworkmanager/llms.txt

This Go example demonstrates how to scan for available Wi-Fi access points using gonetworkmanager. It first identifies wireless devices, requests a scan, waits for completion, and then lists details for each discovered access point, including SSID, signal strength, frequency, and MAC address.

```go
package main

import (
    "fmt"
    "log"
    "time"
    "github.com/Wifx/gonetworkmanager/v3"
)

func main() {
    nm, err := gonetworkmanager.NewNetworkManager()
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }

    devices, err := nm.GetDevices()
    if err != nil {
        log.Fatalf("Failed to get devices: %v", err)
    }

    for _, device := range devices {
        deviceType, _ := device.GetPropertyDeviceType()
        if deviceType != gonetworkmanager.NmDeviceTypeWifi {
            continue
        }

        wirelessDevice, err := gonetworkmanager.NewDeviceWireless(device.GetPath())
        if err != nil {
            continue
        }

        // Request a scan
        err = wirelessDevice.RequestScan()
        if err != nil {
            log.Printf("Scan request failed: %v", err)
        }

        time.Sleep(3 * time.Second) // Wait for scan to complete

        accessPoints, err := wirelessDevice.GetAccessPoints()
        if err != nil {
            log.Printf("Failed to get access points: %v", err)
            continue
        }

        fmt.Printf("Found %d access points:\n", len(accessPoints))
        for _, ap := range accessPoints {
            ssid, _ := ap.GetPropertySSID()
            strength, _ := ap.GetPropertyStrength()
            frequency, _ := ap.GetPropertyFrequency()
            hwAddr, _ := ap.GetPropertyHWAddress()

            fmt.Printf("  SSID: %s\n", ssid)
            fmt.Printf("    Signal: %d%%\n", strength)
            fmt.Printf("    Frequency: %d MHz\n", frequency)
            fmt.Printf("    MAC: %s\n\n", hwAddr)
        }
    }
}
```

--------------------------------

### Create Static IP Connection for Ethernet using Go

Source: https://context7.com/wifx/gonetworkmanager/llms.txt

This code example demonstrates how to create and configure a wired Ethernet connection with a static IP address using the gonetworkmanager library. It specifies the interface name, IP address, prefix, and gateway, and sets IPv6 to ignore. The connection is then added to NetworkManager.

```go
package main

import (
    "fmt"
    "log"
    "github.com/Wifx/gonetworkmanager/v3"
    "github.com/google/uuid"
)

func main() {
    settings, err := gonetworkmanager.NewSettings()
    if err != nil {
        log.Fatalf("Failed to get settings: %v", err)
    }

    // Define connection parameters
    connectionID := "Static-Ethernet"
    interfaceName := "eth0"
    ipAddress := "192.168.1.100"
    ipPrefix := uint32(24)
    gateway := "192.168.1.1"

    // Build connection settings
    connection := make(map[string]map[string]interface{})

    // Ethernet section
    connection["802-3-ethernet"] = make(map[string]interface{})
    connection["802-3-ethernet"]["auto-negotiate"] = false

    // Connection section
    connection["connection"] = make(map[string]interface{})
    connection["connection"]["id"] = connectionID
    connection["connection"]["type"] = "802-3-ethernet"
    connectionUUID, _ := uuid.NewUUID()
    connection["connection"]["uuid"] = connectionUUID.String()
    connection["connection"]["interface-name"] = interfaceName
    connection["connection"]["autoconnect"] = true

    // IPv4 section with static configuration
    connection["ipv4"] = make(map[string]interface{})
    connection["ipv4"]["method"] = "manual"
    connection["ipv4"]["gateway"] = gateway

    addressData := make([]map[string]interface{}, 1)
    addressData[0] = make(map[string]interface{})
    addressData[0]["address"] = ipAddress
    addressData[0]["prefix"] = ipPrefix
    connection["ipv4"]["address-data"] = addressData

    // IPv6 section
    connection["ipv6"] = make(map[string]interface{})
    connection["ipv6"]["method"] = "ignore"

    // Add the connection
    conn, err := settings.AddConnection(connection)
    if err != nil {
        log.Fatalf("Failed to add connection: %v", err)
    }

    fmt.Printf("Connection '%s' created successfully\n", connectionID)
    fmt.Printf("Connection path: %s\n", conn.GetPath())
}

```

--------------------------------

### Get IP Configuration Details for Active Connections in Go

Source: https://context7.com/wifx/gonetworkmanager/llms.txt

This Go code snippet retrieves IPv4 and IPv6 configuration details for active network devices using gonetworkmanager. It iterates through devices, checks if they are activated, and then fetches and prints IP addresses, gateways, and DNS server information. It also shows how to get DHCP4 options.

```go
package main

import (
    "fmt"
    "log"
    "github.com/Wifx/gonetworkmanager/v3"
)

func main() {
    nm, err := gonetworkmanager.NewNetworkManager()
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }

    devices, err := nm.GetDevices()
    if err != nil {
        log.Fatalf("Failed to get devices: %v", err)
    }

    for _, device := range devices {
        iface, _ := device.GetPropertyInterface()
        state, _ := device.GetPropertyState()

        if state != gonetworkmanager.NmDeviceStateActivated {
            continue
        }

        fmt.Printf("Device: %s\n", iface)

        // Get IPv4 configuration
        ip4Config, err := device.GetPropertyIP4Config()
        if err == nil && ip4Config != nil {
            addresses, err := ip4Config.GetPropertyAddressData()
            if err == nil {
                fmt.Println("  IPv4 Addresses:")
                for _, addr := range addresses {
                    fmt.Printf("    %s/%d\n", addr.Address, addr.Prefix)
                }
            }

            gateway, err := ip4Config.GetPropertyGateway()
            if err == nil && gateway != "" {
                fmt.Printf("  IPv4 Gateway: %s\n", gateway)
            }

            nameservers, err := ip4Config.GetPropertyNameservers()
            if err == nil && len(nameservers) > 0 {
                fmt.Printf("  DNS Servers: %v\n", nameservers)
            }
        }

        // Get DHCP4 configuration
        dhcp4Config, err := device.GetPropertyDHCP4Config()
        if err == nil && dhcp4Config != nil {
            options, err := dhcp4Config.GetPropertyOptions()
            if err == nil {
                fmt.Printf("  DHCP Options: %v\n", options)
            }
        }

        fmt.Println()
    }
}
```

--------------------------------

### List and Manage Saved Network Connections in Go

Source: https://context7.com/wifx/gonetworkmanager/llms.txt

This Go snippet demonstrates how to retrieve and display details of saved network connections using gonetworkmanager. It fetches all connections, iterates through them, and prints their ID, type, UUID, and status (saved or unsaved). It also shows how to get the filename if the connection is saved to disk.

```go
package main

import (
    "fmt"
    "log"
    "github.com/Wifx/gonetworkmanager/v3"
)

func main() {
    settings, err := gonetworkmanager.NewSettings()
    if err != nil {
        log.Fatalf("Failed to get settings: %v", err)
    }

    connections, err := settings.ListConnections()
    if err != nil {
        log.Fatalf("Failed to list connections: %v", err)
    }

    fmt.Printf("Found %d saved connections:\n\n", len(connections))

    for _, conn := range connections {
        connSettings, err := conn.GetSettings()
        if err != nil {
            continue
        }

        connSection := connSettings["connection"]
        id := connSection["id"].(string)
        connType := connSection["type"].(string)
        uuid := connSection["uuid"].(string)

        fmt.Printf("Connection: %s\n", id)
        fmt.Printf("  Type: %s\n", connType)
        fmt.Printf("  UUID: %s\n", uuid)

        // Check if connection is saved to disk
        unsaved, err := conn.GetPropertyUnsaved()
        if err == nil && unsaved {
            fmt.Printf("  Status: Unsaved (in-memory only)\n")
        }

        // Get filename if available
        filename, err := conn.GetPropertyFilename()
        if err == nil && filename != "" {
            fmt.Printf("  File: %s\n", filename)
        }

        fmt.Println()
    }
}
```

--------------------------------

### Create and Rollback Network Checkpoint with gonetworkmanager

Source: https://context7.com/wifx/gonetworkmanager/llms.txt

Creates a network configuration checkpoint for rollback purposes. It takes a list of devices, a timeout for the checkpoint, and an optional specific timeout for rollback. The snippet demonstrates creating a checkpoint, simulating changes, and then either rolling back or destroying the checkpoint.

```go
package main

import (
    "fmt"
    "log"
    "time"
    "github.com/Wifx/gonetworkmanager/v3"
)

func main() {
    nm, err := gonetworkmanager.NewNetworkManager()
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }

    devices, err := nm.GetDevices()
    if err != nil {
        log.Fatalf("Failed to get devices: %v", err)
    }

    // Create checkpoint for all devices with 30 second timeout
    checkpoint, err := nm.CheckpointCreate(devices, 30, 0)
    if err != nil {
        log.Fatalf("Failed to create checkpoint: %v", err)
    }

    fmt.Printf("Checkpoint created: %s\n", checkpoint.GetPath())

    created, _ := checkpoint.GetPropertyCreated()
    rollbackTimeout, _ := checkpoint.GetPropertyRollbackTimeout()

    fmt.Printf("Created at: %d\n", created)
    fmt.Printf("Auto-rollback in: %d seconds\n", rollbackTimeout)

    // Simulate network configuration changes
    fmt.Println("Making network changes...")
    time.Sleep(10 * time.Second)

    // Manually rollback if needed
    fmt.Print("Rollback checkpoint? (y/n): ")
    var response string
    fmt.Scanln(&response)

    if response == "y" {
        results, err := nm.CheckpointRollback(checkpoint)
        if err != nil {
            log.Fatalf("Rollback failed: %v", err)
        }

        fmt.Println("Rollback completed:")
        for path, result := range results {
            fmt.Printf("  Device %s: %s\n", path, result.String())
        }
    } else {
        // Destroy checkpoint to prevent auto-rollback
        err = nm.CheckpointDestroy(checkpoint)
        if err != nil {
            log.Printf("Failed to destroy checkpoint: %v", err)
        } else {
            fmt.Println("Checkpoint destroyed, changes kept")
        }
    }
}
```

--------------------------------

### Initialize NetworkManager Instance in Go

Source: https://context7.com/wifx/gonetworkmanager/llms.txt

This Go snippet demonstrates how to create a new NetworkManager instance to interact with the NetworkManager daemon. It includes error handling for connection failures and retrieves the NetworkManager version and current state.

```go
package main

import (
    "fmt"
    "log"
    "github.com/Wifx/gonetworkmanager/v3"
)

func main() {
    nm, err := gonetworkmanager.NewNetworkManager()
    if err != nil {
        log.Fatalf("Failed to connect to NetworkManager: %v", err)
    }

    version, err := nm.GetPropertyVersion()
    if err != nil {
        log.Fatalf("Failed to get version: %v", err)
    }

    fmt.Printf("NetworkManager version: %s\n", version)

    state, err := nm.GetPropertyState()
    if err != nil {
        log.Fatalf("Failed to get state: %v", err)
    }

    fmt.Printf("NetworkManager state: %s\n", state.String())
}
```

--------------------------------

### Untitled

No description

--------------------------------

### Connect to Wi-Fi Network using Go

Source: https://context7.com/wifx/gonetworkmanager/llms.txt

This snippet shows how to activate a wireless connection to a specific Wi-Fi access point using provided SSID and password. It utilizes the gonetworkmanager library to find wireless devices, access points, and establish a WPA2-PSK secured connection.

```go
package main

import (
    "fmt"
    "log"
    "github.com/Wifx/gonetworkmanager/v3"
)

func main() {
    nm, err := gonetworkmanager.NewNetworkManager()
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }

    devices, err := nm.GetDevices()
    if err != nil {
        log.Fatalf("Failed to get devices: %v", err)
    }

    var wirelessDevice gonetworkmanager.DeviceWireless
    for _, device := range devices {
        deviceType, _ := device.GetPropertyDeviceType()
        if deviceType == gonetworkmanager.NmDeviceTypeWifi {
            wirelessDevice, _ = gonetworkmanager.NewDeviceWireless(device.GetPath())
            break
        }
    }

    if wirelessDevice == nil {
        log.Fatal("No wireless device found")
    }

    accessPoints, err := wirelessDevice.GetAccessPoints()
    if err != nil {
        log.Fatalf("Failed to get access points: %v", err)
    }

    var targetAP gonetworkmanager.AccessPoint
    targetSSID := "MyNetwork"

    for _, ap := range accessPoints {
        ssid, _ := ap.GetPropertySSID()
        if ssid == targetSSID {
            targetAP = ap
            break
        }
    }

    if targetAP == nil {
        log.Fatalf("Access point '%s' not found", targetSSID)
    }

    // Create connection settings with WPA2 credentials
    connection := make(map[string]map[string]interface{})
    connection["802-11-wireless"] = make(map[string]interface{})
    connection["802-11-wireless"]["security"] = "802-11-wireless-security"
    connection["802-11-wireless-security"] = make(map[string]interface{})
    connection["802-11-wireless-security"]["key-mgmt"] = "wpa-psk"
    connection["802-11-wireless-security"]["psk"] = "MyPassword123"

    activeConn, err := nm.AddAndActivateWirelessConnection(connection, wirelessDevice, targetAP)
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }

    connID, _ := activeConn.GetPropertyID()
    state, _ := activeConn.GetPropertyState()
    fmt.Printf("Connection '%s' activated with state: %s\n", connID, state.String())
}

```

--------------------------------

### Untitled

No description

--------------------------------

### List Network Devices in Go

Source: https://context7.com/wifx/gonetworkmanager/llms.txt

This Go code snippet shows how to enumerate all available network devices using gonetworkmanager. It retrieves properties such as interface name, device type, and current state for each device, printing them to the console.

```go
package main

import (
    "fmt"
    "log"
    "github.com/Wifx/gonetworkmanager/v3"
)

func main() {
    nm, err := gonetworkmanager.NewNetworkManager()
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }

    devices, err := nm.GetPropertyAllDevices()
    if err != nil {
        log.Fatalf("Failed to get devices: %v", err)
    }

    for _, device := range devices {
        iface, err := device.GetPropertyInterface()
        if err != nil {
            continue
        }

        deviceType, err := device.GetPropertyDeviceType()
        if err != nil {
            continue
        }

        state, err := device.GetPropertyState()
        if err != nil {
            continue
        }

        fmt.Printf("Device: %s\n", iface)
        fmt.Printf("  Type: %s\n", deviceType.String())
        fmt.Printf("  State: %s\n", state.String())
        fmt.Printf("  Path: %s\n\n", device.GetPath())
    }
}
```

--------------------------------

### Activate Existing Connection with gonetworkmanager

Source: https://context7.com/wifx/gonetworkmanager/llms.txt

Activates a saved network connection profile on a specified device. It requires the connection's UUID and the target device's interface name. The snippet monitors the activation state and reports success or failure.

```go
package main

import (
    "fmt"
    "log"
    "time"
    "github.com/Wifx/gonetworkmanager/v3"
)

func main() {
    nm, err := gonetworkmanager.NewNetworkManager()
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }

    settings, err := gonetworkmanager.NewSettings()
    if err != nil {
        log.Fatalf("Failed to get settings: %v", err)
    }

    // Find connection by UUID
    connectionUUID := "your-connection-uuid-here"
    conn, err := settings.GetConnectionByUUID(connectionUUID)
    if err != nil {
        log.Fatalf("Connection not found: %v", err)
    }

    // Get appropriate device
    device, err := nm.GetDeviceByIpIface("eth0")
    if err != nil {
        log.Fatalf("Device not found: %v", err)
    }

    // Activate the connection
    activeConn, err := nm.ActivateConnection(conn, device, nil)
    if err != nil {
        log.Fatalf("Failed to activate: %v", err)
    }

    fmt.Println("Connection activation started...")

    // Monitor activation
    for i := 0; i < 30; i++ {
        state, err := activeConn.GetPropertyState()
        if err != nil {
            log.Printf("Failed to get state: %v", err)
            break
        }

        fmt.Printf("State: %s\n", state.String())

        if state == gonetworkmanager.NmActiveConnectionStateActivated {
            fmt.Println("Connection activated successfully!")
            break
        } else if state == gonetworkmanager.NmActiveConnectionStateDeactivated {
            fmt.Println("Connection failed to activate")
            break
        }

        time.Sleep(1 * time.Second)
    }
}
```

--------------------------------

### Untitled

No description

--------------------------------

### Untitled

No description

--------------------------------

### Deactivate Connection with gonetworkmanager

Source: https://context7.com/wifx/gonetworkmanager/llms.txt

Disconnects an active network connection. It retrieves all active connections, prompts the user to select which one to deactivate, and then calls the deactivation function. Handles cases where no active connections are found.

```go
package main

import (
    "fmt"
    "log"
    "github.com/Wifx/gonetworkmanager/v3"
)

func main() {
    nm, err := gonetworkmanager.NewNetworkManager()
    if err != nil {
        log.Fatalf("Failed to connect: %v", err)
    }

    activeConns, err := nm.GetPropertyActiveConnections()
    if err != nil {
        log.Fatalf("Failed to get active connections: %v", err)
    }

    if len(activeConns) == 0 {
        log.Fatal("No active connections to deactivate")
    }

    for _, conn := range activeConns {
        connID, err := conn.GetPropertyID()
        if err != nil {
            continue
        }

        connType, _ := conn.GetPropertyType()

        fmt.Printf("Found connection: %s (type: %s)\n", connID, connType)
        fmt.Print("Deactivate? (y/n): ")

        var response string
        fmt.Scanln(&response)

        if response == "y" {
            err = nm.DeactivateConnection(conn)
            if err != nil {
                log.Printf("Failed to deactivate: %v", err)
            } else {
                fmt.Printf("Connection '%s' deactivated\n", connID)
            }
        }
    }
}
```
Tokens:
Raw