Allow another user to control the process

Question

I have an sh script which runs on our server. It is started with nohup from another script so that i can easily close session and it still runs

Main script (which will start this one) is also an sh script. And it can be executed with two parameters:

--start (will start application)
--stop (will stop it using kill PID)

But since application is started by me, none else (except root) can stop already running instance or restart it.

So i was thinking more about changing owner to nobody. Would that help it? If yes, then how can it be done?

Answer 1

Set up the script to shut itself down on some event, instead of running until killed. Then make the main script trigger that event at --stop (the event can be something simple like creating a specific file, or something more complex like writing a command to a fifo that the script periodically reads). This way, other users should be able to shut the script down no matter who started it.

How to do this depends on the details of your script. If it doesn't have a loop in which it can check the shutdown condition itself, you may be able to do something like have it spawn a background process that periodically checks the condition and kills its parent pid when met.

Answer 2

Setup a user especially for running this script.

And run the script using:

su -l <user> -c "<command>"

---

Update:

Proposing this kind of approach assumed that modifing the script in question is not an option.

Answer 3

Changing owner to nobody would of course help in your objective. The below describes one way of doing this by using a dedicated helper program which is invisible to the user.

Solution: You can use setuid program to make sure the script is always run as the same user. Because of security reasons, you probably are not allowed to make your shell script setuid, but you can write a simple launcher program, maybe in C:

#include <stdio.h>
#include <unistd.h>

#define PROG "./daemon.sh"

int main(int argc, char** argv)
{
    char action[32];

    if (argc < 2) {
            fprintf(stderr, "Usage: %s { --start | --stop }n", argv[0]);
            return 0;
    }

    snprintf(action, sizeof(action), "%s-the-real-thing", argv[1]);
    return execl(PROG, PROG, action, (char *)0);
}

Here we are supposing your script is named daemon.sh and is in the same directory where you run the script. You can use full path or change in other obvious ways according to your need.

Compile and make setuid as follows (assuming here name launcher.c and we decide to run as nobody):

$ gcc -Wall launcher.c -o launcher
$ sudo chown nobody launcher
$ sudo chmod u+s launcher

You need to modify your shell script daemon program slightly:

#!/bin/sh

prog=$(basename $0)

start()
{
    i=0
    while :; do
        i=$(expr $i + 1)
        echo "Daemon working like a mad horse... ($i)"
        sleep 1
    done
}

stop()
{
    pids=$(ps axu | grep "$prog.*--start" | grep -v grep | awk '{print $2}')
    echo "Killing [$pids]"
    [ -n "$pids" ] && exec /bin/kill -KILL $pids
}

case "$1" in
    --start|--stop)         exec ./launcher $1;;
    --start-the-real-thing) start;;
    --stop-the-real-thing)  stop;;
    *)                      echo "Bad argument \"$1\"";;
esac

Here start function is where all the interesting funk is done until your kill the program by calling the stop function. There are some obvious changes required to run this from anywhere, and I am hoping your existing kill logic is more elegant.

Usage is like before:

./daemon.sh --start
./daemon.sh --stop

Explanation: the above will execute ./launcher --start or ./launcher --stop, repectively. This will change the effective user to nobody (or whatever you chose to setuid the program), and execute either ./daemon.sh --start-the-real-thing or ./daemon.sh --stop-the-real-thing which will perform the desired original action.

Because the simple launcher program only allows running the named script, the security is easy to control (just to make sure, you can check in the launcher program that argv[1] really is --start or --stop, then exactly two command line combinations can be run as ).

Answer 4

You can try below options:

1. create a TCP socket in your process, to which a client process started by other user can communicate.
2. From your user, start a separate TCP server, which can accept some limited set of commands over TCP. That server can accept the daemon-shutdown command from any user. That process can then issue a kill command for your main process.
3. Create a named fifo, which can be made as writable by any user. Create a child thread, which would try to read from that fifo. Since by nature, the fifo read calls are blocking calls, that thread will keep sleeping (& will not consume your CPU). After some other user writes something to that fifo, the thread will wake up & cleanly terminate the parent thread.
4. Same as above, but the thread waiting is part of another process, started by the same user. That process, when wakes up, will kill main process.

In my opinion, 3rd approach is the cleanest one, among the three.

EDIT: Since the 'main process' is actually a shell script, the 'thread' would change to sub-shell. & the child thread to be waiting would be simple 'cat fifo'.

Answer 5

If you have root access, you could use sudo and configure it to allow running the script with the --stop argument as root.