Allow to specify user to run screen on

Author: PinkLolicorn

command.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"github.com/pkg/errors"
+	"os/exec"
+	"os/user"
+	"strconv"
+	"syscall"
+)
+
+type UserInfo struct {
+	name string
+	gid  uint32
+	uid  uint32
+}
+
+func getUserInfoByName(userName string) (UserInfo, error) {
+
+	screenUser, err := user.Lookup(userName)
+	if err != nil {
+		return UserInfo{}, err
+	}
+
+	gid64, _ := strconv.ParseUint(screenUser.Gid, 10, 32)
+	gid := uint32(gid64)
+
+	uid64, _ := strconv.ParseUint(screenUser.Uid, 10, 32)
+	uid := uint32(uid64)
+
+	return UserInfo{userName, gid, uid}, nil
+}
+
+func executeCommand(userInfo UserInfo, args ...string) (string, error) {
+
+	baseCmd := args[0]
+	cmdArgs := args[1:]
+
+	cmd := exec.Command(baseCmd, cmdArgs...)
+	currentUser, _ := user.Current()
+	root := currentUser.Gid == "0"
+
+	if userInfo.name != currentUser.Username && !root {
+		return "", errors.New("Screen daemon requires root privileges to switch between users")
+	}
+
+	if root {
+		cmd.SysProcAttr = &syscall.SysProcAttr{}
+		cmd.SysProcAttr.Credential = &syscall.Credential{Uid: userInfo.uid, Gid: userInfo.gid}
+	}
+
+	out, err := cmd.Output()
+	if err != nil {
+		return string(out), err
+	}
+
+	return string(out), nil
+}

daemon.go

@@ -24,6 +24,7 @@ import (
 
 type ScreenInfo struct {
 	Name string `ini:"name"`
+	User string `ini:"user"`
 }
 
 type ExecutionInfo struct {

daemons/example.ini

@@ -1,5 +1,6 @@
 [Screen]
 name = Example Daemon
+user = example
 
 [Execution]
 command = bash

main.go

@@ -20,26 +20,11 @@ package main
 
 import (
 	"log"
-	"os/exec"
 	"path/filepath"
 	"strconv"
 	"time"
 )
 
-func executeCommand(args ...string) (string, error) {
-
-	baseCmd := args[0]
-	cmdArgs := args[1:]
-
-	cmd := exec.Command(baseCmd, cmdArgs...)
-	out, err := cmd.Output()
-	if err != nil {
-		return string(out), err
-	}
-
-	return string(out), nil
-}
-
 func main() {
 
 	files, err := filepath.Glob("daemons/*.ini")
@@ -71,20 +56,21 @@ func main() {
 
 			command := daemon.Command
 			name := daemon.Name
+			user := daemon.User
 
-			screen, err := runScreen(name, command)
+			screen, err := runScreen(user, name, command)
 			if err != nil {
 				if err.Error() == "SCREEN_ALREADY_EXISTS" {
 					if firstRun {
-						log.Print("(", name, ") WARNING: skipped, screen already exists")
+						log.Print("(", name, " on ", user, ") WARNING: skipped, screen already exists")
 					}
 				} else {
-					log.Fatal("(", name, ") FAILED: ", command, " [", err, "]")
+					log.Fatal("(", name, " on ", user, ") FAILED: ", command, " [", err, "]")
 				}
 				continue
 			}
 
-			log.Print("(" + strconv.Itoa(screen.id) + ", " + screen.name + ") STARTED: " + command)
+			log.Print("("+strconv.Itoa(screen.id)+", "+screen.name, " on ", user, ") STARTED: "+command)
 		}
 
 		firstRun = false

screen.go

@@ -29,9 +29,9 @@ type Screen struct {
 	name string
 }
 
-func runScreen(screenName string, command string) (Screen, error) {
+func runScreen(userName string, screenName string, command string) (Screen, error) {
 
-	exists, err := doesScreenExists(screenName)
+	exists, err := doesScreenExists(userName, screenName)
 	if err != nil {
 		return Screen{}, err
 	}
@@ -43,15 +43,20 @@ func runScreen(screenName string, command string) (Screen, error) {
 	args := []string{"screen", "-dmS", screenName}
 	args = append(args, strings.Split(command, " ")...)
 
-	_, err = executeCommand(args...)
+	userInfo, err := getUserInfoByName(userName)
+	if err != nil {
+		return Screen{}, err
+	}
+
+	_, err = executeCommand(userInfo, args...)
 	if err != nil {
 		if err.Error() == "exit status 1" {
 			return Screen{}, errors.New("exit status 1: check command")
 		}
 		return Screen{}, err
 	}
 
-	screen, err := getScreenByName(screenName)
+	screen, err := getScreenByName(userName, screenName)
 	if err != nil {
 		if err.Error() == "SCREEN_NOT_FOUND" {
 			return Screen{}, errors.New("Screen " + screenName + " not present after creation")
@@ -62,9 +67,14 @@ func runScreen(screenName string, command string) (Screen, error) {
 	return screen, nil
 }
 
-func getRunningScreens() ([]Screen, error) {
+func getRunningScreens(userName string) ([]Screen, error) {
+
+	userInfo, err := getUserInfoByName(userName)
+	if err != nil {
+		return []Screen{}, err
+	}
 
-	output, err := executeCommand("screen", "-ls")
+	output, err := executeCommand(userInfo, "screen", "-ls")
 	if err != nil {
 		if !strings.HasPrefix(output, "No Sockets found in") {
 			return []Screen{}, err
@@ -96,9 +106,9 @@ func getRunningScreens() ([]Screen, error) {
 	return screens, nil
 }
 
-func doesScreenExists(screenName string) (bool, error) {
+func doesScreenExists(userName string, screenName string) (bool, error) {
 
-	_, err := getScreenByName(screenName)
+	_, err := getScreenByName(userName, screenName)
 	if err != nil {
 		if err.Error() == "SCREEN_NOT_FOUND" {
 			return false, nil
@@ -109,9 +119,9 @@ func doesScreenExists(screenName string) (bool, error) {
 	return true, nil
 }
 
-func getScreenByName(screenName string) (Screen, error) {
+func getScreenByName(userName string, screenName string) (Screen, error) {
 
-	screens, err := getRunningScreens()
+	screens, err := getRunningScreens(userName)
 	if err != nil {
 		return Screen{}, err
 	}