arozos-mirror/src/wifi.go

package main

import (
	"encoding/json"
	"net/http"
	"runtime"
	"strings"

	wifi "imuslab.com/arozos/mod/network/wifi"
	prout "imuslab.com/arozos/mod/prouter"
	"imuslab.com/arozos/mod/utils"
)

/*
	Network WiFi Module

	This module handle wifi connections and scanning on the devices that support wpa_supplicant like the Raspberry Pi
	Require service launch with Dbus (Work well on stock Raspberry Pi OS)
*/

var (
	wifiManager *wifi.WiFiManager
)

func WiFiInit() {
	//Start the Wifi Manager
	wifiManager = wifi.NewWiFiManager(sysdb, sudo_mode, *wpa_supplicant_path, *wan_interface_name)

	//Only activate script on linux and if hardware management is enabled
	router := prout.NewModuleRouter(prout.RouterOption{
		ModuleName:  "System Setting",
		AdminOnly:   true,
		UserHandler: userHandler,
		DeniedHandler: func(w http.ResponseWriter, r *http.Request) {
			utils.SendErrorResponse(w, "Permission Denied")
		},
	})

	//Allow hardware management. Generate the endpoint for WiFi Control
	if *allow_hardware_management {

		//Register endpoints
		router.HandleFunc("/system/network/scanWifi", network_wifi_handleScan)
		router.HandleFunc("/system/network/connectWifi", network_wifi_handleConnect)
		router.HandleFunc("/system/network/removeWifi", network_wifi_handleWiFiRemove)
		router.HandleFunc("/system/network/wifiinfo", network_wifi_handleWiFiInfo)

		//Sudo mode only for wifi toggle
		if sudo_mode {
			router.HandleFunc("/system/network/power", network_wifi_handleWiFiPower)
		}

		//Register WiFi Settings if system have WiFi interface
		wlanInterfaces, _ := wifiManager.GetWirelessInterfaces()
		if len(wlanInterfaces) > 0 {
			//Contain at least 1 wireless interface Register System Settings
			registerSetting(settingModule{
				Name:     "WiFi Info",
				Desc:     "Current Connected WiFi Information",
				IconPath: "SystemAO/network/img/WiFi.png",
				Group:    "Network",
				StartDir: "SystemAO/network/wifiinfo.html",
			})
			registerSetting(settingModule{
				Name:         "WiFi Settings",
				Desc:         "Set up WiFi connections",
				IconPath:     "SystemAO/network/img/WiFi.png",
				Group:        "Network",
				StartDir:     "SystemAO/network/wifi.html",
				RequireAdmin: true,
			})
		}
	}

}

func network_wifi_handleWiFiPower(w http.ResponseWriter, r *http.Request) {
	//Require admin permission to scan and connect wifi
	user, err := userHandler.GetUserInfoFromRequest(w, r)
	if err != nil {
		utils.SendErrorResponse(w, "Internal Server Error")
		return
	}

	if !user.IsAdmin() {
		utils.SendErrorResponse(w, "Permission Denied")
		return
	}

	status, _ := utils.PostPara(r, "status")
	if status == "" {
		//Show current power status
		infs, err := wifiManager.GetWirelessInterfaces()
		if err != nil {
			utils.SendErrorResponse(w, err.Error())
			return
		}

		type WlanInterfaceStatus struct {
			Name         string
			Running      bool
			Controllable bool //SetInterfacePower is supported on this platform
		}

		results := []WlanInterfaceStatus{}
		for _, inf := range infs {
			status, _ := wifiManager.GetInterfacePowerStatuts(strings.TrimSpace(inf))
			results = append(results, WlanInterfaceStatus{
				Name:         inf,
				Running:      status,
				Controllable: wifiManager.CanControlInterfacePower(),
			})
		}

		js, _ := json.Marshal(results)
		utils.SendJSONResponse(w, string(js))

	} else {
		//Change current power status
		wlaninterface, err := utils.PostPara(r, "interface")
		if err != nil {
			utils.SendErrorResponse(w, "Invalid interface")
			return
		}

		if status == "on" {
			err := wifiManager.SetInterfacePower(wlaninterface, true)
			if err != nil {
				utils.SendErrorResponse(w, err.Error())
			} else {
				utils.SendOK(w)
			}
		} else if status == "off" {
			err := wifiManager.SetInterfacePower(wlaninterface, false)
			if err != nil {
				utils.SendErrorResponse(w, err.Error())
			} else {
				utils.SendOK(w)
			}
		} else {
			utils.SendErrorResponse(w, "Invalid status")
		}
	}

}

