src/usr.bin/ssh/clientloop.c - diff

Return to clientloop.c CVS log

Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/clientloop.c between version 1.141.2.3 and 1.142

version 1.141.2.3, 2006/11/08 00:44:05

version 1.142, 2005/09/09 19:18:05

Line 1

/* $OpenBSD$ */

* Author: Tatu Ylonen <ylo@cs.hut.fi>

Line 59

Line 58

* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "includes.h"

RCSID("$OpenBSD$");

#include <sys/types.h>

#include <sys/ioctl.h>

#include <sys/stat.h>

#include <sys/socket.h>

#include <sys/time.h>

#include <sys/param.h>

#include <ctype.h>

#include <errno.h>

#include <paths.h>

#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <termios.h>

#include <pwd.h>

#include <unistd.h>

#include "xmalloc.h"

#include "ssh.h"

#include "ssh1.h"

#include "ssh2.h"

#include "xmalloc.h"

#include "packet.h"

#include "buffer.h"

#include "compat.h"

#include "channels.h"

#include "dispatch.h"

#include "buffer.h"

#include "bufaux.h"

#include "key.h"

#include "cipher.h"

#include "kex.h"

#include "log.h"

#include "readconf.h"

#include "clientloop.h"

#include "sshconnect.h"

#include "authfd.h"

#include "atomicio.h"

#include "sshpty.h"

Line 130

Line 113

static volatile sig_atomic_t received_window_change_signal = 0;

static volatile sig_atomic_t received_signal = 0;

/* Flag indicating whether the user's terminal is in non-blocking mode. */

/* Flag indicating whether the user\'s terminal is in non-blocking mode. */

static int in_non_blocking_mode = 0;

/* Common data for the client loop code. */

static volatile sig_atomic_t quit_pending; /* Set non-zero to quit the loop. */

static int quit_pending; /* Set to non-zero to quit the client loop. */

static int escape_char; /* Escape character. */

static int escape_pending; /* Last character was the escape character */

static int last_was_cr; /* Last character was a newline. */

Line 194

Line 177

* Signal handler for the window change signal (SIGWINCH). This just sets a

* flag indicating that the window has changed.

/*ARGSUSED */

static void

window_change_handler(int sig)

