*
*
* SSH2 support added by Markus Friedl.
- * Copyright (c) 1999,2000 Markus Friedl. All rights reserved.
+ * Copyright (c) 1999, 2000, 2001 Markus Friedl. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
*/
#include "includes.h"
-RCSID("$OpenBSD: clientloop.c,v 1.69 2001/05/08 19:17:31 markus Exp $");
+RCSID("$OpenBSD: clientloop.c,v 1.85 2001/10/24 08:51:35 markus Exp $");
#include "ssh.h"
#include "ssh1.h"
* because this is updated in a signal handler.
*/
static volatile int received_window_change_signal = 0;
+static volatile int received_signal = 0;
/* Flag indicating whether the user\'s terminal is in non-blocking mode. */
static int in_non_blocking_mode = 0;
static int need_rekeying; /* Set to non-zero if rekeying is requested. */
static int session_closed = 0; /* In SSH2: login session closed. */
-void client_init_dispatch(void);
+static void client_init_dispatch(void);
int session_ident = -1;
/*XXX*/
/* Restores stdin to blocking mode. */
-void
+static void
leave_non_blocking(void)
{
if (in_non_blocking_mode) {
/* Puts stdin terminal in non-blocking mode. */
-void
+static void
enter_non_blocking(void)
{
in_non_blocking_mode = 1;
* flag indicating that the window has changed.
*/
-void
+static void
window_change_handler(int sig)
{
received_window_change_signal = 1;
* signals must be trapped to restore terminal modes.
*/
-void
+static void
signal_handler(int sig)
{
- if (in_raw_mode())
- leave_raw_mode();
- if (in_non_blocking_mode)
- leave_non_blocking();
- channel_stop_listening();
- packet_close();
- fatal("Killed by signal %d.", sig);
+ received_signal = sig;
+ quit_pending = 1;
}
/*
* available resolution.
*/
-double
+static double
get_current_time(void)
{
struct timeval tv;
* not appear to wake up when redirecting from /dev/null.
*/
-void
+static void
client_check_initial_eof_on_stdin(void)
{
int len;
* connection.
*/
-void
+static void
client_make_packets_from_stdin_data(void)
{
u_int len;
* appropriate.
*/
-void
+static void
client_check_window_change(void)
{
struct winsize ws;
* one of the file descriptors).
*/
-void
+static void
client_wait_until_can_do_something(fd_set **readsetp, fd_set **writesetp,
- int *maxfdp, int rekeying)
+ int *maxfdp, int *nallocp, int rekeying)
{
/* Add any selections by the channel mechanism. */
- channel_prepare_select(readsetp, writesetp, maxfdp, rekeying);
+ channel_prepare_select(readsetp, writesetp, maxfdp, nallocp, rekeying);
if (!compat20) {
/* Read from the connection, unless our buffers are full. */
if (buffer_len(&stderr_buffer) > 0)
FD_SET(fileno(stderr), *writesetp);
} else {
- FD_SET(connection_in, *readsetp);
+ /* channel_prepare_select could have closed the last channel */
+ if (session_closed && !channel_still_open() &&
+ !packet_have_data_to_write()) {
+ /* clear mask since we did not call select() */
+ memset(*readsetp, 0, *maxfdp);
+ memset(*writesetp, 0, *maxfdp);
+ return;
+ } else {
+ FD_SET(connection_in, *readsetp);
+ }
}
/* Select server connection if have data to write to the server. */
}
}
-void
+static void
client_suspend_self(Buffer *bin, Buffer *bout, Buffer *berr)
{
struct winsize oldws, newws;
enter_raw_mode();
}
-void
+static void
client_process_net_input(fd_set * readset)
{
int len;
}
/* process the characters one by one */
-int
+static int
process_escapes(Buffer *bin, Buffer *bout, Buffer *berr, char *buf, int len)
{
char string[1024];
leave_raw_mode();
/* Stop listening for new connections. */
- channel_stop_listening();
+ channel_close_all(); /* proto1 only XXXX */
printf("%c& [backgrounded]\n", escape_char);
"%c?\r\n\
Supported escape sequences:\r\n\
~. - terminate connection\r\n\
-~R - Request rekey (SSH protocol 2 only)\r\n\
+~R - Request rekey (SSH protocol 2 only)\r\n\
~^Z - suspend ssh\r\n\
~# - list forwarded connections\r\n\
~& - background ssh (when waiting for connections to terminate)\r\n\
return bytes;
}
-void
+static void
client_process_input(fd_set * readset)
{
int len;
packet_start(SSH_CMSG_EOF);
packet_send();
}
- } else if (escape_char == -1) {
+ } else if (escape_char == SSH_ESCAPECHAR_NONE) {
/*
* Normal successful read, and no escape character.
* Just append the data to buffer.
}
}
-void
+static void
client_process_output(fd_set * writeset)
{
int len;
* preparatory phase.
*/
-void
+static void
client_process_buffered_input_packets(void)
{
dispatch_run(DISPATCH_NONBLOCK, &quit_pending, compat20 ? xxx_kex : NULL);
/* scan buf[] for '~' before sending data to the peer */
-int
+static int
simple_escape_filter(Channel *c, char *buf, int len)
{
/* XXX we assume c->extended is writeable */
return process_escapes(&c->input, &c->output, &c->extended, buf, len);
}
-void
+static void
client_channel_closed(int id, void *arg)
{
if (id != session_ident)
error("client_channel_closed: id %d != session_ident %d",
id, session_ident);
+ channel_cancel_cleanup(id);
session_closed = 1;
if (in_raw_mode())
leave_raw_mode();
/*
* Implements the interactive session with the server. This is called after
* the user has been authenticated, and a command has been started on the
- * remote host. If escape_char != -1, it is the character used as an escape
- * character for terminating or suspending the session.
+ * remote host. If escape_char != SSH_ESCAPECHAR_NONE, it is the character
+ * used as an escape character for terminating or suspending the session.
*/
int
{
fd_set *readset = NULL, *writeset = NULL;
double start_time, total_time;
- int max_fd = 0, len, rekeying = 0;
+ int max_fd = 0, max_fd2 = 0, len, rekeying = 0, nalloc = 0;
char buf[100];
debug("Entering interactive session.");
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
signal(SIGTERM, signal_handler);
- signal(SIGPIPE, SIG_IGN);
if (have_pty)
signal(SIGWINCH, window_change_handler);
if (compat20) {
session_ident = ssh2_chan_id;
- if (escape_char != -1)
+ if (escape_char != SSH_ESCAPECHAR_NONE)
channel_register_filter(session_ident,
simple_escape_filter);
if (session_ident != -1)
* Wait until we have something to do (something becomes
* available on one of the descriptors).
*/
+ max_fd2 = max_fd;
client_wait_until_can_do_something(&readset, &writeset,
- &max_fd, rekeying);
+ &max_fd2, &nalloc, rekeying);
if (quit_pending)
break;
if (have_pty)
signal(SIGWINCH, SIG_DFL);
- /* Stop listening for connections. */
- channel_stop_listening();
+ channel_free_all();
+
+ if (have_pty)
+ leave_raw_mode();
+
+ /* restore blocking io */
+ if (!isatty(fileno(stdin)))
+ unset_nonblock(fileno(stdin));
+ if (!isatty(fileno(stdout)))
+ unset_nonblock(fileno(stdout));
+ if (!isatty(fileno(stderr)))
+ unset_nonblock(fileno(stderr));
+
+ if (received_signal) {
+ if (in_non_blocking_mode) /* XXX */
+ leave_non_blocking();
+ fatal("Killed by signal %d.", received_signal);
+ }
/*
* In interactive mode (with pseudo tty) display a message indicating
snprintf(buf, sizeof buf, "Connection to %.64s closed.\r\n", host);
buffer_append(&stderr_buffer, buf, strlen(buf));
}
+
/* Output any buffered data for stdout. */
- if (buffer_len(&stdout_buffer) > 0) {
- len = atomicio(write, fileno(stdout), buffer_ptr(&stdout_buffer),
+ while (buffer_len(&stdout_buffer) > 0) {
+ len = write(fileno(stdout), buffer_ptr(&stdout_buffer),
buffer_len(&stdout_buffer));
- if (len != buffer_len(&stdout_buffer))
+ if (len <= 0) {
error("Write failed flushing stdout buffer.");
+ break;
+ }
buffer_consume(&stdout_buffer, len);
stdout_bytes += len;
}
/* Output any buffered data for stderr. */
- if (buffer_len(&stderr_buffer) > 0) {
- len = atomicio(write, fileno(stderr), buffer_ptr(&stderr_buffer),
+ while (buffer_len(&stderr_buffer) > 0) {
+ len = write(fileno(stderr), buffer_ptr(&stderr_buffer),
buffer_len(&stderr_buffer));
- if (len != buffer_len(&stderr_buffer))
+ if (len <= 0) {
error("Write failed flushing stderr buffer.");
+ break;
+ }
buffer_consume(&stderr_buffer, len);
stderr_bytes += len;
}
- if (have_pty)
- leave_raw_mode();
-
/* Clear and free any buffers. */
memset(buf, 0, sizeof(buf));
buffer_free(&stdin_buffer);
/*********/
-void
+static void
client_input_stdout_data(int type, int plen, void *ctxt)
{
u_int data_len;
memset(data, 0, data_len);
xfree(data);
}
-void
+static void
client_input_stderr_data(int type, int plen, void *ctxt)
{
u_int data_len;
memset(data, 0, data_len);
xfree(data);
}
-void
+static void
client_input_exit_status(int type, int plen, void *ctxt)
{
packet_integrity_check(plen, 4, type);
quit_pending = 1;
}
-Channel *
+static Channel *
client_request_forwarded_tcpip(const char *request_type, int rchan)
{
Channel* c = NULL;
debug("client_request_forwarded_tcpip: listen %s port %d, originator %s port %d",
listen_address, listen_port, originator_address, originator_port);
- sock = channel_connect_by_listen_adress(listen_port);
+ sock = channel_connect_by_listen_address(listen_port);
if (sock < 0) {
xfree(originator_address);
xfree(listen_address);
return c;
}
-Channel*
+static Channel*
client_request_x11(const char *request_type, int rchan)
{
Channel *c = NULL;
error("client_request_x11: channel_new failed");
close(sock);
}
+ c->force_drain = 1;
return c;
}
-Channel*
+static Channel*
client_request_agent(const char *request_type, int rchan)
{
Channel *c = NULL;
error("client_request_agent: channel_new failed");
close(sock);
}
+ c->force_drain = 1;
return c;
}
/* XXXX move to generic input handler */
-void
+static void
client_input_channel_open(int type, int plen, void *ctxt)
{
Channel *c = NULL;
}
xfree(ctype);
}
-void
+static void
client_input_channel_req(int type, int plen, void *ctxt)
{
Channel *c = NULL;
xfree(rtype);
}
-void
+static void
client_init_dispatch_20(void)
{
dispatch_init(&dispatch_protocol_error);
/* rekeying */
dispatch_set(SSH2_MSG_KEXINIT, &kex_input_kexinit);
}
-void
+static void
client_init_dispatch_13(void)
{
dispatch_init(NULL);
dispatch_set(SSH_SMSG_X11_OPEN, options.forward_x11 ?
&x11_input_open : &deny_input_open);
}
-void
+static void
client_init_dispatch_15(void)
{
client_init_dispatch_13();
dispatch_set(SSH_MSG_CHANNEL_CLOSE, &channel_input_ieof);
dispatch_set(SSH_MSG_CHANNEL_CLOSE_CONFIRMATION, & channel_input_oclose);
}
-void
+static void
client_init_dispatch(void)
{
if (compat20)
andersk / openssh.git / blobdiff