TeeJee.ProcessHelper Namespace Reference

Functions
static void	init_tmp ()
int	exec_sync (string cmd, out string? std_out=null, out string? std_err=null)
int	exec_script_sync (string script, out string? std_out=null, out string? std_err=null, bool supress_errors=false, bool run_as_admin=false, bool cleanup_tmp=true, bool print_to_terminal=false)
int	exec_script_async (string script)
static int	exec_user_async (string command)
string?	save_bash_script_temp (string commands, string? script_path=null, bool force_locale=true, bool supress_errors=false)
string	get_temp_file_path ()
static bool	cmd_exists (string cmd_tool)
string	get_process_exe_name (long pid=-1)
Pid	get_process_parent (Pid process=-1)
int	get_euid_of_process (Pid process)
Pid	get_user_process ()
string?[]	get_process_env (Pid pid)
string?	get_env (string[] env, string name, string? default_value=null)
Pid[]	get_process_children (Pid parent_pid)
void	process_quit (Pid process_pid, bool killChildren=true)
void	process_kill (Pid process_pid, bool killChildren=true)
void	process_send_signal (Pid process_pid, Posix.Signal sig, bool children=true)
void	process_set_priority (Pid procID, int prio)
int	process_get_priority (Pid procID)
void	process_set_priority_normal (Pid procID)
void	process_set_priority_low (Pid procID)

Variables
string	TEMP_DIR

Function Documentation

cmd_exists()

bool TeeJee.ProcessHelper.cmd_exists ( string cmd_tool )

static

Definition at line 283 of file TeeJee.Process.vala.

                                                  {
        string? path = Environment.find_program_in_path(cmd_tool);
        return (path != null) && (path.length > 0);
    }

References cmd_exists().

Referenced by cmd_exists(), and TeeJee.System.exo_open_folder().

exec_script_async()

int TeeJee.ProcessHelper.exec_script_async

(

string

script

)

Definition at line 171 of file TeeJee.Process.vala.

                                                {
 
        /* Executes commands synchronously.
         * Pipes and multiple commands are fully supported.
         * Commands are written to a temporary bash script and executed.
         * Return value indicates if script was started successfully.
         *  */
 
        try {
 
            string scriptfile = save_bash_script_temp (script);
 
            string[] argv = new string[1];
            argv[0] = scriptfile;
 
            string[] env = Environ.get();
            
            Pid child_pid;
            Process.spawn_async_with_pipes(
                TEMP_DIR, //working dir
                argv, //argv
                env, //environment
                SpawnFlags.SEARCH_PATH,
                null,
                out child_pid);
 
            return 0;
        }
        catch (Error e){
            log_error (e.message);
            return 1;
        }
    }

References Error, exec_script_async(), TeeJee.Logging.log_error(), save_bash_script_temp(), and TEMP_DIR.

Referenced by exec_script_async(), and TeeJee.System.exo_open_folder().

exec_script_sync()

int TeeJee.ProcessHelper.exec_script_sync	(	string	script,
		out string?	std_out = null,
		out string?	std_err = null,
		bool	supress_errors = false,
		bool	run_as_admin = false,
		bool	cleanup_tmp = true,
		bool	print_to_terminal = false )

Definition at line 84 of file TeeJee.Process.vala.

                                                            {
 
        /* Executes commands synchronously.
         * Pipes and multiple commands are fully supported.
         * Commands are written to a temporary bash script and executed.
         * std_out, std_err can be null. Output will be written to terminal if null.
         * */
 
        string? sh_file = save_bash_script_temp(script, null, true, supress_errors);
        if (sh_file == null) {
            // saving the script failed
            return -1;
        }
 
        string sh_file_admin = "";
        
        if (run_as_admin){
            
            var script_admin = "#!/usr/bin/env bash\n";
            script_admin += "pkexec env DISPLAY=$DISPLAY XAUTHORITY=$XAUTHORITY";
            script_admin += " '%s'".printf(escape_single_quote(sh_file));
            
            sh_file_admin = GLib.Path.build_filename(file_parent(sh_file),"script-admin.sh");
 
            save_bash_script_temp(script_admin, sh_file_admin, true, supress_errors);
        }
        
        try {
            string[] argv = new string[1];
            if (run_as_admin){
                argv[0] = sh_file_admin;
            }
            else{
                argv[0] = sh_file;
            }
 
            string[] env = Environ.get();
 
            int exit_code;
 
            if (print_to_terminal){
                
                Process.spawn_sync (
                    TEMP_DIR, //working dir
                    argv, //argv
                    env, //environment
                    SpawnFlags.SEARCH_PATH,
                    null,   // child_setup
                    null,
                    null,
                    out exit_code
                    );
            }
            else{
        
                Process.spawn_sync (
                    TEMP_DIR, //working dir
                    argv, //argv
                    env, //environment
                    SpawnFlags.SEARCH_PATH,
                    null,   // child_setup
                    out std_out,
                    out std_err,
                    out exit_code
                    );
            }
 
            if (cleanup_tmp){
                file_delete(sh_file);
                if (run_as_admin){
                    file_delete(sh_file_admin);
                }
            }
            
            return exit_code;
        }
        catch (Error e){
            if (!supress_errors){
                log_error (e.message);
            }
            return -1;
        }
    }

