src/core/execute.h

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 #ifndef fooexecutehfoo
   4 #define fooexecutehfoo
   5
   6 /***
   7   This file is part of systemd.
   8
   9   Copyright 2010 Lennart Poettering
  10
  11   systemd is free software; you can redistribute it and/or modify it
  12   under the terms of the GNU Lesser General Public License as published by
  13   the Free Software Foundation; either version 2.1 of the License, or
  14   (at your option) any later version.
  15
  16   systemd is distributed in the hope that it will be useful, but
  17   WITHOUT ANY WARRANTY; without even the implied warranty of
  18   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19   Lesser General Public License for more details.
  20
  21   You should have received a copy of the GNU Lesser General Public License
  22   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  23 ***/
  24
  25 typedef struct ExecStatus ExecStatus;
  26 typedef struct ExecCommand ExecCommand;
  27 typedef struct ExecContext ExecContext;
  28
  29 #include <linux/types.h>
  30 #include <sys/time.h>
  31 #include <sys/resource.h>
  32 #include <sys/capability.h>
  33 #include <stdbool.h>
  34 #include <stdio.h>
  35 #include <sched.h>
  36
  37 struct CGroupBonding;
  38 struct CGroupAttribute;
  39
  40 #include "list.h"
  41 #include "util.h"
  42
  43 typedef enum KillMode {
  44         KILL_CONTROL_GROUP = 0,
  45         KILL_PROCESS,
  46         KILL_NONE,
  47         _KILL_MODE_MAX,
  48         _KILL_MODE_INVALID = -1
  49 } KillMode;
  50
  51 typedef enum KillWho {
  52         KILL_MAIN,
  53         KILL_CONTROL,
  54         KILL_ALL,
  55         _KILL_WHO_MAX,
  56         _KILL_WHO_INVALID = -1
  57 } KillWho;
  58
  59 typedef enum ExecInput {
  60         EXEC_INPUT_NULL,
  61         EXEC_INPUT_TTY,
  62         EXEC_INPUT_TTY_FORCE,
  63         EXEC_INPUT_TTY_FAIL,
  64         EXEC_INPUT_SOCKET,
  65         _EXEC_INPUT_MAX,
  66         _EXEC_INPUT_INVALID = -1
  67 } ExecInput;
  68
  69 typedef enum ExecOutput {
  70         EXEC_OUTPUT_INHERIT,
  71         EXEC_OUTPUT_NULL,
  72         EXEC_OUTPUT_TTY,
  73         EXEC_OUTPUT_SYSLOG,
  74         EXEC_OUTPUT_SYSLOG_AND_CONSOLE,
  75         EXEC_OUTPUT_KMSG,
  76         EXEC_OUTPUT_KMSG_AND_CONSOLE,
  77         EXEC_OUTPUT_JOURNAL,
  78         EXEC_OUTPUT_JOURNAL_AND_CONSOLE,
  79         EXEC_OUTPUT_SOCKET,
  80         _EXEC_OUTPUT_MAX,
  81         _EXEC_OUTPUT_INVALID = -1
  82 } ExecOutput;
  83
  84 struct ExecStatus {
  85         dual_timestamp start_timestamp;
  86         dual_timestamp exit_timestamp;
  87         pid_t pid;
  88         int code;     /* as in siginfo_t::si_code */
  89         int status;   /* as in sigingo_t::si_status */
  90 };
  91
  92 struct ExecCommand {
  93         char *path;
  94         char **argv;
  95         ExecStatus exec_status;
  96         LIST_FIELDS(ExecCommand, command); /* useful for chaining commands */
  97         bool ignore;
  98 };
  99
 100 struct ExecContext {
 101         char **environment;
 102         char **environment_files;
 103
 104         struct rlimit *rlimit[RLIMIT_NLIMITS];
 105         char *working_directory, *root_directory;
 106
 107         mode_t umask;
 108         int oom_score_adjust;
 109         int nice;
 110         int ioprio;
 111         int cpu_sched_policy;
 112         int cpu_sched_priority;
 113
 114         cpu_set_t *cpuset;
 115         unsigned cpuset_ncpus;
 116
 117         ExecInput std_input;
 118         ExecOutput std_output;
 119         ExecOutput std_error;
 120
 121         nsec_t timer_slack_nsec;
 122
 123         char *tcpwrap_name;
 124
 125         char *tty_path;
 126
 127         bool tty_reset;
 128         bool tty_vhangup;
 129         bool tty_vt_disallocate;
 130
 131         bool ignore_sigpipe;
 132
 133         /* Since resolving these names might might involve socket
 134          * connections and we don't want to deadlock ourselves these
 135          * names are resolved on execution only and in the child
 136          * process. */
 137         char *user;
 138         char *group;
 139         char **supplementary_groups;
 140
 141         char *pam_name;
 142
 143         char *utmp_id;
 144
 145         char **read_write_dirs, **read_only_dirs, **inaccessible_dirs;
 146         unsigned long mount_flags;
 147
 148         uint64_t capability_bounding_set_drop;
 149
 150         /* Not relevant for spawning processes, just for killing */
 151         KillMode kill_mode;
 152         int kill_signal;
 153         bool send_sigkill;
 154
 155         cap_t capabilities;
 156         int secure_bits;
 157
 158         int syslog_priority;
 159         char *syslog_identifier;
 160         bool syslog_level_prefix;
 161
 162         bool cpu_sched_reset_on_fork;
 163         bool non_blocking;
 164         bool private_tmp;
 165         bool private_network;
 166
 167         bool no_new_privileges;
 168
 169         bool control_group_modify;
 170         int control_group_persistent;
 171
 172         /* This is not exposed to the user but available
 173          * internally. We need it to make sure that whenever we spawn
 174          * /bin/mount it is run in the same process group as us so
 175          * that the autofs logic detects that it belongs to us and we
 176          * don't enter a trigger loop. */
 177         bool same_pgrp;
 178
 179         uint32_t *syscall_filter;
 180
 181         bool oom_score_adjust_set:1;
 182         bool nice_set:1;
 183         bool ioprio_set:1;
 184         bool cpu_sched_set:1;
 185 };
 186
 187 int exec_spawn(ExecCommand *command,
 188                char **argv,
 189                const ExecContext *context,
 190                int fds[], unsigned n_fds,
 191                char **environment,
 192                bool apply_permissions,
 193                bool apply_chroot,
 194                bool apply_tty_stdin,
 195                bool confirm_spawn,
 196                struct CGroupBonding *cgroup_bondings,
 197                struct CGroupAttribute *cgroup_attributes,
 198                const char *cgroup_suffix,
 199                const char *unit_id,
 200                int pipe_fd[2],
 201                pid_t *ret);
 202
 203 void exec_command_done(ExecCommand *c);
 204 void exec_command_done_array(ExecCommand *c, unsigned n);
 205
 206 void exec_command_free_list(ExecCommand *c);
 207 void exec_command_free_array(ExecCommand **c, unsigned n);
 208
 209 char *exec_command_line(char **argv);
 210
 211 void exec_command_dump(ExecCommand *c, FILE *f, const char *prefix);
 212 void exec_command_dump_list(ExecCommand *c, FILE *f, const char *prefix);
 213 void exec_command_append_list(ExecCommand **l, ExecCommand *e);
 214 int exec_command_set(ExecCommand *c, const char *path, ...);
 215
 216 void exec_context_init(ExecContext *c);
 217 void exec_context_done(ExecContext *c);
 218 void exec_context_dump(ExecContext *c, FILE* f, const char *prefix);
 219 void exec_context_tty_reset(const ExecContext *context);
 220
 221 int exec_context_load_environment(const ExecContext *c, char ***l);
 222
 223 void exec_status_start(ExecStatus *s, pid_t pid);
 224 void exec_status_exit(ExecStatus *s, ExecContext *context, pid_t pid, int code, int status);
 225 void exec_status_dump(ExecStatus *s, FILE *f, const char *prefix);
 226
 227 const char* exec_output_to_string(ExecOutput i);
 228 ExecOutput exec_output_from_string(const char *s);
 229
 230 const char* exec_input_to_string(ExecInput i);
 231 ExecInput exec_input_from_string(const char *s);
 232
 233 const char *kill_mode_to_string(KillMode k);
 234 KillMode kill_mode_from_string(const char *s);
 235
 236 const char *kill_who_to_string(KillWho k);
 237 KillWho kill_who_from_string(const char *s);
 238
 239 #endif