-/* $OpenBSD: clientloop.c,v 1.199 2008/06/12 21:06:25 djm Exp $ */
+/* $OpenBSD: clientloop.c,v 1.216 2010/01/09 05:04:24 djm Exp $ */
/*
* Author: Tatu Ylonen <ylo@cs.hut.fi>
* Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
#include "atomicio.h"
#include "sshpty.h"
#include "misc.h"
-#include "monitor_fdpass.h"
#include "match.h"
#include "msg.h"
+#include "roaming.h"
/* import options */
extern Options options;
*/
extern char *host;
+/* Force TTY allocation */
+extern int force_tty_flag;
+
/*
* Flag to indicate that we have received a window change signal which has
* not yet been processed. This will cause a message indicating the new
static Buffer stdin_buffer; /* Buffer for stdin data. */
static Buffer stdout_buffer; /* Buffer for stdout data. */
static Buffer stderr_buffer; /* Buffer for stderr data. */
-static u_long stdin_bytes, stdout_bytes, stderr_bytes;
static u_int buffer_high;/* Soft max buffer size. */
static int connection_in; /* Connection to server (input). */
static int connection_out; /* Connection to server (output). */
static void client_init_dispatch(void);
int session_ident = -1;
+int session_resumed = 0;
+
/* Track escape per proto2 channel */
struct escape_filter_ctx {
int escape_pending;
packet_put_string(buffer_ptr(&stdin_buffer), len);
packet_send();
buffer_consume(&stdin_buffer, len);
- stdin_bytes += len;
/* If we have a pending EOF, send it now. */
if (stdin_eof && buffer_len(&stdin_buffer) == 0) {
packet_start(SSH_CMSG_EOF);
xfree(gc);
}
- keep_alive_timeouts = 0;
+ packet_set_alive_timeouts(0);
}
static void
server_alive_check(void)
{
- if (++keep_alive_timeouts > options.server_alive_count_max) {
+ if (packet_inc_alive_timeouts() > options.server_alive_count_max) {
logit("Timeout, server not responding.");
cleanup_exit(255);
}
atomicio(vwrite, fileno(stderr), buffer_ptr(berr),
buffer_len(berr));
- leave_raw_mode();
+ leave_raw_mode(force_tty_flag);
/*
* Free (and clear) the buffer to reduce the amount of data that gets
buffer_init(bout);
buffer_init(berr);
- enter_raw_mode();
+ enter_raw_mode(force_tty_flag);
}
static void
client_process_net_input(fd_set *readset)
{
- int len;
- char buf[8192];
+ int len, cont = 0;
+ char buf[SSH_IOBUFSZ];
/*
* Read input from the server, and add any such data to the buffer of
*/
if (FD_ISSET(connection_in, readset)) {
/* Read as much as possible. */
- len = read(connection_in, buf, sizeof(buf));
- if (len == 0) {
+ len = roaming_read(connection_in, buf, sizeof(buf), &cont);
+ if (len == 0 && cont == 0) {
/*
* Received EOF. The remote host has closed the
* connection.
void
client_register_global_confirm(global_confirm_cb *cb, void *ctx)
{
- struct global_confirm *gc, *first_gc;
+ struct global_confirm *gc, *last_gc;
/* Coalesce identical callbacks */
- first_gc = TAILQ_LAST(&global_confirms, global_confirms);
- if (first_gc && first_gc->cb == cb && first_gc->ctx == ctx) {
- if (++first_gc->ref_count >= INT_MAX)
- fatal("%s: first_gc->ref_count = %d",
- __func__, first_gc->ref_count);
+ last_gc = TAILQ_LAST(&global_confirms, global_confirms);
+ if (last_gc && last_gc->cb == cb && last_gc->ctx == ctx) {
+ if (++last_gc->ref_count >= INT_MAX)
+ fatal("%s: last_gc->ref_count = %d",
+ __func__, last_gc->ref_count);
return;
}
void (*handler)(int);
char *s, *cmd, *cancel_host;
int delete = 0;
- int local = 0;
- u_short cancel_port;
+ int local = 0, remote = 0, dynamic = 0;
+ int cancel_port;
Forward fwd;
bzero(&fwd, sizeof(fwd));
fwd.listen_host = fwd.connect_host = NULL;
- leave_raw_mode();
+ leave_raw_mode(force_tty_flag);
handler = signal(SIGINT, SIG_IGN);
cmd = s = read_passphrase("\r\nssh> ", RP_ECHO);
if (s == NULL)
"Request local forward");
logit(" -R[bind_address:]port:host:hostport "
"Request remote forward");
+ logit(" -D[bind_address:]port "
+ "Request dynamic forward");
logit(" -KR[bind_address:]port "
"Cancel remote forward");
if (!options.permit_local_command)
delete = 1;
s++;
}
- if (*s != 'L' && *s != 'R') {
+ if (*s == 'L')
+ local = 1;
+ else if (*s == 'R')
+ remote = 1;
+ else if (*s == 'D')
+ dynamic = 1;
+ else {
logit("Invalid command.");
goto out;
}
- if (*s == 'L')
- local = 1;
- if (local && delete) {
+
+ if ((local || dynamic) && delete) {
logit("Not supported.");
goto out;
}
- if ((!local || delete) && !compat20) {
+ if (remote && delete && !compat20) {
logit("Not supported for SSH protocol version 1.");
goto out;
}
cancel_port = a2port(cancel_host);
cancel_host = NULL;
}
- if (cancel_port == 0) {
+ if (cancel_port <= 0) {
logit("Bad forwarding close port");
goto out;
}
channel_request_rforward_cancel(cancel_host, cancel_port);
} else {
- if (!parse_forward(&fwd, s)) {
+ if (!parse_forward(&fwd, s, dynamic, remote)) {
logit("Bad forwarding specification.");
goto out;
}
- if (local) {
+ if (local || dynamic) {
if (channel_setup_local_fwd_listener(fwd.listen_host,
fwd.listen_port, fwd.connect_host,
fwd.connect_port, options.gateway_ports) < 0) {
out:
signal(SIGINT, handler);
- enter_raw_mode();
+ enter_raw_mode(force_tty_flag);
if (cmd)
xfree(cmd);
if (fwd.listen_host != NULL)
* more new connections).
*/
/* Restore tty modes. */
- leave_raw_mode();
+ leave_raw_mode(force_tty_flag);
/* Stop listening for new connections. */
channel_stop_listening();
Supported escape sequences:\r\n\
%c. - terminate session\r\n\
%cB - send a BREAK to the remote system\r\n\
- %cC - open a command line\r\n\
%cR - Request rekey (SSH protocol 2 only)\r\n\
%c# - list forwarded connections\r\n\
%c? - this message\r\n\
escape_char, escape_char,
escape_char, escape_char,
escape_char, escape_char,
- escape_char, escape_char,
- escape_char);
+ escape_char, escape_char);
} else {
snprintf(string, sizeof string,
"%c?\r\n\
continue;
case 'C':
+ if (c && c->ctl_fd != -1)
+ goto noescape;
process_cmdline();
continue;
client_process_input(fd_set *readset)
{
int len;
- char buf[8192];
+ char buf[SSH_IOBUFSZ];
/* Read input from stdin. */
if (FD_ISSET(fileno(stdin), readset)) {
}
/* Consume printed data from the buffer. */
buffer_consume(&stdout_buffer, len);
- stdout_bytes += len;
}
/* Write buffered output to stderr. */
if (FD_ISSET(fileno(stderr), writeset)) {
}
/* Consume printed characters from the buffer. */
buffer_consume(&stderr_buffer, len);
- stderr_bytes += len;
}
}
{
channel_cancel_cleanup(id);
session_closed = 1;
- leave_raw_mode();
+ leave_raw_mode(force_tty_flag);
}
/*
fd_set *readset = NULL, *writeset = NULL;
double start_time, total_time;
int max_fd = 0, max_fd2 = 0, len, rekeying = 0;
+ u_int64_t ibytes, obytes;
u_int nalloc = 0;
char buf[100];
max_fd = MAX(max_fd, fileno(stdout));
max_fd = MAX(max_fd, fileno(stderr));
}
- stdin_bytes = 0;
- stdout_bytes = 0;
- stderr_bytes = 0;
quit_pending = 0;
escape_char1 = escape_char_arg;
signal(SIGWINCH, window_change_handler);
if (have_pty)
- enter_raw_mode();
+ enter_raw_mode(force_tty_flag);
if (compat20) {
session_ident = ssh2_chan_id;
client_process_output(writeset);
}
+ if (session_resumed) {
+ connection_in = packet_get_connection_in();
+ connection_out = packet_get_connection_out();
+ max_fd = MAX(max_fd, connection_out);
+ max_fd = MAX(max_fd, connection_in);
+ session_resumed = 0;
+ }
+
/*
* Send as much buffered packet data as possible to the
* sender.
/* Stop watching for window change. */
signal(SIGWINCH, SIG_DFL);
+ if (compat20) {
+ packet_start(SSH2_MSG_DISCONNECT);
+ packet_put_int(SSH2_DISCONNECT_BY_APPLICATION);
+ packet_put_cstring("disconnected by user");
+ packet_send();
+ packet_write_wait();
+ }
+
channel_free_all();
if (have_pty)
- leave_raw_mode();
+ leave_raw_mode(force_tty_flag);
/* restore blocking io */
if (!isatty(fileno(stdin)))
break;
}
buffer_consume(&stdout_buffer, len);
- stdout_bytes += len;
}
/* Output any buffered data for stderr. */
break;
}
buffer_consume(&stderr_buffer, len);
- stderr_bytes += len;
}
/* Clear and free any buffers. */
/* Report bytes transferred, and transfer rates. */
total_time = get_current_time() - start_time;
- debug("Transferred: stdin %lu, stdout %lu, stderr %lu bytes in %.1f "
- "seconds", stdin_bytes, stdout_bytes, stderr_bytes, total_time);
+ packet_get_state(MODE_IN, NULL, NULL, NULL, &ibytes);
+ packet_get_state(MODE_OUT, NULL, NULL, NULL, &obytes);
+ verbose("Transferred: sent %llu, received %llu bytes, in %.1f seconds",
+ obytes, ibytes, total_time);
if (total_time > 0)
- debug("Bytes per second: stdin %.1f, stdout %.1f, stderr %.1f",
- stdin_bytes / total_time, stdout_bytes / total_time,
- stderr_bytes / total_time);
-
+ verbose("Bytes per second: sent %.1f, received %.1f",
+ obytes / total_time, ibytes / total_time);
/* Return the exit status of the program. */
debug("Exit status %d", exit_status);
return exit_status;
{
Channel *c = NULL;
char *listen_address, *originator_address;
- int listen_port, originator_port;
+ u_short listen_port, originator_port;
/* Get rest of the packet */
listen_address = packet_get_string(NULL);
{
Channel *c = NULL;
char *originator;
- int originator_port;
+ u_short originator_port;
int sock;
if (!options.forward_x11) {
return 0;
if (!compat20) {
- error("Tunnel forwarding is not support for protocol 1");
+ error("Tunnel forwarding is not supported for protocol 1");
return -1;
}
chan_rcvd_eow(c);
} else if (strcmp(rtype, "exit-status") == 0) {
exitval = packet_get_int();
- if (id == session_ident) {
+ if (c->ctl_fd != -1) {
+ /* Dispatch to mux client */
+ atomicio(vwrite, c->ctl_fd, &exitval, sizeof(exitval));
+ success = 1;
+ } else if (id == session_ident) {
+ /* Record exit value of local session */
success = 1;
exit_status = exitval;
- } else if (c->ctl_fd == -1) {
+ } else {
error("client_input_channel_req: unexpected channel %d",
session_ident);
- } else {
- atomicio(vwrite, c->ctl_fd, &exitval, sizeof(exitval));
- success = 1;
}
packet_check_eom();
}
if (reply) {
packet_start(success ?
SSH2_MSG_CHANNEL_SUCCESS : SSH2_MSG_CHANNEL_FAILURE);
- packet_put_int(id);
+ packet_put_int(c->remote_id);
packet_send();
}
xfree(rtype);
void
cleanup_exit(int i)
{
- leave_raw_mode();
+ leave_raw_mode(force_tty_flag);
leave_non_blocking();
if (options.control_path != NULL && muxserver_sock != -1)
unlink(options.control_path);
andersk / openssh.git / blobdiff