References Error, TeeJee.FileSystem.escape_single_quote(), exec_script_sync(), TeeJee.FileSystem.file_delete(), TeeJee.FileSystem.file_parent(), TeeJee.Logging.log_error(), save_bash_script_temp(), and TEMP_DIR.

Referenced by Main.check_and_repair_filesystems(), exec_script_sync(), Device.get_block_devices_using_blkid(), init_tmp(), Device.luks_lock(), Device.luks_unlock(), Main.restore_current_console(), Main.restore_execute_btrfs(), Main.restore_other_console(), Main.restore_other_gui(), Main.run_post_backup_hooks(), and Device.unmount().

exec_sync()

int TeeJee.ProcessHelper.exec_sync	(	string	cmd,
		out string?	std_out = null,
		out string?	std_err = null )

Definition at line 67 of file TeeJee.Process.vala.

                                                                                         {
 
        /* Executes single command synchronously.
         * Pipes and multiple commands are not supported.
         * std_out, std_err can be null. Output will be written to terminal if null. */
 
        try {
            int status;
            Process.spawn_command_line_sync(cmd, out std_out, out std_err, out status);
            return status;
        }
        catch (Error e){
            log_error (e.message);
            return -1;
        }
    }

References Error, exec_sync(), and TeeJee.Logging.log_error().

Referenced by CronTab.add_job(), Device.automount_udisks_iso(), SnapshotRepo.build_synthetic_device_for_path(), Main.check_and_remove_timeshift_btrfs(), Main.cleanup_unmount_devices(), Main.create_pre_restore_snapshot_btrfs(), Main.create_snapshot_with_btrfs(), CronTab.crontab_read_all(), exec_sync(), TeeJee.FileSystem.file_gzip(), Device.find_child_devices_using_dmsetup(), Device.get_block_devices_using_lsblk(), Device.get_disk_space_using_df(), CronTab.install(), Device.mount(), SmbMount.mount(), Main.query_subvolume_id(), Main.query_subvolume_quota(), Subvolume.remove(), CronTab.remove_job(), Subvolume.restore(), and Device.test_lsblk_version().

exec_user_async()

int TeeJee.ProcessHelper.exec_user_async ( string command )

static

executes a command as the "normal" unprivileged user async may execute the command as root if the user could not be determined or the name could not be resolved

Definition at line 209 of file TeeJee.Process.vala.

                                                      {
        // find correct user
        int uid = TeeJee.System.get_user_id();
        string cmd = command;
        if(uid > 0) {
            // non root
            string? user = TeeJee.System.get_username_from_uid(uid);
            if(user != null) {
                cmd = "pkexec --user %s env DISPLAY=$DISPLAY XAUTHORITY=$XAUTHORITY DBUS_SESSION_BUS_ADDRESS=$DBUS_SESSION_BUS_ADDRESS ".printf(user) + cmd;
            }
        }
 
        log_debug(cmd);
        return TeeJee.ProcessHelper.exec_script_async(cmd);
    }

References exec_user_async(), and TeeJee.Logging.log_debug().

Referenced by exec_user_async(), and TeeJee.System.xdg_open().

get_env()

string? TeeJee.ProcessHelper.get_env	(	string[]	env,
		string	name,
		string?	default_value = null )

Definition at line 356 of file TeeJee.Process.vala.

                                                                                  {
        foreach(string env_var in env) {
            string[] splitted = env_var.split("=", 2);
            if(splitted[0] == name) {
                if (splitted.length == 2) {
                    return splitted[1];
                }
            }
        }
        return default_value;
    }

