rpi/rcond
1
0
Fork 0
mirror of https://github.com/0x1d/rcond.git synced 2025-12-14 18:25:21 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

feat: return json responses

Browse Source
This commit is contained in:
0x1d
2025-05-04 17:25:29 +02:00
parent d15ec1f8cb
commit 666c9c9eb8
2 changed files with 209 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
pkg/http/handlers.go
View File

@@ -11,10 +11,6 @@ import (
"github.com/gorilla/mux"
)
const (
NETWORK_CONNECTION_UUID = "7d706027-727c-4d4c-a816-f0e1b99db8ab"
)
type configureAPRequest struct {
Interface string `json:"interface"`
SSID string `json:"ssid"`
@@ -34,15 +30,25 @@ type authorizedKeyRequest struct {
PubKey string `json:"pubkey"`
}
type errorResponse struct {
Error string `json:"error"`
}
func writeError(w http.ResponseWriter, message string, code int) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(code)
json.NewEncoder(w).Encode(errorResponse{Error: message})
}
func HandleConfigureAP(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
writeError(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
var req configureAPRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
writeError(w, err.Error(), http.StatusBadRequest)
return
}
@@ -50,7 +56,7 @@ func HandleConfigureAP(w http.ResponseWriter, r *http.Request) {
uuid, err := network.ConfigureAP(req.Interface, req.SSID, req.Password)
if err != nil {
log.Printf("Failed to configure access point on interface %s: %v", req.Interface, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
writeError(w, err.Error(), http.StatusInternalServerError)
return
}
log.Printf("Successfully configured access point on interface %s with UUID %s", req.Interface, uuid)
@@ -64,19 +70,20 @@ func HandleConfigureAP(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(resp); err != nil {
log.Printf("Failed to encode response: %v", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
writeError(w, err.Error(), http.StatusInternalServerError)
return
}
}
func HandleNetworkUp(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPut {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
writeError(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
var req networkUpRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
writeError(w, err.Error(), http.StatusBadRequest)
return
}
vars := mux.Vars(r)
@@ -85,84 +92,90 @@ func HandleNetworkUp(w http.ResponseWriter, r *http.Request) {
log.Printf("Bringing up network interface %s with UUID %s", iface, req.UUID)
if err := network.Up(iface, req.UUID); err != nil {
log.Printf("Failed to bring up network interface %s: %v", iface, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
writeError(w, err.Error(), http.StatusInternalServerError)
return
}
log.Printf("Successfully brought up network interface %s", iface)
w.WriteHeader(http.StatusOK)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]string{"status": "success"})
}
func HandleNetworkDown(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodDelete {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
writeError(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
vars := mux.Vars(r)
iface := vars["interface"]
if err := network.Down(iface); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
writeError(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]string{"status": "success"})
}
func HandleNetworkRemove(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodDelete {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
writeError(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
vars := mux.Vars(r)
uuid := vars["uuid"]
if err := network.Remove(uuid); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
writeError(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]string{"status": "success"})
}
func HandleGetHostname(w http.ResponseWriter, r *http.Request) {
hostname, err := network.GetHostname()
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
writeError(w, err.Error(), http.StatusInternalServerError)
return
}
w.Write([]byte(hostname))
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]string{"hostname": hostname})
}
func HandleSetHostname(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
writeError(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
var req setHostnameRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
writeError(w, err.Error(), http.StatusBadRequest)
return
}
if err := network.SetHostname(req.Hostname); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
writeError(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]string{"status": "success"})
}
func HandleAddAuthorizedKey(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
writeError(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
var req authorizedKeyRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
writeError(w, err.Error(), http.StatusBadRequest)
return
}
vars := mux.Vars(r)
@@ -170,42 +183,44 @@ func HandleAddAuthorizedKey(w http.ResponseWriter, r *http.Request) {
fingerprint, err := user.AddAuthorizedKey(username, req.PubKey)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
writeError(w, err.Error(), http.StatusInternalServerError)
return
}
w.Write([]byte(fingerprint))
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]string{"fingerprint": fingerprint})
}
func HandleRemoveAuthorizedKey(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodDelete {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
writeError(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
vars := mux.Vars(r)
fingerprint := vars["fingerprint"]
if fingerprint == "" {
http.Error(w, "fingerprint parameter is required", http.StatusBadRequest)
writeError(w, "fingerprint parameter is required", http.StatusBadRequest)
return
}
username := vars["user"]
if username == "" {
http.Error(w, "user parameter is required", http.StatusBadRequest)
writeError(w, "user parameter is required", http.StatusBadRequest)
return
}
fingerprintBytes, err := base64.RawURLEncoding.DecodeString(fingerprint)
if err != nil {
http.Error(w, "invalid fingerprint base64", http.StatusBadRequest)
writeError(w, "invalid fingerprint base64", http.StatusBadRequest)
return
}
if err := user.RemoveAuthorizedKey(username, string(fingerprintBytes)); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
writeError(w, err.Error(), http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]string{"status": "success"})
}