mirror of
https://github.com/Macrame-App/Macrame
synced 2025-12-29 07:19:26 +00:00
317 lines
6.9 KiB
Go
317 lines
6.9 KiB
Go
/*
|
|
Macrame is a program that enables the user to create keyboard macros and button panels.
|
|
The macros are saved as simple JSON files and can be linked to the button panels. The panels can
|
|
be created with HTML and CSS.
|
|
|
|
Copyright (C) 2025 Jesse Malotaux
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package app
|
|
|
|
import (
|
|
"be/app/helper"
|
|
"be/app/structs"
|
|
"encoding/json"
|
|
"fmt"
|
|
"math/rand"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
func GetServerIP(w http.ResponseWriter, r *http.Request) {
|
|
ifs, err := net.Interfaces()
|
|
if err != nil {
|
|
MCRMLog(err)
|
|
return
|
|
}
|
|
|
|
for _, ifi := range ifs {
|
|
// Skip interfaces that are down
|
|
if ifi.Flags&net.FlagUp == 0 {
|
|
continue
|
|
}
|
|
// Skip loopback interfaces
|
|
if ifi.Flags&net.FlagLoopback != 0 {
|
|
continue
|
|
}
|
|
|
|
addrs, err := ifi.Addrs()
|
|
if err != nil {
|
|
MCRMLog(err)
|
|
continue
|
|
}
|
|
|
|
for _, addr := range addrs {
|
|
var ip net.IP
|
|
|
|
switch v := addr.(type) {
|
|
case *net.IPNet:
|
|
ip = v.IP
|
|
case *net.IPAddr:
|
|
ip = v.IP
|
|
}
|
|
|
|
if ip == nil || ip.To4() == nil {
|
|
continue
|
|
}
|
|
|
|
// Skip APIPA (169.254.x.x) addresses
|
|
if ip.IsLinkLocalUnicast() {
|
|
continue
|
|
}
|
|
|
|
// Found a good IP, return it
|
|
json.NewEncoder(w).Encode(ip.String())
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func DeviceList(w http.ResponseWriter, r *http.Request) {
|
|
dir := "devices"
|
|
|
|
files, err := os.ReadDir(dir)
|
|
if err != nil {
|
|
os.MkdirAll(dir, 0600)
|
|
files = nil
|
|
MCRMLog("DeviceList Error: ", err)
|
|
}
|
|
|
|
devices := make(map[string]map[string]interface{})
|
|
|
|
for _, file := range files {
|
|
filePath := dir + "/" + file.Name()
|
|
ext := filepath.Ext(filePath)
|
|
device := strings.TrimSuffix(file.Name(), ext)
|
|
|
|
if _, ok := devices[device]; !ok {
|
|
devices[device] = make(map[string]interface{})
|
|
}
|
|
|
|
if ext == ".json" {
|
|
devices[device]["settings"] = readDeviceSettings(filePath)
|
|
}
|
|
if ext == ".key" {
|
|
devices[device]["key"] = true
|
|
}
|
|
}
|
|
|
|
result := map[string]interface{}{
|
|
"devices": devices,
|
|
}
|
|
|
|
json.NewEncoder(w).Encode(result)
|
|
}
|
|
|
|
func readDeviceSettings(filepath string) (settings structs.Settings) {
|
|
data, err := os.ReadFile(filepath)
|
|
if err != nil {
|
|
MCRMLog("readDeviceSettings Error: ", err)
|
|
}
|
|
|
|
err = json.Unmarshal(data, &settings)
|
|
if err != nil {
|
|
MCRMLog("readDeviceSettings JSON Error: ", err)
|
|
}
|
|
|
|
return settings
|
|
}
|
|
|
|
func DeviceAccessCheck(w http.ResponseWriter, r *http.Request) {
|
|
var req structs.Check
|
|
|
|
err := json.NewDecoder(r.Body).Decode(&req)
|
|
|
|
if err != nil {
|
|
MCRMLog("DeviceAccessCheck Error: ", err)
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
_, errSett := os.Stat("devices/" + req.Uuid + ".json")
|
|
_, errKey := os.Stat("devices/" + req.Uuid + ".key")
|
|
|
|
if (errSett == nil) && (errKey == nil) {
|
|
json.NewEncoder(w).Encode("authorized")
|
|
} else if (errSett == nil) && (errKey != nil) {
|
|
MCRMLog("DeviceAccessCheck: UUID: ", req.Uuid, "; Access: Unauthorized")
|
|
json.NewEncoder(w).Encode("unauthorized")
|
|
} else {
|
|
MCRMLog("DeviceAccessCheck: UUID: ", req.Uuid, "; Access: Unlinked")
|
|
json.NewEncoder(w).Encode("unlinked")
|
|
}
|
|
}
|
|
|
|
func DeviceAccessRequest(w http.ResponseWriter, r *http.Request) {
|
|
var req structs.Request
|
|
|
|
err := json.NewDecoder(r.Body).Decode(&req)
|
|
|
|
if err != nil {
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
deviceSettings := structs.Settings{Name: req.Name, Type: req.Type}
|
|
|
|
settingsJSON, err := json.Marshal(deviceSettings)
|
|
if err != nil {
|
|
MCRMLog("DeviceAccessRequest JSON Error: ", err)
|
|
return
|
|
}
|
|
|
|
err = os.WriteFile("devices/"+req.Uuid+".json", settingsJSON, 0644)
|
|
|
|
if err != nil {
|
|
MCRMLog("DeviceAccessRequest Error: ", err)
|
|
return
|
|
}
|
|
|
|
json.NewEncoder(w).Encode("unauthorized")
|
|
}
|
|
|
|
func PingLink(w http.ResponseWriter, r *http.Request) {
|
|
var req structs.Check
|
|
err := json.NewDecoder(r.Body).Decode(&req)
|
|
|
|
if err != nil {
|
|
MCRMLog("PingLink Error: ", err)
|
|
json.NewEncoder(w).Encode(false)
|
|
return
|
|
}
|
|
|
|
key, keyErr := os.ReadFile("devices/" + req.Uuid + ".key")
|
|
pin, pinErr := os.ReadFile("devices/" + req.Uuid + ".tmp")
|
|
|
|
encryptedKey, encErr := helper.EncryptAES(string(pin), string(key))
|
|
|
|
if keyErr == nil && pinErr == nil && encErr == nil {
|
|
MCRMLog("PINGLINK FIXED")
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Write([]byte(encryptedKey))
|
|
return
|
|
} else {
|
|
MCRMLog("PingLink Error: keyErr:", keyErr, "; pinErr:", pinErr, "; encErr:", encErr)
|
|
}
|
|
|
|
json.NewEncoder(w).Encode(false)
|
|
}
|
|
|
|
func StartLink(w http.ResponseWriter, r *http.Request) {
|
|
var req structs.Check
|
|
|
|
err := json.NewDecoder(r.Body).Decode(&req)
|
|
|
|
if err != nil {
|
|
MCRMLog("StartLink Error: ", err)
|
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
pin := fmt.Sprintf("%04d", rand.Intn(10000))
|
|
|
|
deviceKey := helper.GenerateKey()
|
|
|
|
errKey := helper.SaveDeviceKey(req.Uuid, deviceKey)
|
|
savedPin, errPin := helper.TempPinFile(req.Uuid, pin)
|
|
|
|
if errKey == nil && errPin == nil && savedPin {
|
|
json.NewEncoder(w).Encode(pin)
|
|
} else {
|
|
MCRMLog("StartLink Error: errKey:", errKey, "; errPin:", errPin)
|
|
}
|
|
}
|
|
|
|
func PollLink(w http.ResponseWriter, r *http.Request) {
|
|
var req structs.Check
|
|
|
|
err := json.NewDecoder(r.Body).Decode(&req)
|
|
|
|
if err != nil {
|
|
json.NewEncoder(w).Encode(false)
|
|
return
|
|
}
|
|
|
|
if helper.CheckPinFile(req.Uuid) {
|
|
json.NewEncoder(w).Encode(true)
|
|
return
|
|
}
|
|
|
|
json.NewEncoder(w).Encode(false)
|
|
}
|
|
|
|
func RemoveLink(data string, w http.ResponseWriter, r *http.Request) {
|
|
req := &structs.Check{}
|
|
_, err := helper.ParseRequest(req, data, r)
|
|
|
|
if err != nil {
|
|
MCRMLog("RemoveLink ParseRequest Error: ", err)
|
|
json.NewEncoder(w).Encode(false)
|
|
return
|
|
}
|
|
|
|
err = os.Remove("devices/" + req.Uuid + ".key")
|
|
|
|
if err != nil {
|
|
MCRMLog("RemoveLink Remove Error: ", err)
|
|
json.NewEncoder(w).Encode(false)
|
|
return
|
|
}
|
|
|
|
json.NewEncoder(w).Encode(true)
|
|
}
|
|
|
|
func Handshake(w http.ResponseWriter, r *http.Request) {
|
|
var req structs.Handshake
|
|
|
|
err := json.NewDecoder(r.Body).Decode(&req)
|
|
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
deviceKey, err := helper.GetKeyByUuid(req.Uuid)
|
|
|
|
if err != nil {
|
|
MCRMLog("Handshake GetKeyByUuid Error: ", err)
|
|
json.NewEncoder(w).Encode(false)
|
|
return
|
|
}
|
|
|
|
decryptShake, _ := helper.DecryptAES(deviceKey, req.Shake)
|
|
|
|
helper.RemovePinFile(req.Uuid)
|
|
|
|
if decryptShake == getDateStr() {
|
|
json.NewEncoder(w).Encode(true)
|
|
return
|
|
} else {
|
|
os.Remove("devices/" + req.Uuid + ".key")
|
|
}
|
|
|
|
json.NewEncoder(w).Encode(false)
|
|
}
|
|
|
|
func getDateStr() string {
|
|
date := time.Now()
|
|
year, month, day := date.Date()
|
|
formattedDate := fmt.Sprintf("%04d%02d%02d", year, month, day)
|
|
return formattedDate
|
|
}
|