References get_env().

Referenced by get_env().

get_euid_of_process()

int TeeJee.ProcessHelper.get_euid_of_process

(

Pid

process

)

Definition at line 320 of file TeeJee.Process.vala.

                                                {
        GLib.File file = GLib.File.new_for_path("/proc/%d".printf(process));
        try {
            GLib.FileInfo info = file.query_info(FileAttribute.UNIX_UID, GLib.FileQueryInfoFlags.NONE);
            return (int) info.get_attribute_uint32(FileAttribute.UNIX_UID);
        } catch(GLib.Error e) {
            log_debug("failed to fetch user of process %i %s".printf(process, e.message));
        }
        return -1;
    }

References get_euid_of_process(), and TeeJee.Logging.log_debug().

Referenced by get_euid_of_process(), and get_user_process().

get_process_children()

Pid[] TeeJee.ProcessHelper.get_process_children

(

Pid

parent_pid

)

Definition at line 368 of file TeeJee.Process.vala.

                                                      {
 
        /* Returns the list of child processes owned by a given process */
 
        // no explicit check for the existence of /proc/ as this might be a time-of-check-time-of-use bug.
        File procfs = File.new_for_path("/proc/");
 
        try {
            FileEnumerator enumerator = procfs.enumerate_children(FileAttribute.STANDARD_NAME, FileQueryInfoFlags.NOFOLLOW_SYMLINKS);
            FileInfo info;
            Pid[] childList = {};
            while ((info = enumerator.next_file()) != null) {
                if(info.get_file_type() != FileType.DIRECTORY) {
                    // only interested in directories
                    continue;
                }
 
                string name = info.get_name();
 
                uint64 pid;
                if(!uint64.try_parse(name, out pid)) {
                    // make sure to not access any other directories that may be present in /proc for some reason
                    continue;
                }
 
                string? fileCont = file_read("/proc/%s/stat".printf(name));
                if(fileCont == null) {
                    // stat file of pid might not be readable (because of permissions or the process died since we got its pid)
                    continue;
                }
 
                // the format of the stat file is documented in man 5 proc
                // it begging is: pid (comm) status ppid ...
 
                // the process name could contain a space or ) and confuse the parsing.
                // so we make sure to take the last ) and only parse the stuff after that.
                int index = fileCont.last_index_of_char(')');
                string parseline = fileCont.substring(index);
                string[] split = parseline.split(" ", 4); // we are not interested in the part after ppid so just leave it a big string
                if(split.length != 4) {
                    // format of stat file is not matching - should never happen
                    log_error("can not parse state of %ld".printf((long) pid));
                    continue;
                }
 
                uint64 ppid = uint64.parse(split[2]);
                if(ppid != 0 && ppid == parent_pid) {
                    // the process is a child of the target parent process
                    childList += (Pid) pid;
                }
            }
            return childList;
        } catch (Error e) {
            log_error(e.message);
            log_error("Failed to get child processes of %ld".printf(parent_pid));
        }
        return {};
    }

References Error, TeeJee.FileSystem.file_read(), get_process_children(), and TeeJee.Logging.log_error().

Referenced by get_process_children(), and process_send_signal().

get_process_env()

string?[] TeeJee.ProcessHelper.get_process_env

(

Pid

pid

)

Definition at line 348 of file TeeJee.Process.vala.

                                              {
        if(pid < 1) {
            return null;
        }
        return file_read_array("/proc/%i/environ".printf(pid), '\0');
    }

References TeeJee.FileSystem.file_read_array(), and get_process_env().

Referenced by get_process_env().

get_process_exe_name()

string TeeJee.ProcessHelper.get_process_exe_name

(

long

pid = -1

)

Definition at line 290 of file TeeJee.Process.vala.

                                                   {
        string pidStr = (pid <= 0 ? "self" : pid.to_string());
        string path = "/proc/%s/exe".printf(pidStr);
        string link;
        try {
            link = GLib.FileUtils.read_link(path);
        } catch (Error e) {
            return "";
        }
 
        return GLib.Path.get_basename(link);
    }

References Error, and get_process_exe_name().

Referenced by AppLock.create(), and get_process_exe_name().

get_process_parent()

Pid TeeJee.ProcessHelper.get_process_parent

