feat: implement core functionality for super-frpc service

This commit introduces the core functionality for the super-frpc service including: - Configuration management - User authentication and authorization - Database integration - FRPC instance management - API endpoints for user operations - Token-based authentication system - Password hashing and validation
2026-02-23 00:19:57 +08:00
parent 6bf143e69e
commit 2a8a8ef262
13 changed files with 1704 additions and 0 deletions
@@ -0,0 +1,733 @@
+package main
+
+import (
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+type InstanceInfo struct {
+	Name        string                 `json:"name"`
+	ServerAddr  string                 `json:"serverAddr"`
+	ServerPort  string                 `json:"serverPort"`
+	AuthMethod  string                 `json:"auth_method"`
+	BootAtStart bool                   `json:"bootAtStart"`
+	RunUser     string                 `json:"runUser"`
+	Additional  map[string]interface{} `json:"additionalProperties"`
+}
+
+type CreateInstanceRequest struct {
+	Token        string                 `json:"token"`
+	TimeStamp    int64                  `json:"timeStamp"`
+	InstanceInfo InstanceInfo           `json:"instanceInfo"`
+	BootAtStart  bool                   `json:"bootAtStart"`
+	RunUser      string                 `json:"runUser"`
+	Additional   map[string]interface{} `json:"additionalProperties"`
+}
+
+type FrpcInstance struct {
+	ID          int
+	UserID      int
+	Name        string
+	ServerAddr  string
+	ServerPort  string
+	AuthMethod  string
+	BootAtStart bool
+	RunUser     string
+	ConfigPath  string
+	CreatedAt   time.Time
+}
+
+var frpcDB *sql.DB
+
+func InitFrpcDatabase(dbPath string) error {
+	var err error
+	frpcDB, err = sql.Open("sqlite", dbPath)
+	if err != nil {
+		return fmt.Errorf("failed to open frpc database: %w", err)
+	}
+
+	if err = frpcDB.Ping(); err != nil {
+		return fmt.Errorf("failed to ping frpc database: %w", err)
+	}
+
+	createTableSQL := `
+	CREATE TABLE IF NOT EXISTS frpcInstances (
+		id INTEGER PRIMARY KEY AUTOINCREMENT,
+		userID INTEGER NOT NULL,
+		name TEXT NOT NULL,
+		serverAddr TEXT NOT NULL,
+		serverPort TEXT NOT NULL,
+		auth_method TEXT NOT NULL,
+		bootAtStart INTEGER NOT NULL DEFAULT 0,
+		runUser TEXT NOT NULL DEFAULT 'root',
+		configPath TEXT NOT NULL,
+		createdAt TEXT NOT NULL,
+		UNIQUE(userID, name)
+	);
+	`
+	_, err = frpcDB.Exec(createTableSQL)
+	if err != nil {
+		return fmt.Errorf("failed to create frpcInstances table: %w", err)
+	}
+
+	return nil
+}
+
+func CloseFrpcDatabase() error {
+	if frpcDB != nil {
+		return frpcDB.Close()
+	}
+	return nil
+}
+
+func CreateInstanceHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		SendErrorResponse(w, http.StatusMethodNotAllowed, "invalid request method")
+		return
+	}
+
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		SendErrorResponse(w, http.StatusBadRequest, "failed to read request body")
+		return
+	}
+	defer r.Body.Close()
+
+	var req CreateInstanceRequest
+	if err := json.Unmarshal(body, &req); err != nil {
+		SendErrorResponse(w, http.StatusBadRequest, "invalid request format")
+		return
+	}
+
+	userID, _, err := ValidateRequest(w, r)
+	if err != nil {
+		SendErrorResponse(w, http.StatusUnauthorized, err.Error())
+		return
+	}
+
+	if err := CheckPermission(userID, "superuser", "admin"); err != nil {
+		SendErrorResponse(w, http.StatusForbidden, err.Error())
+		return
+	}
+
+	if req.InstanceInfo.Name == "" || req.InstanceInfo.ServerAddr == "" ||
+		req.InstanceInfo.ServerPort == "" || req.InstanceInfo.AuthMethod == "" {
+		SendErrorResponse(w, http.StatusBadRequest, "missing required fields in instanceInfo")
+		return
+	}
+
+	runUser := req.RunUser
+	if runUser == "" {
+		runUser = "root"
+	}
+
+	user, err := GetUserByID(userID)
+	if err != nil {
+		SendErrorResponse(w, http.StatusInternalServerError, "failed to get user info")
+		return
+	}
+
+	configDir, err := GetConfigDir()
+	if err != nil {
+		SendErrorResponse(w, http.StatusInternalServerError, "failed to get config directory")
+		return
+	}
+
+	configFileName := fmt.Sprintf("superfrpc_%s_%s.toml", user.Username, req.InstanceInfo.Name)
+	configPath := filepath.Join(configDir, configFileName)
+
+	configContent := generateFrpcConfig(req.InstanceInfo)
+	if err := os.WriteFile(configPath, []byte(configContent), 0644); err != nil {
+		SendErrorResponse(w, http.StatusInternalServerError, "failed to create config file")
+		return
+	}
+
+	_, err = frpcDB.Exec(`
+		INSERT INTO frpcInstances (userID, name, serverAddr, serverPort, auth_method, bootAtStart, runUser, configPath, createdAt)
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+	`, userID, req.InstanceInfo.Name, req.InstanceInfo.ServerAddr, req.InstanceInfo.ServerPort,
+		req.InstanceInfo.AuthMethod, req.BootAtStart, runUser, configPath, time.Now().Format(time.RFC3339))
+
+	if err != nil {
+		os.Remove(configPath)
+		SendErrorResponse(w, http.StatusInternalServerError, "failed to save instance to database")
+		return
+	}
+
+	if req.BootAtStart {
+		if err := createBootService(user.Username, req.InstanceInfo.Name, configPath, runUser); err != nil {
+			frpcDB.Exec("DELETE FROM frpcInstances WHERE userID = ? AND name = ?", userID, req.InstanceInfo.Name)
+			os.Remove(configPath)
+			SendErrorResponse(w, http.StatusInternalServerError, "failed to create boot service")
+			return
+		}
+	}
+
+	SendSuccessResponse(w, "instance created successfully", map[string]interface{}{
+		"name":        req.InstanceInfo.Name,
+		"configPath":  configPath,
+		"bootAtStart": req.BootAtStart,
+	})
+}
+
+func DeleteInstanceHandler(w http.ResponseWriter, r *http.Request, instanceName string) {
+	if r.Method != http.MethodPost {
+		SendErrorResponse(w, http.StatusMethodNotAllowed, "invalid request method")
+		return
+	}
+
+	userID, _, err := ValidateRequest(w, r)
+	if err != nil {
+		SendErrorResponse(w, http.StatusUnauthorized, err.Error())
+		return
+	}
+
+	if err := CheckPermission(userID, "superuser", "admin"); err != nil {
+		SendErrorResponse(w, http.StatusForbidden, err.Error())
+		return
+	}
+
+	user, err := GetUserByID(userID)
+	if err != nil {
+		SendErrorResponse(w, http.StatusInternalServerError, "failed to get user info")
+		return
+	}
+
+	var instance FrpcInstance
+	err = frpcDB.QueryRow(`
+		SELECT id, userID, name, serverAddr, serverPort, auth_method, bootAtStart, runUser, configPath, createdAt
+		FROM frpcInstances WHERE userID = ? AND name = ?
+	`, userID, instanceName).Scan(
+		&instance.ID, &instance.UserID, &instance.Name, &instance.ServerAddr, &instance.ServerPort,
+		&instance.AuthMethod, &instance.BootAtStart, &instance.RunUser, &instance.ConfigPath, &instance.CreatedAt)
+
+	if err == sql.ErrNoRows {
+		SendErrorResponse(w, http.StatusNotFound, "instance not found")
+		return
+	}
+	if err != nil {
+		SendErrorResponse(w, http.StatusInternalServerError, "failed to query instance")
+		return
+	}
+
+	if instance.BootAtStart {
+		if err := removeBootService(user.Username, instanceName); err != nil {
+			SendErrorResponse(w, http.StatusInternalServerError, "failed to remove boot service")
+			return
+		}
+	}
+
+	if _, err := os.Stat(instance.ConfigPath); err == nil {
+		if err := os.Remove(instance.ConfigPath); err != nil {
+			SendErrorResponse(w, http.StatusInternalServerError, "failed to remove config file")
+			return
+		}
+	}
+
+	_, err = frpcDB.Exec("DELETE FROM frpcInstances WHERE id = ?", instance.ID)
+	if err != nil {
+		SendErrorResponse(w, http.StatusInternalServerError, "failed to delete instance from database")
+		return
+	}
+
+	SendSuccessResponse(w, "instance deleted successfully", map[string]interface{}{
+		"name": instanceName,
+	})
+}
+
+func ModifyInstanceHandler(w http.ResponseWriter, r *http.Request, instanceName string) {
+	if r.Method != http.MethodPost {
+		SendErrorResponse(w, http.StatusMethodNotAllowed, "invalid request method")
+		return
+	}
+
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		SendErrorResponse(w, http.StatusBadRequest, "failed to read request body")
+		return
+	}
+	defer r.Body.Close()
+
+	var reqMap map[string]interface{}
+	if err := json.Unmarshal(body, &reqMap); err != nil {
+		SendErrorResponse(w, http.StatusBadRequest, "invalid request format")
+		return
+	}
+
+	userID, _, err := ValidateRequest(w, r)
+	if err != nil {
+		SendErrorResponse(w, http.StatusUnauthorized, err.Error())
+		return
+	}
+
+	if err := CheckPermission(userID, "superuser", "admin"); err != nil {
+		SendErrorResponse(w, http.StatusForbidden, err.Error())
+		return
+	}
+
+	user, err := GetUserByID(userID)
+	if err != nil {
+		SendErrorResponse(w, http.StatusInternalServerError, "failed to get user info")
+		return
+	}
+
+	var instance FrpcInstance
+	err = frpcDB.QueryRow(`
+		SELECT id, userID, name, serverAddr, serverPort, auth_method, bootAtStart, runUser, configPath, createdAt
+		FROM frpcInstances WHERE userID = ? AND name = ?
+	`, userID, instanceName).Scan(
+		&instance.ID, &instance.UserID, &instance.Name, &instance.ServerAddr, &instance.ServerPort,
+		&instance.AuthMethod, &instance.BootAtStart, &instance.RunUser, &instance.ConfigPath, &instance.CreatedAt)
+
+	if err == sql.ErrNoRows {
+		SendErrorResponse(w, http.StatusNotFound, "instance not found")
+		return
+	}
+	if err != nil {
+		SendErrorResponse(w, http.StatusInternalServerError, "failed to query instance")
+		return
+	}
+
+	newName := instance.Name
+	newServerAddr := instance.ServerAddr
+	newServerPort := instance.ServerPort
+	newAuthMethod := instance.AuthMethod
+	newRunUser := instance.RunUser
+	newBootAtStart := instance.BootAtStart
+
+	if v, ok := reqMap["name"].(string); ok && v != "" {
+		newName = v
+	}
+	if v, ok := reqMap["serverAddr"].(string); ok && v != "" {
+		newServerAddr = v
+	}
+	if v, ok := reqMap["serverPort"].(string); ok && v != "" {
+		newServerPort = v
+	}
+	if v, ok := reqMap["auth_method"].(string); ok && v != "" {
+		newAuthMethod = v
+	}
+	if v, ok := reqMap["runUser"].(string); ok && v != "" {
+		newRunUser = v
+	}
+	if v, ok := reqMap["bootAtStart"].(bool); ok {
+		newBootAtStart = v
+	}
+
+	oldConfigPath := instance.ConfigPath
+	var newConfigPath string
+	if newName != instance.Name || newRunUser != instance.RunUser {
+		configDir, err := GetConfigDir()
+		if err != nil {
+			SendErrorResponse(w, http.StatusInternalServerError, "failed to get config directory")
+			return
+		}
+
+		newConfigFileName := fmt.Sprintf("superfrpc_%s_%s.toml", user.Username, newName)
+		newConfigPath = filepath.Join(configDir, newConfigFileName)
+
+		if oldConfigPath != newConfigPath {
+			if _, err := os.Stat(oldConfigPath); err == nil {
+				if err := os.Rename(oldConfigPath, newConfigPath); err != nil {
+					SendErrorResponse(w, http.StatusInternalServerError, "failed to rename config file")
+					return
+				}
+			}
+		}
+	} else {
+		newConfigPath = oldConfigPath
+	}
+
+	info := InstanceInfo{
+		Name:       newName,
+		ServerAddr: newServerAddr,
+		ServerPort: newServerPort,
+		AuthMethod: newAuthMethod,
+		RunUser:    newRunUser,
+	}
+
+	configContent := generateFrpcConfig(info)
+	if err := os.WriteFile(newConfigPath, []byte(configContent), 0644); err != nil {
+		SendErrorResponse(w, http.StatusInternalServerError, "failed to update config file")
+		return
+	}
+
+	_, err = frpcDB.Exec(`
+		UPDATE frpcInstances 
+		SET name = ?, serverAddr = ?, serverPort = ?, auth_method = ?, bootAtStart = ?, runUser = ?, configPath = ?
+		WHERE id = ?
+	`, newName, newServerAddr, newServerPort, newAuthMethod, newBootAtStart, newRunUser, newConfigPath, instance.ID)
+
+	if err != nil {
+		SendErrorResponse(w, http.StatusInternalServerError, "failed to update instance in database")
+		return
+	}
+
+	if instance.BootAtStart && !newBootAtStart {
+		removeBootService(user.Username, instanceName)
+	} else if !instance.BootAtStart && newBootAtStart {
+		createBootService(user.Username, newName, newConfigPath, newRunUser)
+	} else if instance.BootAtStart && newBootAtStart && (instance.Name != newName || instance.RunUser != newRunUser) {
+		removeBootService(user.Username, instanceName)
+		createBootService(user.Username, newName, newConfigPath, newRunUser)
+	}
+
+	SendSuccessResponse(w, "instance modified successfully", map[string]interface{}{
+		"name":       newName,
+		"configPath": newConfigPath,
+	})
+}
+
+func ListInstancesHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		SendErrorResponse(w, http.StatusMethodNotAllowed, "invalid request method")
+		return
+	}
+
+	userID, _, err := ValidateRequest(w, r)
+	if err != nil {
+		SendErrorResponse(w, http.StatusUnauthorized, err.Error())
+		return
+	}
+
+	userType, err := GetUserType(userID)
+	if err != nil {
+		SendErrorResponse(w, http.StatusInternalServerError, "failed to get user type")
+		return
+	}
+
+	rows, err := frpcDB.Query(`
+		SELECT id, userID, name, serverAddr, serverPort, auth_method, bootAtStart, runUser, configPath, createdAt
+		FROM frpcInstances WHERE userID = ?
+	`, userID)
+	if err != nil {
+		SendErrorResponse(w, http.StatusInternalServerError, "failed to query instances")
+		return
+	}
+	defer rows.Close()
+
+	var instances []map[string]interface{}
+	for rows.Next() {
+		var instance FrpcInstance
+		var createdAtStr string
+		if err := rows.Scan(
+			&instance.ID, &instance.UserID, &instance.Name, &instance.ServerAddr, &instance.ServerPort,
+			&instance.AuthMethod, &instance.BootAtStart, &instance.RunUser, &instance.ConfigPath, &createdAtStr,
+		); err != nil {
+			SendErrorResponse(w, http.StatusInternalServerError, "failed to scan instance")
+			return
+		}
+
+		instanceData := map[string]interface{}{
+			"name":        instance.Name,
+			"serverAddr":  instance.ServerAddr,
+			"serverPort":  instance.ServerPort,
+			"auth_method": instance.AuthMethod,
+			"bootAtStart": instance.BootAtStart,
+			"runUser":     instance.RunUser,
+			"configPath":  instance.ConfigPath,
+			"createdAt":   createdAtStr,
+		}
+
+		if userType == "visitor" {
+			delete(instanceData, "serverAddr")
+			delete(instanceData, "serverPort")
+			delete(instanceData, "auth_method")
+		}
+
+		instances = append(instances, instanceData)
+	}
+
+	if instances == nil {
+		instances = []map[string]interface{}{}
+	}
+
+	SendSuccessResponse(w, "instances retrieved successfully", instances)
+}
+
+func generateFrpcConfig(info InstanceInfo) string {
+	var sb strings.Builder
+	sb.WriteString("[common]\n")
+	sb.WriteString(fmt.Sprintf("server_addr = %s\n", info.ServerAddr))
+	sb.WriteString(fmt.Sprintf("server_port = %s\n", info.ServerPort))
+	sb.WriteString(fmt.Sprintf("auth_method = %s\n", info.AuthMethod))
+
+	for key, value := range info.Additional {
+		sb.WriteString(fmt.Sprintf("%s = %v\n", key, value))
+	}
+
+	return sb.String()
+}
+
+func GetConfigDir() (string, error) {
+	config, err := GetConfig()
+	if err != nil {
+		return "", err
+	}
+	return config.InstancePath, nil
+}
+
+func GetFrpcPath() (string, error) {
+	config, err := GetConfig()
+	if err != nil {
+		return "", err
+	}
+	return config.FrpcPath, nil
+}
+
+func detectInitSystem() string {
+	if _, err := os.Stat("/run/systemd/system"); err == nil {
+		return "systemd"
+	}
+	if _, err := os.Stat("/etc/init.d"); err == nil {
+		return "init.d"
+	}
+	return "unknown"
+}
+
+func createBootService(username, instanceName, configPath, runUser string) error {
+	initSystem := detectInitSystem()
+
+	switch initSystem {
+	case "systemd":
+		return createSystemdService(username, instanceName, configPath, runUser)
+	case "init.d":
+		return createInitDService(username, instanceName, configPath, runUser)
+	default:
+		return errors.New("unsupported init system")
+	}
+}
+
+func createSystemdService(username, instanceName, configPath, runUser string) error {
+	frpcPath, err := GetFrpcPath()
+	if err != nil {
+		return err
+	}
+
+	serviceName := fmt.Sprintf("superfrpc_%s_%s", username, instanceName)
+	serviceContent := fmt.Sprintf(`[Unit]
+Description=superfrpc_%s_%s
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=%s -c %s
+User=%s
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+`, username, instanceName, frpcPath, configPath, runUser)
+
+	servicePath := filepath.Join("/etc/systemd/system", serviceName+".service")
+	if err := os.WriteFile(servicePath, []byte(serviceContent), 0644); err != nil {
+		return fmt.Errorf("failed to create systemd service file: %w", err)
+	}
+
+	cmd := exec.Command("systemctl", "enable", serviceName)
+	if output, err := cmd.CombinedOutput(); err != nil {
+		os.Remove(servicePath)
+		return fmt.Errorf("failed to enable service: %s, output: %s", err, output)
+	}
+
+	cmd = exec.Command("systemctl", "daemon-reload")
+	if output, err := cmd.CombinedOutput(); err != nil {
+		return fmt.Errorf("failed to reload daemon: %s, output: %s", err, output)
+	}
+
+	return nil
+}
+
+func createInitDService(username, instanceName, configPath, runUser string) error {
+	frpcPath, err := GetFrpcPath()
+	if err != nil {
+		return err
+	}
+
+	serviceName := fmt.Sprintf("superfrpc_%s_%s", username, instanceName)
+
+	var serviceContent string
+	runUserArg := ""
+	if runUser != "" && runUser != "root" {
+		runUserArg = runUser
+		serviceContent = fmt.Sprintf(`#!/bin/sh
+
+### BEGIN INIT INFO
+# Provides:          %s
+# Required-Start:    $network $remote_fs $syslog
+# Required-Stop:     $network $remote_fs $syslog
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Description:       superfrpc %s %s
+### END INIT INFO
+
+NAME="%s"
+PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
+DAEMON=%s
+DAEMON_ARGS="-c %s"
+SCRIPTNAME=/etc/init.d/$NAME
+USER=%s
+
+[ -x "$DAEMON" ] || exit 0
+
+case "$1" in
+  start)
+        echo -n "Starting $NAME: "
+        start-stop-daemon -S -c $USER -b -m -p /var/run/$NAME.pid --start --exec $DAEMON -- $DAEMON_ARGS
+        echo "$NAME."
+        ;;
+  stop)
+        echo -n "Stopping $NAME: "
+        start-stop-daemon -K -p /var/run/$NAME.pid
+        rm -f /var/run/$NAME.pid
+        echo "$NAME."
+        ;;
+  restart)
+        $0 stop
+        $0 start
+        ;;
+  status)
+        if [ -f /var/run/$NAME.pid ]; then
+            echo "$NAME is running (pid $(cat /var/run/$NAME.pid))"
+        else
+            echo "$NAME is not running"
+        fi
+        ;;
+  *)
+        echo "Usage: $SCRIPTNAME {start|stop|restart|status}"
+        exit 1
+        ;;
+esac
+
+exit 0
+`, serviceName, username, instanceName, serviceName, frpcPath, configPath, runUserArg)
+	} else {
+		serviceContent = fmt.Sprintf(`#!/bin/sh
+
+### BEGIN INIT INFO
+# Provides:          %s
+# Required-Start:    $network $remote_fs $syslog
+# Required-Stop:     $network $remote_fs $syslog
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Description:       superfrpc %s %s
+### END INIT INFO
+
+NAME="%s"
+PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
+DAEMON=%s
+DAEMON_ARGS="-c %s"
+SCRIPTNAME=/etc/init.d/$NAME
+
+[ -x "$DAEMON" ] || exit 0
+
+case "$1" in
+  start)
+        echo -n "Starting $NAME: "
+        start-stop-daemon -S -b -m -p /var/run/$NAME.pid --start --exec $DAEMON -- $DAEMON_ARGS
+        echo "$NAME."
+        ;;
+  stop)
+        echo -n "Stopping $NAME: "
+        start-stop-daemon -K -p /var/run/$NAME.pid
+        rm -f /var/run/$NAME.pid
+        echo "$NAME."
+        ;;
+  restart)
+        $0 stop
+        $0 start
+        ;;
+  status)
+        if [ -f /var/run/$NAME.pid ]; then
+            echo "$NAME is running (pid $(cat /var/run/$NAME.pid))"
+        else
+            echo "$NAME is not running"
+        fi
+        ;;
+  *)
+        echo "Usage: $SCRIPTNAME {start|stop|restart|status}"
+        exit 1
+        ;;
+esac
+
+exit 0
+`, serviceName, username, instanceName, serviceName, frpcPath, configPath)
+	}
+
+	servicePath := filepath.Join("/etc/init.d", serviceName)
+	if err := os.WriteFile(servicePath, []byte(serviceContent), 0755); err != nil {
+		return fmt.Errorf("failed to create init.d service file: %w", err)
+	}
+
+	cmd := exec.Command("/etc/init.d", serviceName, "enable")
+	if output, err := cmd.CombinedOutput(); err != nil {
+		os.Remove(servicePath)
+		return fmt.Errorf("failed to enable service: %s, output: %s", err, output)
+	}
+
+	return nil
+}
+
+func removeBootService(username, instanceName string) error {
+	initSystem := detectInitSystem()
+
+	serviceName := fmt.Sprintf("superfrpc_%s_%s", username, instanceName)
+
+	switch initSystem {
+	case "systemd":
+		cmd := exec.Command("systemctl", "disable", serviceName)
+		cmd.CombinedOutput()
+
+		servicePath := filepath.Join("/etc/systemd/system", serviceName+".service")
+		os.Remove(servicePath)
+
+		cmd = exec.Command("systemctl", "daemon-reload")
+		cmd.CombinedOutput()
+
+	case "init.d":
+		cmd := exec.Command("/etc/init.d", serviceName, "disable")
+		cmd.CombinedOutput()
+
+		servicePath := filepath.Join("/etc/init.d", serviceName)
+		os.Remove(servicePath)
+	}
+
+	return nil
+}
+
+func GetUserInstances(userID int) ([]FrpcInstance, error) {
+	rows, err := frpcDB.Query(`
+		SELECT id, userID, name, serverAddr, serverPort, auth_method, bootAtStart, runUser, configPath, createdAt
+		FROM frpcInstances WHERE userID = ?
+	`, userID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var instances []FrpcInstance
+	for rows.Next() {
+		var instance FrpcInstance
+		var createdAtStr string
+		if err := rows.Scan(
+			&instance.ID, &instance.UserID, &instance.Name, &instance.ServerAddr, &instance.ServerPort,
+			&instance.AuthMethod, &instance.BootAtStart, &instance.RunUser, &instance.ConfigPath, &createdAtStr,
+		); err != nil {
+			return nil, err
+		}
+		instance.CreatedAt, _ = time.Parse(time.RFC3339, createdAtStr)
+		instances = append(instances, instance)
+	}
+
+	return instances, nil
+}