src/script.c: newline
[vlock.git] / src / script.c
blob017539a1df7b46907084d5ae6d2fd399df56dbce
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);
188 if (data == NULL) {
189 return errno != 0;
190 } else {
191 /* Parse the dependency data. */
192 bool result = parse_dependency(data, dependency_list);
193 int errsv = errno;
194 free(data);
195 errno = errsv;
196 return result;
200 /* Read the dependency data by starting the script with the name of the
201 * dependency as a single command line argument. The script should then print
202 * the dependencies to its stdout one on per line. */
203 static char *read_dependency(const char *path, const char *dependency_name)
205 char *error = NULL;
206 int pipe_fds[2];
207 pid_t pid;
208 struct timeval timeout = (struct timeval){1, 0};
209 char *data = ensure_calloc(1, sizeof *data);
210 size_t data_length = 0;
212 /* Open a pipe for the script. */
213 if (pipe(pipe_fds) < 0)
214 fatal_error("pipe() failed");
216 pid = fork();
218 if (pid == 0) {
219 /* Child. */
220 int nullfd = open("/dev/null", O_RDWR);
222 if (nullfd < 0)
223 _exit(1);
225 /* Redirect stdio. */
226 (void) dup2(nullfd, STDIN_FILENO);
227 (void) dup2(pipe_fds[1], STDOUT_FILENO);
228 (void) dup2(nullfd, STDERR_FILENO);
230 /* Close all other file descriptors. */
231 close_all_fds();
233 /* Drop privileges. */
234 setgid(getgid());
235 setuid(getuid());
237 (void) execl(path, path, dependency_name, NULL);
239 _exit(1);
242 /* Close write end of the pipe. */
243 (void) close(pipe_fds[1]);
245 if (pid < 0) {
246 (void) close(pipe_fds[0]);
247 free(data);
248 fatal_error("fork() failed");
251 /* Read the dependency from the child. Reading fails if either the timeout
252 * elapses or more that LINE_MAX bytes are read. */
253 for (;;) {
254 struct timeval t = timeout;
255 struct timeval t1;
256 struct timeval t2;
257 char buffer[LINE_MAX];
258 ssize_t length;
260 fd_set read_fds;
262 FD_ZERO(&read_fds);
263 FD_SET(pipe_fds[0], &read_fds);
265 /* t1 is before select. */
266 (void) gettimeofday(&t1, NULL);
268 if (select(pipe_fds[0]+1, &read_fds, NULL, NULL, &t) != 1) {
269 timeout:
270 asprintf(&error, "timeout while reading dependency '%s' from '%s", dependency_name, path);
271 goto read_error;
274 /* t2 is after select. */
275 (void) gettimeofday(&t2, NULL);
277 /* Get the time that during select. */
278 timersub(&t2, &t1, &t2);
280 /* This is very unlikely. */
281 if (timercmp(&t2, &timeout, >))
282 goto timeout;
284 /* Reduce the timeout. */
285 timersub(&timeout, &t2, &timeout);
287 /* Read dependency data from the script. */
288 length = read(pipe_fds[0], buffer, sizeof buffer - 1);
290 /* Did the script close its stdin or exit? */
291 if (length <= 0)
292 break;
294 if (data_length+length+1 > LINE_MAX) {
295 asprintf(&error, "too much data while reading dependency '%s' from '%s'", dependency_name, path);
296 goto read_error;
299 /* Append the buffer to the data string. */
300 data = ensure_realloc(data, data_length+length);
301 strncpy(data+data_length, buffer, length);
302 data_length += length;
305 /* Terminate the data string. */
306 data[data_length] = '\0';
308 /* Close the read end of the pipe. */
309 (void) close(pipe_fds[0]);
310 /* Kill the script. */
311 if (!wait_for_death(pid, 0, 500000L))
312 ensure_death(pid);
314 return data;
316 read_error:
317 free(data);
318 (void) close(pipe_fds[0]);
319 if (!wait_for_death(pid, 0, 500000L))
320 ensure_death(pid);
321 fprintf(stderr, "%s\n", error);
322 free(error);
323 abort();
326 static bool parse_dependency(char *data, struct list *dependency_list)
328 for (char *s = data, *saveptr;; s = NULL) {
329 char *token = strtok_r(s, "\n", &saveptr);
331 if (token == NULL)
332 break;
334 list_append(dependency_list, ensure_not_null(strdup(token), "could not copy string"));
337 return true;