func network_wifi_handleScan(w http.ResponseWriter, r *http.Request) {
	//Require admin permission to scan and connect wifi
	user, err := userHandler.GetUserInfoFromRequest(w, r)
	if err != nil {
		utils.SendErrorResponse(w, "Internal Server Error")
		return
	}

	if !user.IsAdmin() {
		utils.SendErrorResponse(w, "Permission Denied")
		return
	}

	//Get a list of current on system wireless interface
	wirelessInterfaces, err := wifiManager.GetWirelessInterfaces()
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}

	if len(wirelessInterfaces) == 0 {
		//No wireless interface
		utils.SendErrorResponse(w, "Wireless Interface Not Found")
		return
	}

	//Scan with the requested interface, or the first one if none is given
	scanInterface := wirelessInterfaces[0]
	requestedInterface, _ := utils.GetPara(r, "interface")
	if requestedInterface != "" {
		found := false
		for _, inf := range wirelessInterfaces {
			if strings.TrimSpace(inf) == requestedInterface {
				scanInterface = inf
				found = true
				break
			}
		}
		if !found {
			utils.SendErrorResponse(w, "Wireless Interface Not Found")
			return
		}
	}
	scannedWiFiInfo, err := wifiManager.ScanNearbyWiFi(strings.TrimSpace(scanInterface))
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}
	jsonString, _ := json.Marshal(scannedWiFiInfo)
	utils.SendJSONResponse(w, string(jsonString))
}

func network_wifi_handleConnect(w http.ResponseWriter, r *http.Request) {
	user, err := userHandler.GetUserInfoFromRequest(w, r)
	if err != nil {
		utils.SendErrorResponse(w, "Internal Server Error")
		return
	}
	//Get information from client and create a new network config file
	if !user.IsAdmin() {
		utils.SendErrorResponse(w, "Permission denied")
		return
	}

	ssid, err := utils.PostPara(r, "ESSID")
	if err != nil {
		utils.SendErrorResponse(w, "ESSID not given")
		return
	}
	connType, _ := utils.PostPara(r, "ConnType")
	password, _ := utils.PostPara(r, "pwd")
	systemWideLogger.PrintAndLog("WiFi", "WiFi Switch Request Received. Genering Network Configuration...", nil)

	identity, err := utils.PostPara(r, "identity")
	if err != nil {
		identity = ""
	}

	result, err := wifiManager.ConnectWiFi(ssid, password, connType, identity)
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}
	jsonString, err := json.Marshal(result)
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}
	utils.SendJSONResponse(w, string(jsonString))

	systemWideLogger.PrintAndLog("WiFi", "WiFi Connected", nil)

}

func network_wifi_handleWiFiRemove(w http.ResponseWriter, r *http.Request) {
	//Require admin permission to scan and connect wifi
	user, err := userHandler.GetUserInfoFromRequest(w, r)
	if err != nil {
		utils.SendErrorResponse(w, "Internal Server Error")
		return
	}

	if !user.IsAdmin() {
		utils.SendErrorResponse(w, "Permission Denied")
		return
	}

	//Get ESSID from post request
	ESSID, err := utils.PostPara(r, "ESSID")
	if err != nil {
		utils.SendErrorResponse(w, "ESSID not given")
		return
	}

	err = wifiManager.RemoveWifi(ESSID)
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}
	utils.SendOK(w)
}

func network_wifi_handleWiFiInfo(w http.ResponseWriter, r *http.Request) {
	//Get and return the current conencted WiFi Information
	_, err := authAgent.GetUserName(w, r)
	if err != nil {
		utils.SendErrorResponse(w, "User not logged in")
		return
	}

	//Detailed state of every wireless interface
	interfaces, err := wifiManager.GetInterfaceStatus()
	if err != nil {
		utils.SendErrorResponse(w, "Failed to retrieve WiFi Information: "+err.Error())
		return
	}

	//ESSID and Interface are kept for older clients: the first connected
	//interface, or the first interface when none is connected
	ESSID, interfaceName := "", ""
	for _, inf := range interfaces {
		if inf.Connected {
			ESSID, interfaceName = inf.SSID, inf.Name
			break
		}
	}
	if interfaceName == "" && len(interfaces) > 0 {
		interfaceName = interfaces[0].Name
	} else if interfaceName == "" {
		//Platforms without a status implementation
		ESSID, interfaceName, err = wifiManager.GetConnectedWiFi()
		if err != nil {
			utils.SendErrorResponse(w, "Failed to retrieve WiFi Information")
			return
		}
	}

	jsonString, _ := json.Marshal(struct {
		ESSID           string
		Interface       string
		Interfaces      []wifi.WiFiInterfaceStatus
		Platform        string
		CanConnect      bool //Connecting to and forgetting networks is supported
		CanControlPower bool //The radio power toggle is supported
	}{
		ESSID:           ESSID,
		Interface:       interfaceName,
		Interfaces:      interfaces,
		Platform:        runtime.GOOS,
		CanConnect:      wifiManager.CanConnect(),
		CanControlPower: sudo_mode && wifiManager.CanControlInterfacePower(),
	})
	utils.SendJSONResponse(w, string(jsonString))
}