(

Pid

process = -1

)

Definition at line 304 of file TeeJee.Process.vala.

                                                  {
        string pidStr = (process <= 0 ? "self" : process.to_string());
        string path = "/proc/%s/stat".printf(pidStr);
        string stats = file_read(path);
        string details = stats.split(")", 2)[1];
        string[] splitted = details.split(" ", 3);
        if(splitted.length == 3) {
            return int.parse(splitted[2]);
        }
 
        log_debug("can not parse process stat %s".printf(stats));
        return -1;
    }

References TeeJee.FileSystem.file_read(), get_process_parent(), and TeeJee.Logging.log_debug().

Referenced by get_process_parent(), and get_user_process().

get_temp_file_path()

string TeeJee.ProcessHelper.get_temp_file_path

(

)

Definition at line 274 of file TeeJee.Process.vala.

                                      {
 
        /* Generates temporary file path */
 
        return TEMP_DIR + "/" + timestamp_numeric() + (new Rand()).next_int().to_string();
    }

References get_temp_file_path(), TEMP_DIR, and TeeJee.Misc.timestamp_numeric().

Referenced by CronTab.add_job(), get_temp_file_path(), CronTab.remove_job(), and save_bash_script_temp().

get_user_process()

Pid TeeJee.ProcessHelper.get_user_process

(

)

Definition at line 332 of file TeeJee.Process.vala.

                                  {
        Pid ppid = -1;
        int targetUser = TeeJee.System.get_user_id();
        int user = 0;
 
        do {
            ppid = get_process_parent(ppid);
            user = get_euid_of_process (ppid);
        } while(user != targetUser && ppid > 1);
        if(user == targetUser) {
            return ppid;
        }
        return -1;
    }

References get_euid_of_process(), get_process_parent(), and get_user_process().

Referenced by get_user_process().

init_tmp()

void TeeJee.ProcessHelper.init_tmp ( )

static

Definition at line 37 of file TeeJee.Process.vala.

                                 {
 
        // a list of folders where temp files could be stored
        string[] tempPlaces = {
            Environment.get_tmp_dir(), // system temp dir
            "/var/tmp", // another system temp dir, if the first one failed, this one is likely to fail too
            Environment.get_home_dir() + "/.temp", // user temp dir
            "/dev/shm", // shared memory
        };
 
        foreach (string tempPlace in tempPlaces) {
            string std_out, std_err;
 
            TEMP_DIR = tempPlace + "/bastionguard-backup-" + random_string();
            dir_create(TEMP_DIR);
            Posix.chmod(TEMP_DIR, 0750);
            exec_script_sync("echo 'ok'",out std_out,out std_err, true);
 
            if ((std_out == null) || (std_out.strip() != "ok")){
                // this dir does not work for some reason - probably no disk space
                dir_delete(TEMP_DIR);
            } else {
                // script worked - we have found a tempdir to use
                return;
            }
        }
 
        stderr.printf("No usable temp directory was found!\n");
    }

References TeeJee.FileSystem.dir_create(), TeeJee.FileSystem.dir_delete(), exec_script_sync(), init_tmp(), TeeJee.Misc.random_string(), and TEMP_DIR.

Referenced by init_tmp().

process_get_priority()

int TeeJee.ProcessHelper.process_get_priority

(

Pid

procID

)

Definition at line 473 of file TeeJee.Process.vala.

                                                {
 
        /* Get process priority */
 
        return Posix.getpriority (Posix.PRIO_PROCESS, procID);
    }

References process_get_priority().

Referenced by process_get_priority().

process_kill()

void TeeJee.ProcessHelper.process_kill	(	Pid	process_pid,
		bool	killChildren = true )

Definition at line 438 of file TeeJee.Process.vala.

                                                                      {
 
        /* Kills specified process and its children (optional).
         * Sends signal SIGKILL to the process to kill it forcefully.
         * It is recommended to use the function process_quit() instead.
         * */
        
        process_send_signal(process_pid, Posix.Signal.KILL, killChildren);
    }

References process_kill(), and process_send_signal().

Referenced by process_kill().

process_quit()

void TeeJee.ProcessHelper.process_quit	(	Pid	process_pid,
		bool	killChildren = true )

Definition at line 429 of file TeeJee.Process.vala.

                                                                     {
 
        /* Terminates specified process and its children (optional).
         * Sends signal SIGTERM to the process to allow it to quit gracefully.
         * */
 
        process_send_signal(process_pid, Posix.Signal.TERM, killChildren);
    }

