X-Git-Url: https://git.distorted.org.uk/u/mdw/putty/blobdiff_plain/28d00fe40d0aac1c65a317f89f030036acd791cb..70637309a61321d83a4d0576b875b7dcb7085fa5:/unix/pty.c diff --git a/unix/pty.c b/unix/pty.c index 44348a3e..b621d8be 100644 --- a/unix/pty.c +++ b/unix/pty.c @@ -13,7 +13,7 @@ #define _XOPEN_SOURCE #define _XOPEN_SOURCE_EXTENDED -#include +#define _GNU_SOURCE #include #include @@ -27,8 +27,10 @@ #include #include #include +#include #include #include +#include #include "putty.h" @@ -67,28 +69,34 @@ #endif #endif -int pty_master_fd; +static Config pty_cfg; +static int pty_master_fd; +static void *pty_frontend; static char pty_name[FILENAME_MAX]; -static int pty_stamped_utmp = 0; +static int pty_signal_pipe[2]; static int pty_child_pid; -static int pty_utmp_helper_pid, pty_utmp_helper_pipe; static int pty_term_width, pty_term_height; -static sig_atomic_t pty_child_dead; +static int pty_child_dead, pty_finished; static int pty_exit_code; +char **pty_argv; +int use_pty_argv = TRUE; + +static void pty_close(void); + #ifndef OMIT_UTMP +static int pty_utmp_helper_pid, pty_utmp_helper_pipe; +static int pty_stamped_utmp = 0; static struct utmp utmp_entry; -#endif -char **pty_argv; static void setup_utmp(char *ttyname, char *location) { -#ifndef OMIT_UTMP #ifdef HAVE_LASTLOG struct lastlog lastlog_entry; FILE *lastlog; #endif struct passwd *pw; FILE *wtmp; + time_t uttime; pw = getpwuid(getuid()); memset(&utmp_entry, 0, sizeof(utmp_entry)); @@ -98,7 +106,10 @@ static void setup_utmp(char *ttyname, char *location) strncpy(utmp_entry.ut_id, ttyname+8, lenof(utmp_entry.ut_id)); strncpy(utmp_entry.ut_user, pw->pw_name, lenof(utmp_entry.ut_user)); strncpy(utmp_entry.ut_host, location, lenof(utmp_entry.ut_host)); - time(&utmp_entry.ut_time); + /* Apparently there are some architectures where (struct utmp).ut_time + * is not essentially time_t (e.g. Linux amd64). Hence the temporary. */ + time(&uttime); + utmp_entry.ut_time = uttime; /* may truncate */ #if defined HAVE_PUTUTLINE utmpname(UTMP_FILE); @@ -126,20 +137,20 @@ static void setup_utmp(char *ttyname, char *location) pty_stamped_utmp = 1; -#endif } static void cleanup_utmp(void) { -#ifndef OMIT_UTMP FILE *wtmp; + time_t uttime; if (!pty_stamped_utmp) return; utmp_entry.ut_type = DEAD_PROCESS; memset(utmp_entry.ut_user, 0, lenof(utmp_entry.ut_user)); - time(&utmp_entry.ut_time); + time(&uttime); + utmp_entry.ut_time = uttime; if ((wtmp = fopen(WTMP_FILE, "a")) != NULL) { fwrite(&utmp_entry, 1, sizeof(utmp_entry), wtmp); @@ -157,27 +168,23 @@ static void cleanup_utmp(void) #endif pty_stamped_utmp = 0; /* ensure we never double-cleanup */ -#endif } +#endif static void sigchld_handler(int signum) { - pid_t pid; - int status; - pid = waitpid(-1, &status, WNOHANG); - if (pid == pty_child_pid && (WIFEXITED(status) || WIFSIGNALED(status))) { - pty_exit_code = status; - pty_child_dead = TRUE; - } + write(pty_signal_pipe[1], "x", 1); } +#ifndef OMIT_UTMP static void fatal_sig_handler(int signum) { - signal(signum, SIG_DFL); + putty_signal(signum, SIG_DFL); cleanup_utmp(); setuid(getuid()); raise(signum); } +#endif static void pty_open_master(void) { @@ -250,9 +257,14 @@ static void pty_open_master(void) */ void pty_pre_init(void) { +#ifndef OMIT_UTMP pid_t pid; int pipefd[2]; +#endif + /* 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()) { @@ -288,7 +300,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, @@ -306,47 +318,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); } } @@ -355,14 +365,13 @@ void pty_pre_init(void) close(pipefd[0]); pty_utmp_helper_pid = pid; pty_utmp_helper_pipe = pipefd[1]; - signal(SIGCHLD, sigchld_handler); } #endif /* Drop privs. */ { - int gid = getgid(), uid = getuid(); #ifndef HAVE_NO_SETRESUID + int gid = getgid(), uid = getuid(); int setresgid(gid_t, gid_t, gid_t); int setresuid(uid_t, uid_t, uid_t); setresgid(gid, gid, gid); @@ -374,6 +383,107 @@ void pty_pre_init(void) } } +int pty_select_result(int fd, int event) +{ + char buf[4096]; + int ret; + int finished = FALSE; + + if (fd == pty_master_fd && event == 1) { + + ret = read(pty_master_fd, buf, sizeof(buf)); + + /* + * Clean termination condition is that either ret == 0, or ret + * < 0 and errno == EIO. Not sure why the latter, but it seems + * to happen. Boo. + */ + if (ret == 0 || (ret < 0 && errno == EIO)) { + /* + * We assume a clean exit if the pty has closed but the + * actual child process hasn't. The only way I can + * imagine this happening is if it detaches itself from + * the pty and goes daemonic - in which case the + * expected usage model would precisely _not_ be for + * the pterm window to hang around! + */ + finished = TRUE; + if (!pty_child_dead) + pty_exit_code = 0; + } else if (ret < 0) { + perror("read pty master"); + exit(1); + } else if (ret > 0) { + from_backend(pty_frontend, 0, buf, ret); + } + } else if (fd == pty_signal_pipe[0]) { + pid_t pid; + int status; + char c[1]; + + read(pty_signal_pipe[0], c, 1); /* ignore its value; it'll be `x' */ + + do { + pid = waitpid(-1, &status, WNOHANG); + if (pid == pty_child_pid && + (WIFEXITED(status) || WIFSIGNALED(status))) { + /* + * The primary child process died. We could keep + * the terminal open for remaining subprocesses to + * output to, but conventional wisdom seems to feel + * that that's the Wrong Thing for an xterm-alike, + * so we bail out now (though we don't necessarily + * _close_ the window, depending on the state of + * Close On Exit). This would be easy enough to + * change or make configurable if necessary. + */ + pty_exit_code = status; + pty_child_dead = TRUE; + finished = TRUE; + } + } while(pid > 0); + } + + if (finished && !pty_finished) { + uxsel_del(pty_master_fd); + pty_close(); + pty_master_fd = -1; + + pty_finished = TRUE; + + /* + * This is a slight layering-violation sort of hack: only + * if we're not closing on exit (COE is set to Never, or to + * Only On Clean and it wasn't a clean exit) do we output a + * `terminated' message. + */ + if (pty_cfg.close_on_exit == FORCE_OFF || + (pty_cfg.close_on_exit == AUTO && pty_exit_code != 0)) { + char message[512]; + if (WIFEXITED(pty_exit_code)) + sprintf(message, "\r\n[pterm: process terminated with exit" + " code %d]\r\n", WEXITSTATUS(pty_exit_code)); + else if (WIFSIGNALED(pty_exit_code)) +#ifdef HAVE_NO_STRSIGNAL + sprintf(message, "\r\n[pterm: process terminated on signal" + " %d]\r\n", WTERMSIG(pty_exit_code)); +#else + sprintf(message, "\r\n[pterm: process terminated on signal" + " %d (%.400s)]\r\n", WTERMSIG(pty_exit_code), + strsignal(WTERMSIG(pty_exit_code))); +#endif + from_backend(pty_frontend, 0, message, strlen(message)); + } + } + return !finished; +} + +static void pty_uxsel_setup(void) +{ + uxsel_set(pty_master_fd, 1, pty_select_result); + uxsel_set(pty_signal_pipe[0], 1, pty_select_result); +} + /* * Called to set up the pty. * @@ -382,16 +492,20 @@ 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, void **backend_handle, - char *host, int port, char **realhost, int nodelay) +static const char *pty_init(void *frontend, void **backend_handle, Config *cfg, + char *host, int port, char **realhost, int nodelay, + int keepalive) { int slavefd; pid_t pid, pgrp; + long windowid; + pty_frontend = frontend; *backend_handle = NULL; /* we can't sensibly use this, sadly */ - pty_term_width = cfg.width; - pty_term_height = cfg.height; + pty_cfg = *cfg; /* structure copy */ + pty_term_width = cfg->width; + pty_term_height = cfg->height; if (pty_master_fd < 0) pty_open_master(); @@ -403,29 +517,35 @@ static char *pty_init(void *frontend, void **backend_handle, { struct termios attrs; tcgetattr(pty_master_fd, &attrs); - attrs.c_cc[VERASE] = cfg.bksp_is_delete ? '\177' : '\010'; + attrs.c_cc[VERASE] = cfg->bksp_is_delete ? '\177' : '\010'; tcsetattr(pty_master_fd, TCSANOW, &attrs); } +#ifndef OMIT_UTMP /* * Stamp utmp (that is, tell the utmp helper process to do so), * or not. */ - if (!cfg.stamp_utmp) + if (!cfg->stamp_utmp) { close(pty_utmp_helper_pipe); /* just let the child process die */ - else { - char *location = get_x_display(); + pty_utmp_helper_pipe = -1; + } else { + 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); if (ret < 0) { perror("pterm: writing to utmp helper process"); close(pty_utmp_helper_pipe); /* arrgh, just give up */ + pty_utmp_helper_pipe = -1; break; } pos += ret; } } +#endif + + windowid = get_windowid(pty_frontend); /* * Fork and execute the command. @@ -445,7 +565,7 @@ static char *pty_init(void *frontend, void **backend_handle, slavefd = open(pty_name, O_RDWR); if (slavefd < 0) { perror("slave pty: open"); - exit(1); + _exit(1); } close(pty_master_fd); @@ -457,32 +577,60 @@ static char *pty_init(void *frontend, void **backend_handle, ioctl(slavefd, TIOCSCTTY, 1); pgrp = getpid(); tcsetpgrp(slavefd, pgrp); - setpgrp(); + setpgid(pgrp, pgrp); close(open(pty_name, O_WRONLY, 0)); - setpgrp(); + setpgid(pgrp, pgrp); /* Close everything _else_, for tidiness. */ for (i = 3; i < 1024; i++) close(i); { - char term_env_var[10 + sizeof(cfg.termtype)]; - sprintf(term_env_var, "TERM=%s", cfg.termtype); + char term_env_var[10 + sizeof(cfg->termtype)]; + sprintf(term_env_var, "TERM=%s", cfg->termtype); putenv(term_env_var); } + { + char windowid_env_var[40]; + sprintf(windowid_env_var, "WINDOWID=%ld", windowid); + putenv(windowid_env_var); + } + { + char *e = cfg->environmt; + char *var, *varend, *val, *varval; + while (*e) { + var = e; + while (*e && *e != '\t') e++; + varend = e; + if (*e == '\t') e++; + val = e; + while (*e) e++; + e++; + + varval = dupprintf("%.*s=%s", varend-var, var, val); + putenv(varval); + /* + * We must not free varval, since putenv links it + * into the environment _in place_. Weird, but + * there we go. Memory usage will be rationalised + * as soon as we exec anyway. + */ + } + } + /* * SIGINT and SIGQUIT may have been set to ignored by our * 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 { char *shell = getenv("SHELL"); char *shellname; - if (cfg.login_shell) { + if (cfg->login_shell) { char *p = strrchr(shell, '/'); - shellname = smalloc(2+strlen(shell)); + shellname = snewn(2+strlen(shell), char); p = p ? p+1 : shell; sprintf(shellname, "-%s", p); } else @@ -494,17 +642,39 @@ static char *pty_init(void *frontend, void **backend_handle, * 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); + pty_finished = FALSE; + } + + if (pipe(pty_signal_pipe) < 0) { + perror("pipe"); + exit(1); } + pty_uxsel_setup(); return NULL; } +static void pty_reconfig(void *handle, Config *cfg) +{ + /* + * We don't have much need to reconfigure this backend, but + * unfortunately we do need to pick up the setting of Close On + * Exit so we know whether to give a `terminated' message. + */ + pty_cfg = *cfg; /* structure copy */ +} + +/* + * Stub routine (never called in pterm). + */ +static void pty_free(void *handle) +{ +} + /* * Called to send data down the pty. */ @@ -525,13 +695,18 @@ static int pty_send(void *handle, char *buf, int len) return 0; } -void pty_close(void) +static 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 */ +#ifndef OMIT_UTMP + if (pty_utmp_helper_pipe >= 0) { + close(pty_utmp_helper_pipe); /* this causes utmp to be cleaned up */ + pty_utmp_helper_pipe = -1; + } +#endif } /* @@ -554,8 +729,10 @@ static void pty_size(void *handle, int width, int 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(0); - size.ws_ypixel = (unsigned short) pty_term_height * font_dimension(1); + 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; } @@ -569,6 +746,21 @@ static void pty_special(void *handle, Telnet_Special code) return; } +/* + * Return a list of the special codes that make sense in this + * protocol. + */ +static const struct telnet_special *pty_get_specials(void *handle) +{ + /* + * Hmm. When I get round to having this actually usable, it + * might be quite nice to have the ability to deliver a few + * well chosen signals to the child process - SIGINT, SIGTERM, + * SIGKILL at least. + */ + return NULL; +} + static Socket pty_socket(void *handle) { return NULL; /* shouldn't ever be needed */ @@ -589,9 +781,19 @@ static int pty_ldisc(void *handle, int option) return 0; /* neither editing nor echoing */ } +static void pty_provide_ldisc(void *handle, void *ldisc) +{ + /* 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) + if (!pty_finished) return -1; /* not dead yet */ else return pty_exit_code; @@ -599,14 +801,19 @@ static int pty_exitcode(void *handle) Backend pty_backend = { pty_init, + pty_free, + pty_reconfig, pty_send, pty_sendbuffer, pty_size, pty_special, + pty_get_specials, pty_socket, pty_exitcode, pty_sendok, pty_ldisc, + pty_provide_ldisc, + pty_provide_logctx, pty_unthrottle, 1 };