]> ruderich.org/simon Gitweb - wall-notify/wall-notify.git/blob - wall-notify.c
806204e09c975c27c6885b3785724c6e0662162e
[wall-notify/wall-notify.git] / wall-notify.c
1 /*
2  * Receive wall messages and pass them to a notification program via stdin.
3  *
4  * Copyright (C) 2014  Simon Ruderich
5  *
6  * This program is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation, either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20
21 #include <config.h>
22
23 #include <assert.h>
24 #include <fcntl.h>
25 #include <limits.h>
26 #include <pwd.h>
27 #include <signal.h>
28 #include <stdint.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <sys/select.h>
33 #include <sys/stat.h>
34 #include <sys/time.h>
35 #include <sys/types.h>
36 #include <sys/wait.h>
37 #include <unistd.h>
38
39 #ifdef USE_UTEMPTER
40 # include <utempter.h>
41 #endif
42 #ifdef USE_UTMPX
43 # include <utmpx.h>
44 #endif
45 #ifndef DONT_USE_X11
46 # include <pthread.h>
47 # include <X11/Xlib.h>
48 #endif
49
50
51 static void sig_handler(int signal) {
52     (void)signal;
53 }
54 static void setup_signals(void) {
55     struct sigaction action;
56
57     memset(&action, 0, sizeof(action));
58     sigemptyset(&action.sa_mask);
59     action.sa_handler = sig_handler;
60
61     /* Handle all important signals which might be sent to us so we break out
62      * of the read()-loop below and can perform our cleanup. */
63     sigaction(SIGHUP,  &action, NULL);
64     sigaction(SIGINT,  &action, NULL);
65     sigaction(SIGQUIT, &action, NULL);
66     sigaction(SIGUSR1, &action, NULL);
67     sigaction(SIGUSR2, &action, NULL);
68 }
69
70 static int open_tty(void) {
71     int ptm;
72     const char *name;
73
74     ptm = posix_openpt(O_RDWR);
75     if (ptm < 0) {
76         return -1;
77     }
78     if (grantpt(ptm) != 0) {
79         return -1;
80     }
81
82     /* Prevent write access for other users so they can't use wall to send
83      * messages to this program. */
84     name = ptsname(ptm);
85     if (!name) {
86         return -1;
87     }
88     if (chmod(name, S_IRUSR | S_IWUSR) != 0) {
89         return -1;
90     }
91
92     if (unlockpt(ptm) != 0) {
93         return -1;
94     }
95
96     return ptm;
97 }
98
99 #ifdef USE_UTMPX
100 static const char *skip_prefix(const char *string, const char *prefix) {
101     size_t length = strlen(prefix);
102
103     if (!strncmp(string, prefix, length)) {
104         return string + length;
105     } else {
106         return string;
107     }
108 }
109 static int set_utmpx(short type, int ptm) {
110     struct utmpx entry;
111
112     const char *tty, *user, *id, *line;
113     struct timeval now;
114
115     user = getpwuid(getuid())->pw_name;
116     gettimeofday(&now, NULL);
117
118     tty = ptsname(ptm);
119     if (!tty) {
120         return 0;
121     }
122
123     id   = skip_prefix(tty, "/dev/pts/");
124     line = skip_prefix(tty, "/dev/");
125
126     /* Create utmp entry for the given terminal. */
127     memset(&entry, 0, sizeof(entry));
128
129     snprintf(entry.ut_user, sizeof(entry.ut_user), "%s", user);
130     snprintf(entry.ut_id,   sizeof(entry.ut_id),   "%s", id);
131     snprintf(entry.ut_line, sizeof(entry.ut_line), "%s", line);
132
133     entry.ut_pid  = getpid();
134     entry.ut_type = type;
135     entry.ut_tv.tv_sec  = now.tv_sec;
136     entry.ut_tv.tv_usec = now.tv_usec;
137
138     /* Write the entry to the utmp file. */
139     setutxent();
140     if (!pututxline(&entry)) {
141         return 0;
142     }
143     endutxent();
144
145     return 1;
146 }
147 #endif
148 static int login(int ptm) {
149 #if defined(USE_UTEMPTER)
150     int result = utempter_add_record(ptm, NULL);
151     /* Exit value of utempter_*() is not correct on all systems, e.g.
152      * FreeBSD() always returns 0. Checking the utmpx database manually is
153      * difficult because we don't know the exact values for ut_id and ut_line,
154      * therefore we only check the return value on systems known to return a
155      * useful value. */
156 # ifndef __linux
157     result = 1;
158 # endif
159     return result;
160 #elif defined(USE_UTMPX)
161     return set_utmpx(USER_PROCESS, ptm);
162 #else
163 # error "neither USE_UTEMPTER nor USE_UTMPX defined"
164 #endif
165 }
166 static int logout(int ptm) {
167 #if defined(USE_UTEMPTER)
168     int result = utempter_remove_record(ptm);
169     /* See above. */
170 # ifndef __linux
171     result = 1;
172 # endif
173     return result;
174 #elif defined(USE_UTMPX)
175     return set_utmpx(DEAD_PROCESS, ptm);
176 #else
177 # error "neither USE_UTEMPTER nor USE_UTMPX defined"
178 #endif
179 }
180
181 static int wait_for_write(int fd, int timeout) {
182     fd_set rfds;
183     struct timeval tv;
184     int result;
185
186     FD_ZERO(&rfds);
187     FD_SET(fd, &rfds);
188
189     tv.tv_sec  = timeout;
190     tv.tv_usec = 0;
191
192     result = select(fd + 1, &rfds, NULL, NULL, &tv);
193     if (result < 0) {
194         perror("select");
195         return 0;
196     }
197     if (result == 0) {
198         /* Timeout. */
199         return 0;
200     }
201
202     /* Got more data to read. */
203     return 1;
204 }
205
206 #ifdef USE_UTMPX
207 static void drop_privileges(void) {
208     uid_t uid, ruid, euid, suid;
209     gid_t gid, rgid, egid, sgid;
210
211     uid = getuid();
212     gid = getgid();
213
214     /* Drop all privileges. */
215     if (setresuid(uid, uid, uid) != 0) {
216         perror("setresuid");
217         exit(EXIT_FAILURE);
218     }
219     if (setresgid(gid, gid, gid) != 0) {
220         perror("setresgid");
221         exit(EXIT_FAILURE);
222     }
223
224     /* Verify all privileges were dropped. */
225     if (getresuid(&ruid, &euid, &suid) != 0) {
226         perror("getresuid");
227         exit(EXIT_FAILURE);
228     }
229     if (getresgid(&rgid, &egid, &sgid) != 0) {
230         perror("getresgid");
231         exit(EXIT_FAILURE);
232     }
233     if (uid == ruid && uid == euid && uid == suid
234             && gid == rgid && gid == egid && gid == sgid) {
235         /* Everything fine. */
236         return;
237     }
238
239     fprintf(stderr, "failed to drop privileges, aborting\n");
240     exit(EXIT_FAILURE);
241 }
242 #endif
243
244 static void pass_buffer_to_program(const char *buffer, size_t length, char **argv) {
245     int fds[2];
246     FILE *fh;
247
248     pid_t pid;
249
250     if (pipe(fds) != 0) {
251         perror("pipe");
252         return;
253     }
254
255     fh = fdopen(fds[1] /* write side */, "w");
256     if (!fh) {
257         perror("fdopen");
258         close(fds[0]);
259         close(fds[1]);
260         return;
261     }
262
263     pid = fork();
264     if (pid < 0) {
265         perror("fork");
266         goto out;
267     } else if (pid == 0) {
268         /* child */
269
270 #ifdef USE_UTMPX
271         drop_privileges();
272 #endif
273
274         close(fds[1]); /* write side */
275
276         /* Pass read side as stdin to the program. */
277         if (dup2(fds[0], STDIN_FILENO) < 0) {
278             perror("dup2");
279             exit(EXIT_FAILURE);
280         }
281         close(fds[0]);
282
283         /* Double fork so `wall-notify` doesn't have to wait for the
284          * notification process to terminate. We can't just use
285          * signal(SIGCHLD, SIG_IGN); because utempter on at least FreeBSD
286          * doesn't work if SIGCHLD is ignored. */
287         pid = fork();
288         if (pid < 0) {
289             perror("fork");
290             exit(EXIT_FAILURE);
291         } else if (pid == 0) {
292             execvp(argv[0], argv);
293             perror("execvp");
294             exit(EXIT_FAILURE);
295         }
296
297         exit(EXIT_SUCCESS);
298     }
299     /* father */
300
301     if (fwrite(buffer, 1, length, fh) != length) {
302         perror("fwrite");
303         /* continue to perform cleanup */
304     }
305
306 out:
307     close(fds[0]); /* read side */
308     fclose(fh);
309
310     if (waitpid(pid, NULL, 0) < 0) {
311         perror("waitpid");
312     }
313 }
314 static void handle_wall(int fd, char **argv) {
315     char buffer[4096];
316     ssize_t r;
317
318     assert(SSIZE_MAX <= SIZE_MAX);
319     while ((r = read(fd, buffer, sizeof(buffer))) > 0) {
320         size_t space;
321         ssize_t r2;
322
323         /* To prevent partial messages (sometimes it takes multiple reads to
324          * get the complete message) wait for a short time to get the rest of
325          * the message. */
326         space = sizeof(buffer) - (size_t)r;
327         while (space > 0 && wait_for_write(fd, 1 /* second */)) {
328             r2 = read(fd, buffer + r, space);
329             if (r2 <= 0) {
330                 break;
331             }
332             r += r2;
333             space -= (size_t)r2;
334         }
335
336         pass_buffer_to_program(buffer, (size_t)r, argv);
337     }
338 }
339 #ifndef DONT_USE_X11
340 static void *x11_event_loop_thread(void *unused) {
341     Display *display;
342     XEvent event;
343
344     (void)unused;
345
346     pthread_detach(pthread_self());
347
348     display = XOpenDisplay(NULL);
349     if (!display) {
350         fprintf(stderr, "failed to connect to X server\n");
351         exit(EXIT_FAILURE);
352     }
353
354     /* Do nothing. We just want to die if the X11 session is closed. */
355     while (1) {
356         XNextEvent(display, &event);
357     }
358 }
359 #endif
360
361 static void usage(const char *argv0) {
362     fprintf(stderr, "usage: %s [-X] <cmd args..>\n", argv0);
363     fprintf(stderr, "Pass wall messages to <cmd args..>.\n");
364     fprintf(stderr, "\n");
365     fprintf(stderr, "-X quit when the current X session terminates\n");
366 #ifdef DONT_USE_X11
367     fprintf(stderr, "\n");
368     fprintf(stderr, "compiled without X11 support, -X disabled\n");
369 #endif
370     exit(EXIT_FAILURE);
371 }
372
373
374 int main(int argc, char **argv) {
375     int enable_x11;
376     int ptm, pts;
377     char *name;
378     const char *argv0;
379
380     argv0 = argv[0];
381     /* Don't pass our argv[0] to the notification program. */
382     argv++;
383
384     enable_x11 = 0;
385     if (argc > 1 && argv[0][0] == '-') {
386         if (!strcmp("-X", argv[0])) {
387             enable_x11 = 1;
388         } else {
389             if (strcmp("-h", argv[0])) {
390                 fprintf(stderr, "%s: unknown option '%s'!\n\n", argv0, argv[0]);
391             }
392             usage(argv0);
393         }
394         argc--; /* for usage */
395         argv++;
396     }
397
398     if (argc < 2) {
399         usage(argv0);
400     }
401
402     ptm = open_tty();
403     if (ptm < 0) {
404         perror("open_tty");
405         exit(EXIT_FAILURE);
406     }
407     name = ptsname(ptm);
408     if (!name) {
409         perror("ptsname");
410         exit(EXIT_FAILURE);
411     }
412
413 #ifdef DEBUG
414     printf("%s\n", name);
415 #endif
416
417     /* We need to open the slave or reading from the master yields EOF after
418      * the first wall write to it. */
419     pts = open(name, O_RDWR);
420     if (pts < 0) {
421         perror(name);
422         exit(EXIT_FAILURE);
423     }
424
425     /* Start a thread which connects to X11. This way we die if the user logs
426      * out of its X11 session. */
427     if (enable_x11) {
428 #ifdef DONT_USE_X11
429         fprintf(stderr, "%s: option -X is disabled!\n\n", argv0);
430         usage(argv0);
431 #else
432         pthread_t tid;
433
434         if (pthread_create(&tid, NULL, x11_event_loop_thread, NULL) != 0) {
435             perror("pthread_create");
436             exit(EXIT_FAILURE);
437         }
438 #endif
439     }
440
441     /* Cleanup on signals. Necessary before login(). */
442     setup_signals();
443
444     if (!login(ptm)) {
445         perror("login");
446         exit(EXIT_FAILURE);
447     }
448
449     /* Main loop. Handle all wall messages sent to our PTY. */
450     handle_wall(ptm, argv);
451
452     if (!logout(ptm)) {
453         perror("logout");
454         exit(EXIT_FAILURE);
455     }
456
457     close(ptm);
458     close(pts);
459
460     return EXIT_SUCCESS;
461 }