References process_quit(), and process_send_signal().

Referenced by process_quit(), and AsyncTask.stop().

process_send_signal()

void TeeJee.ProcessHelper.process_send_signal	(	Pid	process_pid,
		Posix.Signal	sig,
		bool	children = true )

Definition at line 448 of file TeeJee.Process.vala.

                                                                                           {
 
        /* Sends a signal to a process and its children (optional). */
        
        // get the childs before sending the signal, as the childs might not be accessible afterwards
        Pid[] child_pids = get_process_children (process_pid);
        Posix.kill (process_pid, sig);
         
         if (children){
            foreach (Pid pid in child_pids){
                Posix.kill (pid, sig);
            }
        }
    }

References get_process_children(), and process_send_signal().

Referenced by process_kill(), process_quit(), and process_send_signal().

process_set_priority()

void TeeJee.ProcessHelper.process_set_priority	(	Pid	procID,
		int	prio )

Definition at line 465 of file TeeJee.Process.vala.

                                                           {
 
        /* Set process priority */
 
        if (Posix.getpriority (Posix.PRIO_PROCESS, procID) != prio)
            Posix.setpriority (Posix.PRIO_PROCESS, procID, prio);
    }

References process_set_priority().

Referenced by process_set_priority(), process_set_priority_low(), and process_set_priority_normal().

process_set_priority_low()

void TeeJee.ProcessHelper.process_set_priority_low

(

Pid

procID

)

Definition at line 487 of file TeeJee.Process.vala.

                                                     {
 
        /* Set low priority for process */
 
        process_set_priority (procID, 5);
    }

References process_set_priority(), and process_set_priority_low().

Referenced by process_set_priority_low().

process_set_priority_normal()

void TeeJee.ProcessHelper.process_set_priority_normal

(

Pid

procID

)

Definition at line 480 of file TeeJee.Process.vala.

                                                        {
 
        /* Set normal priority for process */
 
        process_set_priority (procID, 0);
    }

References process_set_priority(), and process_set_priority_normal().

Referenced by process_set_priority_normal().

save_bash_script_temp()

string? TeeJee.ProcessHelper.save_bash_script_temp	(	string	commands,
		string?	script_path = null,
		bool	force_locale = true,
		bool	supress_errors = false )

Definition at line 225 of file TeeJee.Process.vala.

                                                          {
 
        string sh_path = script_path;
        
        /* Creates a temporary bash script with given commands
         * Returns the script file path */
 
        var script = new StringBuilder();
        script.append ("#!/usr/bin/env bash\n");
        script.append ("\n");
        if (force_locale){
            script.append("LANG=C\n");
            script.append("LC_ALL=C.UTF-8\n");
        }
        script.append ("\n");
        script.append ("%s\n".printf(commands));
        script.append ("\n\nexitCode=$?\n");
        script.append ("echo ${exitCode} > status\n");
 
        if ((sh_path == null) || (sh_path.length == 0)){
            sh_path = get_temp_file_path();
        }
 
        try{
            //write script file
            var file = File.new_for_path (sh_path);
            if (file.query_exists ()) {
                file.delete ();
            }
            var file_stream = file.create (FileCreateFlags.REPLACE_DESTINATION);
            var data_stream = new DataOutputStream (file_stream);
            data_stream.put_string (script.str);
            data_stream.close();
 
            // set execute permission
            Posix.chmod (sh_path, 0744);
 
            return sh_path;
        }
        catch (Error e) {
            if (!supress_errors){
                log_error (e.message);
            }
        }
 
        return null;
    }

References Error, get_temp_file_path(), TeeJee.Logging.log_error(), and save_bash_script_temp().

Referenced by exec_script_async(), exec_script_sync(), AsyncTask.prepare(), Main.restore_current_gui(), and save_bash_script_temp().

Variable Documentation

TEMP_DIR

string TeeJee.ProcessHelper.TEMP_DIR

Definition at line 31 of file TeeJee.Process.vala.

Referenced by AsyncTask.AsyncTask(), Main.estimate_system_size(), exec_script_async(), exec_script_sync(), TerminalWindow.execute_script(), Main.exit_app(), get_temp_file_path(), init_tmp(), and TerminalWindow.start_shell().