Initial Commit

cmd/ectl/go.mod

@@ -0,0 +1,5 @@
+module ectl
+
+go 1.23.4
+
+require rsc.io/getopt v0.0.0-20170811000552-20be20937449 // indirect

cmd/ectl/go.sum

@@ -0,0 +1,2 @@
+rsc.io/getopt v0.0.0-20170811000552-20be20937449 h1:UukjJOsjQH0DIuyyrcod6CXHS6cdaMMuJmrt+SN1j4A=
+rsc.io/getopt v0.0.0-20170811000552-20be20937449/go.mod h1:dhCdeqAxkyt5u3/sKRkUXuHaMXUu1Pt13GTQAM2xnig=

cmd/ectl/main.go

@@ -0,0 +1,192 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"net"
+	"os"
+	"path"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+)
+
+// Build-time variables
+var version = "dev"
+var sysconfdir = "/etc/"
+var runstatedir = "/var/run/"
+
+var socket net.Conn
+
+func main() {
+
+	// Set and parse flags
+	printVersion := flag.Bool("version", false, "print version and exit")
+	flag.Parse()
+
+	// Dial esvm socket
+	dialSocket()
+	defer socket.Close()
+
+	if flag.NArg() < 1 {
+		printUsage()
+		os.Exit(1)
+	}
+
+	if *printVersion || flag.Args()[0] == "version" {
+		fmt.Printf("Enit Control version %s\n", version)
+		return
+	} else if flag.Args()[0] == "help" {
+		printUsage()
+		return
+	} else if flag.Args()[0] == "shutdown" || flag.Args()[0] == "poweroff" || flag.Args()[0] == "halt" {
+		err := syscall.Kill(1, syscall.SIGUSR1)
+		if err != nil {
+			log.Fatalf("Could not send shutdown signal! Error: %s\n", err)
+		}
+		return
+	} else if flag.Args()[0] == "reboot" || flag.Args()[0] == "restart" || flag.Args()[0] == "reset" {
+		err := syscall.Kill(1, syscall.SIGTERM)
+		if err != nil {
+			log.Fatalf("Could not send shutdown signal! Error: %s\n", err)
+		}
+		return
+	} else if flag.Args()[0] == "service" || flag.Args()[0] == "sv" {
+		if len(flag.Args()) <= 1 {
+			fmt.Println("Usage: ectl service <start/stop/enable/disable/status/list> [service]")
+			return
+		} else if flag.Args()[1] == "list" {
+			fmt.Println("list")
+			return
+		} else if len(flag.Args()) <= 2 {
+			fmt.Printf("Usage: ectl service %s <service>\n", flag.Args()[1])
+			return
+		} else if flag.Args()[1] == "start" {
+			flag.Args()[2] = strings.TrimSuffix(flag.Args()[2], ".esv")
+			if _, err := os.Stat(path.Join(sysconfdir, "esvm/services/", flag.Args()[2]+".esv")); err != nil {
+				log.Fatalf("Could not start service! Error: %s\n", err)
+			}
+
+			_, err := socket.Write([]byte("start " + flag.Args()[2]))
+			if err != nil {
+				log.Fatalf("Could not start service! Error: %s\n", err)
+			}
+
+			buf := make([]byte, 1024)
+			n, err := socket.Read(buf)
+			if err != nil {
+				log.Fatalf("Could not start service! Error: %s\n", err)
+			}
+			if string(buf[:n]) != "ok" {
+				log.Fatalf("Could not start service! Error: expcted 'ok' got '%s'\n", string(buf))
+			}
+
+			fmt.Println("Service started successfully!")
+			return
+		} else if flag.Args()[1] == "stop" {
+			flag.Args()[2] = strings.TrimSuffix(flag.Args()[2], ".esv")
+			if _, err := os.Stat(path.Join(sysconfdir, "esvm/services/", flag.Args()[2]+".esv")); err != nil {
+				log.Fatalf("Could not stop service! Error: %s\n", err)
+			}
+
+			_, err := socket.Write([]byte("stop " + flag.Args()[2]))
+			if err != nil {
+				log.Fatalf("Could not stop service! Error: %s\n", err)
+			}
+
+			buf := make([]byte, 1024)
+			n, err := socket.Read(buf)
+			if err != nil {
+				log.Fatalf("Could not stop service! Error: %s\n", err)
+			}
+			if string(buf[:n]) != "ok" {
+				log.Fatalf("Could not stop service! Error: expcted 'ok' got '%s'\n", string(buf))
+			}
+			fmt.Println("Service stopped successfully!")
+			return
+		} else if flag.Args()[1] == "restart" || flag.Args()[1] == "reload" {
+			flag.Args()[2] = strings.TrimSuffix(flag.Args()[2], ".esv")
+			if _, err := os.Stat(path.Join(sysconfdir, "esvm/services/", flag.Args()[2]+".esv")); err != nil {
+				log.Fatalf("Could not stop service! Error: %s\n", err)
+			}
+
+			_, err := socket.Write([]byte("restart " + flag.Args()[2]))
+			if err != nil {
+				log.Fatalf("Could not restart service! Error: %s\n", err)
+			}
+
+			buf := make([]byte, 1024)
+			n, err := socket.Read(buf)
+			if err != nil {
+				log.Fatalf("Could not restart service! Error: %s\n", err)
+			}
+			if string(buf[:n]) != "ok" {
+				log.Fatalf("Could not restart service! Error: expcted 'ok' got '%s'\n", string(buf))
+			}
+			fmt.Println("Service restarted successfully!")
+			return
+		} else if flag.Args()[1] == "status" {
+			flag.Args()[2] = strings.TrimSuffix(flag.Args()[2], ".esv")
+			if _, err := os.Stat(path.Join(sysconfdir, "esvm/services/", flag.Args()[2]+".esv")); err != nil {
+				log.Fatalf("Could not stop service! Error: %s\n", err)
+			}
+
+			var state uint64
+			bytes, err := os.ReadFile(path.Join(runstatedir, "esvm", flag.Args()[2], "state"))
+			if err != nil {
+				state = 0
+			}
+			state, err = strconv.ParseUint(string(bytes), 10, 8)
+
+			fmt.Println("Service name: " + flag.Args()[2])
+			switch state {
+			case 0:
+				fmt.Println("Service state: Unknown")
+			case 1:
+				fmt.Println("Service state: Unloaded")
+			case 2:
+				fmt.Println("Service state: Running")
+			case 3:
+				fmt.Println("Service state: Stopped")
+			case 4:
+				fmt.Println("Service state: Crashed")
+			}
+			return
+		}
+	}
+
+	printUsage()
+	os.Exit(1)
+}
+
+func printUsage() {
+	fmt.Println("Available sucommands:")
+	fmt.Println("ectl version | Show enit version")
+	fmt.Println("ectl shutdown/poweroff/halt | Shutdown the system")
+	fmt.Println("ectl reboot/restart | Reboot the system")
+	fmt.Println("ectl help | Show command explanations")
+	fmt.Println("ectl sv/service start <service> | Start a service")
+	fmt.Println("ectl sv/service stop <service> | Stop a service")
+	fmt.Println("ectl sv/service enable <service> | Enable a service at startup")
+	fmt.Println("ectl sv/service disable <service> | Disable a service at startup")
+	fmt.Println("ectl sv/service status <service> | Show service status")
+	fmt.Println("ectl sv/service list | Show all enabled services")
+}
+
+func dialSocket() {
+	if _, err := os.Stat(path.Join(runstatedir, "esvm/esvm.sock")); err != nil {
+		log.Fatalf("Could not find esvm.sock! Error: %s\n", err)
+	}
+
+	var err error
+	socket, err = net.Dial("unix", path.Join(runstatedir, "esvm/esvm.sock"))
+	if err != nil {
+		log.Fatalf("Failed to connect to esvm.sock! Error: %s\n", err)
+	}
+
+	if err := socket.SetDeadline(time.Now().Add(5 * time.Second)); err != nil {
+		log.Fatalf("Failed to set write deadline! Error: %s\n", err)
+	}
+}

