Merge with vlock-2
[vlock.git] / src / script.c
blob3006dc69683eb4609847a99d029f6279fd7b1426
1 /* script.c -- script routines for vlock, the VT locking program for linux
3 * This program is copyright (C) 2007 Frank Benkstein, and is free
4 * software which is freely distributable under the terms of the
5 * GNU General Public License version 2, included as the file COPYING in this
6 * distribution. It is NOT public domain software, and any
7 * redistribution not permitted by the GNU General Public License is
8 * expressly forbidden without prior written permission from
9 * the author.
13 /* Scripts are executables that are run as unprivileged child processes of
14 * vlock. They communicate with vlock through stdin and stdout.
16 * When dependencies are retrieved they are launched once for each dependency
17 * and should print the names of the plugins they depend on on stdout one per
18 * line. The dependency requested is given as a single command line argument.
20 * In hook mode the script is called once with "hooks" as a single command line
21 * argument. It should not exit until its stdin closes. The hook that should
22 * be executed is written to its stdin on a single line.
24 * Currently there is no way for a script to communicate errors or even success
25 * to vlock. If it exits it will linger as a zombie until the plugin is
26 * destroyed.
29 #if !defined(__FreeBSD__) && !defined(_GNU_SOURCE)
30 #define _GNU_SOURCE
31 #endif
33 #include <stdio.h>
34 #include <string.h>
35 #include <stdlib.h>
36 #include <unistd.h>
37 #include <limits.h>
38 #include <sys/select.h>
39 #include <fcntl.h>
40 #include <signal.h>
41 #include <errno.h>
42 #include <sys/time.h>
43 #include <time.h>
45 #include "list.h"
46 #include "process.h"
47 #include "util.h"
49 #include "plugin.h"
51 static bool init_script(struct plugin *p);
52 static void destroy_script(struct plugin *p);
53 static bool call_script_hook(struct plugin *p, const char *hook_name);
55 struct plugin_type *script = &(struct plugin_type){
56 .init = init_script,
57 .destroy = destroy_script,
58 .call_hook = call_script_hook,
61 struct script_context
63 /* The pipe file descriptor that is connected to the script's stdin. */
64 int fd;
65 /* The PID of the script. */
66 pid_t pid;
69 /* Get the dependency from the script. */
70 static bool get_dependency(const char *path, const char *dependency_name,
71 struct list *dependency_list);
72 /* Launch the script creating a new script_context. No error detection aborts
73 * on fatal errors. */
74 static struct script_context *launch_script(const char *path);
76 bool init_script(struct plugin *p)
78 char *path;
80 if (asprintf(&path, "%s/%s", VLOCK_SCRIPT_DIR, p->name) < 0) {
81 errno = ENOMEM;
82 return false;
85 /* Test for access. This must be done manually because vlock most likely
86 * runs as a setuid executable and would otherwise override restrictions.
88 * Also there is currently no error detection in case exec() fails later.
90 if (access(path, X_OK) < 0) {
91 free(path);
92 return false;
95 /* Get the dependency information. */
96 for (size_t i = 0; i < nr_dependencies; i++)
97 if (!get_dependency(path, dependency_names[i], p->dependencies[i]))
98 return false;
100 /* Launch the script. */
101 p->context = launch_script(path);
103 free(path);
105 return true;
108 static void destroy_script(struct plugin *p)
110 struct script_context *context = p->context;
112 if (context != NULL) {
113 /* Close the pipe. */
114 (void) close(context->fd);
116 /* Kill the child process. */
117 if (!wait_for_death(context->pid, 0, 500000L))
118 ensure_death(context->pid);
120 free(context);
124 /* Invoke the hook by writing it on a single line to the scripts stdin. */
125 static bool call_script_hook(struct plugin *s, const char *hook_name)
127 struct script_context *context = s->context;
128 char *data;
129 ssize_t data_length;
130 ssize_t length;
131 struct sigaction act, oldact;
133 /* Format the line. */
134 data_length = asprintf(&data, "%s\n", hook_name);
136 if (data_length < 0)
137 fatal_error("memory allocation failed");
139 /* When writing to a pipe when the read end is closed the kernel invariably
140 * sends SIGPIPE. Ignore it. */
141 (void) sigemptyset(&(act.sa_mask));
142 act.sa_flags = SA_RESTART;
143 act.sa_handler = SIG_IGN;
144 (void) sigaction(SIGPIPE, &act, &oldact);
146 /* Send hook name and a newline through the pipe. */
147 length = write(context->fd, data, data_length);
149 /* Restore the previous SIGPIPE handler. */
150 (void) sigaction(SIGPIPE, &oldact, NULL);
152 /* Scripts fail silently. */
153 return (length == data_length);
156 static struct script_context *launch_script(const char *path)
158 struct script_context *script = ensure_malloc(sizeof *script);
159 const char *argv[] = { path, "hooks", NULL };
160 struct child_process child = {
161 .path = path,
162 .argv = argv,
163 .stdin_fd = REDIRECT_PIPE,
164 .stdout_fd = REDIRECT_PIPE,
165 .stderr_fd = REDIRECT_PIPE,
166 .function = NULL,
169 create_child(&child);
170 script->fd = child.stdin_fd;
171 script->pid = child.pid;
173 return script;
176 static char *read_dependency(const char *path, const char *dependency_name);
177 static bool parse_dependency(char *data, struct list *dependency_list);
179 /* Get the dependency from the script. */
180 static bool get_dependency(const char *path, const char *dependency_name,
181 struct list *dependency_list)
183 /* Read the dependency data. */
184 char *data;
185 errno = 0;
186 data = read_dependency(path, dependency_name);
189 if (data == NULL) {
190 return errno != 0;
191 } else {
192 /* Parse the dependency data. */
193 bool result = parse_dependency(data, dependency_list);
194 int errsv = errno;
195 free(data);
196 errno = errsv;
197 return result;
201 /* Read the dependency data by starting the script with the name of the
202 * dependency as a single command line argument. The script should then print
203 * the dependencies to its stdout one on per line. */
204 static char *read_dependency(const char *path, const char *dependency_name)
206 char *error = NULL;
207 int pipe_fds[2];
208 pid_t pid;
209 struct timeval timeout = (struct timeval){1, 0};
210 char *data = ensure_calloc(1, sizeof *data);
211 size_t data_length = 0;
213 /* Open a pipe for the script. */
214 if (pipe(pipe_fds) < 0)
215 fatal_error("pipe() failed");
217 pid = fork();
219 if (pid == 0) {
220 /* Child. */
221 int nullfd = open("/dev/null", O_RDWR);
223 if (nullfd < 0)
224 _exit(1);
226 /* Redirect stdio. */
227 (void) dup2(nullfd, STDIN_FILENO);
228 (void) dup2(pipe_fds[1], STDOUT_FILENO);
229 (void) dup2(nullfd, STDERR_FILENO);
231 /* Close all other file descriptors. */
232 close_all_fds();
234 /* Drop privileges. */
235 setgid(getgid());
236 setuid(getuid());
238 (void) execl(path, path, dependency_name, NULL);
240 _exit(1);
243 /* Close write end of the pipe. */
244 (void) close(pipe_fds[1]);
246 if (pid < 0) {
247 (void) close(pipe_fds[0]);
248 free(data);
249 fatal_error("fork() failed");
252 /* Read the dependency from the child. Reading fails if either the timeout
253 * elapses or more that LINE_MAX bytes are read. */
254 for (;;) {
255 struct timeval t = timeout;
256 struct timeval t1;
257 struct timeval t2;
258 char buffer[LINE_MAX];
259 ssize_t length;
261 fd_set read_fds;
263 FD_ZERO(&read_fds);
264 FD_SET(pipe_fds[0], &read_fds);
266 /* t1 is before select. */
267 (void) gettimeofday(&t1, NULL);
269 if (select(pipe_fds[0]+1, &read_fds, NULL, NULL, &t) != 1) {
270 timeout:
271 asprintf(&error, "timeout while reading dependency '%s' from '%s", dependency_name, path);
272 goto read_error;
275 /* t2 is after select. */
276 (void) gettimeofday(&t2, NULL);
278 /* Get the time that during select. */
279 timersub(&t2, &t1, &t2);
281 /* This is very unlikely. */
282 if (timercmp(&t2, &timeout, >))
283 goto timeout;
285 /* Reduce the timeout. */
286 timersub(&timeout, &t2, &timeout);
288 /* Read dependency data from the script. */
289 length = read(pipe_fds[0], buffer, sizeof buffer - 1);
291 /* Did the script close its stdin or exit? */
292 if (length <= 0)
293 break;
295 if (data_length+length+1 > LINE_MAX) {
296 asprintf(&error, "too much data while reading dependency '%s' from '%s'", dependency_name, path);
297 goto read_error;
300 /* Append the buffer to the data string. */
301 data = ensure_realloc(data, data_length+length);
302 strncpy(data+data_length, buffer, length);
303 data_length += length;
306 /* Terminate the data string. */
307 data[data_length] = '\0';
309 /* Close the read end of the pipe. */
310 (void) close(pipe_fds[0]);
311 /* Kill the script. */
312 if (!wait_for_death(pid, 0, 500000L))
313 ensure_death(pid);
315 return data;
317 read_error:
318 free(data);
319 (void) close(pipe_fds[0]);
320 if (!wait_for_death(pid, 0, 500000L))
321 ensure_death(pid);
322 fprintf(stderr, "%s\n", error);
323 free(error);
324 abort();
327 static bool parse_dependency(char *data, struct list *dependency_list)
329 for (char *s = data, *saveptr;; s = NULL) {
330 char *token = strtok_r(s, "\n", &saveptr);
332 if (token == NULL)
333 break;
335 list_append(dependency_list, ensure_not_null(strdup(token), "could not copy string"));
338 return true;