chiark / gitweb /
adcb32d0be733af138ceb7bec97821065d6cb016
[elogind.git] / src / shared / pty.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2014 David Herrmann <dh.herrmann@gmail.com>
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 /*
23  * PTY
24  * A PTY object represents a single PTY connection between a master and a
25  * child. The child process is fork()ed so the caller controls what program
26  * will be run.
27  *
28  * Programs like /bin/login tend to perform a vhangup() on their TTY
29  * before running the login procedure. This also causes the pty master
30  * to get a EPOLLHUP event as long as no client has the TTY opened.
31  * This means, we cannot use the TTY connection as reliable way to track
32  * the client. Instead, we _must_ rely on the PID of the client to track
33  * them.
34  * However, this has the side effect that if the client forks and the
35  * parent exits, we loose them and restart the client. But this seems to
36  * be the expected behavior so we implement it here.
37  *
38  * Unfortunately, epoll always polls for EPOLLHUP so as long as the
39  * vhangup() is ongoing, we will _always_ get EPOLLHUP and cannot sleep.
40  * This gets worse if the client closes the TTY but doesn't exit.
41  * Therefore, the fd must be edge-triggered in the epoll-set so we
42  * only get the events once they change.
43  */
44
45 #include <errno.h>
46 #include <fcntl.h>
47 #include <limits.h>
48 #include <linux/ioctl.h>
49 #include <signal.h>
50 #include <stdbool.h>
51 #include <stdint.h>
52 #include <stdio.h>
53 #include <stdlib.h>
54 #include <string.h>
55 #include <sys/epoll.h>
56 #include <sys/eventfd.h>
57 #include <sys/ioctl.h>
58 #include <sys/types.h>
59 #include <sys/uio.h>
60 #include <sys/wait.h>
61 #include <termios.h>
62 #include <unistd.h>
63
64 #include "barrier.h"
65 #include "macro.h"
66 #include "pty.h"
67 #include "ring.h"
68 #include "util.h"
69
70 #define PTY_BUFSIZE 16384
71
72 enum {
73         PTY_ROLE_UNKNOWN,
74         PTY_ROLE_PARENT,
75         PTY_ROLE_CHILD,
76 };
77
78 struct Pty {
79         unsigned long ref;
80         Barrier barrier;
81         int fd;
82         pid_t child;
83         sd_event_source *fd_source;
84         sd_event_source *child_source;
85
86         char in_buf[PTY_BUFSIZE];
87         Ring out_buf;
88
89         pty_event_t event_fn;
90         void *event_fn_userdata;
91
92         bool needs_requeue : 1;
93         unsigned int role : 2;
94 };
95
96 int pty_new(Pty **out) {
97         _pty_unref_ Pty *pty = NULL;
98         int r;
99
100         assert_return(out, -EINVAL);
101
102         pty = new0(Pty, 1);
103         if (!pty)
104                 return -ENOMEM;
105
106         pty->ref = 1;
107         pty->fd = -1;
108         pty->barrier = (Barrier) BARRIER_NULL;
109
110         pty->fd = posix_openpt(O_RDWR | O_NOCTTY | O_CLOEXEC | O_NONBLOCK);
111         if (pty->fd < 0)
112                 return -errno;
113
114         /*
115          * The slave-node is initialized to uid/gid of the caller of
116          * posix_openpt(). Only if devpts is mounted with fixed uid/gid this is
117          * skipped. In that case, grantpt() can overwrite these, but then you
118          * have to be root to use chown() (or a pt_chown helper has to be
119          * present). In those cases grantpt() really does something,
120          * otherwise it's a no-op. We call grantpt() here to try supporting
121          * those cases, even though no-one uses that, I guess. If you need other
122          * access-rights, set them yourself after this call returns (no, this is
123          * not racy, it looks racy, but races regarding your own UID are never
124          * important as an attacker could ptrace you; and the slave-pty is also
125          * still locked).
126          */
127         r = grantpt(pty->fd);
128         if (r < 0)
129                 return -errno;
130
131         r = barrier_create(&pty->barrier);
132         if (r < 0)
133                 return r;
134
135         *out = pty;
136         pty = NULL;
137         return 0;
138 }
139
140 Pty *pty_ref(Pty *pty) {
141         if (!pty || pty->ref < 1)
142                 return NULL;
143
144         ++pty->ref;
145         return pty;
146 }
147
148 Pty *pty_unref(Pty *pty) {
149         if (!pty || pty->ref < 1 || --pty->ref > 0)
150                 return NULL;
151
152         pty_close(pty);
153         pty->child_source = sd_event_source_unref(pty->child_source);
154         barrier_destroy(&pty->barrier);
155         ring_clear(&pty->out_buf);
156         free(pty);
157
158         return NULL;
159 }
160
161 Barrier *pty_get_barrier(Pty *pty) {
162         assert(pty);
163         return &pty->barrier;
164 }
165
166 bool pty_is_unknown(Pty *pty) {
167         return pty && pty->role == PTY_ROLE_UNKNOWN;
168 }
169
170 bool pty_is_parent(Pty *pty) {
171         return pty && pty->role == PTY_ROLE_PARENT;
172 }
173
174 bool pty_is_child(Pty *pty) {
175         return pty && pty->role == PTY_ROLE_CHILD;
176 }
177
178 bool pty_has_child(Pty *pty) {
179         return pty_is_parent(pty) && pty->child > 0;
180 }
181
182 pid_t pty_get_child(Pty *pty) {
183         return pty_has_child(pty) ? pty->child : -ECHILD;
184 }
185
186 bool pty_is_open(Pty *pty) {
187         return pty && pty->fd >= 0;
188 }
189
190 int pty_get_fd(Pty *pty) {
191         assert_return(pty, -EINVAL);
192
193         return pty_is_open(pty) ? pty->fd : -EPIPE;
194 }
195
196 int pty_make_child(Pty *pty) {
197         char slave_name[1024];
198         int r, fd;
199
200         assert_return(pty, -EINVAL);
201         assert_return(pty_is_unknown(pty), -EALREADY);
202
203         r = ptsname_r(pty->fd, slave_name, sizeof(slave_name));
204         if (r < 0)
205                 return -errno;
206
207         fd = open(slave_name, O_RDWR | O_CLOEXEC | O_NOCTTY);
208         if (fd < 0)
209                 return -errno;
210
211         safe_close(pty->fd);
212         pty->fd = fd;
213         pty->child = getpid();
214         pty->role = PTY_ROLE_CHILD;
215         barrier_set_role(&pty->barrier, BARRIER_CHILD);
216
217         return 0;
218 }
219
220 int pty_make_parent(Pty *pty, pid_t child) {
221         assert_return(pty, -EINVAL);
222         assert_return(pty_is_unknown(pty), -EALREADY);
223
224         pty->child = child;
225         pty->role = PTY_ROLE_PARENT;
226
227         return 0;
228 }
229
230 int pty_unlock(Pty *pty) {
231         assert_return(pty, -EINVAL);
232         assert_return(pty_is_unknown(pty) || pty_is_parent(pty), -EINVAL);
233         assert_return(pty_is_open(pty), -ENODEV);
234
235         return unlockpt(pty->fd) < 0 ? -errno : 0;
236 }
237
238 int pty_setup_child(Pty *pty) {
239         struct termios attr;
240         pid_t pid;
241         int r;
242
243         assert_return(pty, -EINVAL);
244         assert_return(pty_is_child(pty), -EINVAL);
245         assert_return(pty_is_open(pty), -EALREADY);
246
247         r = sigprocmask_many(SIG_SETMASK, -1);
248         if (r < 0)
249                 return r;
250
251         r = reset_all_signal_handlers();
252         if (r < 0)
253                 return r;
254
255         pid = setsid();
256         if (pid < 0 && errno != EPERM)
257                 return -errno;
258
259         r = ioctl(pty->fd, TIOCSCTTY, 0);
260         if (r < 0)
261                 return -errno;
262
263         r = tcgetattr(pty->fd, &attr);
264         if (r < 0)
265                 return -errno;
266
267         /* erase character should be normal backspace, PLEASEEE! */
268         attr.c_cc[VERASE] = 010;
269         /* always set UTF8 flag */
270         attr.c_iflag |= IUTF8;
271
272         r = tcsetattr(pty->fd, TCSANOW, &attr);
273         if (r < 0)
274                 return -errno;
275
276         if (dup2(pty->fd, STDIN_FILENO) != STDIN_FILENO ||
277             dup2(pty->fd, STDOUT_FILENO) != STDOUT_FILENO ||
278             dup2(pty->fd, STDERR_FILENO) != STDERR_FILENO)
279                 return -errno;
280
281         /* only close FD if it's not a std-fd */
282         pty->fd = (pty->fd > 2) ? safe_close(pty->fd) : -1;
283
284         return 0;
285 }
286
287 void pty_close(Pty *pty) {
288         if (!pty_is_open(pty))
289                 return;
290
291         pty->fd_source = sd_event_source_unref(pty->fd_source);
292         pty->fd = safe_close(pty->fd);
293 }
294
295 /*
296  * Drain input-queue and dispatch data via the event-handler. Returns <0 on
297  * error, 0 if queue is empty and 1 if we couldn't empty the input queue fast
298  * enough and there's still data left.
299  */
300 static int pty_dispatch_read(Pty *pty) {
301         unsigned int i;
302         ssize_t len;
303         int r;
304
305         /*
306          * We're edge-triggered, means we need to read the whole queue. This,
307          * however, might cause us to stall if the writer is faster than we
308          * are. Therefore, we read twice and if the second read still returned
309          * data, we reschedule.
310          */
311
312         for (i = 0; i < 2; ++i) {
313                 len = read(pty->fd, pty->in_buf, sizeof(pty->in_buf) - 1);
314                 if (len < 0) {
315                         if (errno == EINTR)
316                                 continue;
317
318                         return (errno == EAGAIN) ? 0 : -errno;
319                 } else if (len == 0) {
320                         continue;
321                 }
322
323                 /* set terminating zero for debugging safety */
324                 pty->in_buf[len] = 0;
325                 r = pty->event_fn(pty, pty->event_fn_userdata, PTY_DATA, pty->in_buf, len);
326                 if (r < 0)
327                         return r;
328         }
329
330         /* still data left, make sure we're queued again */
331         pty->needs_requeue = true;
332
333         return 1;
334 }
335
336 /*
337  * Drain output-queue by writing data to the pty. Returns <0 on error, 0 if the
338  * output queue is empty now and 1 if we couldn't empty the output queue fast
339  * enough and there's still data left.
340  */
341 static int pty_dispatch_write(Pty *pty) {
342         struct iovec vec[2];
343         unsigned int i;
344         ssize_t len;
345         size_t num;
346
347         /*
348          * Same as pty_dispatch_read(), we're edge-triggered so we need to call
349          * write() until either all data is written or it returns EAGAIN. We
350          * call it twice and if it still writes successfully, we reschedule.
351          */
352
353         for (i = 0; i < 2; ++i) {
354                 num = ring_peek(&pty->out_buf, vec);
355                 if (num < 1)
356                         return 0;
357
358                 len = writev(pty->fd, vec, (int)num);
359                 if (len < 0) {
360                         if (errno == EINTR)
361                                 continue;
362
363                         return (errno == EAGAIN) ? 1 : -errno;
364                 } else if (len == 0) {
365                         continue;
366                 }
367
368                 ring_pull(&pty->out_buf, (size_t)len);
369         }
370
371         /* still data left, make sure we're queued again */
372         if (ring_get_size(&pty->out_buf) > 0) {
373                 pty->needs_requeue = true;
374                 return 1;
375         }
376
377         return 0;
378 }
379
380 static int pty_fd_fn(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
381         Pty *pty = userdata;
382         int r_hup = 0, r_write = 0, r_read = 0, r;
383
384         /*
385          * Whenever we encounter I/O errors, we have to make sure to drain the
386          * input queue first, before we handle any HUP. A child might send us
387          * a message and immediately close the queue. We must not handle the
388          * HUP first or we loose data.
389          * Therefore, if we read a message successfully, we always return
390          * success and wait for the next event-loop iteration. Furthermore,
391          * whenever there is a write-error, we must try reading from the input
392          * queue even if EPOLLIN is not set. The input might have arrived in
393          * between epoll_wait() and write(). Therefore, write-errors are only
394          * ever handled if the input-queue is empty. In all other cases they
395          * are ignored until either reading fails or the input queue is empty.
396          */
397
398         if (revents & (EPOLLHUP | EPOLLERR))
399                 r_hup = -EPIPE;
400
401         if (revents & EPOLLOUT)
402                 r_write = pty_dispatch_write(pty);
403
404         /* Awesome! Kernel signals HUP without IN but queues are not empty.. */
405         if ((revents & EPOLLIN) || r_hup < 0 || r_write < 0) {
406                 r_read = pty_dispatch_read(pty);
407                 if (r_read > 0)
408                         return 0; /* still data left to fetch next round */
409         }
410
411         if (r_hup < 0 || r_write < 0 || r_read < 0) {
412                 /* PTY closed and input-queue drained */
413                 pty_close(pty);
414                 r = pty->event_fn(pty, pty->event_fn_userdata, PTY_HUP, NULL, 0);
415                 if (r < 0)
416                         return r;
417         }
418
419         return 0;
420 }
421
422 static int pty_fd_prepare_fn(sd_event_source *source, void *userdata) {
423         Pty *pty = userdata;
424         int r;
425
426         if (pty->needs_requeue) {
427                 /*
428                  * We're edge-triggered. In case we couldn't handle all events
429                  * or in case new write-data is queued, we set needs_requeue.
430                  * Before going asleep, we set the io-events *again*. sd-event
431                  * notices that we're edge-triggered and forwards the call to
432                  * the kernel even if the events didn't change. The kernel will
433                  * check the events and re-queue us on the ready queue in case
434                  * an event is pending.
435                  */
436                 r = sd_event_source_set_io_events(source, EPOLLHUP | EPOLLERR | EPOLLIN | EPOLLOUT | EPOLLET);
437                 if (r >= 0)
438                         pty->needs_requeue = false;
439         }
440
441         return 0;
442 }
443
444 static int pty_child_fn(sd_event_source *source, const siginfo_t *si, void *userdata) {
445         Pty *pty = userdata;
446         int r;
447
448         pty->child = 0;
449
450         r = pty->event_fn(pty, pty->event_fn_userdata, PTY_CHILD, si, sizeof(*si));
451         if (r < 0)
452                 return r;
453
454         return 0;
455 }
456
457 int pty_attach_event(Pty *pty, sd_event *event, pty_event_t event_fn, void *event_fn_userdata) {
458         int r;
459
460         assert_return(pty, -EINVAL);
461         assert_return(event, -EINVAL);
462         assert_return(event_fn, -EINVAL);
463         assert_return(pty_is_parent(pty), -EINVAL);
464
465         pty_detach_event(pty);
466
467         if (pty_is_open(pty)) {
468                 r = sd_event_add_io(event,
469                                     &pty->fd_source,
470                                     pty->fd,
471                                     EPOLLHUP | EPOLLERR | EPOLLIN | EPOLLOUT | EPOLLET,
472                                     pty_fd_fn,
473                                     pty);
474                 if (r < 0)
475                         goto error;
476
477                 r = sd_event_source_set_prepare(pty->fd_source, pty_fd_prepare_fn);
478                 if (r < 0)
479                         goto error;
480         }
481
482         if (pty_has_child(pty)) {
483                 r = sd_event_add_child(event,
484                                        &pty->child_source,
485                                        pty->child,
486                                        WEXITED,
487                                        pty_child_fn,
488                                        pty);
489                 if (r < 0)
490                         goto error;
491         }
492
493         pty->event_fn = event_fn;
494         pty->event_fn_userdata = event_fn_userdata;
495
496         return 0;
497
498 error:
499         pty_detach_event(pty);
500         return r;
501 }
502
503 void pty_detach_event(Pty *pty) {
504         if (!pty)
505                 return;
506
507         pty->child_source = sd_event_source_unref(pty->child_source);
508         pty->fd_source = sd_event_source_unref(pty->fd_source);
509         pty->event_fn = NULL;
510         pty->event_fn_userdata = NULL;
511 }
512
513 int pty_write(Pty *pty, const void *buf, size_t size) {
514         bool was_empty;
515         int r;
516
517         assert_return(pty, -EINVAL);
518         assert_return(pty_is_open(pty), -ENODEV);
519         assert_return(pty_is_parent(pty), -ENODEV);
520
521         if (size < 1)
522                 return 0;
523
524         /*
525          * Push @buf[0..@size] into the output ring-buffer. In case the
526          * ring-buffer wasn't empty beforehand, we're already waiting for
527          * EPOLLOUT and we're done. If it was empty, we have to re-queue the
528          * FD for EPOLLOUT as we're edge-triggered and wouldn't get any new
529          * EPOLLOUT event.
530          */
531
532         was_empty = ring_get_size(&pty->out_buf) < 1;
533
534         r = ring_push(&pty->out_buf, buf, size);
535         if (r < 0)
536                 return r;
537
538         if (was_empty)
539                 pty->needs_requeue = true;
540
541         return 0;
542 }
543
544 int pty_signal(Pty *pty, int sig) {
545         assert_return(pty, -EINVAL);
546         assert_return(pty_is_open(pty), -ENODEV);
547         assert_return(pty_is_parent(pty), -ENODEV);
548
549         return ioctl(pty->fd, TIOCSIG, sig) < 0 ? -errno : 0;
550 }
551
552 int pty_resize(Pty *pty, unsigned short term_width, unsigned short term_height) {
553         struct winsize ws;
554
555         assert_return(pty, -EINVAL);
556         assert_return(pty_is_open(pty), -ENODEV);
557         assert_return(pty_is_parent(pty), -ENODEV);
558
559         zero(ws);
560         ws.ws_col = term_width;
561         ws.ws_row = term_height;
562
563         /*
564          * This will send SIGWINCH to the pty slave foreground process group.
565          * We will also get one, but we don't need it.
566          */
567         return ioctl(pty->fd, TIOCSWINSZ, &ws) < 0 ? -errno : 0;
568 }
569
570 pid_t pty_fork(Pty **out, sd_event *event, pty_event_t event_fn, void *event_fn_userdata, unsigned short initial_term_width, unsigned short initial_term_height) {
571         _pty_unref_ Pty *pty = NULL;
572         int r;
573         pid_t pid;
574
575         assert_return(out, -EINVAL);
576         assert_return((event && event_fn) || (!event && !event_fn), -EINVAL);
577
578         r = pty_new(&pty);
579         if (r < 0)
580                 return r;
581
582         r = pty_unlock(pty);
583         if (r < 0)
584                 return r;
585
586         pid = fork();
587         if (pid < 0)
588                 return -errno;
589
590         if (pid == 0) {
591                 /* child */
592
593                 r = pty_make_child(pty);
594                 if (r < 0)
595                         _exit(-r);
596
597                 r = pty_setup_child(pty);
598                 if (r < 0)
599                         _exit(-r);
600
601                 /* sync with parent */
602                 if (!barrier_place_and_sync(&pty->barrier))
603                         _exit(1);
604
605                 /* fallthrough and return the child's PTY object */
606         } else {
607                 /* parent */
608
609                 r = pty_make_parent(pty, pid);
610                 if (r < 0)
611                         goto parent_error;
612
613                 r = pty_resize(pty, initial_term_width, initial_term_height);
614                 if (r < 0)
615                         goto parent_error;
616
617                 if (event) {
618                         r = pty_attach_event(pty, event, event_fn, event_fn_userdata);
619                         if (r < 0)
620                                 goto parent_error;
621                 }
622
623                 /* sync with child */
624                 if (!barrier_place_and_sync(&pty->barrier)) {
625                         r = -ECHILD;
626                         goto parent_error;
627                 }
628
629                 /* fallthrough and return the parent's PTY object */
630         }
631
632         *out = pty;
633         pty = NULL;
634         return pid;
635
636 parent_error:
637         barrier_abort(&pty->barrier);
638         waitpid(pty->child, NULL, 0);
639         pty->child = 0;
640         return r;
641 }