{

Line 206

Line 189

* Signal handler for signals that cause the program to terminate. These

* signals must be trapped to restore terminal modes.

/*ARGSUSED */

static void

signal_handler(int sig)

{

Line 438

Line 421

if (ioctl(fileno(stdin), TIOCGWINSZ, &ws) < 0)

return;

packet_start(SSH_CMSG_WINDOW_SIZE);

packet_put_int((u_int)ws.ws_row);

packet_put_int(ws.ws_row);

packet_put_int((u_int)ws.ws_col);

packet_put_int(ws.ws_col);

packet_put_int((u_int)ws.ws_xpixel);

packet_put_int(ws.ws_xpixel);

packet_put_int((u_int)ws.ws_ypixel);

packet_put_int(ws.ws_ypixel);

packet_send();

}

Line 456

Line 439

static void

server_alive_check(void)

{

if (++server_alive_timeouts > options.server_alive_count_max) {

if (++server_alive_timeouts > options.server_alive_count_max)

logit("Timeout, server not responding.");

packet_disconnect("Timeout, server not responding.");

cleanup_exit(255);

}

packet_start(SSH2_MSG_GLOBAL_REQUEST);

packet_put_cstring("keepalive@openssh.com");

packet_put_char(1); /* boolean: want reply */

Line 587

Line 568

}

static void

client_process_net_input(fd_set *readset)

client_process_net_input(fd_set * readset)

{

int len;

char buf[8192];

Line 695

Line 676

}

static void

client_process_control(fd_set *readset)

client_process_control(fd_set * readset)

{

Buffer m;

Channel *c;

Line 826

Line 807

return;

}

cctx = xcalloc(1, sizeof(*cctx));

cctx = xmalloc(sizeof(*cctx));

memset(cctx, 0, sizeof(*cctx));

cctx->want_tty = (flags & SSHMUX_FLAG_TTY) != 0;

cctx->want_subsys = (flags & SSHMUX_FLAG_SUBSYS) != 0;

cctx->want_x_fwd = (flags & SSHMUX_FLAG_X11_FWD) != 0;

Line 841

Line 823

env_len = MIN(env_len, 4096);

debug3("%s: receiving %d env vars", __func__, env_len);

if (env_len != 0) {

cctx->env = xcalloc(env_len + 1, sizeof(*cctx->env));

cctx->env = xmalloc(sizeof(*cctx->env) * (env_len + 1));

for (i = 0; i < env_len; i++)

cctx->env[i] = buffer_get_string(&m, &len);

cctx->env[i] = NULL;

Line 849

Line 831

debug2("%s: accepted tty %d, subsys %d, cmd %s", __func__,

cctx->want_tty, cctx->want_subsys, cmd);

xfree(cmd);

/* Gather fds from client */

new_fd[0] = mm_receive_fd(client_fd);

Line 930

Line 911

if (*s == 'h' || *s == 'H' || *s == '?') {

logit("Commands:");

logit(" -L[bind_address:]port:host:hostport "

logit(" -Lport:host:hostport Request local forward");

"Request local forward");

logit(" -Rport:host:hostport Request remote forward");

logit(" -R[bind_address:]port:host:hostport "

logit(" -KRhostport Cancel remote forward");

"Request remote forward");

logit(" -KR[bind_address:]port "

"Cancel remote forward");

if (!options.permit_local_command)

goto out;

logit(" !args "

"Execute local command");

goto out;

}

if (*s == '!' && options.permit_local_command) {

s++;

ssh_local_cmd(s);

goto out;

}

if (*s == 'K') {

delete = 1;

s++;

Line 1000

Line 968

goto out;

}

} else {

if (channel_request_remote_forwarding(fwd.listen_host,

channel_request_remote_forwarding(fwd.listen_host,

fwd.listen_port, fwd.connect_host,

fwd.connect_port) < 0) {

fwd.connect_port);

logit("Port forwarding failed.");

goto out;

}

logit("Forwarding port.");

Line 1197

Line 1162

}

static void

client_process_input(fd_set *readset)

client_process_input(fd_set * readset)

{

int len;

char buf[8192];

Line 1250

Line 1215

}

static void

client_process_output(fd_set *writeset)

client_process_output(fd_set * writeset)

{

int len;

char buf[100];

Line 1411

Line 1376

session_ident = ssh2_chan_id;

if (escape_char != SSH_ESCAPECHAR_NONE)

channel_register_filter(session_ident,

simple_escape_filter, NULL);

simple_escape_filter);

if (session_ident != -1)

channel_register_cleanup(session_ident,

client_channel_closed, 0);

client_channel_closed);

} else {

/* Check if we should immediately send eof on stdin. */

client_check_initial_eof_on_stdin();

Line 1713

Line 1678

if (!options.forward_x11) {

error("Warning: ssh server tried X11 forwarding.");

error("Warning: this is probably a break-in attempt by a malicious server.");

error("Warning: this is probably a break in attempt by a malicious server.");

return NULL;

}

originator = packet_get_string(NULL);

Line 1746

Line 1711

if (!options.forward_agent) {

error("Warning: ssh server tried agent forwarding.");

error("Warning: this is probably a break-in attempt by a malicious server.");

error("Warning: this is probably a break in attempt by a malicious server.");

return NULL;

}

sock = ssh_get_authentication_socket();

Line 1894

Line 1859

channel_request_start(id, "pty-req", 0);

packet_put_cstring(term != NULL ? term : "");

packet_put_int((u_int)ws.ws_col);

packet_put_int(ws.ws_col);

packet_put_int((u_int)ws.ws_row);

packet_put_int(ws.ws_row);

packet_put_int((u_int)ws.ws_xpixel);

packet_put_int(ws.ws_xpixel);

packet_put_int((u_int)ws.ws_ypixel);

packet_put_int(ws.ws_ypixel);

tio = get_saved_tio();

tty_make_modes(-1, tiop != NULL ? tiop : &tio);

packet_send();

Line 1915

Line 1880

/* Split */

name = xstrdup(env[i]);

if ((val = strchr(name, '=')) == NULL) {

xfree(name);

free(name);

continue;

}

*val++ = '\0';

Line 1929

Line 1894

}

if (!matched) {

debug3("Ignored env %s", name);

xfree(name);

free(name);

continue;

}

Line 1938

Line 1903

packet_put_cstring(name);

packet_put_cstring(val);

packet_send();

xfree(name);

free(name);

}