cmd/enit/go.mod

@@ -0,0 +1,3 @@
+module enit
+
+go 1.23.4

cmd/enit/go.sum

@@ -0,0 +1,4 @@
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

cmd/enit/main.go

@@ -0,0 +1,177 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path"
+	"strconv"
+	"syscall"
+)
+
+// Build-time variables
+var version = "dev"
+var sysconfdir = "/etc/"
+var runstatedir = "/var/run/"
+
+var serviceManagerPid int
+
+func main() {
+	// Parse flags
+	printVersion := flag.Bool("version", false, "print version and exit")
+	flag.Parse()
+
+	if *printVersion {
+		fmt.Printf("Enit version %s\n", version)
+		os.Exit(0)
+	}
+
+	if os.Getpid() != 1 {
+		fmt.Println("Enit must be run as PID 1!")
+		os.Exit(1)
+	}
+
+	fmt.Println("Starting Enit...")
+
+	// Mount virtual filesystems
+	mountVirtualFilesystems()
+	// Mount filesystems in fstab
+	mountFilesystems()
+	// Start service manager
+	startServiceManager()
+
+	// Run function once to wait zombie processes created by initcpio
+	waitZombieProcesses()
+
+	fmt.Println()
+	startTerminal()
+
+	// Catch signals
+	catchSignals()
+}
+
+func mountVirtualFilesystems() {
+	fmt.Print("Mounting virtual filesystems... ")
+
+	if err := os.Mkdir("/dev/pts", 0755); err != nil {
+		panic(err)
+	}
+	if err := syscall.Mount("none", "/dev/pts", "devpts", syscall.MS_NOSUID|syscall.MS_NOEXEC, ""); err != nil {
+		panic(err)
+	}
+
+	fmt.Println("Done.")
+}
+
+func mountFilesystems() {
+	fmt.Print("Mounting filesystems... ")
+
+	cmd := exec.Command("/bin/mount", "-a")
+	err := cmd.Run()
+
+	if err != nil {
+		log.Println("Could not mount fstab entries!")
+		panic(err)
+	}
+
+	fmt.Println("Done.")
+}
+
+func startServiceManager() {
+	fmt.Print("Initializing service manager... ")
+
+	cmd := exec.Command("/sbin/esvm", path.Join(runstatedir, "esvm"), path.Join(sysconfdir, "esvm"))
+	err := cmd.Start()
+	if err != nil {
+		log.Println("Could not initialize service manager!")
+		panic(err)
+	}
+	serviceManagerPid = cmd.Process.Pid
+
+	fmt.Println("Done")
+}
+
+func waitZombieProcesses() {
+	for {
+		if wpid, _ := syscall.Wait4(-1, nil, syscall.WNOHANG, nil); wpid <= 0 {
+			break
+		}
+	}
+}
+
+func startTerminal() {
+	for i := 1; i < 6; i++ {
+		cmd := exec.Command("/sbin/agetty", "--noclear", "tty"+strconv.Itoa(i))
+		cmd.Stdin = os.Stdin
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		err := cmd.Start()
+
+		if err != nil {
+			log.Println("Could not start agetty terminal on tty" + strconv.Itoa(i) + "!")
+			panic(err)
+		}
+	}
+}
+
+func catchSignals() {
+	sigc := make(chan os.Signal, 1)
+	signal.Notify(sigc, syscall.SIGUSR1, syscall.SIGTERM, syscall.SIGINT, syscall.SIGCHLD)
+	defer close(sigc)
+	defer signal.Stop(sigc)
+	for {
+		switch <-sigc {
+		case syscall.SIGUSR1:
+			close(sigc)
+			signal.Stop(sigc)
+			shutdownSystem()
+		case syscall.SIGTERM, syscall.SIGINT:
+			close(sigc)
+			signal.Stop(sigc)
+			rebootSystem()
+		case syscall.SIGCHLD:
+			waitZombieProcesses()
+		}
+	}
+}
+
+func shutdownSystem() {
+	fmt.Println("Shutting down...")
+
+	fmt.Println("Stopping services... ")
+	err := syscall.Kill(serviceManagerPid, syscall.SIGTERM)
+	if err != nil {
+		log.Println("Could not stop service manager!")
+		panic(err)
+	}
+	fmt.Print("Done.")
+
+	fmt.Println("Sending shutdown syscall...")
+	syscall.Sync()
+	err = syscall.Reboot(syscall.LINUX_REBOOT_CMD_POWER_OFF)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func rebootSystem() {
+	fmt.Println("Rebooting...")
+
+	fmt.Println("Stopping service manager... ")
+	err := syscall.Kill(serviceManagerPid, syscall.SIGTERM)
+	if err != nil {
+		log.Println("Could not stop service manager!")
+		panic(err)
+	}
+	fmt.Print("Done.")
+
+	fmt.Println("Sending reboot syscall...")
+	syscall.Sync()
+	err = syscall.Reboot(syscall.LINUX_REBOOT_CMD_RESTART)
+	if err != nil {
+		panic(err)
+	}
+}

cmd/esvm/go.mod

@@ -0,0 +1,5 @@
+module esvm
+
+go 1.23.4
+
+require gopkg.in/yaml.v3 v3.0.1 // indirect

cmd/esvm/go.sum

@@ -0,0 +1,3 @@
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

cmd/esvm/main.go

@@ -0,0 +1,426 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"gopkg.in/yaml.v3"
+	"io"
+	"log"
+	"net"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path"
+	"strconv"
+	"strings"
+	"syscall"
+)
+
+type EnitServiceState uint8
+
+const (
+	EnitServiceUnknown EnitServiceState = iota
+	EnitServiceUnloaded
+	EnitServiceRunning
+	EnitServiceStopped
+	EnitServiceCrashed
+	EnitServiceCompleted
+)
+
+type EnitService struct {
+	Name           string `yaml:"name"`
+	Description    string `yaml:"description,omitempty"`
+	Type           string `yaml:"type"`
+	StartCmd       string `yaml:"start_cmd"`
+	ExitMethod     string `yaml:"exit_method"`
+	StopCmd        string `yaml:"stop_cmd,omitempty"`
+	ServiceRunPath string
+	stopChannel    chan bool
+}
+
+// Build-time variables
+var version = "dev"
+
+var runtimeServiceDir string
+var serviceConfigDir string
+
+var Services = make([]EnitService, 0)
+
+var socket net.Listener
+
+func main() {
+	// Parse flags
+	printVersion := flag.Bool("version", false, "print version and exit")
+	flag.Parse()
+
+	if *printVersion || flag.NArg() != 2 {
+		fmt.Printf("Enit Service Manager version %s\n", version)
+		os.Exit(0)
+	}
+
+	// Set directory variables
+	runtimeServiceDir = flag.Arg(0)
+	serviceConfigDir = flag.Arg(1)
+
+	if os.Getppid() != 1 {
+		fmt.Println("Enit must be run by PID 1!")
+		os.Exit(1)
+	}
+
+	err := Init()
+	if err != nil {
+		log.Fatalf("Could not initialize esvm! Error: %s", err)
+	}
+
+	sigc := make(chan os.Signal, 1)
+	signal.Notify(sigc, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		<-sigc
+		Destroy()
+		os.Exit(0)
+	}()
+
+	for {
+		listenToSocket()
+	}
+}
+
+func Init() error {
+	if _, err := os.Stat(runtimeServiceDir); err == nil {
+		return fmt.Errorf("runtime service directory %s already exists", runtimeServiceDir)
+	}
+
+	err := os.MkdirAll(runtimeServiceDir, 0755)
+	if err != nil {
+		return err
+	}
+
+	socket, err = net.Listen("unix", path.Join(runtimeServiceDir, "esvm.sock"))
+	if err != nil {
+		return err
+	}
+
+	if stat, err := os.Stat(serviceConfigDir); err != nil || !stat.IsDir() {
+		return nil
+	}
+
+	dirEntries, err := os.ReadDir(path.Join(serviceConfigDir, "services"))
+	if err != nil {
+		return err
+	}
+
+	for _, entry := range dirEntries {
+		if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".esv") {
+			bytes, err := os.ReadFile(path.Join(serviceConfigDir, "services", entry.Name()))
+			if err != nil {
+				log.Printf("Could not read service file at %s!", path.Join(serviceConfigDir, "services", entry.Name()))
+			}
+
+			service := EnitService{
+				StopCmd:     "",
+				stopChannel: make(chan bool),
+			}
+			if err := yaml.Unmarshal(bytes, &service); err != nil {
+				log.Printf("Could not read service file at %s!", path.Join(serviceConfigDir, "services", entry.Name()))
+			}
+
+			switch service.Type {
+			case "simple", "background":
+			default:
+				return fmt.Errorf("unknown service type: %s", service.Type)
+			}
+
+			switch service.ExitMethod {
+			case "stop_command", "kill":
+			default:
+				return fmt.Errorf("unknown exit method: %s", service.ExitMethod)
+			}
+
+			service.ServiceRunPath = path.Join(runtimeServiceDir, service.Name)
+			err = os.MkdirAll(path.Join(service.ServiceRunPath), 0755)
+			if err != nil {
+				return err
+			}
+
+			err = service.setCurrentState(EnitServiceUnloaded)
+			if err != nil {
+				return err
+			}
+
+			Services = append(Services, service)
+
+			if err := service.StartService(); err != nil {
+				log.Printf("Could not start service %s: %s\n", service.Name, err)
+			}
+		}
+	}
+
+	return nil
+}
+
+func Destroy() {
+	for _, service := range Services {
+		if err := service.StopService(); err != nil {
+			log.Printf("Error stopping service %s: %s\n", service.Name, err)
+		}
+	}
+}
+
+func GetServiceByName(name string) *EnitService {
+	for _, service := range Services {
+		if service.Name == name {
+			return &service
+		}
+	}
+	return nil
+}
+
+func (service *EnitService) GetProcess() *os.Process {
+	bytes, err := os.ReadFile(path.Join(service.ServiceRunPath, "process"))
+	if err != nil {
+		return nil
+	}
+
+	pid, err := strconv.Atoi(strings.TrimSpace(string(bytes)))
+	if err != nil {
+		return nil
+	}
+
+	process, err := os.FindProcess(pid)
+	if err != nil {
+		return nil
+	}
+
+	return process
+}
+
+func (service *EnitService) setProcessID(pid int) error {
+	if err := os.WriteFile(path.Join(service.ServiceRunPath, "process"), []byte(strconv.Itoa(pid)), 0644); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (service *EnitService) GetCurrentState() EnitServiceState {
+	bytes, err := os.ReadFile(path.Join(service.ServiceRunPath, "state"))
+	if err != nil {
+		return EnitServiceUnknown
+	}
+
+	state, err := strconv.Atoi(strings.TrimSpace(string(bytes)))
+	if err != nil {
+		return EnitServiceUnknown
+	}
+	return EnitServiceState(state)
+}
+
+func (service *EnitService) setCurrentState(state EnitServiceState) error {
+	if err := os.WriteFile(path.Join(service.ServiceRunPath, "state"), []byte(strconv.Itoa(int(state))), 0644); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (service *EnitService) StartService() error {
+	if service == nil {
+		return nil
+	}
+	if service.GetCurrentState() == EnitServiceRunning {
+		return nil
+	}
+
+	cmd := exec.Command("/bin/sh", "-c", service.StartCmd)
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+
+	go func() {
+		err := cmd.Wait()
+		select {
+		case <-service.stopChannel:
+			_ = service.setCurrentState(EnitServiceStopped)
+		default:
+			if service.Type == "simple" && err == nil {
+				_ = service.setCurrentState(EnitServiceCompleted)
+			}
+			_ = service.setCurrentState(EnitServiceCrashed)
+		}
+
+	}()
+
+	err := service.setProcessID(cmd.Process.Pid)
+	if err != nil {
+		return err
+	}
+
+	err = service.setCurrentState(EnitServiceRunning)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (service *EnitService) StopService() error {
+	if service.GetCurrentState() != EnitServiceRunning {
+		return nil
+	}
+
+	if service.ExitMethod == "kill" {
+		if service.GetProcess() == nil {
+			return nil
+		}
+		go func() { service.stopChannel <- true }()
+		err := service.GetProcess().Kill()
+		if err != nil {
+			return err
+		}
+	} else {
+		cmd := exec.Command("/bin/sh", "-c", service.StopCmd)
+		if err := cmd.Run(); err != nil {
+			return err
+		}
+	}
+
+	err := service.setCurrentState(EnitServiceStopped)
+	if err != nil {
+		return err
+	}
+
+	err = service.setProcessID(0)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (service *EnitService) RestartService() error {
+	if err := service.StopService(); err != nil {
+		return err
+	}
+
+	if err := service.StartService(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func checkForServiceCommand() {
+	for _, service := range Services {
+		if _, err := os.Stat(path.Join(service.ServiceRunPath, "start")); err == nil {
+			err := service.StartService()
+			if err != nil {
+				return
+			}
+			err = os.Remove(path.Join(service.ServiceRunPath, "start"))
+			if err != nil {
+				return
+			}
+		} else if _, err := os.Stat(path.Join(service.ServiceRunPath, "stop")); err == nil {
+			err := service.StopService()
+			if err != nil {
+				return
+			}
+			err = os.Remove(path.Join(service.ServiceRunPath, "stop"))
+			if err != nil {
+				return
+			}
+		} else if _, err := os.Stat(path.Join(service.ServiceRunPath, "restart")); err == nil {
+			err := service.RestartService()
+			if err != nil {
+				return
+			}
+			err = os.Remove(path.Join(service.ServiceRunPath, "restart"))
+			if err != nil {
+				return
+			}
+		}
+	}
+}
+
+func listenToSocket() {
+	conn, err := socket.Accept()
+	if err != nil {
+		log.Println("Could not accept socket connection!")
+		panic(err)
+	}
+
+	// Handle the connection in a separate goroutine.
+	go func(conn net.Conn) {
+		defer conn.Close()
+		// Create a buffer for incoming data.
+		buf := make([]byte, 4096)
+
+		// Read data from the connection.
+		n, err := conn.Read(buf)
+		if err == io.EOF {
+			return
+		}
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		command := string(buf[:n])
+		commandSplit := strings.Split(command, " ")
+
+		if len(commandSplit) >= 2 {
+			if commandSplit[0] == "start" {
+				service := GetServiceByName(commandSplit[1])
+				if service == nil {
+					_, err := conn.Write([]byte("service not found"))
+					if err != nil {
+						return
+					}
+				}
+				if err := service.StartService(); err != nil {
+					_, err := conn.Write([]byte("could not start service"))
+					if err != nil {
+						return
+					}
+				}
+				_, err := conn.Write([]byte("ok"))
+				if err != nil {
+					return
+				}
+			} else if commandSplit[0] == "stop" {
+				service := GetServiceByName(commandSplit[1])
+				if service == nil {
+					_, err := conn.Write([]byte("service not found"))
+					if err != nil {
+						return
+					}
+				}
+				if err := service.StopService(); err != nil {
+					_, err := conn.Write([]byte("could not stop service"))
+					if err != nil {
+						return
+					}
+				}
+				_, err := conn.Write([]byte("ok"))
+				if err != nil {
+					return
+				}
+			} else if commandSplit[0] == "restart" {
+				service := GetServiceByName(commandSplit[1])
+				if service == nil {
+					_, err := conn.Write([]byte("service not found"))
+					if err != nil {
+						return
+					}
+				}
+				if err := service.RestartService(); err != nil {
+					_, err := conn.Write([]byte("could not restart service"))
+					if err != nil {
+						return
+					}
+				}
+				_, err := conn.Write([]byte("ok"))
+				if err != nil {
+					return
+				}
+			}
+		}
+	}(conn)
+}