#include <string.h>
#include <unistd.h>
#include <signal.h>
+#include <assert.h>
#include <fcntl.h>
#include <termios.h>
#include <grp.h>
#include "putty.h"
#include "tree234.h"
-#ifdef HAVE_UTMPX_H
+#ifndef OMIT_UTMP
#include <utmpx.h>
#endif
int term_width, term_height;
int child_dead, finished;
int exit_code;
+ bufchain output_data;
};
/*
char **pty_argv;
static void pty_close(Pty pty);
+static void pty_try_write(Pty pty);
#ifndef OMIT_UTMP
static void setup_utmp(char *ttyname, char *location)
static int pty_open_slave(Pty pty)
{
- if (pty->slave_fd < 0)
+ if (pty->slave_fd < 0) {
pty->slave_fd = open(pty->name, O_RDWR);
+ cloexec(pty->slave_fd);
+ }
return pty->slave_fd;
}
strcpy(pty->name, master_name);
pty->name[5] = 't'; /* /dev/ptyXX -> /dev/ttyXX */
+ cloexec(pty->master_fd);
+
if (pty_open_slave(pty) >= 0 &&
access(pty->name, R_OK | W_OK) == 0)
goto got_one;
exit(1);
}
+ cloexec(pty->master_fd);
+
pty->name[FILENAME_MAX-1] = '\0';
strncpy(pty->name, ptsname(pty->master_fd), FILENAME_MAX-1);
#endif
+ {
+ /*
+ * Set the pty master into non-blocking mode.
+ */
+ int fl;
+ fl = fcntl(pty->master_fd, F_GETFL);
+ if (fl != -1 && !(fl & O_NONBLOCK))
+ fcntl(pty->master_fd, F_SETFL, fl | O_NONBLOCK);
+ }
+
if (!ptys_by_fd)
ptys_by_fd = newtree234(pty_compare_by_fd);
add234(ptys_by_fd, pty);
#endif
pty = single_pty = snew(struct pty_tag);
+ bufchain_init(&pty->output_data);
/* set the child signal handler straight away; it needs to be set
* before we ever fork. */
perror("pterm: pipe");
exit(1);
}
+ cloexec(pipefd[0]);
+ cloexec(pipefd[1]);
pid = fork();
if (pid < 0) {
perror("pterm: fork");
} else if (ret > 0) {
from_backend(pty->frontend, 0, buf, ret);
}
- }
+ } else if (event == 2) {
+ /*
+ * Attempt to send data down the pty.
+ */
+ pty_try_write(pty);
+ }
}
if (finished && !pty->finished) {
static void pty_uxsel_setup(Pty pty)
{
- uxsel_set(pty->master_fd, 1, pty_select_result);
+ int rwx;
+
+ rwx = 1; /* always want to read from pty */
+ if (bufchain_size(&pty->output_data))
+ rwx |= 2; /* might also want to write to it */
+ uxsel_set(pty->master_fd, rwx, pty_select_result);
/*
* In principle this only needs calling once for all pty
}
if (pid == 0) {
- int i;
/*
* We are the child.
*/
dup2(slavefd, 0);
dup2(slavefd, 1);
dup2(slavefd, 2);
+ close(slavefd);
setsid();
- ioctl(slavefd, TIOCSCTTY, 1);
+#ifdef TIOCSCTTY
+ ioctl(0, TIOCSCTTY, 1);
+#endif
pgrp = getpid();
- tcsetpgrp(slavefd, pgrp);
+ tcsetpgrp(0, pgrp);
setpgid(pgrp, pgrp);
close(open(pty->name, O_WRONLY, 0));
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 = dupprintf("TERM=%s", cfg->termtype);
putenv(term_env_var);
+ /* We mustn't free term_env_var, as putenv links it into the
+ * environment in place.
+ */
}
#ifndef NOT_X_WINDOWS /* for Mac OS X native compilation */
{
- char windowid_env_var[40];
- sprintf(windowid_env_var, "WINDOWID=%ld", windowid);
+ char *windowid_env_var = dupprintf("WINDOWID=%ld", windowid);
putenv(windowid_env_var);
+ /* We mustn't free windowid_env_var, as putenv links it into the
+ * environment in place.
+ */
}
#endif
{
add234(ptys_by_pid, pty);
}
- if (pty_signal_pipe[0] < 0 && pipe(pty_signal_pipe) < 0) {
- perror("pipe");
- exit(1);
+ if (pty_signal_pipe[0] < 0) {
+ if (pipe(pty_signal_pipe) < 0) {
+ perror("pipe");
+ exit(1);
+ }
+ cloexec(pty_signal_pipe[0]);
+ cloexec(pty_signal_pipe[1]);
}
pty_uxsel_setup(pty);
*backend_handle = pty;
+ *realhost = dupprintf("\0");
+
return NULL;
}
sfree(pty);
}
+static void pty_try_write(Pty pty)
+{
+ void *data;
+ int len, ret;
+
+ assert(pty->master_fd >= 0);
+
+ while (bufchain_size(&pty->output_data) > 0) {
+ bufchain_prefix(&pty->output_data, &data, &len);
+ ret = write(pty->master_fd, data, len);
+
+ if (ret < 0 && (errno == EWOULDBLOCK)) {
+ /*
+ * We've sent all we can for the moment.
+ */
+ break;
+ }
+ if (ret < 0) {
+ perror("write pty master");
+ exit(1);
+ }
+ bufchain_consume(&pty->output_data, ret);
+ }
+
+ pty_uxsel_setup(pty);
+}
+
/*
* Called to send data down the pty.
*/
Pty pty = (Pty)handle;
if (pty->master_fd < 0)
- return 0; /* ignore all writes if fd closed */
+ return 0; /* ignore all writes if fd closed */
- while (len > 0) {
- int ret = write(pty->master_fd, buf, len);
- if (ret < 0) {
- perror("write pty master");
- exit(1);
- }
- buf += ret;
- len -= ret;
- }
- return 0;
+ bufchain_add(&pty->output_data, buf, len);
+ pty_try_write(pty);
+
+ return bufchain_size(&pty->output_data);
}
static void pty_close(Pty pty)
return NULL;
}
-static Socket pty_socket(void *handle)
+static int pty_connected(void *handle)
{
/* Pty pty = (Pty)handle; */
- return NULL; /* shouldn't ever be needed */
+ return TRUE;
}
static int pty_sendok(void *handle)
pty_size,
pty_special,
pty_get_specials,
- pty_socket,
+ pty_connected,
pty_exitcode,
pty_sendok,
pty_ldisc,
pty_provide_logctx,
pty_unthrottle,
pty_cfg_info,
- 1
+ "pty",
+ -1,
+ 0
};