X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/putty/blobdiff_plain/887035a593c8c0a1af853657c80046e17dc5581a..dbd2a0be87198275be4a3bf46ad64681e2688d86:/unix/pty.c diff --git a/unix/pty.c b/unix/pty.c index 98ea4f27..0084e64a 100644 --- a/unix/pty.c +++ b/unix/pty.c @@ -1,3 +1,16 @@ +/* + * Pseudo-tty backend for pterm. + * + * Unlike the other backends, data for this one is not neatly + * encapsulated into a data structure, because it wouldn't make + * sense to do so - the utmp stuff has to be done before a backend + * is initialised, and starting a second pterm from the same + * process would therefore be infeasible because privileges would + * already have been dropped. Hence, I haven't bothered to keep the + * data dynamically allocated: instead, the backend handle is just + * a null pointer and ignored everywhere. + */ + #define _XOPEN_SOURCE #define _XOPEN_SOURCE_EXTENDED #include @@ -16,9 +29,9 @@ #include #include #include +#include #include "putty.h" -#include "terminal.h" #ifndef FALSE #define FALSE 0 @@ -56,23 +69,19 @@ #endif int pty_master_fd; +static void *pty_frontend; static char pty_name[FILENAME_MAX]; static int pty_stamped_utmp = 0; static int pty_child_pid; static int pty_utmp_helper_pid, pty_utmp_helper_pipe; -static sig_atomic_t pty_child_dead; +static int pty_term_width, pty_term_height; +static volatile sig_atomic_t pty_child_dead; +static volatile int pty_exit_code; #ifndef OMIT_UTMP static struct utmp utmp_entry; #endif char **pty_argv; -int pty_child_is_dead(void) -{ - return pty_child_dead; -} - -static void pty_size(void); - static void setup_utmp(char *ttyname, char *location) { #ifndef OMIT_UTMP @@ -155,16 +164,23 @@ static void cleanup_utmp(void) static void sigchld_handler(int signum) { + int save_errno = errno; pid_t pid; int status; - pid = waitpid(-1, &status, WNOHANG); - if (pid == pty_child_pid && (WIFEXITED(status) || WIFSIGNALED(status))) - pty_child_dead = TRUE; + + do { + pid = waitpid(-1, &status, WNOHANG); + if (pid == pty_child_pid && (WIFEXITED(status) || WIFSIGNALED(status))) { + pty_exit_code = status; + pty_child_dead = TRUE; + } + } while(pid > 0); + errno = save_errno; } static void fatal_sig_handler(int signum) { - signal(signum, SIG_DFL); + putty_signal(signum, SIG_DFL); cleanup_utmp(); setuid(getuid()); raise(signum); @@ -244,6 +260,9 @@ void pty_pre_init(void) pid_t pid; int pipefd[2]; + /* set the child signal handler straight away; it needs to be set + * before we ever fork. */ + putty_signal(SIGCHLD, sigchld_handler); pty_master_fd = -1; if (geteuid() != getuid() || getegid() != getgid()) { @@ -279,7 +298,7 @@ void pty_pre_init(void) ret = read(pipefd[0], buffer, lenof(buffer)); if (ret <= 0) { cleanup_utmp(); - exit(0); + _exit(0); } else if (!pty_stamped_utmp) { if (dlen < lenof(display)) memcpy(display+dlen, buffer, @@ -297,47 +316,45 @@ void pty_pre_init(void) * unfortunately unprotected against SIGKILL, * but that's life. */ - signal(SIGHUP, fatal_sig_handler); - signal(SIGINT, fatal_sig_handler); - signal(SIGQUIT, fatal_sig_handler); - signal(SIGILL, fatal_sig_handler); - signal(SIGABRT, fatal_sig_handler); - signal(SIGFPE, fatal_sig_handler); - signal(SIGPIPE, fatal_sig_handler); - signal(SIGALRM, fatal_sig_handler); - signal(SIGTERM, fatal_sig_handler); - signal(SIGSEGV, fatal_sig_handler); - signal(SIGUSR1, fatal_sig_handler); - signal(SIGUSR2, fatal_sig_handler); + putty_signal(SIGHUP, fatal_sig_handler); + putty_signal(SIGINT, fatal_sig_handler); + putty_signal(SIGQUIT, fatal_sig_handler); + putty_signal(SIGILL, fatal_sig_handler); + putty_signal(SIGABRT, fatal_sig_handler); + putty_signal(SIGFPE, fatal_sig_handler); + putty_signal(SIGPIPE, fatal_sig_handler); + putty_signal(SIGALRM, fatal_sig_handler); + putty_signal(SIGTERM, fatal_sig_handler); + putty_signal(SIGSEGV, fatal_sig_handler); + putty_signal(SIGUSR1, fatal_sig_handler); + putty_signal(SIGUSR2, fatal_sig_handler); #ifdef SIGBUS - signal(SIGBUS, fatal_sig_handler); + putty_signal(SIGBUS, fatal_sig_handler); #endif #ifdef SIGPOLL - signal(SIGPOLL, fatal_sig_handler); + putty_signal(SIGPOLL, fatal_sig_handler); #endif #ifdef SIGPROF - signal(SIGPROF, fatal_sig_handler); + putty_signal(SIGPROF, fatal_sig_handler); #endif #ifdef SIGSYS - signal(SIGSYS, fatal_sig_handler); + putty_signal(SIGSYS, fatal_sig_handler); #endif #ifdef SIGTRAP - signal(SIGTRAP, fatal_sig_handler); + putty_signal(SIGTRAP, fatal_sig_handler); #endif #ifdef SIGVTALRM - signal(SIGVTALRM, fatal_sig_handler); + putty_signal(SIGVTALRM, fatal_sig_handler); #endif #ifdef SIGXCPU - signal(SIGXCPU, fatal_sig_handler); + putty_signal(SIGXCPU, fatal_sig_handler); #endif #ifdef SIGXFSZ - signal(SIGXFSZ, fatal_sig_handler); + putty_signal(SIGXFSZ, fatal_sig_handler); #endif #ifdef SIGIO - signal(SIGIO, fatal_sig_handler); + putty_signal(SIGIO, fatal_sig_handler); #endif - /* Also clean up utmp on normal exit. */ - atexit(cleanup_utmp); setup_utmp(pty_name, display); } } @@ -346,7 +363,6 @@ void pty_pre_init(void) close(pipefd[0]); pty_utmp_helper_pid = pid; pty_utmp_helper_pipe = pipefd[1]; - signal(SIGCHLD, sigchld_handler); } #endif @@ -373,12 +389,18 @@ void pty_pre_init(void) * Also places the canonical host name into `realhost'. It must be * freed by the caller. */ -static char *pty_init(void *frontend, +static char *pty_init(void *frontend, void **backend_handle, char *host, int port, char **realhost, int nodelay) { int slavefd; pid_t pid, pgrp; + pty_frontend = frontend; + *backend_handle = NULL; /* we can't sensibly use this, sadly */ + + pty_term_width = cfg.width; + pty_term_height = cfg.height; + if (pty_master_fd < 0) pty_open_master(); @@ -400,7 +422,7 @@ static char *pty_init(void *frontend, if (!cfg.stamp_utmp) close(pty_utmp_helper_pipe); /* just let the child process die */ else { - char *location = get_x_display(); + char *location = get_x_display(pty_frontend); int len = strlen(location)+1, pos = 0; /* +1 to include NUL */ while (pos < len) { int ret = write(pty_utmp_helper_pipe, location+pos, len - pos); @@ -431,7 +453,7 @@ static char *pty_init(void *frontend, slavefd = open(pty_name, O_RDWR); if (slavefd < 0) { perror("slave pty: open"); - exit(1); + _exit(1); } close(pty_master_fd); @@ -459,8 +481,8 @@ static char *pty_init(void *frontend, * parent, particularly by things like sh -c 'pterm &' and * some window managers. Reverse this for our child process. */ - signal(SIGINT, SIG_DFL); - signal(SIGQUIT, SIG_DFL); + putty_signal(SIGINT, SIG_DFL); + putty_signal(SIGQUIT, SIG_DFL); if (pty_argv) execvp(pty_argv[0], pty_argv); else { @@ -480,13 +502,11 @@ static char *pty_init(void *frontend, * If we're here, exec has gone badly foom. */ perror("exec"); - exit(127); + _exit(127); } else { - close(slavefd); pty_child_pid = pid; pty_child_dead = FALSE; - signal(SIGCHLD, sigchld_handler); - } + } return NULL; } @@ -494,8 +514,11 @@ static char *pty_init(void *frontend, /* * Called to send data down the pty. */ -static int pty_send(char *buf, int len) +static int pty_send(void *handle, char *buf, int len) { + if (pty_master_fd < 0) + return 0; /* ignore all writes if fd closed */ + while (len > 0) { int ret = write(pty_master_fd, buf, len); if (ret < 0) { @@ -508,10 +531,19 @@ static int pty_send(char *buf, int len) return 0; } +void pty_close(void) +{ + if (pty_master_fd >= 0) { + close(pty_master_fd); + pty_master_fd = -1; + } + close(pty_utmp_helper_pipe); /* this causes utmp to be cleaned up */ +} + /* * Called to query the current socket sendability status. */ -static int pty_sendbuffer(void) +static int pty_sendbuffer(void *handle) { return 0; } @@ -519,14 +551,19 @@ static int pty_sendbuffer(void) /* * Called to set the size of the window */ -static void pty_size(void) +static void pty_size(void *handle, int width, int height) { struct winsize size; - size.ws_row = (unsigned short)term->rows; - size.ws_col = (unsigned short)term->cols; - size.ws_xpixel = (unsigned short) term->cols * font_dimension(0); - size.ws_ypixel = (unsigned short) term->rows * font_dimension(1); + pty_term_width = width; + pty_term_height = height; + + size.ws_row = (unsigned short)pty_term_height; + size.ws_col = (unsigned short)pty_term_width; + size.ws_xpixel = (unsigned short) pty_term_width * + font_dimension(pty_frontend, 0); + size.ws_ypixel = (unsigned short) pty_term_height * + font_dimension(pty_frontend, 1); ioctl(pty_master_fd, TIOCSWINSZ, (void *)&size); return; } @@ -534,36 +571,48 @@ static void pty_size(void) /* * Send special codes. */ -static void pty_special(Telnet_Special code) +static void pty_special(void *handle, Telnet_Special code) { /* Do nothing! */ return; } -static Socket pty_socket(void) +static Socket pty_socket(void *handle) { return NULL; /* shouldn't ever be needed */ } -static int pty_sendok(void) +static int pty_sendok(void *handle) { return 1; } -static void pty_unthrottle(int backlog) +static void pty_unthrottle(void *handle, int backlog) { /* do nothing */ } -static int pty_ldisc(int option) +static int pty_ldisc(void *handle, int option) { return 0; /* neither editing nor echoing */ } -static int pty_exitcode(void) +static void pty_provide_ldisc(void *handle, void *ldisc) { - /* Shouldn't ever be required */ - return 0; + /* This is a stub. */ +} + +static void pty_provide_logctx(void *handle, void *logctx) +{ + /* This is a stub. */ +} + +static int pty_exitcode(void *handle) +{ + if (!pty_child_dead) + return -1; /* not dead yet */ + else + return pty_exit_code; } Backend pty_backend = { @@ -576,6 +625,8 @@ Backend pty_backend = { pty_exitcode, pty_sendok, pty_ldisc, + pty_provide_ldisc, + pty_provide_logctx, pty_unthrottle, 1 };