xref: /freebsd/crypto/openssh/clientloop.c (revision e146993e33182e13df79b5a957f2734f663fd836)
1*e146993eSDag-Erling Smørgrav /* $OpenBSD: clientloop.c,v 1.236 2011/06/22 22:08:42 djm Exp $ */
289986192SBrooks Davis /* $FreeBSD$ */
3511b41d2SMark Murray /*
4511b41d2SMark Murray  * Author: Tatu Ylonen <ylo@cs.hut.fi>
5511b41d2SMark Murray  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
6511b41d2SMark Murray  *                    All rights reserved
7511b41d2SMark Murray  * The main loop for the interactive session (client side).
8511b41d2SMark Murray  *
9b66f2d16SKris Kennaway  * As far as I am concerned, the code I have written for this software
10b66f2d16SKris Kennaway  * can be used freely for any purpose.  Any derived versions of this
11b66f2d16SKris Kennaway  * software must be clearly marked as such, and if the derived work is
12b66f2d16SKris Kennaway  * incompatible with the protocol description in the RFC file, it must be
13b66f2d16SKris Kennaway  * called by a name other than "ssh" or "Secure Shell".
14b66f2d16SKris Kennaway  *
15b66f2d16SKris Kennaway  *
16b66f2d16SKris Kennaway  * Copyright (c) 1999 Theo de Raadt.  All rights reserved.
17b66f2d16SKris Kennaway  *
18b66f2d16SKris Kennaway  * Redistribution and use in source and binary forms, with or without
19b66f2d16SKris Kennaway  * modification, are permitted provided that the following conditions
20b66f2d16SKris Kennaway  * are met:
21b66f2d16SKris Kennaway  * 1. Redistributions of source code must retain the above copyright
22b66f2d16SKris Kennaway  *    notice, this list of conditions and the following disclaimer.
23b66f2d16SKris Kennaway  * 2. Redistributions in binary form must reproduce the above copyright
24b66f2d16SKris Kennaway  *    notice, this list of conditions and the following disclaimer in the
25b66f2d16SKris Kennaway  *    documentation and/or other materials provided with the distribution.
26b66f2d16SKris Kennaway  *
27b66f2d16SKris Kennaway  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
28b66f2d16SKris Kennaway  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
29b66f2d16SKris Kennaway  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
30b66f2d16SKris Kennaway  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
31b66f2d16SKris Kennaway  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
32b66f2d16SKris Kennaway  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
33b66f2d16SKris Kennaway  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
34b66f2d16SKris Kennaway  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
35b66f2d16SKris Kennaway  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
36b66f2d16SKris Kennaway  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37b66f2d16SKris Kennaway  *
38b66f2d16SKris Kennaway  *
39a04a10f8SKris Kennaway  * SSH2 support added by Markus Friedl.
40ae1f160dSDag-Erling Smørgrav  * Copyright (c) 1999, 2000, 2001 Markus Friedl.  All rights reserved.
41b66f2d16SKris Kennaway  *
42b66f2d16SKris Kennaway  * Redistribution and use in source and binary forms, with or without
43b66f2d16SKris Kennaway  * modification, are permitted provided that the following conditions
44b66f2d16SKris Kennaway  * are met:
45b66f2d16SKris Kennaway  * 1. Redistributions of source code must retain the above copyright
46b66f2d16SKris Kennaway  *    notice, this list of conditions and the following disclaimer.
47b66f2d16SKris Kennaway  * 2. Redistributions in binary form must reproduce the above copyright
48b66f2d16SKris Kennaway  *    notice, this list of conditions and the following disclaimer in the
49b66f2d16SKris Kennaway  *    documentation and/or other materials provided with the distribution.
50b66f2d16SKris Kennaway  *
51b66f2d16SKris Kennaway  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
52b66f2d16SKris Kennaway  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
53b66f2d16SKris Kennaway  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
54b66f2d16SKris Kennaway  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
55b66f2d16SKris Kennaway  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
56b66f2d16SKris Kennaway  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57b66f2d16SKris Kennaway  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58b66f2d16SKris Kennaway  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59b66f2d16SKris Kennaway  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
60b66f2d16SKris Kennaway  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
61511b41d2SMark Murray  */
62511b41d2SMark Murray 
63511b41d2SMark Murray #include "includes.h"
64511b41d2SMark Murray 
65761efaa7SDag-Erling Smørgrav #include <sys/types.h>
66761efaa7SDag-Erling Smørgrav #include <sys/ioctl.h>
67761efaa7SDag-Erling Smørgrav #include <sys/param.h>
68761efaa7SDag-Erling Smørgrav #ifdef HAVE_SYS_STAT_H
69761efaa7SDag-Erling Smørgrav # include <sys/stat.h>
70761efaa7SDag-Erling Smørgrav #endif
71761efaa7SDag-Erling Smørgrav #ifdef HAVE_SYS_TIME_H
72761efaa7SDag-Erling Smørgrav # include <sys/time.h>
73761efaa7SDag-Erling Smørgrav #endif
74761efaa7SDag-Erling Smørgrav #include <sys/socket.h>
75761efaa7SDag-Erling Smørgrav 
76761efaa7SDag-Erling Smørgrav #include <ctype.h>
77761efaa7SDag-Erling Smørgrav #include <errno.h>
78761efaa7SDag-Erling Smørgrav #ifdef HAVE_PATHS_H
79761efaa7SDag-Erling Smørgrav #include <paths.h>
80761efaa7SDag-Erling Smørgrav #endif
81761efaa7SDag-Erling Smørgrav #include <signal.h>
82761efaa7SDag-Erling Smørgrav #include <stdarg.h>
83761efaa7SDag-Erling Smørgrav #include <stdio.h>
84761efaa7SDag-Erling Smørgrav #include <stdlib.h>
85761efaa7SDag-Erling Smørgrav #include <string.h>
86761efaa7SDag-Erling Smørgrav #include <termios.h>
87761efaa7SDag-Erling Smørgrav #include <pwd.h>
88761efaa7SDag-Erling Smørgrav #include <unistd.h>
89761efaa7SDag-Erling Smørgrav 
90d4af9e69SDag-Erling Smørgrav #include "openbsd-compat/sys-queue.h"
91761efaa7SDag-Erling Smørgrav #include "xmalloc.h"
92511b41d2SMark Murray #include "ssh.h"
931e8db6e2SBrian Feldman #include "ssh1.h"
941e8db6e2SBrian Feldman #include "ssh2.h"
95511b41d2SMark Murray #include "packet.h"
96511b41d2SMark Murray #include "buffer.h"
97a04a10f8SKris Kennaway #include "compat.h"
98a04a10f8SKris Kennaway #include "channels.h"
99a04a10f8SKris Kennaway #include "dispatch.h"
1001e8db6e2SBrian Feldman #include "key.h"
101761efaa7SDag-Erling Smørgrav #include "cipher.h"
1021e8db6e2SBrian Feldman #include "kex.h"
1031e8db6e2SBrian Feldman #include "log.h"
1041e8db6e2SBrian Feldman #include "readconf.h"
1051e8db6e2SBrian Feldman #include "clientloop.h"
106021d409fSDag-Erling Smørgrav #include "sshconnect.h"
1071e8db6e2SBrian Feldman #include "authfd.h"
1081e8db6e2SBrian Feldman #include "atomicio.h"
109d74d50a8SDag-Erling Smørgrav #include "sshpty.h"
1101e8db6e2SBrian Feldman #include "misc.h"
111d74d50a8SDag-Erling Smørgrav #include "match.h"
112d74d50a8SDag-Erling Smørgrav #include "msg.h"
1137aee6ffeSDag-Erling Smørgrav #include "roaming.h"
1145b9b2fafSBrian Feldman 
1155b9b2fafSBrian Feldman /* import options */
1164899dde7SBrian Feldman extern Options options;
1174899dde7SBrian Feldman 
118511b41d2SMark Murray /* Flag indicating that stdin should be redirected from /dev/null. */
119511b41d2SMark Murray extern int stdin_null_flag;
120511b41d2SMark Murray 
121efcad6b7SDag-Erling Smørgrav /* Flag indicating that no shell has been requested */
122efcad6b7SDag-Erling Smørgrav extern int no_shell_flag;
123efcad6b7SDag-Erling Smørgrav 
124d74d50a8SDag-Erling Smørgrav /* Control socket */
125b15c8340SDag-Erling Smørgrav extern int muxserver_sock; /* XXX use mux_client_cleanup() instead */
126d74d50a8SDag-Erling Smørgrav 
127511b41d2SMark Murray /*
128511b41d2SMark Murray  * Name of the host we are connecting to.  This is the name given on the
129511b41d2SMark Murray  * command line, or the HostName specified for the user-supplied name in a
130511b41d2SMark Murray  * configuration file.
131511b41d2SMark Murray  */
132511b41d2SMark Murray extern char *host;
133511b41d2SMark Murray 
134511b41d2SMark Murray /*
135511b41d2SMark Murray  * Flag to indicate that we have received a window change signal which has
136511b41d2SMark Murray  * not yet been processed.  This will cause a message indicating the new
137511b41d2SMark Murray  * window size to be sent to the server a little later.  This is volatile
138511b41d2SMark Murray  * because this is updated in a signal handler.
139511b41d2SMark Murray  */
140ae1f160dSDag-Erling Smørgrav static volatile sig_atomic_t received_window_change_signal = 0;
141ae1f160dSDag-Erling Smørgrav static volatile sig_atomic_t received_signal = 0;
142511b41d2SMark Murray 
143021d409fSDag-Erling Smørgrav /* Flag indicating whether the user's terminal is in non-blocking mode. */
144511b41d2SMark Murray static int in_non_blocking_mode = 0;
145511b41d2SMark Murray 
146e2f6069cSDag-Erling Smørgrav /* Time when backgrounded control master using ControlPersist should exit */
147e2f6069cSDag-Erling Smørgrav static time_t control_persist_exit_time = 0;
148e2f6069cSDag-Erling Smørgrav 
149511b41d2SMark Murray /* Common data for the client loop code. */
150b15c8340SDag-Erling Smørgrav volatile sig_atomic_t quit_pending; /* Set non-zero to quit the loop. */
151d4af9e69SDag-Erling Smørgrav static int escape_char1;	/* Escape character. (proto1 only) */
152d4af9e69SDag-Erling Smørgrav static int escape_pending1;	/* Last character was an escape (proto1 only) */
153511b41d2SMark Murray static int last_was_cr;		/* Last character was a newline. */
154d4af9e69SDag-Erling Smørgrav static int exit_status;		/* Used to store the command exit status. */
155d4af9e69SDag-Erling Smørgrav static int stdin_eof;		/* EOF has been encountered on stderr. */
156511b41d2SMark Murray static Buffer stdin_buffer;	/* Buffer for stdin data. */
157511b41d2SMark Murray static Buffer stdout_buffer;	/* Buffer for stdout data. */
158511b41d2SMark Murray static Buffer stderr_buffer;	/* Buffer for stderr data. */
1591e8db6e2SBrian Feldman static u_int buffer_high;	/* Soft max buffer size. */
160511b41d2SMark Murray static int connection_in;	/* Connection to server (input). */
161511b41d2SMark Murray static int connection_out;	/* Connection to server (output). */
1621e8db6e2SBrian Feldman static int need_rekeying;	/* Set to non-zero if rekeying is requested. */
163e2f6069cSDag-Erling Smørgrav static int session_closed;	/* In SSH2: login session closed. */
164e2f6069cSDag-Erling Smørgrav static int x11_refuse_time;	/* If >0, refuse x11 opens after this time. */
165a04a10f8SKris Kennaway 
166ae1f160dSDag-Erling Smørgrav static void client_init_dispatch(void);
167a04a10f8SKris Kennaway int	session_ident = -1;
168a04a10f8SKris Kennaway 
169b15c8340SDag-Erling Smørgrav int	session_resumed = 0;
170b15c8340SDag-Erling Smørgrav 
171d4af9e69SDag-Erling Smørgrav /* Track escape per proto2 channel */
172d4af9e69SDag-Erling Smørgrav struct escape_filter_ctx {
173d4af9e69SDag-Erling Smørgrav 	int escape_pending;
174d4af9e69SDag-Erling Smørgrav 	int escape_char;
175d74d50a8SDag-Erling Smørgrav };
176d74d50a8SDag-Erling Smørgrav 
177d4af9e69SDag-Erling Smørgrav /* Context for channel confirmation replies */
178d4af9e69SDag-Erling Smørgrav struct channel_reply_ctx {
179d4af9e69SDag-Erling Smørgrav 	const char *request_type;
180*e146993eSDag-Erling Smørgrav 	int id;
181*e146993eSDag-Erling Smørgrav 	enum confirm_action action;
182d4af9e69SDag-Erling Smørgrav };
183d4af9e69SDag-Erling Smørgrav 
184d4af9e69SDag-Erling Smørgrav /* Global request success/failure callbacks */
185d4af9e69SDag-Erling Smørgrav struct global_confirm {
186d4af9e69SDag-Erling Smørgrav 	TAILQ_ENTRY(global_confirm) entry;
187d4af9e69SDag-Erling Smørgrav 	global_confirm_cb *cb;
188d4af9e69SDag-Erling Smørgrav 	void *ctx;
189d4af9e69SDag-Erling Smørgrav 	int ref_count;
190d4af9e69SDag-Erling Smørgrav };
191d4af9e69SDag-Erling Smørgrav TAILQ_HEAD(global_confirms, global_confirm);
192d4af9e69SDag-Erling Smørgrav static struct global_confirms global_confirms =
193d4af9e69SDag-Erling Smørgrav     TAILQ_HEAD_INITIALIZER(global_confirms);
194d4af9e69SDag-Erling Smørgrav 
1951e8db6e2SBrian Feldman /*XXX*/
1961e8db6e2SBrian Feldman extern Kex *xxx_kex;
197511b41d2SMark Murray 
198d74d50a8SDag-Erling Smørgrav void ssh_process_session2_setup(int, int, int, Buffer *);
199d74d50a8SDag-Erling Smørgrav 
200511b41d2SMark Murray /* Restores stdin to blocking mode. */
201511b41d2SMark Murray 
202ae1f160dSDag-Erling Smørgrav static void
2031e8db6e2SBrian Feldman leave_non_blocking(void)
204511b41d2SMark Murray {
205511b41d2SMark Murray 	if (in_non_blocking_mode) {
206d74d50a8SDag-Erling Smørgrav 		unset_nonblock(fileno(stdin));
207511b41d2SMark Murray 		in_non_blocking_mode = 0;
208511b41d2SMark Murray 	}
209511b41d2SMark Murray }
210511b41d2SMark Murray 
211511b41d2SMark Murray /* Puts stdin terminal in non-blocking mode. */
212511b41d2SMark Murray 
213ae1f160dSDag-Erling Smørgrav static void
2141e8db6e2SBrian Feldman enter_non_blocking(void)
215511b41d2SMark Murray {
216511b41d2SMark Murray 	in_non_blocking_mode = 1;
217d74d50a8SDag-Erling Smørgrav 	set_nonblock(fileno(stdin));
218511b41d2SMark Murray }
219511b41d2SMark Murray 
220511b41d2SMark Murray /*
221511b41d2SMark Murray  * Signal handler for the window change signal (SIGWINCH).  This just sets a
222511b41d2SMark Murray  * flag indicating that the window has changed.
223511b41d2SMark Murray  */
224761efaa7SDag-Erling Smørgrav /*ARGSUSED */
225ae1f160dSDag-Erling Smørgrav static void
226511b41d2SMark Murray window_change_handler(int sig)
227511b41d2SMark Murray {
228511b41d2SMark Murray 	received_window_change_signal = 1;
229511b41d2SMark Murray 	signal(SIGWINCH, window_change_handler);
230511b41d2SMark Murray }
231511b41d2SMark Murray 
232511b41d2SMark Murray /*
233511b41d2SMark Murray  * Signal handler for signals that cause the program to terminate.  These
234511b41d2SMark Murray  * signals must be trapped to restore terminal modes.
235511b41d2SMark Murray  */
236761efaa7SDag-Erling Smørgrav /*ARGSUSED */
237ae1f160dSDag-Erling Smørgrav static void
238511b41d2SMark Murray signal_handler(int sig)
239511b41d2SMark Murray {
240ae1f160dSDag-Erling Smørgrav 	received_signal = sig;
241ae1f160dSDag-Erling Smørgrav 	quit_pending = 1;
242511b41d2SMark Murray }
243511b41d2SMark Murray 
244511b41d2SMark Murray /*
245511b41d2SMark Murray  * Returns current time in seconds from Jan 1, 1970 with the maximum
246511b41d2SMark Murray  * available resolution.
247511b41d2SMark Murray  */
248511b41d2SMark Murray 
249ae1f160dSDag-Erling Smørgrav static double
2501e8db6e2SBrian Feldman get_current_time(void)
251511b41d2SMark Murray {
252511b41d2SMark Murray 	struct timeval tv;
253511b41d2SMark Murray 	gettimeofday(&tv, NULL);
254511b41d2SMark Murray 	return (double) tv.tv_sec + (double) tv.tv_usec / 1000000.0;
255511b41d2SMark Murray }
256511b41d2SMark Murray 
257e2f6069cSDag-Erling Smørgrav /*
258e2f6069cSDag-Erling Smørgrav  * Sets control_persist_exit_time to the absolute time when the
259e2f6069cSDag-Erling Smørgrav  * backgrounded control master should exit due to expiry of the
260e2f6069cSDag-Erling Smørgrav  * ControlPersist timeout.  Sets it to 0 if we are not a backgrounded
261e2f6069cSDag-Erling Smørgrav  * control master process, or if there is no ControlPersist timeout.
262e2f6069cSDag-Erling Smørgrav  */
263e2f6069cSDag-Erling Smørgrav static void
264e2f6069cSDag-Erling Smørgrav set_control_persist_exit_time(void)
265e2f6069cSDag-Erling Smørgrav {
266e2f6069cSDag-Erling Smørgrav 	if (muxserver_sock == -1 || !options.control_persist
267*e146993eSDag-Erling Smørgrav 	    || options.control_persist_timeout == 0) {
268e2f6069cSDag-Erling Smørgrav 		/* not using a ControlPersist timeout */
269e2f6069cSDag-Erling Smørgrav 		control_persist_exit_time = 0;
270*e146993eSDag-Erling Smørgrav 	} else if (channel_still_open()) {
271e2f6069cSDag-Erling Smørgrav 		/* some client connections are still open */
272e2f6069cSDag-Erling Smørgrav 		if (control_persist_exit_time > 0)
273e2f6069cSDag-Erling Smørgrav 			debug2("%s: cancel scheduled exit", __func__);
274e2f6069cSDag-Erling Smørgrav 		control_persist_exit_time = 0;
275e2f6069cSDag-Erling Smørgrav 	} else if (control_persist_exit_time <= 0) {
276e2f6069cSDag-Erling Smørgrav 		/* a client connection has recently closed */
277e2f6069cSDag-Erling Smørgrav 		control_persist_exit_time = time(NULL) +
278e2f6069cSDag-Erling Smørgrav 			(time_t)options.control_persist_timeout;
279e2f6069cSDag-Erling Smørgrav 		debug2("%s: schedule exit in %d seconds", __func__,
280e2f6069cSDag-Erling Smørgrav 		    options.control_persist_timeout);
281e2f6069cSDag-Erling Smørgrav 	}
282e2f6069cSDag-Erling Smørgrav 	/* else we are already counting down to the timeout */
283e2f6069cSDag-Erling Smørgrav }
284e2f6069cSDag-Erling Smørgrav 
285043840dfSDag-Erling Smørgrav #define SSH_X11_PROTO "MIT-MAGIC-COOKIE-1"
286043840dfSDag-Erling Smørgrav void
287043840dfSDag-Erling Smørgrav client_x11_get_proto(const char *display, const char *xauth_path,
288e2f6069cSDag-Erling Smørgrav     u_int trusted, u_int timeout, char **_proto, char **_data)
289043840dfSDag-Erling Smørgrav {
290043840dfSDag-Erling Smørgrav 	char cmd[1024];
291043840dfSDag-Erling Smørgrav 	char line[512];
292043840dfSDag-Erling Smørgrav 	char xdisplay[512];
293043840dfSDag-Erling Smørgrav 	static char proto[512], data[512];
294043840dfSDag-Erling Smørgrav 	FILE *f;
295043840dfSDag-Erling Smørgrav 	int got_data = 0, generated = 0, do_unlink = 0, i;
296043840dfSDag-Erling Smørgrav 	char *xauthdir, *xauthfile;
297043840dfSDag-Erling Smørgrav 	struct stat st;
298e2f6069cSDag-Erling Smørgrav 	u_int now;
299043840dfSDag-Erling Smørgrav 
300043840dfSDag-Erling Smørgrav 	xauthdir = xauthfile = NULL;
301043840dfSDag-Erling Smørgrav 	*_proto = proto;
302043840dfSDag-Erling Smørgrav 	*_data = data;
303043840dfSDag-Erling Smørgrav 	proto[0] = data[0] = '\0';
304043840dfSDag-Erling Smørgrav 
305043840dfSDag-Erling Smørgrav 	if (xauth_path == NULL ||(stat(xauth_path, &st) == -1)) {
306043840dfSDag-Erling Smørgrav 		debug("No xauth program.");
307043840dfSDag-Erling Smørgrav 	} else {
308043840dfSDag-Erling Smørgrav 		if (display == NULL) {
309043840dfSDag-Erling Smørgrav 			debug("x11_get_proto: DISPLAY not set");
310043840dfSDag-Erling Smørgrav 			return;
311043840dfSDag-Erling Smørgrav 		}
312043840dfSDag-Erling Smørgrav 		/*
313043840dfSDag-Erling Smørgrav 		 * Handle FamilyLocal case where $DISPLAY does
314043840dfSDag-Erling Smørgrav 		 * not match an authorization entry.  For this we
315043840dfSDag-Erling Smørgrav 		 * just try "xauth list unix:displaynum.screennum".
316043840dfSDag-Erling Smørgrav 		 * XXX: "localhost" match to determine FamilyLocal
317043840dfSDag-Erling Smørgrav 		 *      is not perfect.
318043840dfSDag-Erling Smørgrav 		 */
319043840dfSDag-Erling Smørgrav 		if (strncmp(display, "localhost:", 10) == 0) {
320043840dfSDag-Erling Smørgrav 			snprintf(xdisplay, sizeof(xdisplay), "unix:%s",
321043840dfSDag-Erling Smørgrav 			    display + 10);
322043840dfSDag-Erling Smørgrav 			display = xdisplay;
323043840dfSDag-Erling Smørgrav 		}
324043840dfSDag-Erling Smørgrav 		if (trusted == 0) {
325043840dfSDag-Erling Smørgrav 			xauthdir = xmalloc(MAXPATHLEN);
326043840dfSDag-Erling Smørgrav 			xauthfile = xmalloc(MAXPATHLEN);
3274a421b63SDag-Erling Smørgrav 			mktemp_proto(xauthdir, MAXPATHLEN);
328043840dfSDag-Erling Smørgrav 			if (mkdtemp(xauthdir) != NULL) {
329043840dfSDag-Erling Smørgrav 				do_unlink = 1;
330043840dfSDag-Erling Smørgrav 				snprintf(xauthfile, MAXPATHLEN, "%s/xauthfile",
331043840dfSDag-Erling Smørgrav 				    xauthdir);
332043840dfSDag-Erling Smørgrav 				snprintf(cmd, sizeof(cmd),
333043840dfSDag-Erling Smørgrav 				    "%s -f %s generate %s " SSH_X11_PROTO
334e2f6069cSDag-Erling Smørgrav 				    " untrusted timeout %u 2>" _PATH_DEVNULL,
335e2f6069cSDag-Erling Smørgrav 				    xauth_path, xauthfile, display, timeout);
336043840dfSDag-Erling Smørgrav 				debug2("x11_get_proto: %s", cmd);
337043840dfSDag-Erling Smørgrav 				if (system(cmd) == 0)
338043840dfSDag-Erling Smørgrav 					generated = 1;
339e2f6069cSDag-Erling Smørgrav 				if (x11_refuse_time == 0) {
340e2f6069cSDag-Erling Smørgrav 					now = time(NULL) + 1;
341e2f6069cSDag-Erling Smørgrav 					if (UINT_MAX - timeout < now)
342e2f6069cSDag-Erling Smørgrav 						x11_refuse_time = UINT_MAX;
343e2f6069cSDag-Erling Smørgrav 					else
344e2f6069cSDag-Erling Smørgrav 						x11_refuse_time = now + timeout;
345e2f6069cSDag-Erling Smørgrav 				}
346043840dfSDag-Erling Smørgrav 			}
347043840dfSDag-Erling Smørgrav 		}
348d4af9e69SDag-Erling Smørgrav 
349d4af9e69SDag-Erling Smørgrav 		/*
350d4af9e69SDag-Erling Smørgrav 		 * When in untrusted mode, we read the cookie only if it was
351d4af9e69SDag-Erling Smørgrav 		 * successfully generated as an untrusted one in the step
352d4af9e69SDag-Erling Smørgrav 		 * above.
353d4af9e69SDag-Erling Smørgrav 		 */
354d4af9e69SDag-Erling Smørgrav 		if (trusted || generated) {
355043840dfSDag-Erling Smørgrav 			snprintf(cmd, sizeof(cmd),
356021d409fSDag-Erling Smørgrav 			    "%s %s%s list %s 2>" _PATH_DEVNULL,
357043840dfSDag-Erling Smørgrav 			    xauth_path,
358043840dfSDag-Erling Smørgrav 			    generated ? "-f " : "" ,
359043840dfSDag-Erling Smørgrav 			    generated ? xauthfile : "",
360043840dfSDag-Erling Smørgrav 			    display);
361043840dfSDag-Erling Smørgrav 			debug2("x11_get_proto: %s", cmd);
362043840dfSDag-Erling Smørgrav 			f = popen(cmd, "r");
363043840dfSDag-Erling Smørgrav 			if (f && fgets(line, sizeof(line), f) &&
364043840dfSDag-Erling Smørgrav 			    sscanf(line, "%*s %511s %511s", proto, data) == 2)
365043840dfSDag-Erling Smørgrav 				got_data = 1;
366043840dfSDag-Erling Smørgrav 			if (f)
367043840dfSDag-Erling Smørgrav 				pclose(f);
368d4af9e69SDag-Erling Smørgrav 		} else
369d4af9e69SDag-Erling Smørgrav 			error("Warning: untrusted X11 forwarding setup failed: "
370d4af9e69SDag-Erling Smørgrav 			    "xauth key data not generated");
371043840dfSDag-Erling Smørgrav 	}
372043840dfSDag-Erling Smørgrav 
373043840dfSDag-Erling Smørgrav 	if (do_unlink) {
374043840dfSDag-Erling Smørgrav 		unlink(xauthfile);
375043840dfSDag-Erling Smørgrav 		rmdir(xauthdir);
376043840dfSDag-Erling Smørgrav 	}
377043840dfSDag-Erling Smørgrav 	if (xauthdir)
378043840dfSDag-Erling Smørgrav 		xfree(xauthdir);
379043840dfSDag-Erling Smørgrav 	if (xauthfile)
380043840dfSDag-Erling Smørgrav 		xfree(xauthfile);
381043840dfSDag-Erling Smørgrav 
382043840dfSDag-Erling Smørgrav 	/*
383043840dfSDag-Erling Smørgrav 	 * If we didn't get authentication data, just make up some
384043840dfSDag-Erling Smørgrav 	 * data.  The forwarding code will check the validity of the
385043840dfSDag-Erling Smørgrav 	 * response anyway, and substitute this data.  The X11
386043840dfSDag-Erling Smørgrav 	 * server, however, will ignore this fake data and use
387043840dfSDag-Erling Smørgrav 	 * whatever authentication mechanisms it was using otherwise
388043840dfSDag-Erling Smørgrav 	 * for the local connection.
389043840dfSDag-Erling Smørgrav 	 */
390043840dfSDag-Erling Smørgrav 	if (!got_data) {
391043840dfSDag-Erling Smørgrav 		u_int32_t rnd = 0;
392043840dfSDag-Erling Smørgrav 
393043840dfSDag-Erling Smørgrav 		logit("Warning: No xauth data; "
394043840dfSDag-Erling Smørgrav 		    "using fake authentication data for X11 forwarding.");
395043840dfSDag-Erling Smørgrav 		strlcpy(proto, SSH_X11_PROTO, sizeof proto);
396043840dfSDag-Erling Smørgrav 		for (i = 0; i < 16; i++) {
397043840dfSDag-Erling Smørgrav 			if (i % 4 == 0)
398043840dfSDag-Erling Smørgrav 				rnd = arc4random();
399043840dfSDag-Erling Smørgrav 			snprintf(data + 2 * i, sizeof data - 2 * i, "%02x",
400043840dfSDag-Erling Smørgrav 			    rnd & 0xff);
401043840dfSDag-Erling Smørgrav 			rnd >>= 8;
402043840dfSDag-Erling Smørgrav 		}
403043840dfSDag-Erling Smørgrav 	}
404043840dfSDag-Erling Smørgrav }
405043840dfSDag-Erling Smørgrav 
406511b41d2SMark Murray /*
407511b41d2SMark Murray  * This is called when the interactive is entered.  This checks if there is
408511b41d2SMark Murray  * an EOF coming on stdin.  We must check this explicitly, as select() does
409511b41d2SMark Murray  * not appear to wake up when redirecting from /dev/null.
410511b41d2SMark Murray  */
411511b41d2SMark Murray 
412ae1f160dSDag-Erling Smørgrav static void
4131e8db6e2SBrian Feldman client_check_initial_eof_on_stdin(void)
414511b41d2SMark Murray {
415511b41d2SMark Murray 	int len;
416511b41d2SMark Murray 	char buf[1];
417511b41d2SMark Murray 
418511b41d2SMark Murray 	/*
419511b41d2SMark Murray 	 * If standard input is to be "redirected from /dev/null", we simply
420511b41d2SMark Murray 	 * mark that we have seen an EOF and send an EOF message to the
421511b41d2SMark Murray 	 * server. Otherwise, we try to read a single character; it appears
422511b41d2SMark Murray 	 * that for some files, such /dev/null, select() never wakes up for
423511b41d2SMark Murray 	 * read for this descriptor, which means that we never get EOF.  This
424511b41d2SMark Murray 	 * way we will get the EOF if stdin comes from /dev/null or similar.
425511b41d2SMark Murray 	 */
426511b41d2SMark Murray 	if (stdin_null_flag) {
427511b41d2SMark Murray 		/* Fake EOF on stdin. */
428511b41d2SMark Murray 		debug("Sending eof.");
429511b41d2SMark Murray 		stdin_eof = 1;
430511b41d2SMark Murray 		packet_start(SSH_CMSG_EOF);
431511b41d2SMark Murray 		packet_send();
432511b41d2SMark Murray 	} else {
433511b41d2SMark Murray 		enter_non_blocking();
434511b41d2SMark Murray 
435511b41d2SMark Murray 		/* Check for immediate EOF on stdin. */
436511b41d2SMark Murray 		len = read(fileno(stdin), buf, 1);
437511b41d2SMark Murray 		if (len == 0) {
438d4af9e69SDag-Erling Smørgrav 			/*
439d4af9e69SDag-Erling Smørgrav 			 * EOF.  Record that we have seen it and send
440d4af9e69SDag-Erling Smørgrav 			 * EOF to server.
441d4af9e69SDag-Erling Smørgrav 			 */
442511b41d2SMark Murray 			debug("Sending eof.");
443511b41d2SMark Murray 			stdin_eof = 1;
444511b41d2SMark Murray 			packet_start(SSH_CMSG_EOF);
445511b41d2SMark Murray 			packet_send();
446511b41d2SMark Murray 		} else if (len > 0) {
447511b41d2SMark Murray 			/*
448511b41d2SMark Murray 			 * Got data.  We must store the data in the buffer,
449511b41d2SMark Murray 			 * and also process it as an escape character if
450511b41d2SMark Murray 			 * appropriate.
451511b41d2SMark Murray 			 */
452d4af9e69SDag-Erling Smørgrav 			if ((u_char) buf[0] == escape_char1)
453d4af9e69SDag-Erling Smørgrav 				escape_pending1 = 1;
4541e8db6e2SBrian Feldman 			else
455511b41d2SMark Murray 				buffer_append(&stdin_buffer, buf, 1);
456511b41d2SMark Murray 		}
457511b41d2SMark Murray 		leave_non_blocking();
458511b41d2SMark Murray 	}
459511b41d2SMark Murray }
460511b41d2SMark Murray 
461511b41d2SMark Murray 
462511b41d2SMark Murray /*
463511b41d2SMark Murray  * Make packets from buffered stdin data, and buffer them for sending to the
464511b41d2SMark Murray  * connection.
465511b41d2SMark Murray  */
466511b41d2SMark Murray 
467ae1f160dSDag-Erling Smørgrav static void
4681e8db6e2SBrian Feldman client_make_packets_from_stdin_data(void)
469511b41d2SMark Murray {
4701e8db6e2SBrian Feldman 	u_int len;
471511b41d2SMark Murray 
472511b41d2SMark Murray 	/* Send buffered stdin data to the server. */
473511b41d2SMark Murray 	while (buffer_len(&stdin_buffer) > 0 &&
474511b41d2SMark Murray 	    packet_not_very_much_data_to_write()) {
475511b41d2SMark Murray 		len = buffer_len(&stdin_buffer);
476511b41d2SMark Murray 		/* Keep the packets at reasonable size. */
477511b41d2SMark Murray 		if (len > packet_get_maxsize())
478511b41d2SMark Murray 			len = packet_get_maxsize();
479511b41d2SMark Murray 		packet_start(SSH_CMSG_STDIN_DATA);
480511b41d2SMark Murray 		packet_put_string(buffer_ptr(&stdin_buffer), len);
481511b41d2SMark Murray 		packet_send();
482511b41d2SMark Murray 		buffer_consume(&stdin_buffer, len);
483511b41d2SMark Murray 		/* If we have a pending EOF, send it now. */
484511b41d2SMark Murray 		if (stdin_eof && buffer_len(&stdin_buffer) == 0) {
485511b41d2SMark Murray 			packet_start(SSH_CMSG_EOF);
486511b41d2SMark Murray 			packet_send();
487511b41d2SMark Murray 		}
488511b41d2SMark Murray 	}
489511b41d2SMark Murray }
490511b41d2SMark Murray 
491511b41d2SMark Murray /*
492511b41d2SMark Murray  * Checks if the client window has changed, and sends a packet about it to
493511b41d2SMark Murray  * the server if so.  The actual change is detected elsewhere (by a software
494511b41d2SMark Murray  * interrupt on Unix); this just checks the flag and sends a message if
495511b41d2SMark Murray  * appropriate.
496511b41d2SMark Murray  */
497511b41d2SMark Murray 
498ae1f160dSDag-Erling Smørgrav static void
4991e8db6e2SBrian Feldman client_check_window_change(void)
500511b41d2SMark Murray {
501511b41d2SMark Murray 	struct winsize ws;
502511b41d2SMark Murray 
503a04a10f8SKris Kennaway 	if (! received_window_change_signal)
504a04a10f8SKris Kennaway 		return;
505a04a10f8SKris Kennaway 	/** XXX race */
506511b41d2SMark Murray 	received_window_change_signal = 0;
507511b41d2SMark Murray 
5085b9b2fafSBrian Feldman 	debug2("client_check_window_change: changed");
509a04a10f8SKris Kennaway 
510a04a10f8SKris Kennaway 	if (compat20) {
511d74d50a8SDag-Erling Smørgrav 		channel_send_window_changes();
512a04a10f8SKris Kennaway 	} else {
513d74d50a8SDag-Erling Smørgrav 		if (ioctl(fileno(stdin), TIOCGWINSZ, &ws) < 0)
514d74d50a8SDag-Erling Smørgrav 			return;
515511b41d2SMark Murray 		packet_start(SSH_CMSG_WINDOW_SIZE);
516761efaa7SDag-Erling Smørgrav 		packet_put_int((u_int)ws.ws_row);
517761efaa7SDag-Erling Smørgrav 		packet_put_int((u_int)ws.ws_col);
518761efaa7SDag-Erling Smørgrav 		packet_put_int((u_int)ws.ws_xpixel);
519761efaa7SDag-Erling Smørgrav 		packet_put_int((u_int)ws.ws_ypixel);
520511b41d2SMark Murray 		packet_send();
521511b41d2SMark Murray 	}
522511b41d2SMark Murray }
523511b41d2SMark Murray 
524efcad6b7SDag-Erling Smørgrav static void
525efcad6b7SDag-Erling Smørgrav client_global_request_reply(int type, u_int32_t seq, void *ctxt)
526efcad6b7SDag-Erling Smørgrav {
527d4af9e69SDag-Erling Smørgrav 	struct global_confirm *gc;
528d4af9e69SDag-Erling Smørgrav 
529d4af9e69SDag-Erling Smørgrav 	if ((gc = TAILQ_FIRST(&global_confirms)) == NULL)
530d4af9e69SDag-Erling Smørgrav 		return;
531d4af9e69SDag-Erling Smørgrav 	if (gc->cb != NULL)
532d4af9e69SDag-Erling Smørgrav 		gc->cb(type, seq, gc->ctx);
533d4af9e69SDag-Erling Smørgrav 	if (--gc->ref_count <= 0) {
534d4af9e69SDag-Erling Smørgrav 		TAILQ_REMOVE(&global_confirms, gc, entry);
535d4af9e69SDag-Erling Smørgrav 		bzero(gc, sizeof(*gc));
536d4af9e69SDag-Erling Smørgrav 		xfree(gc);
537d4af9e69SDag-Erling Smørgrav 	}
538d4af9e69SDag-Erling Smørgrav 
5397aee6ffeSDag-Erling Smørgrav 	packet_set_alive_timeouts(0);
540efcad6b7SDag-Erling Smørgrav }
541efcad6b7SDag-Erling Smørgrav 
542efcad6b7SDag-Erling Smørgrav static void
543efcad6b7SDag-Erling Smørgrav server_alive_check(void)
544efcad6b7SDag-Erling Smørgrav {
5457aee6ffeSDag-Erling Smørgrav 	if (packet_inc_alive_timeouts() > options.server_alive_count_max) {
5464a421b63SDag-Erling Smørgrav 		logit("Timeout, server %s not responding.", host);
54792eb0aa1SDag-Erling Smørgrav 		cleanup_exit(255);
54892eb0aa1SDag-Erling Smørgrav 	}
549efcad6b7SDag-Erling Smørgrav 	packet_start(SSH2_MSG_GLOBAL_REQUEST);
550efcad6b7SDag-Erling Smørgrav 	packet_put_cstring("keepalive@openssh.com");
551efcad6b7SDag-Erling Smørgrav 	packet_put_char(1);     /* boolean: want reply */
552efcad6b7SDag-Erling Smørgrav 	packet_send();
553d4af9e69SDag-Erling Smørgrav 	/* Insert an empty placeholder to maintain ordering */
554d4af9e69SDag-Erling Smørgrav 	client_register_global_confirm(NULL, NULL);
555efcad6b7SDag-Erling Smørgrav }
556efcad6b7SDag-Erling Smørgrav 
557511b41d2SMark Murray /*
558511b41d2SMark Murray  * Waits until the client can do something (some data becomes available on
559511b41d2SMark Murray  * one of the file descriptors).
560511b41d2SMark Murray  */
561ae1f160dSDag-Erling Smørgrav static void
5621e8db6e2SBrian Feldman client_wait_until_can_do_something(fd_set **readsetp, fd_set **writesetp,
563d74d50a8SDag-Erling Smørgrav     int *maxfdp, u_int *nallocp, int rekeying)
564511b41d2SMark Murray {
565efcad6b7SDag-Erling Smørgrav 	struct timeval tv, *tvp;
566e2f6069cSDag-Erling Smørgrav 	int timeout_secs;
567efcad6b7SDag-Erling Smørgrav 	int ret;
568efcad6b7SDag-Erling Smørgrav 
5691e8db6e2SBrian Feldman 	/* Add any selections by the channel mechanism. */
570ae1f160dSDag-Erling Smørgrav 	channel_prepare_select(readsetp, writesetp, maxfdp, nallocp, rekeying);
571511b41d2SMark Murray 
572a04a10f8SKris Kennaway 	if (!compat20) {
573511b41d2SMark Murray 		/* Read from the connection, unless our buffers are full. */
574511b41d2SMark Murray 		if (buffer_len(&stdout_buffer) < buffer_high &&
575511b41d2SMark Murray 		    buffer_len(&stderr_buffer) < buffer_high &&
576511b41d2SMark Murray 		    channel_not_very_much_buffered_data())
5771e8db6e2SBrian Feldman 			FD_SET(connection_in, *readsetp);
578511b41d2SMark Murray 		/*
579511b41d2SMark Murray 		 * Read from stdin, unless we have seen EOF or have very much
580511b41d2SMark Murray 		 * buffered data to send to the server.
581511b41d2SMark Murray 		 */
582511b41d2SMark Murray 		if (!stdin_eof && packet_not_very_much_data_to_write())
5831e8db6e2SBrian Feldman 			FD_SET(fileno(stdin), *readsetp);
584511b41d2SMark Murray 
585a04a10f8SKris Kennaway 		/* Select stdout/stderr if have data in buffer. */
586a04a10f8SKris Kennaway 		if (buffer_len(&stdout_buffer) > 0)
5871e8db6e2SBrian Feldman 			FD_SET(fileno(stdout), *writesetp);
588a04a10f8SKris Kennaway 		if (buffer_len(&stderr_buffer) > 0)
5891e8db6e2SBrian Feldman 			FD_SET(fileno(stderr), *writesetp);
590a04a10f8SKris Kennaway 	} else {
591ae1f160dSDag-Erling Smørgrav 		/* channel_prepare_select could have closed the last channel */
592ae1f160dSDag-Erling Smørgrav 		if (session_closed && !channel_still_open() &&
593ae1f160dSDag-Erling Smørgrav 		    !packet_have_data_to_write()) {
594ae1f160dSDag-Erling Smørgrav 			/* clear mask since we did not call select() */
595ae1f160dSDag-Erling Smørgrav 			memset(*readsetp, 0, *nallocp);
596ae1f160dSDag-Erling Smørgrav 			memset(*writesetp, 0, *nallocp);
597ae1f160dSDag-Erling Smørgrav 			return;
598ae1f160dSDag-Erling Smørgrav 		} else {
5991e8db6e2SBrian Feldman 			FD_SET(connection_in, *readsetp);
600a04a10f8SKris Kennaway 		}
601ae1f160dSDag-Erling Smørgrav 	}
602511b41d2SMark Murray 
603511b41d2SMark Murray 	/* Select server connection if have data to write to the server. */
604511b41d2SMark Murray 	if (packet_have_data_to_write())
6051e8db6e2SBrian Feldman 		FD_SET(connection_out, *writesetp);
606511b41d2SMark Murray 
607511b41d2SMark Murray 	/*
608511b41d2SMark Murray 	 * Wait for something to happen.  This will suspend the process until
609511b41d2SMark Murray 	 * some selected descriptor can be read, written, or has some other
610e2f6069cSDag-Erling Smørgrav 	 * event pending, or a timeout expires.
611511b41d2SMark Murray 	 */
612511b41d2SMark Murray 
613e2f6069cSDag-Erling Smørgrav 	timeout_secs = INT_MAX; /* we use INT_MAX to mean no timeout */
614e2f6069cSDag-Erling Smørgrav 	if (options.server_alive_interval > 0 && compat20)
615e2f6069cSDag-Erling Smørgrav 		timeout_secs = options.server_alive_interval;
616e2f6069cSDag-Erling Smørgrav 	set_control_persist_exit_time();
617e2f6069cSDag-Erling Smørgrav 	if (control_persist_exit_time > 0) {
618e2f6069cSDag-Erling Smørgrav 		timeout_secs = MIN(timeout_secs,
619e2f6069cSDag-Erling Smørgrav 			control_persist_exit_time - time(NULL));
620e2f6069cSDag-Erling Smørgrav 		if (timeout_secs < 0)
621e2f6069cSDag-Erling Smørgrav 			timeout_secs = 0;
622e2f6069cSDag-Erling Smørgrav 	}
623e2f6069cSDag-Erling Smørgrav 	if (timeout_secs == INT_MAX)
624efcad6b7SDag-Erling Smørgrav 		tvp = NULL;
625efcad6b7SDag-Erling Smørgrav 	else {
626e2f6069cSDag-Erling Smørgrav 		tv.tv_sec = timeout_secs;
627efcad6b7SDag-Erling Smørgrav 		tv.tv_usec = 0;
628efcad6b7SDag-Erling Smørgrav 		tvp = &tv;
629efcad6b7SDag-Erling Smørgrav 	}
630e2f6069cSDag-Erling Smørgrav 
631efcad6b7SDag-Erling Smørgrav 	ret = select((*maxfdp)+1, *readsetp, *writesetp, NULL, tvp);
632efcad6b7SDag-Erling Smørgrav 	if (ret < 0) {
633511b41d2SMark Murray 		char buf[100];
6341e8db6e2SBrian Feldman 
6351e8db6e2SBrian Feldman 		/*
6361e8db6e2SBrian Feldman 		 * We have to clear the select masks, because we return.
6371e8db6e2SBrian Feldman 		 * We have to return, because the mainloop checks for the flags
6381e8db6e2SBrian Feldman 		 * set by the signal handlers.
6391e8db6e2SBrian Feldman 		 */
640ae1f160dSDag-Erling Smørgrav 		memset(*readsetp, 0, *nallocp);
641ae1f160dSDag-Erling Smørgrav 		memset(*writesetp, 0, *nallocp);
6421e8db6e2SBrian Feldman 
643511b41d2SMark Murray 		if (errno == EINTR)
644511b41d2SMark Murray 			return;
645511b41d2SMark Murray 		/* Note: we might still have data in the buffers. */
646511b41d2SMark Murray 		snprintf(buf, sizeof buf, "select: %s\r\n", strerror(errno));
647511b41d2SMark Murray 		buffer_append(&stderr_buffer, buf, strlen(buf));
648511b41d2SMark Murray 		quit_pending = 1;
649efcad6b7SDag-Erling Smørgrav 	} else if (ret == 0)
650efcad6b7SDag-Erling Smørgrav 		server_alive_check();
651511b41d2SMark Murray }
652511b41d2SMark Murray 
653ae1f160dSDag-Erling Smørgrav static void
654b66f2d16SKris Kennaway client_suspend_self(Buffer *bin, Buffer *bout, Buffer *berr)
655511b41d2SMark Murray {
656511b41d2SMark Murray 	/* Flush stdout and stderr buffers. */
657b66f2d16SKris Kennaway 	if (buffer_len(bout) > 0)
658d4af9e69SDag-Erling Smørgrav 		atomicio(vwrite, fileno(stdout), buffer_ptr(bout),
659d4af9e69SDag-Erling Smørgrav 		    buffer_len(bout));
660b66f2d16SKris Kennaway 	if (buffer_len(berr) > 0)
661d4af9e69SDag-Erling Smørgrav 		atomicio(vwrite, fileno(stderr), buffer_ptr(berr),
662d4af9e69SDag-Erling Smørgrav 		    buffer_len(berr));
663511b41d2SMark Murray 
664*e146993eSDag-Erling Smørgrav 	leave_raw_mode(options.request_tty == REQUEST_TTY_FORCE);
665511b41d2SMark Murray 
666511b41d2SMark Murray 	/*
667511b41d2SMark Murray 	 * Free (and clear) the buffer to reduce the amount of data that gets
668511b41d2SMark Murray 	 * written to swap.
669511b41d2SMark Murray 	 */
670b66f2d16SKris Kennaway 	buffer_free(bin);
671b66f2d16SKris Kennaway 	buffer_free(bout);
672b66f2d16SKris Kennaway 	buffer_free(berr);
673511b41d2SMark Murray 
674511b41d2SMark Murray 	/* Send the suspend signal to the program itself. */
675511b41d2SMark Murray 	kill(getpid(), SIGTSTP);
676511b41d2SMark Murray 
6775e8dbd04SDag-Erling Smørgrav 	/* Reset window sizes in case they have changed */
678511b41d2SMark Murray 	received_window_change_signal = 1;
679511b41d2SMark Murray 
680511b41d2SMark Murray 	/* OK, we have been continued by the user. Reinitialize buffers. */
681b66f2d16SKris Kennaway 	buffer_init(bin);
682b66f2d16SKris Kennaway 	buffer_init(bout);
683b66f2d16SKris Kennaway 	buffer_init(berr);
684511b41d2SMark Murray 
685*e146993eSDag-Erling Smørgrav 	enter_raw_mode(options.request_tty == REQUEST_TTY_FORCE);
686511b41d2SMark Murray }
687511b41d2SMark Murray 
688ae1f160dSDag-Erling Smørgrav static void
689a04a10f8SKris Kennaway client_process_net_input(fd_set *readset)
690511b41d2SMark Murray {
6917aee6ffeSDag-Erling Smørgrav 	int len, cont = 0;
6927aee6ffeSDag-Erling Smørgrav 	char buf[SSH_IOBUFSZ];
693511b41d2SMark Murray 
694511b41d2SMark Murray 	/*
695511b41d2SMark Murray 	 * Read input from the server, and add any such data to the buffer of
696511b41d2SMark Murray 	 * the packet subsystem.
697511b41d2SMark Murray 	 */
698511b41d2SMark Murray 	if (FD_ISSET(connection_in, readset)) {
699511b41d2SMark Murray 		/* Read as much as possible. */
7007aee6ffeSDag-Erling Smørgrav 		len = roaming_read(connection_in, buf, sizeof(buf), &cont);
7017aee6ffeSDag-Erling Smørgrav 		if (len == 0 && cont == 0) {
702d4af9e69SDag-Erling Smørgrav 			/*
703d4af9e69SDag-Erling Smørgrav 			 * Received EOF.  The remote host has closed the
704d4af9e69SDag-Erling Smørgrav 			 * connection.
705d4af9e69SDag-Erling Smørgrav 			 */
706d4af9e69SDag-Erling Smørgrav 			snprintf(buf, sizeof buf,
707d4af9e69SDag-Erling Smørgrav 			    "Connection to %.300s closed by remote host.\r\n",
708511b41d2SMark Murray 			    host);
709511b41d2SMark Murray 			buffer_append(&stderr_buffer, buf, strlen(buf));
710511b41d2SMark Murray 			quit_pending = 1;
711511b41d2SMark Murray 			return;
712511b41d2SMark Murray 		}
713511b41d2SMark Murray 		/*
714511b41d2SMark Murray 		 * There is a kernel bug on Solaris that causes select to
715511b41d2SMark Murray 		 * sometimes wake up even though there is no data available.
716511b41d2SMark Murray 		 */
717d4af9e69SDag-Erling Smørgrav 		if (len < 0 &&
718d4af9e69SDag-Erling Smørgrav 		    (errno == EAGAIN || errno == EINTR || errno == EWOULDBLOCK))
719511b41d2SMark Murray 			len = 0;
720511b41d2SMark Murray 
721511b41d2SMark Murray 		if (len < 0) {
722d4af9e69SDag-Erling Smørgrav 			/*
723d4af9e69SDag-Erling Smørgrav 			 * An error has encountered.  Perhaps there is a
724d4af9e69SDag-Erling Smørgrav 			 * network problem.
725d4af9e69SDag-Erling Smørgrav 			 */
726d4af9e69SDag-Erling Smørgrav 			snprintf(buf, sizeof buf,
727d4af9e69SDag-Erling Smørgrav 			    "Read from remote host %.300s: %.100s\r\n",
728511b41d2SMark Murray 			    host, strerror(errno));
729511b41d2SMark Murray 			buffer_append(&stderr_buffer, buf, strlen(buf));
730511b41d2SMark Murray 			quit_pending = 1;
731511b41d2SMark Murray 			return;
732511b41d2SMark Murray 		}
733511b41d2SMark Murray 		packet_process_incoming(buf, len);
734511b41d2SMark Murray 	}
735a04a10f8SKris Kennaway }
736a04a10f8SKris Kennaway 
737545d5ecaSDag-Erling Smørgrav static void
738d4af9e69SDag-Erling Smørgrav client_status_confirm(int type, Channel *c, void *ctx)
739d74d50a8SDag-Erling Smørgrav {
740d4af9e69SDag-Erling Smørgrav 	struct channel_reply_ctx *cr = (struct channel_reply_ctx *)ctx;
741d4af9e69SDag-Erling Smørgrav 	char errmsg[256];
742d4af9e69SDag-Erling Smørgrav 	int tochan;
743d74d50a8SDag-Erling Smørgrav 
744*e146993eSDag-Erling Smørgrav 	/*
745*e146993eSDag-Erling Smørgrav 	 * If a TTY was explicitly requested, then a failure to allocate
746*e146993eSDag-Erling Smørgrav 	 * one is fatal.
747*e146993eSDag-Erling Smørgrav 	 */
748*e146993eSDag-Erling Smørgrav 	if (cr->action == CONFIRM_TTY &&
749*e146993eSDag-Erling Smørgrav 	    (options.request_tty == REQUEST_TTY_FORCE ||
750*e146993eSDag-Erling Smørgrav 	    options.request_tty == REQUEST_TTY_YES))
751*e146993eSDag-Erling Smørgrav 		cr->action = CONFIRM_CLOSE;
752*e146993eSDag-Erling Smørgrav 
753d4af9e69SDag-Erling Smørgrav 	/* XXX supress on mux _client_ quietmode */
754d4af9e69SDag-Erling Smørgrav 	tochan = options.log_level >= SYSLOG_LEVEL_ERROR &&
755b15c8340SDag-Erling Smørgrav 	    c->ctl_chan != -1 && c->extended_usage == CHAN_EXTENDED_WRITE;
756d74d50a8SDag-Erling Smørgrav 
757d4af9e69SDag-Erling Smørgrav 	if (type == SSH2_MSG_CHANNEL_SUCCESS) {
758d4af9e69SDag-Erling Smørgrav 		debug2("%s request accepted on channel %d",
759d4af9e69SDag-Erling Smørgrav 		    cr->request_type, c->self);
760d4af9e69SDag-Erling Smørgrav 	} else if (type == SSH2_MSG_CHANNEL_FAILURE) {
761d4af9e69SDag-Erling Smørgrav 		if (tochan) {
762d4af9e69SDag-Erling Smørgrav 			snprintf(errmsg, sizeof(errmsg),
763d4af9e69SDag-Erling Smørgrav 			    "%s request failed\r\n", cr->request_type);
764d4af9e69SDag-Erling Smørgrav 		} else {
765d4af9e69SDag-Erling Smørgrav 			snprintf(errmsg, sizeof(errmsg),
766d4af9e69SDag-Erling Smørgrav 			    "%s request failed on channel %d",
767d4af9e69SDag-Erling Smørgrav 			    cr->request_type, c->self);
768d74d50a8SDag-Erling Smørgrav 		}
769d4af9e69SDag-Erling Smørgrav 		/* If error occurred on primary session channel, then exit */
770*e146993eSDag-Erling Smørgrav 		if (cr->action == CONFIRM_CLOSE && c->self == session_ident)
771d4af9e69SDag-Erling Smørgrav 			fatal("%s", errmsg);
772*e146993eSDag-Erling Smørgrav 		/*
773*e146993eSDag-Erling Smørgrav 		 * If error occurred on mux client, append to
774*e146993eSDag-Erling Smørgrav 		 * their stderr.
775*e146993eSDag-Erling Smørgrav 		 */
776*e146993eSDag-Erling Smørgrav 		if (tochan) {
777*e146993eSDag-Erling Smørgrav 			buffer_append(&c->extended, errmsg,
778*e146993eSDag-Erling Smørgrav 			    strlen(errmsg));
779*e146993eSDag-Erling Smørgrav 		} else
780d4af9e69SDag-Erling Smørgrav 			error("%s", errmsg);
781*e146993eSDag-Erling Smørgrav 		if (cr->action == CONFIRM_TTY) {
782*e146993eSDag-Erling Smørgrav 			/*
783*e146993eSDag-Erling Smørgrav 			 * If a TTY allocation error occurred, then arrange
784*e146993eSDag-Erling Smørgrav 			 * for the correct TTY to leave raw mode.
785*e146993eSDag-Erling Smørgrav 			 */
786*e146993eSDag-Erling Smørgrav 			if (c->self == session_ident)
787*e146993eSDag-Erling Smørgrav 				leave_raw_mode(0);
788*e146993eSDag-Erling Smørgrav 			else
789*e146993eSDag-Erling Smørgrav 				mux_tty_alloc_failed(c);
790*e146993eSDag-Erling Smørgrav 		} else if (cr->action == CONFIRM_CLOSE) {
791d4af9e69SDag-Erling Smørgrav 			chan_read_failed(c);
792d4af9e69SDag-Erling Smørgrav 			chan_write_failed(c);
793d74d50a8SDag-Erling Smørgrav 		}
794d74d50a8SDag-Erling Smørgrav 	}
795d4af9e69SDag-Erling Smørgrav 	xfree(cr);
796d4af9e69SDag-Erling Smørgrav }
797d74d50a8SDag-Erling Smørgrav 
798d74d50a8SDag-Erling Smørgrav static void
799d4af9e69SDag-Erling Smørgrav client_abandon_status_confirm(Channel *c, void *ctx)
800d74d50a8SDag-Erling Smørgrav {
801d4af9e69SDag-Erling Smørgrav 	xfree(ctx);
802d74d50a8SDag-Erling Smørgrav }
803d74d50a8SDag-Erling Smørgrav 
804*e146993eSDag-Erling Smørgrav void
805*e146993eSDag-Erling Smørgrav client_expect_confirm(int id, const char *request,
806*e146993eSDag-Erling Smørgrav     enum confirm_action action)
807d74d50a8SDag-Erling Smørgrav {
808d4af9e69SDag-Erling Smørgrav 	struct channel_reply_ctx *cr = xmalloc(sizeof(*cr));
809d74d50a8SDag-Erling Smørgrav 
810d4af9e69SDag-Erling Smørgrav 	cr->request_type = request;
811*e146993eSDag-Erling Smørgrav 	cr->action = action;
812d74d50a8SDag-Erling Smørgrav 
813d4af9e69SDag-Erling Smørgrav 	channel_register_status_confirm(id, client_status_confirm,
814d4af9e69SDag-Erling Smørgrav 	    client_abandon_status_confirm, cr);
815d4af9e69SDag-Erling Smørgrav }
816d4af9e69SDag-Erling Smørgrav 
817d4af9e69SDag-Erling Smørgrav void
818d4af9e69SDag-Erling Smørgrav client_register_global_confirm(global_confirm_cb *cb, void *ctx)
819d4af9e69SDag-Erling Smørgrav {
820d4af9e69SDag-Erling Smørgrav 	struct global_confirm *gc, *last_gc;
821d4af9e69SDag-Erling Smørgrav 
822d4af9e69SDag-Erling Smørgrav 	/* Coalesce identical callbacks */
823d4af9e69SDag-Erling Smørgrav 	last_gc = TAILQ_LAST(&global_confirms, global_confirms);
824d4af9e69SDag-Erling Smørgrav 	if (last_gc && last_gc->cb == cb && last_gc->ctx == ctx) {
825d4af9e69SDag-Erling Smørgrav 		if (++last_gc->ref_count >= INT_MAX)
826d4af9e69SDag-Erling Smørgrav 			fatal("%s: last_gc->ref_count = %d",
827d4af9e69SDag-Erling Smørgrav 			    __func__, last_gc->ref_count);
828d74d50a8SDag-Erling Smørgrav 		return;
829d74d50a8SDag-Erling Smørgrav 	}
830d74d50a8SDag-Erling Smørgrav 
831d4af9e69SDag-Erling Smørgrav 	gc = xmalloc(sizeof(*gc));
832d4af9e69SDag-Erling Smørgrav 	gc->cb = cb;
833d4af9e69SDag-Erling Smørgrav 	gc->ctx = ctx;
834d4af9e69SDag-Erling Smørgrav 	gc->ref_count = 1;
835d4af9e69SDag-Erling Smørgrav 	TAILQ_INSERT_TAIL(&global_confirms, gc, entry);
836d74d50a8SDag-Erling Smørgrav }
837d74d50a8SDag-Erling Smørgrav 
838d74d50a8SDag-Erling Smørgrav static void
839545d5ecaSDag-Erling Smørgrav process_cmdline(void)
840545d5ecaSDag-Erling Smørgrav {
841545d5ecaSDag-Erling Smørgrav 	void (*handler)(int);
8425e8dbd04SDag-Erling Smørgrav 	char *s, *cmd, *cancel_host;
843d74d50a8SDag-Erling Smørgrav 	int delete = 0;
844cce7d346SDag-Erling Smørgrav 	int local = 0, remote = 0, dynamic = 0;
845cce7d346SDag-Erling Smørgrav 	int cancel_port;
8465e8dbd04SDag-Erling Smørgrav 	Forward fwd;
847545d5ecaSDag-Erling Smørgrav 
848d4af9e69SDag-Erling Smørgrav 	bzero(&fwd, sizeof(fwd));
849d4af9e69SDag-Erling Smørgrav 	fwd.listen_host = fwd.connect_host = NULL;
850d4af9e69SDag-Erling Smørgrav 
851*e146993eSDag-Erling Smørgrav 	leave_raw_mode(options.request_tty == REQUEST_TTY_FORCE);
852545d5ecaSDag-Erling Smørgrav 	handler = signal(SIGINT, SIG_IGN);
853545d5ecaSDag-Erling Smørgrav 	cmd = s = read_passphrase("\r\nssh> ", RP_ECHO);
854545d5ecaSDag-Erling Smørgrav 	if (s == NULL)
855545d5ecaSDag-Erling Smørgrav 		goto out;
856d4af9e69SDag-Erling Smørgrav 	while (isspace(*s))
857545d5ecaSDag-Erling Smørgrav 		s++;
858d74d50a8SDag-Erling Smørgrav 	if (*s == '-')
859d74d50a8SDag-Erling Smørgrav 		s++;	/* Skip cmdline '-', if any */
860d74d50a8SDag-Erling Smørgrav 	if (*s == '\0')
861545d5ecaSDag-Erling Smørgrav 		goto out;
862d74d50a8SDag-Erling Smørgrav 
863d74d50a8SDag-Erling Smørgrav 	if (*s == 'h' || *s == 'H' || *s == '?') {
864d74d50a8SDag-Erling Smørgrav 		logit("Commands:");
865761efaa7SDag-Erling Smørgrav 		logit("      -L[bind_address:]port:host:hostport    "
866761efaa7SDag-Erling Smørgrav 		    "Request local forward");
867761efaa7SDag-Erling Smørgrav 		logit("      -R[bind_address:]port:host:hostport    "
868761efaa7SDag-Erling Smørgrav 		    "Request remote forward");
869cce7d346SDag-Erling Smørgrav 		logit("      -D[bind_address:]port                  "
870cce7d346SDag-Erling Smørgrav 		    "Request dynamic forward");
871761efaa7SDag-Erling Smørgrav 		logit("      -KR[bind_address:]port                 "
872761efaa7SDag-Erling Smørgrav 		    "Cancel remote forward");
873021d409fSDag-Erling Smørgrav 		if (!options.permit_local_command)
874021d409fSDag-Erling Smørgrav 			goto out;
875761efaa7SDag-Erling Smørgrav 		logit("      !args                                  "
876761efaa7SDag-Erling Smørgrav 		    "Execute local command");
877021d409fSDag-Erling Smørgrav 		goto out;
878021d409fSDag-Erling Smørgrav 	}
879021d409fSDag-Erling Smørgrav 
880021d409fSDag-Erling Smørgrav 	if (*s == '!' && options.permit_local_command) {
881021d409fSDag-Erling Smørgrav 		s++;
882021d409fSDag-Erling Smørgrav 		ssh_local_cmd(s);
883d74d50a8SDag-Erling Smørgrav 		goto out;
884d74d50a8SDag-Erling Smørgrav 	}
885d74d50a8SDag-Erling Smørgrav 
886d74d50a8SDag-Erling Smørgrav 	if (*s == 'K') {
887d74d50a8SDag-Erling Smørgrav 		delete = 1;
888d74d50a8SDag-Erling Smørgrav 		s++;
889d74d50a8SDag-Erling Smørgrav 	}
890cce7d346SDag-Erling Smørgrav 	if (*s == 'L')
891cce7d346SDag-Erling Smørgrav 		local = 1;
892cce7d346SDag-Erling Smørgrav 	else if (*s == 'R')
893cce7d346SDag-Erling Smørgrav 		remote = 1;
894cce7d346SDag-Erling Smørgrav 	else if (*s == 'D')
895cce7d346SDag-Erling Smørgrav 		dynamic = 1;
896cce7d346SDag-Erling Smørgrav 	else {
897d95e11bfSDag-Erling Smørgrav 		logit("Invalid command.");
898545d5ecaSDag-Erling Smørgrav 		goto out;
899545d5ecaSDag-Erling Smørgrav 	}
900cce7d346SDag-Erling Smørgrav 
901cce7d346SDag-Erling Smørgrav 	if ((local || dynamic) && delete) {
902d74d50a8SDag-Erling Smørgrav 		logit("Not supported.");
903d74d50a8SDag-Erling Smørgrav 		goto out;
904d74d50a8SDag-Erling Smørgrav 	}
905cce7d346SDag-Erling Smørgrav 	if (remote && delete && !compat20) {
906d95e11bfSDag-Erling Smørgrav 		logit("Not supported for SSH protocol version 1.");
907545d5ecaSDag-Erling Smørgrav 		goto out;
908545d5ecaSDag-Erling Smørgrav 	}
909d74d50a8SDag-Erling Smørgrav 
910d4af9e69SDag-Erling Smørgrav 	while (isspace(*++s))
911d4af9e69SDag-Erling Smørgrav 		;
912545d5ecaSDag-Erling Smørgrav 
913b15c8340SDag-Erling Smørgrav 	/* XXX update list of forwards in options */
914d74d50a8SDag-Erling Smørgrav 	if (delete) {
9155e8dbd04SDag-Erling Smørgrav 		cancel_port = 0;
9165e8dbd04SDag-Erling Smørgrav 		cancel_host = hpdelim(&s);	/* may be NULL */
9175e8dbd04SDag-Erling Smørgrav 		if (s != NULL) {
9185e8dbd04SDag-Erling Smørgrav 			cancel_port = a2port(s);
9195e8dbd04SDag-Erling Smørgrav 			cancel_host = cleanhostname(cancel_host);
920d74d50a8SDag-Erling Smørgrav 		} else {
9215e8dbd04SDag-Erling Smørgrav 			cancel_port = a2port(cancel_host);
9225e8dbd04SDag-Erling Smørgrav 			cancel_host = NULL;
9235e8dbd04SDag-Erling Smørgrav 		}
924cce7d346SDag-Erling Smørgrav 		if (cancel_port <= 0) {
9255e8dbd04SDag-Erling Smørgrav 			logit("Bad forwarding close port");
926545d5ecaSDag-Erling Smørgrav 			goto out;
927545d5ecaSDag-Erling Smørgrav 		}
9285e8dbd04SDag-Erling Smørgrav 		channel_request_rforward_cancel(cancel_host, cancel_port);
9295e8dbd04SDag-Erling Smørgrav 	} else {
930cce7d346SDag-Erling Smørgrav 		if (!parse_forward(&fwd, s, dynamic, remote)) {
9315e8dbd04SDag-Erling Smørgrav 			logit("Bad forwarding specification.");
932545d5ecaSDag-Erling Smørgrav 			goto out;
933545d5ecaSDag-Erling Smørgrav 		}
934cce7d346SDag-Erling Smørgrav 		if (local || dynamic) {
9355e8dbd04SDag-Erling Smørgrav 			if (channel_setup_local_fwd_listener(fwd.listen_host,
9365e8dbd04SDag-Erling Smørgrav 			    fwd.listen_port, fwd.connect_host,
9375e8dbd04SDag-Erling Smørgrav 			    fwd.connect_port, options.gateway_ports) < 0) {
938d95e11bfSDag-Erling Smørgrav 				logit("Port forwarding failed.");
939545d5ecaSDag-Erling Smørgrav 				goto out;
940545d5ecaSDag-Erling Smørgrav 			}
9415e8dbd04SDag-Erling Smørgrav 		} else {
942761efaa7SDag-Erling Smørgrav 			if (channel_request_remote_forwarding(fwd.listen_host,
9435e8dbd04SDag-Erling Smørgrav 			    fwd.listen_port, fwd.connect_host,
944761efaa7SDag-Erling Smørgrav 			    fwd.connect_port) < 0) {
945761efaa7SDag-Erling Smørgrav 				logit("Port forwarding failed.");
946761efaa7SDag-Erling Smørgrav 				goto out;
947761efaa7SDag-Erling Smørgrav 			}
9485e8dbd04SDag-Erling Smørgrav 		}
9495e8dbd04SDag-Erling Smørgrav 
950d95e11bfSDag-Erling Smørgrav 		logit("Forwarding port.");
951d74d50a8SDag-Erling Smørgrav 	}
952d74d50a8SDag-Erling Smørgrav 
953545d5ecaSDag-Erling Smørgrav out:
954545d5ecaSDag-Erling Smørgrav 	signal(SIGINT, handler);
955*e146993eSDag-Erling Smørgrav 	enter_raw_mode(options.request_tty == REQUEST_TTY_FORCE);
956545d5ecaSDag-Erling Smørgrav 	if (cmd)
957545d5ecaSDag-Erling Smørgrav 		xfree(cmd);
958d4af9e69SDag-Erling Smørgrav 	if (fwd.listen_host != NULL)
959d4af9e69SDag-Erling Smørgrav 		xfree(fwd.listen_host);
960d4af9e69SDag-Erling Smørgrav 	if (fwd.connect_host != NULL)
961d4af9e69SDag-Erling Smørgrav 		xfree(fwd.connect_host);
962545d5ecaSDag-Erling Smørgrav }
963545d5ecaSDag-Erling Smørgrav 
964d4af9e69SDag-Erling Smørgrav /*
965d4af9e69SDag-Erling Smørgrav  * Process the characters one by one, call with c==NULL for proto1 case.
966d4af9e69SDag-Erling Smørgrav  */
967ae1f160dSDag-Erling Smørgrav static int
968d4af9e69SDag-Erling Smørgrav process_escapes(Channel *c, Buffer *bin, Buffer *bout, Buffer *berr,
969d4af9e69SDag-Erling Smørgrav     char *buf, int len)
970b66f2d16SKris Kennaway {
971b66f2d16SKris Kennaway 	char string[1024];
972b66f2d16SKris Kennaway 	pid_t pid;
973b66f2d16SKris Kennaway 	int bytes = 0;
9741e8db6e2SBrian Feldman 	u_int i;
9751e8db6e2SBrian Feldman 	u_char ch;
976b66f2d16SKris Kennaway 	char *s;
977d4af9e69SDag-Erling Smørgrav 	int *escape_pendingp, escape_char;
978d4af9e69SDag-Erling Smørgrav 	struct escape_filter_ctx *efc;
979d4af9e69SDag-Erling Smørgrav 
980d4af9e69SDag-Erling Smørgrav 	if (c == NULL) {
981d4af9e69SDag-Erling Smørgrav 		escape_pendingp = &escape_pending1;
982d4af9e69SDag-Erling Smørgrav 		escape_char = escape_char1;
983d4af9e69SDag-Erling Smørgrav 	} else {
984d4af9e69SDag-Erling Smørgrav 		if (c->filter_ctx == NULL)
985d4af9e69SDag-Erling Smørgrav 			return 0;
986d4af9e69SDag-Erling Smørgrav 		efc = (struct escape_filter_ctx *)c->filter_ctx;
987d4af9e69SDag-Erling Smørgrav 		escape_pendingp = &efc->escape_pending;
988d4af9e69SDag-Erling Smørgrav 		escape_char = efc->escape_char;
989d4af9e69SDag-Erling Smørgrav 	}
990b66f2d16SKris Kennaway 
991043840dfSDag-Erling Smørgrav 	if (len <= 0)
992043840dfSDag-Erling Smørgrav 		return (0);
993043840dfSDag-Erling Smørgrav 
994043840dfSDag-Erling Smørgrav 	for (i = 0; i < (u_int)len; i++) {
995b66f2d16SKris Kennaway 		/* Get one character at a time. */
996b66f2d16SKris Kennaway 		ch = buf[i];
997b66f2d16SKris Kennaway 
998d4af9e69SDag-Erling Smørgrav 		if (*escape_pendingp) {
999b66f2d16SKris Kennaway 			/* We have previously seen an escape character. */
1000b66f2d16SKris Kennaway 			/* Clear the flag now. */
1001d4af9e69SDag-Erling Smørgrav 			*escape_pendingp = 0;
1002b66f2d16SKris Kennaway 
1003b66f2d16SKris Kennaway 			/* Process the escaped character. */
1004b66f2d16SKris Kennaway 			switch (ch) {
1005b66f2d16SKris Kennaway 			case '.':
1006b66f2d16SKris Kennaway 				/* Terminate the connection. */
1007d4af9e69SDag-Erling Smørgrav 				snprintf(string, sizeof string, "%c.\r\n",
1008d4af9e69SDag-Erling Smørgrav 				    escape_char);
1009b66f2d16SKris Kennaway 				buffer_append(berr, string, strlen(string));
1010b66f2d16SKris Kennaway 
1011b15c8340SDag-Erling Smørgrav 				if (c && c->ctl_chan != -1) {
1012d4af9e69SDag-Erling Smørgrav 					chan_read_failed(c);
1013d4af9e69SDag-Erling Smørgrav 					chan_write_failed(c);
1014d4af9e69SDag-Erling Smørgrav 					return 0;
1015d4af9e69SDag-Erling Smørgrav 				} else
1016b66f2d16SKris Kennaway 					quit_pending = 1;
1017b66f2d16SKris Kennaway 				return -1;
1018b66f2d16SKris Kennaway 
1019b66f2d16SKris Kennaway 			case 'Z' - 64:
1020d4af9e69SDag-Erling Smørgrav 				/* XXX support this for mux clients */
1021b15c8340SDag-Erling Smørgrav 				if (c && c->ctl_chan != -1) {
1022d4af9e69SDag-Erling Smørgrav  noescape:
1023d4af9e69SDag-Erling Smørgrav 					snprintf(string, sizeof string,
1024d4af9e69SDag-Erling Smørgrav 					    "%c%c escape not available to "
1025d4af9e69SDag-Erling Smørgrav 					    "multiplexed sessions\r\n",
1026d4af9e69SDag-Erling Smørgrav 					    escape_char, ch);
1027d4af9e69SDag-Erling Smørgrav 					buffer_append(berr, string,
1028d4af9e69SDag-Erling Smørgrav 					    strlen(string));
1029d4af9e69SDag-Erling Smørgrav 					continue;
1030d4af9e69SDag-Erling Smørgrav 				}
1031d4af9e69SDag-Erling Smørgrav 				/* Suspend the program. Inform the user */
1032d4af9e69SDag-Erling Smørgrav 				snprintf(string, sizeof string,
1033d4af9e69SDag-Erling Smørgrav 				    "%c^Z [suspend ssh]\r\n", escape_char);
1034b66f2d16SKris Kennaway 				buffer_append(berr, string, strlen(string));
1035b66f2d16SKris Kennaway 
1036b66f2d16SKris Kennaway 				/* Restore terminal modes and suspend. */
1037b66f2d16SKris Kennaway 				client_suspend_self(bin, bout, berr);
1038b66f2d16SKris Kennaway 
1039b66f2d16SKris Kennaway 				/* We have been continued. */
1040b66f2d16SKris Kennaway 				continue;
1041b66f2d16SKris Kennaway 
1042d95e11bfSDag-Erling Smørgrav 			case 'B':
1043d95e11bfSDag-Erling Smørgrav 				if (compat20) {
1044d95e11bfSDag-Erling Smørgrav 					snprintf(string, sizeof string,
1045d95e11bfSDag-Erling Smørgrav 					    "%cB\r\n", escape_char);
1046d95e11bfSDag-Erling Smørgrav 					buffer_append(berr, string,
1047d95e11bfSDag-Erling Smørgrav 					    strlen(string));
1048d95e11bfSDag-Erling Smørgrav 					channel_request_start(session_ident,
1049d95e11bfSDag-Erling Smørgrav 					    "break", 0);
1050d95e11bfSDag-Erling Smørgrav 					packet_put_int(1000);
1051d95e11bfSDag-Erling Smørgrav 					packet_send();
1052d95e11bfSDag-Erling Smørgrav 				}
1053d95e11bfSDag-Erling Smørgrav 				continue;
1054d95e11bfSDag-Erling Smørgrav 
10551e8db6e2SBrian Feldman 			case 'R':
10561e8db6e2SBrian Feldman 				if (compat20) {
10571e8db6e2SBrian Feldman 					if (datafellows & SSH_BUG_NOREKEY)
1058d4af9e69SDag-Erling Smørgrav 						logit("Server does not "
1059d4af9e69SDag-Erling Smørgrav 						    "support re-keying");
10601e8db6e2SBrian Feldman 					else
10611e8db6e2SBrian Feldman 						need_rekeying = 1;
10621e8db6e2SBrian Feldman 				}
10631e8db6e2SBrian Feldman 				continue;
10641e8db6e2SBrian Feldman 
1065b66f2d16SKris Kennaway 			case '&':
1066b15c8340SDag-Erling Smørgrav 				if (c && c->ctl_chan != -1)
1067d4af9e69SDag-Erling Smørgrav 					goto noescape;
1068b66f2d16SKris Kennaway 				/*
1069d4af9e69SDag-Erling Smørgrav 				 * Detach the program (continue to serve
1070d4af9e69SDag-Erling Smørgrav 				 * connections, but put in background and no
1071d4af9e69SDag-Erling Smørgrav 				 * more new connections).
1072b66f2d16SKris Kennaway 				 */
1073ae1f160dSDag-Erling Smørgrav 				/* Restore tty modes. */
1074*e146993eSDag-Erling Smørgrav 				leave_raw_mode(
1075*e146993eSDag-Erling Smørgrav 				    options.request_tty == REQUEST_TTY_FORCE);
1076ae1f160dSDag-Erling Smørgrav 
1077ae1f160dSDag-Erling Smørgrav 				/* Stop listening for new connections. */
1078ae1f160dSDag-Erling Smørgrav 				channel_stop_listening();
1079ae1f160dSDag-Erling Smørgrav 
1080ae1f160dSDag-Erling Smørgrav 				snprintf(string, sizeof string,
1081ae1f160dSDag-Erling Smørgrav 				    "%c& [backgrounded]\n", escape_char);
1082ae1f160dSDag-Erling Smørgrav 				buffer_append(berr, string, strlen(string));
1083ae1f160dSDag-Erling Smørgrav 
1084ae1f160dSDag-Erling Smørgrav 				/* Fork into background. */
1085ae1f160dSDag-Erling Smørgrav 				pid = fork();
1086ae1f160dSDag-Erling Smørgrav 				if (pid < 0) {
1087ae1f160dSDag-Erling Smørgrav 					error("fork: %.100s", strerror(errno));
1088ae1f160dSDag-Erling Smørgrav 					continue;
1089ae1f160dSDag-Erling Smørgrav 				}
1090ae1f160dSDag-Erling Smørgrav 				if (pid != 0) {	/* This is the parent. */
1091ae1f160dSDag-Erling Smørgrav 					/* The parent just exits. */
1092ae1f160dSDag-Erling Smørgrav 					exit(0);
1093ae1f160dSDag-Erling Smørgrav 				}
1094ae1f160dSDag-Erling Smørgrav 				/* The child continues serving connections. */
1095ae1f160dSDag-Erling Smørgrav 				if (compat20) {
1096ae1f160dSDag-Erling Smørgrav 					buffer_append(bin, "\004", 1);
1097ae1f160dSDag-Erling Smørgrav 					/* fake EOF on stdin */
1098ae1f160dSDag-Erling Smørgrav 					return -1;
1099ae1f160dSDag-Erling Smørgrav 				} else if (!stdin_eof) {
1100b66f2d16SKris Kennaway 					/*
1101d4af9e69SDag-Erling Smørgrav 					 * Sending SSH_CMSG_EOF alone does not
1102d4af9e69SDag-Erling Smørgrav 					 * always appear to be enough.  So we
1103d4af9e69SDag-Erling Smørgrav 					 * try to send an EOF character first.
1104b66f2d16SKris Kennaway 					 */
1105b66f2d16SKris Kennaway 					packet_start(SSH_CMSG_STDIN_DATA);
1106b66f2d16SKris Kennaway 					packet_put_string("\004", 1);
1107b66f2d16SKris Kennaway 					packet_send();
1108b66f2d16SKris Kennaway 					/* Close stdin. */
1109b66f2d16SKris Kennaway 					stdin_eof = 1;
1110b66f2d16SKris Kennaway 					if (buffer_len(bin) == 0) {
1111b66f2d16SKris Kennaway 						packet_start(SSH_CMSG_EOF);
1112b66f2d16SKris Kennaway 						packet_send();
1113b66f2d16SKris Kennaway 					}
1114b66f2d16SKris Kennaway 				}
1115b66f2d16SKris Kennaway 				continue;
1116b66f2d16SKris Kennaway 
1117b66f2d16SKris Kennaway 			case '?':
1118b15c8340SDag-Erling Smørgrav 				if (c && c->ctl_chan != -1) {
1119b66f2d16SKris Kennaway 					snprintf(string, sizeof string,
1120b66f2d16SKris Kennaway "%c?\r\n\
1121b66f2d16SKris Kennaway Supported escape sequences:\r\n\
1122d4af9e69SDag-Erling Smørgrav   %c.  - terminate session\r\n\
1123d4af9e69SDag-Erling Smørgrav   %cB  - send a BREAK to the remote system\r\n\
1124d4af9e69SDag-Erling Smørgrav   %cR  - Request rekey (SSH protocol 2 only)\r\n\
1125d4af9e69SDag-Erling Smørgrav   %c#  - list forwarded connections\r\n\
1126d4af9e69SDag-Erling Smørgrav   %c?  - this message\r\n\
1127d4af9e69SDag-Erling Smørgrav   %c%c  - send the escape character by typing it twice\r\n\
1128d4af9e69SDag-Erling Smørgrav (Note that escapes are only recognized immediately after newline.)\r\n",
1129d4af9e69SDag-Erling Smørgrav 					    escape_char, escape_char,
1130d4af9e69SDag-Erling Smørgrav 					    escape_char, escape_char,
1131d4af9e69SDag-Erling Smørgrav 					    escape_char, escape_char,
1132cce7d346SDag-Erling Smørgrav 					    escape_char, escape_char);
1133d4af9e69SDag-Erling Smørgrav 				} else {
1134d4af9e69SDag-Erling Smørgrav 					snprintf(string, sizeof string,
1135d4af9e69SDag-Erling Smørgrav "%c?\r\n\
1136d4af9e69SDag-Erling Smørgrav Supported escape sequences:\r\n\
1137d4af9e69SDag-Erling Smørgrav   %c.  - terminate connection (and any multiplexed sessions)\r\n\
1138d95e11bfSDag-Erling Smørgrav   %cB  - send a BREAK to the remote system\r\n\
11394b17dab0SDag-Erling Smørgrav   %cC  - open a command line\r\n\
11404b17dab0SDag-Erling Smørgrav   %cR  - Request rekey (SSH protocol 2 only)\r\n\
11414b17dab0SDag-Erling Smørgrav   %c^Z - suspend ssh\r\n\
11424b17dab0SDag-Erling Smørgrav   %c#  - list forwarded connections\r\n\
11434b17dab0SDag-Erling Smørgrav   %c&  - background ssh (when waiting for connections to terminate)\r\n\
11444b17dab0SDag-Erling Smørgrav   %c?  - this message\r\n\
11454b17dab0SDag-Erling Smørgrav   %c%c  - send the escape character by typing it twice\r\n\
1146b66f2d16SKris Kennaway (Note that escapes are only recognized immediately after newline.)\r\n",
1147d4af9e69SDag-Erling Smørgrav 					    escape_char, escape_char,
1148d4af9e69SDag-Erling Smørgrav 					    escape_char, escape_char,
1149d4af9e69SDag-Erling Smørgrav 					    escape_char, escape_char,
1150d4af9e69SDag-Erling Smørgrav 					    escape_char, escape_char,
1151d4af9e69SDag-Erling Smørgrav 					    escape_char, escape_char,
1152d4af9e69SDag-Erling Smørgrav 					    escape_char);
1153d4af9e69SDag-Erling Smørgrav 				}
1154b66f2d16SKris Kennaway 				buffer_append(berr, string, strlen(string));
1155b66f2d16SKris Kennaway 				continue;
1156b66f2d16SKris Kennaway 
1157b66f2d16SKris Kennaway 			case '#':
1158d4af9e69SDag-Erling Smørgrav 				snprintf(string, sizeof string, "%c#\r\n",
1159d4af9e69SDag-Erling Smørgrav 				    escape_char);
1160b66f2d16SKris Kennaway 				buffer_append(berr, string, strlen(string));
1161b66f2d16SKris Kennaway 				s = channel_open_message();
1162b66f2d16SKris Kennaway 				buffer_append(berr, s, strlen(s));
1163b66f2d16SKris Kennaway 				xfree(s);
1164b66f2d16SKris Kennaway 				continue;
1165b66f2d16SKris Kennaway 
1166545d5ecaSDag-Erling Smørgrav 			case 'C':
1167b15c8340SDag-Erling Smørgrav 				if (c && c->ctl_chan != -1)
1168cce7d346SDag-Erling Smørgrav 					goto noescape;
1169545d5ecaSDag-Erling Smørgrav 				process_cmdline();
1170545d5ecaSDag-Erling Smørgrav 				continue;
1171545d5ecaSDag-Erling Smørgrav 
1172b66f2d16SKris Kennaway 			default:
1173b66f2d16SKris Kennaway 				if (ch != escape_char) {
1174b66f2d16SKris Kennaway 					buffer_put_char(bin, escape_char);
1175b66f2d16SKris Kennaway 					bytes++;
1176b66f2d16SKris Kennaway 				}
1177b66f2d16SKris Kennaway 				/* Escaped characters fall through here */
1178b66f2d16SKris Kennaway 				break;
1179b66f2d16SKris Kennaway 			}
1180b66f2d16SKris Kennaway 		} else {
1181b66f2d16SKris Kennaway 			/*
1182d4af9e69SDag-Erling Smørgrav 			 * The previous character was not an escape char.
1183d4af9e69SDag-Erling Smørgrav 			 * Check if this is an escape.
1184b66f2d16SKris Kennaway 			 */
1185b66f2d16SKris Kennaway 			if (last_was_cr && ch == escape_char) {
1186d4af9e69SDag-Erling Smørgrav 				/*
1187d4af9e69SDag-Erling Smørgrav 				 * It is. Set the flag and continue to
1188d4af9e69SDag-Erling Smørgrav 				 * next character.
1189d4af9e69SDag-Erling Smørgrav 				 */
1190d4af9e69SDag-Erling Smørgrav 				*escape_pendingp = 1;
1191b66f2d16SKris Kennaway 				continue;
1192b66f2d16SKris Kennaway 			}
1193b66f2d16SKris Kennaway 		}
1194b66f2d16SKris Kennaway 
1195b66f2d16SKris Kennaway 		/*
1196b66f2d16SKris Kennaway 		 * Normal character.  Record whether it was a newline,
1197b66f2d16SKris Kennaway 		 * and append it to the buffer.
1198b66f2d16SKris Kennaway 		 */
1199b66f2d16SKris Kennaway 		last_was_cr = (ch == '\r' || ch == '\n');
1200b66f2d16SKris Kennaway 		buffer_put_char(bin, ch);
1201b66f2d16SKris Kennaway 		bytes++;
1202b66f2d16SKris Kennaway 	}
1203b66f2d16SKris Kennaway 	return bytes;
1204b66f2d16SKris Kennaway }
1205b66f2d16SKris Kennaway 
1206ae1f160dSDag-Erling Smørgrav static void
1207a04a10f8SKris Kennaway client_process_input(fd_set *readset)
1208a04a10f8SKris Kennaway {
1209a04a10f8SKris Kennaway 	int len;
12107aee6ffeSDag-Erling Smørgrav 	char buf[SSH_IOBUFSZ];
1211a04a10f8SKris Kennaway 
1212511b41d2SMark Murray 	/* Read input from stdin. */
1213511b41d2SMark Murray 	if (FD_ISSET(fileno(stdin), readset)) {
1214511b41d2SMark Murray 		/* Read as much as possible. */
1215511b41d2SMark Murray 		len = read(fileno(stdin), buf, sizeof(buf));
1216d4af9e69SDag-Erling Smørgrav 		if (len < 0 &&
1217d4af9e69SDag-Erling Smørgrav 		    (errno == EAGAIN || errno == EINTR || errno == EWOULDBLOCK))
12181e8db6e2SBrian Feldman 			return;		/* we'll try again later */
1219511b41d2SMark Murray 		if (len <= 0) {
1220511b41d2SMark Murray 			/*
1221511b41d2SMark Murray 			 * Received EOF or error.  They are treated
1222511b41d2SMark Murray 			 * similarly, except that an error message is printed
1223511b41d2SMark Murray 			 * if it was an error condition.
1224511b41d2SMark Murray 			 */
1225511b41d2SMark Murray 			if (len < 0) {
1226d4af9e69SDag-Erling Smørgrav 				snprintf(buf, sizeof buf, "read: %.100s\r\n",
1227d4af9e69SDag-Erling Smørgrav 				    strerror(errno));
1228511b41d2SMark Murray 				buffer_append(&stderr_buffer, buf, strlen(buf));
1229511b41d2SMark Murray 			}
1230511b41d2SMark Murray 			/* Mark that we have seen EOF. */
1231511b41d2SMark Murray 			stdin_eof = 1;
1232511b41d2SMark Murray 			/*
1233511b41d2SMark Murray 			 * Send an EOF message to the server unless there is
1234511b41d2SMark Murray 			 * data in the buffer.  If there is data in the
1235511b41d2SMark Murray 			 * buffer, no message will be sent now.  Code
1236511b41d2SMark Murray 			 * elsewhere will send the EOF when the buffer
1237511b41d2SMark Murray 			 * becomes empty if stdin_eof is set.
1238511b41d2SMark Murray 			 */
1239511b41d2SMark Murray 			if (buffer_len(&stdin_buffer) == 0) {
1240511b41d2SMark Murray 				packet_start(SSH_CMSG_EOF);
1241511b41d2SMark Murray 				packet_send();
1242511b41d2SMark Murray 			}
1243d4af9e69SDag-Erling Smørgrav 		} else if (escape_char1 == SSH_ESCAPECHAR_NONE) {
1244511b41d2SMark Murray 			/*
1245511b41d2SMark Murray 			 * Normal successful read, and no escape character.
1246511b41d2SMark Murray 			 * Just append the data to buffer.
1247511b41d2SMark Murray 			 */
1248511b41d2SMark Murray 			buffer_append(&stdin_buffer, buf, len);
1249511b41d2SMark Murray 		} else {
1250511b41d2SMark Murray 			/*
1251d4af9e69SDag-Erling Smørgrav 			 * Normal, successful read.  But we have an escape
1252d4af9e69SDag-Erling Smørgrav 			 * character and have to process the characters one
1253d4af9e69SDag-Erling Smørgrav 			 * by one.
1254511b41d2SMark Murray 			 */
1255d4af9e69SDag-Erling Smørgrav 			if (process_escapes(NULL, &stdin_buffer,
1256d4af9e69SDag-Erling Smørgrav 			    &stdout_buffer, &stderr_buffer, buf, len) == -1)
1257511b41d2SMark Murray 				return;
1258511b41d2SMark Murray 		}
1259511b41d2SMark Murray 	}
1260511b41d2SMark Murray }
1261511b41d2SMark Murray 
1262ae1f160dSDag-Erling Smørgrav static void
1263511b41d2SMark Murray client_process_output(fd_set *writeset)
1264511b41d2SMark Murray {
1265511b41d2SMark Murray 	int len;
1266511b41d2SMark Murray 	char buf[100];
1267511b41d2SMark Murray 
1268511b41d2SMark Murray 	/* Write buffered output to stdout. */
1269511b41d2SMark Murray 	if (FD_ISSET(fileno(stdout), writeset)) {
1270511b41d2SMark Murray 		/* Write as much data as possible. */
1271511b41d2SMark Murray 		len = write(fileno(stdout), buffer_ptr(&stdout_buffer),
1272511b41d2SMark Murray 		    buffer_len(&stdout_buffer));
1273511b41d2SMark Murray 		if (len <= 0) {
1274d4af9e69SDag-Erling Smørgrav 			if (errno == EINTR || errno == EAGAIN ||
1275d4af9e69SDag-Erling Smørgrav 			    errno == EWOULDBLOCK)
1276511b41d2SMark Murray 				len = 0;
1277511b41d2SMark Murray 			else {
1278511b41d2SMark Murray 				/*
1279511b41d2SMark Murray 				 * An error or EOF was encountered.  Put an
1280511b41d2SMark Murray 				 * error message to stderr buffer.
1281511b41d2SMark Murray 				 */
1282d4af9e69SDag-Erling Smørgrav 				snprintf(buf, sizeof buf,
1283d4af9e69SDag-Erling Smørgrav 				    "write stdout: %.50s\r\n", strerror(errno));
1284511b41d2SMark Murray 				buffer_append(&stderr_buffer, buf, strlen(buf));
1285511b41d2SMark Murray 				quit_pending = 1;
1286511b41d2SMark Murray 				return;
1287511b41d2SMark Murray 			}
1288511b41d2SMark Murray 		}
1289511b41d2SMark Murray 		/* Consume printed data from the buffer. */
1290511b41d2SMark Murray 		buffer_consume(&stdout_buffer, len);
1291511b41d2SMark Murray 	}
1292511b41d2SMark Murray 	/* Write buffered output to stderr. */
1293511b41d2SMark Murray 	if (FD_ISSET(fileno(stderr), writeset)) {
1294511b41d2SMark Murray 		/* Write as much data as possible. */
1295511b41d2SMark Murray 		len = write(fileno(stderr), buffer_ptr(&stderr_buffer),
1296511b41d2SMark Murray 		    buffer_len(&stderr_buffer));
1297511b41d2SMark Murray 		if (len <= 0) {
1298d4af9e69SDag-Erling Smørgrav 			if (errno == EINTR || errno == EAGAIN ||
1299d4af9e69SDag-Erling Smørgrav 			    errno == EWOULDBLOCK)
1300511b41d2SMark Murray 				len = 0;
1301511b41d2SMark Murray 			else {
1302d4af9e69SDag-Erling Smørgrav 				/*
1303d4af9e69SDag-Erling Smørgrav 				 * EOF or error, but can't even print
1304d4af9e69SDag-Erling Smørgrav 				 * error message.
1305d4af9e69SDag-Erling Smørgrav 				 */
1306511b41d2SMark Murray 				quit_pending = 1;
1307511b41d2SMark Murray 				return;
1308511b41d2SMark Murray 			}
1309511b41d2SMark Murray 		}
1310511b41d2SMark Murray 		/* Consume printed characters from the buffer. */
1311511b41d2SMark Murray 		buffer_consume(&stderr_buffer, len);
1312511b41d2SMark Murray 	}
1313511b41d2SMark Murray }
1314511b41d2SMark Murray 
1315511b41d2SMark Murray /*
1316a04a10f8SKris Kennaway  * Get packets from the connection input buffer, and process them as long as
1317a04a10f8SKris Kennaway  * there are packets available.
1318a04a10f8SKris Kennaway  *
1319a04a10f8SKris Kennaway  * Any unknown packets received during the actual
1320a04a10f8SKris Kennaway  * session cause the session to terminate.  This is
1321a04a10f8SKris Kennaway  * intended to make debugging easier since no
1322a04a10f8SKris Kennaway  * confirmations are sent.  Any compatible protocol
1323a04a10f8SKris Kennaway  * extensions must be negotiated during the
1324a04a10f8SKris Kennaway  * preparatory phase.
1325a04a10f8SKris Kennaway  */
1326a04a10f8SKris Kennaway 
1327ae1f160dSDag-Erling Smørgrav static void
13281e8db6e2SBrian Feldman client_process_buffered_input_packets(void)
1329a04a10f8SKris Kennaway {
1330d4af9e69SDag-Erling Smørgrav 	dispatch_run(DISPATCH_NONBLOCK, &quit_pending,
1331d4af9e69SDag-Erling Smørgrav 	    compat20 ? xxx_kex : NULL);
1332a04a10f8SKris Kennaway }
1333a04a10f8SKris Kennaway 
1334b66f2d16SKris Kennaway /* scan buf[] for '~' before sending data to the peer */
1335b66f2d16SKris Kennaway 
1336d4af9e69SDag-Erling Smørgrav /* Helper: allocate a new escape_filter_ctx and fill in its escape char */
1337d4af9e69SDag-Erling Smørgrav void *
1338d4af9e69SDag-Erling Smørgrav client_new_escape_filter_ctx(int escape_char)
1339b66f2d16SKris Kennaway {
1340d4af9e69SDag-Erling Smørgrav 	struct escape_filter_ctx *ret;
1341d4af9e69SDag-Erling Smørgrav 
1342d4af9e69SDag-Erling Smørgrav 	ret = xmalloc(sizeof(*ret));
1343d4af9e69SDag-Erling Smørgrav 	ret->escape_pending = 0;
1344d4af9e69SDag-Erling Smørgrav 	ret->escape_char = escape_char;
1345d4af9e69SDag-Erling Smørgrav 	return (void *)ret;
1346d4af9e69SDag-Erling Smørgrav }
1347d4af9e69SDag-Erling Smørgrav 
1348d4af9e69SDag-Erling Smørgrav /* Free the escape filter context on channel free */
1349d4af9e69SDag-Erling Smørgrav void
1350d4af9e69SDag-Erling Smørgrav client_filter_cleanup(int cid, void *ctx)
1351d4af9e69SDag-Erling Smørgrav {
1352d4af9e69SDag-Erling Smørgrav 	xfree(ctx);
1353d4af9e69SDag-Erling Smørgrav }
1354d4af9e69SDag-Erling Smørgrav 
1355d4af9e69SDag-Erling Smørgrav int
1356d4af9e69SDag-Erling Smørgrav client_simple_escape_filter(Channel *c, char *buf, int len)
1357d4af9e69SDag-Erling Smørgrav {
1358d4af9e69SDag-Erling Smørgrav 	if (c->extended_usage != CHAN_EXTENDED_WRITE)
1359d4af9e69SDag-Erling Smørgrav 		return 0;
1360d4af9e69SDag-Erling Smørgrav 
1361d4af9e69SDag-Erling Smørgrav 	return process_escapes(c, &c->input, &c->output, &c->extended,
1362d4af9e69SDag-Erling Smørgrav 	    buf, len);
1363b66f2d16SKris Kennaway }
1364b66f2d16SKris Kennaway 
1365ae1f160dSDag-Erling Smørgrav static void
13661e8db6e2SBrian Feldman client_channel_closed(int id, void *arg)
13671e8db6e2SBrian Feldman {
1368ae1f160dSDag-Erling Smørgrav 	channel_cancel_cleanup(id);
13691e8db6e2SBrian Feldman 	session_closed = 1;
1370*e146993eSDag-Erling Smørgrav 	leave_raw_mode(options.request_tty == REQUEST_TTY_FORCE);
13711e8db6e2SBrian Feldman }
13721e8db6e2SBrian Feldman 
1373a04a10f8SKris Kennaway /*
1374511b41d2SMark Murray  * Implements the interactive session with the server.  This is called after
1375511b41d2SMark Murray  * the user has been authenticated, and a command has been started on the
1376ae1f160dSDag-Erling Smørgrav  * remote host.  If escape_char != SSH_ESCAPECHAR_NONE, it is the character
1377ae1f160dSDag-Erling Smørgrav  * used as an escape character for terminating or suspending the session.
1378511b41d2SMark Murray  */
1379511b41d2SMark Murray 
1380511b41d2SMark Murray int
1381b66f2d16SKris Kennaway client_loop(int have_pty, int escape_char_arg, int ssh2_chan_id)
1382511b41d2SMark Murray {
13831e8db6e2SBrian Feldman 	fd_set *readset = NULL, *writeset = NULL;
1384511b41d2SMark Murray 	double start_time, total_time;
1385d74d50a8SDag-Erling Smørgrav 	int max_fd = 0, max_fd2 = 0, len, rekeying = 0;
1386d4af9e69SDag-Erling Smørgrav 	u_int64_t ibytes, obytes;
1387d74d50a8SDag-Erling Smørgrav 	u_int nalloc = 0;
1388511b41d2SMark Murray 	char buf[100];
1389511b41d2SMark Murray 
1390511b41d2SMark Murray 	debug("Entering interactive session.");
1391511b41d2SMark Murray 
1392511b41d2SMark Murray 	start_time = get_current_time();
1393511b41d2SMark Murray 
1394511b41d2SMark Murray 	/* Initialize variables. */
1395d4af9e69SDag-Erling Smørgrav 	escape_pending1 = 0;
1396511b41d2SMark Murray 	last_was_cr = 1;
1397511b41d2SMark Murray 	exit_status = -1;
1398511b41d2SMark Murray 	stdin_eof = 0;
1399511b41d2SMark Murray 	buffer_high = 64 * 1024;
1400511b41d2SMark Murray 	connection_in = packet_get_connection_in();
1401511b41d2SMark Murray 	connection_out = packet_get_connection_out();
14021e8db6e2SBrian Feldman 	max_fd = MAX(connection_in, connection_out);
14031e8db6e2SBrian Feldman 
14041e8db6e2SBrian Feldman 	if (!compat20) {
14051e8db6e2SBrian Feldman 		/* enable nonblocking unless tty */
14061e8db6e2SBrian Feldman 		if (!isatty(fileno(stdin)))
14071e8db6e2SBrian Feldman 			set_nonblock(fileno(stdin));
14081e8db6e2SBrian Feldman 		if (!isatty(fileno(stdout)))
14091e8db6e2SBrian Feldman 			set_nonblock(fileno(stdout));
14101e8db6e2SBrian Feldman 		if (!isatty(fileno(stderr)))
14111e8db6e2SBrian Feldman 			set_nonblock(fileno(stderr));
14121e8db6e2SBrian Feldman 		max_fd = MAX(max_fd, fileno(stdin));
14131e8db6e2SBrian Feldman 		max_fd = MAX(max_fd, fileno(stdout));
14141e8db6e2SBrian Feldman 		max_fd = MAX(max_fd, fileno(stderr));
14151e8db6e2SBrian Feldman 	}
1416511b41d2SMark Murray 	quit_pending = 0;
1417d4af9e69SDag-Erling Smørgrav 	escape_char1 = escape_char_arg;
1418511b41d2SMark Murray 
1419511b41d2SMark Murray 	/* Initialize buffers. */
1420511b41d2SMark Murray 	buffer_init(&stdin_buffer);
1421511b41d2SMark Murray 	buffer_init(&stdout_buffer);
1422511b41d2SMark Murray 	buffer_init(&stderr_buffer);
1423511b41d2SMark Murray 
1424a04a10f8SKris Kennaway 	client_init_dispatch();
1425a04a10f8SKris Kennaway 
1426d0c8c0bcSDag-Erling Smørgrav 	/*
1427d0c8c0bcSDag-Erling Smørgrav 	 * Set signal handlers, (e.g. to restore non-blocking mode)
1428d0c8c0bcSDag-Erling Smørgrav 	 * but don't overwrite SIG_IGN, matches behaviour from rsh(1)
1429d0c8c0bcSDag-Erling Smørgrav 	 */
14305e8dbd04SDag-Erling Smørgrav 	if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
14315e8dbd04SDag-Erling Smørgrav 		signal(SIGHUP, signal_handler);
1432d0c8c0bcSDag-Erling Smørgrav 	if (signal(SIGINT, SIG_IGN) != SIG_IGN)
1433511b41d2SMark Murray 		signal(SIGINT, signal_handler);
1434d0c8c0bcSDag-Erling Smørgrav 	if (signal(SIGQUIT, SIG_IGN) != SIG_IGN)
1435511b41d2SMark Murray 		signal(SIGQUIT, signal_handler);
1436d0c8c0bcSDag-Erling Smørgrav 	if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
1437511b41d2SMark Murray 		signal(SIGTERM, signal_handler);
1438511b41d2SMark Murray 	signal(SIGWINCH, window_change_handler);
1439511b41d2SMark Murray 
1440511b41d2SMark Murray 	if (have_pty)
1441*e146993eSDag-Erling Smørgrav 		enter_raw_mode(options.request_tty == REQUEST_TTY_FORCE);
1442511b41d2SMark Murray 
14431e8db6e2SBrian Feldman 	if (compat20) {
14441e8db6e2SBrian Feldman 		session_ident = ssh2_chan_id;
1445*e146993eSDag-Erling Smørgrav 		if (session_ident != -1) {
1446*e146993eSDag-Erling Smørgrav 			if (escape_char_arg != SSH_ESCAPECHAR_NONE) {
14471e8db6e2SBrian Feldman 				channel_register_filter(session_ident,
1448d4af9e69SDag-Erling Smørgrav 				    client_simple_escape_filter, NULL,
1449d4af9e69SDag-Erling Smørgrav 				    client_filter_cleanup,
1450*e146993eSDag-Erling Smørgrav 				    client_new_escape_filter_ctx(
1451*e146993eSDag-Erling Smørgrav 				    escape_char_arg));
1452*e146993eSDag-Erling Smørgrav 			}
14531e8db6e2SBrian Feldman 			channel_register_cleanup(session_ident,
1454021d409fSDag-Erling Smørgrav 			    client_channel_closed, 0);
1455*e146993eSDag-Erling Smørgrav 		}
14561e8db6e2SBrian Feldman 	} else {
1457b66f2d16SKris Kennaway 		/* Check if we should immediately send eof on stdin. */
1458511b41d2SMark Murray 		client_check_initial_eof_on_stdin();
14591e8db6e2SBrian Feldman 	}
1460b66f2d16SKris Kennaway 
1461511b41d2SMark Murray 	/* Main loop of the client for the interactive session mode. */
1462511b41d2SMark Murray 	while (!quit_pending) {
1463511b41d2SMark Murray 
1464511b41d2SMark Murray 		/* Process buffered packets sent by the server. */
1465511b41d2SMark Murray 		client_process_buffered_input_packets();
1466511b41d2SMark Murray 
14671e8db6e2SBrian Feldman 		if (compat20 && session_closed && !channel_still_open())
1468a04a10f8SKris Kennaway 			break;
1469a04a10f8SKris Kennaway 
14701e8db6e2SBrian Feldman 		rekeying = (xxx_kex != NULL && !xxx_kex->done);
14711e8db6e2SBrian Feldman 
14721e8db6e2SBrian Feldman 		if (rekeying) {
14731e8db6e2SBrian Feldman 			debug("rekeying in progress");
14741e8db6e2SBrian Feldman 		} else {
1475511b41d2SMark Murray 			/*
14761e8db6e2SBrian Feldman 			 * Make packets of buffered stdin data, and buffer
14771e8db6e2SBrian Feldman 			 * them for sending to the server.
1478511b41d2SMark Murray 			 */
1479a04a10f8SKris Kennaway 			if (!compat20)
1480511b41d2SMark Murray 				client_make_packets_from_stdin_data();
1481511b41d2SMark Murray 
1482511b41d2SMark Murray 			/*
14831e8db6e2SBrian Feldman 			 * Make packets from buffered channel data, and
14841e8db6e2SBrian Feldman 			 * enqueue them for sending to the server.
1485511b41d2SMark Murray 			 */
1486511b41d2SMark Murray 			if (packet_not_very_much_data_to_write())
1487511b41d2SMark Murray 				channel_output_poll();
1488511b41d2SMark Murray 
1489511b41d2SMark Murray 			/*
14901e8db6e2SBrian Feldman 			 * Check if the window size has changed, and buffer a
14911e8db6e2SBrian Feldman 			 * message about it to the server if so.
1492511b41d2SMark Murray 			 */
1493511b41d2SMark Murray 			client_check_window_change();
1494511b41d2SMark Murray 
1495511b41d2SMark Murray 			if (quit_pending)
1496511b41d2SMark Murray 				break;
14971e8db6e2SBrian Feldman 		}
1498511b41d2SMark Murray 		/*
1499511b41d2SMark Murray 		 * Wait until we have something to do (something becomes
1500511b41d2SMark Murray 		 * available on one of the descriptors).
1501511b41d2SMark Murray 		 */
1502ae1f160dSDag-Erling Smørgrav 		max_fd2 = max_fd;
15031e8db6e2SBrian Feldman 		client_wait_until_can_do_something(&readset, &writeset,
1504ae1f160dSDag-Erling Smørgrav 		    &max_fd2, &nalloc, rekeying);
1505511b41d2SMark Murray 
1506511b41d2SMark Murray 		if (quit_pending)
1507511b41d2SMark Murray 			break;
1508511b41d2SMark Murray 
15091e8db6e2SBrian Feldman 		/* Do channel operations unless rekeying in progress. */
15101e8db6e2SBrian Feldman 		if (!rekeying) {
15111e8db6e2SBrian Feldman 			channel_after_select(readset, writeset);
1512d95e11bfSDag-Erling Smørgrav 			if (need_rekeying || packet_need_rekeying()) {
1513d95e11bfSDag-Erling Smørgrav 				debug("need rekeying");
15141e8db6e2SBrian Feldman 				xxx_kex->done = 0;
15151e8db6e2SBrian Feldman 				kex_send_kexinit(xxx_kex);
15161e8db6e2SBrian Feldman 				need_rekeying = 0;
15171e8db6e2SBrian Feldman 			}
15181e8db6e2SBrian Feldman 		}
1519511b41d2SMark Murray 
1520a04a10f8SKris Kennaway 		/* Buffer input from the connection.  */
15211e8db6e2SBrian Feldman 		client_process_net_input(readset);
1522511b41d2SMark Murray 
1523a04a10f8SKris Kennaway 		if (quit_pending)
1524a04a10f8SKris Kennaway 			break;
1525a04a10f8SKris Kennaway 
1526a04a10f8SKris Kennaway 		if (!compat20) {
1527a04a10f8SKris Kennaway 			/* Buffer data from stdin */
15281e8db6e2SBrian Feldman 			client_process_input(readset);
1529511b41d2SMark Murray 			/*
1530a04a10f8SKris Kennaway 			 * Process output to stdout and stderr.  Output to
1531a04a10f8SKris Kennaway 			 * the connection is processed elsewhere (above).
1532511b41d2SMark Murray 			 */
15331e8db6e2SBrian Feldman 			client_process_output(writeset);
1534a04a10f8SKris Kennaway 		}
1535511b41d2SMark Murray 
1536b15c8340SDag-Erling Smørgrav 		if (session_resumed) {
1537b15c8340SDag-Erling Smørgrav 			connection_in = packet_get_connection_in();
1538b15c8340SDag-Erling Smørgrav 			connection_out = packet_get_connection_out();
1539b15c8340SDag-Erling Smørgrav 			max_fd = MAX(max_fd, connection_out);
1540b15c8340SDag-Erling Smørgrav 			max_fd = MAX(max_fd, connection_in);
1541b15c8340SDag-Erling Smørgrav 			session_resumed = 0;
1542b15c8340SDag-Erling Smørgrav 		}
1543b15c8340SDag-Erling Smørgrav 
1544d4af9e69SDag-Erling Smørgrav 		/*
1545d4af9e69SDag-Erling Smørgrav 		 * Send as much buffered packet data as possible to the
1546d4af9e69SDag-Erling Smørgrav 		 * sender.
1547d4af9e69SDag-Erling Smørgrav 		 */
15481e8db6e2SBrian Feldman 		if (FD_ISSET(connection_out, writeset))
1549511b41d2SMark Murray 			packet_write_poll();
1550e2f6069cSDag-Erling Smørgrav 
1551e2f6069cSDag-Erling Smørgrav 		/*
1552e2f6069cSDag-Erling Smørgrav 		 * If we are a backgrounded control master, and the
1553e2f6069cSDag-Erling Smørgrav 		 * timeout has expired without any active client
1554e2f6069cSDag-Erling Smørgrav 		 * connections, then quit.
1555e2f6069cSDag-Erling Smørgrav 		 */
1556e2f6069cSDag-Erling Smørgrav 		if (control_persist_exit_time > 0) {
1557e2f6069cSDag-Erling Smørgrav 			if (time(NULL) >= control_persist_exit_time) {
1558e2f6069cSDag-Erling Smørgrav 				debug("ControlPersist timeout expired");
1559e2f6069cSDag-Erling Smørgrav 				break;
1560e2f6069cSDag-Erling Smørgrav 			}
1561e2f6069cSDag-Erling Smørgrav 		}
1562511b41d2SMark Murray 	}
15631e8db6e2SBrian Feldman 	if (readset)
15641e8db6e2SBrian Feldman 		xfree(readset);
15651e8db6e2SBrian Feldman 	if (writeset)
15661e8db6e2SBrian Feldman 		xfree(writeset);
1567511b41d2SMark Murray 
1568511b41d2SMark Murray 	/* Terminate the session. */
1569511b41d2SMark Murray 
1570511b41d2SMark Murray 	/* Stop watching for window change. */
1571511b41d2SMark Murray 	signal(SIGWINCH, SIG_DFL);
1572511b41d2SMark Murray 
15737aee6ffeSDag-Erling Smørgrav 	if (compat20) {
15747aee6ffeSDag-Erling Smørgrav 		packet_start(SSH2_MSG_DISCONNECT);
15757aee6ffeSDag-Erling Smørgrav 		packet_put_int(SSH2_DISCONNECT_BY_APPLICATION);
15767aee6ffeSDag-Erling Smørgrav 		packet_put_cstring("disconnected by user");
15778ad9b54aSDag-Erling Smørgrav 		packet_put_cstring(""); /* language tag */
15787aee6ffeSDag-Erling Smørgrav 		packet_send();
15797aee6ffeSDag-Erling Smørgrav 		packet_write_wait();
15807aee6ffeSDag-Erling Smørgrav 	}
15817aee6ffeSDag-Erling Smørgrav 
1582ae1f160dSDag-Erling Smørgrav 	channel_free_all();
1583ae1f160dSDag-Erling Smørgrav 
1584ae1f160dSDag-Erling Smørgrav 	if (have_pty)
1585*e146993eSDag-Erling Smørgrav 		leave_raw_mode(options.request_tty == REQUEST_TTY_FORCE);
1586ae1f160dSDag-Erling Smørgrav 
1587ae1f160dSDag-Erling Smørgrav 	/* restore blocking io */
1588ae1f160dSDag-Erling Smørgrav 	if (!isatty(fileno(stdin)))
1589ae1f160dSDag-Erling Smørgrav 		unset_nonblock(fileno(stdin));
1590ae1f160dSDag-Erling Smørgrav 	if (!isatty(fileno(stdout)))
1591ae1f160dSDag-Erling Smørgrav 		unset_nonblock(fileno(stdout));
1592ae1f160dSDag-Erling Smørgrav 	if (!isatty(fileno(stderr)))
1593ae1f160dSDag-Erling Smørgrav 		unset_nonblock(fileno(stderr));
1594ae1f160dSDag-Erling Smørgrav 
1595efcad6b7SDag-Erling Smørgrav 	/*
1596efcad6b7SDag-Erling Smørgrav 	 * If there was no shell or command requested, there will be no remote
1597efcad6b7SDag-Erling Smørgrav 	 * exit status to be returned.  In that case, clear error code if the
1598efcad6b7SDag-Erling Smørgrav 	 * connection was deliberately terminated at this end.
1599efcad6b7SDag-Erling Smørgrav 	 */
1600efcad6b7SDag-Erling Smørgrav 	if (no_shell_flag && received_signal == SIGTERM) {
1601efcad6b7SDag-Erling Smørgrav 		received_signal = 0;
1602efcad6b7SDag-Erling Smørgrav 		exit_status = 0;
1603ae1f160dSDag-Erling Smørgrav 	}
1604511b41d2SMark Murray 
1605efcad6b7SDag-Erling Smørgrav 	if (received_signal)
1606efcad6b7SDag-Erling Smørgrav 		fatal("Killed by signal %d.", (int) received_signal);
1607efcad6b7SDag-Erling Smørgrav 
1608511b41d2SMark Murray 	/*
1609511b41d2SMark Murray 	 * In interactive mode (with pseudo tty) display a message indicating
1610511b41d2SMark Murray 	 * that the connection has been closed.
1611511b41d2SMark Murray 	 */
1612511b41d2SMark Murray 	if (have_pty && options.log_level != SYSLOG_LEVEL_QUIET) {
1613d4af9e69SDag-Erling Smørgrav 		snprintf(buf, sizeof buf,
1614d4af9e69SDag-Erling Smørgrav 		    "Connection to %.64s closed.\r\n", host);
1615511b41d2SMark Murray 		buffer_append(&stderr_buffer, buf, strlen(buf));
1616511b41d2SMark Murray 	}
1617ae1f160dSDag-Erling Smørgrav 
1618511b41d2SMark Murray 	/* Output any buffered data for stdout. */
16194a421b63SDag-Erling Smørgrav 	if (buffer_len(&stdout_buffer) > 0) {
16204a421b63SDag-Erling Smørgrav 		len = atomicio(vwrite, fileno(stdout),
16214a421b63SDag-Erling Smørgrav 		    buffer_ptr(&stdout_buffer), buffer_len(&stdout_buffer));
16224a421b63SDag-Erling Smørgrav 		if (len < 0 || (u_int)len != buffer_len(&stdout_buffer))
1623511b41d2SMark Murray 			error("Write failed flushing stdout buffer.");
16244a421b63SDag-Erling Smørgrav 		else
1625511b41d2SMark Murray 			buffer_consume(&stdout_buffer, len);
1626511b41d2SMark Murray 	}
1627511b41d2SMark Murray 
1628511b41d2SMark Murray 	/* Output any buffered data for stderr. */
16294a421b63SDag-Erling Smørgrav 	if (buffer_len(&stderr_buffer) > 0) {
16304a421b63SDag-Erling Smørgrav 		len = atomicio(vwrite, fileno(stderr),
16314a421b63SDag-Erling Smørgrav 		    buffer_ptr(&stderr_buffer), buffer_len(&stderr_buffer));
16324a421b63SDag-Erling Smørgrav 		if (len < 0 || (u_int)len != buffer_len(&stderr_buffer))
1633511b41d2SMark Murray 			error("Write failed flushing stderr buffer.");
16344a421b63SDag-Erling Smørgrav 		else
1635511b41d2SMark Murray 			buffer_consume(&stderr_buffer, len);
1636511b41d2SMark Murray 	}
1637511b41d2SMark Murray 
1638511b41d2SMark Murray 	/* Clear and free any buffers. */
1639511b41d2SMark Murray 	memset(buf, 0, sizeof(buf));
1640511b41d2SMark Murray 	buffer_free(&stdin_buffer);
1641511b41d2SMark Murray 	buffer_free(&stdout_buffer);
1642511b41d2SMark Murray 	buffer_free(&stderr_buffer);
1643511b41d2SMark Murray 
1644511b41d2SMark Murray 	/* Report bytes transferred, and transfer rates. */
1645511b41d2SMark Murray 	total_time = get_current_time() - start_time;
1646d4af9e69SDag-Erling Smørgrav 	packet_get_state(MODE_IN, NULL, NULL, NULL, &ibytes);
1647d4af9e69SDag-Erling Smørgrav 	packet_get_state(MODE_OUT, NULL, NULL, NULL, &obytes);
1648d4af9e69SDag-Erling Smørgrav 	verbose("Transferred: sent %llu, received %llu bytes, in %.1f seconds",
16494a421b63SDag-Erling Smørgrav 	    (unsigned long long)obytes, (unsigned long long)ibytes, total_time);
1650511b41d2SMark Murray 	if (total_time > 0)
1651d4af9e69SDag-Erling Smørgrav 		verbose("Bytes per second: sent %.1f, received %.1f",
1652d4af9e69SDag-Erling Smørgrav 		    obytes / total_time, ibytes / total_time);
1653511b41d2SMark Murray 	/* Return the exit status of the program. */
1654511b41d2SMark Murray 	debug("Exit status %d", exit_status);
1655511b41d2SMark Murray 	return exit_status;
1656511b41d2SMark Murray }
1657a04a10f8SKris Kennaway 
1658a04a10f8SKris Kennaway /*********/
1659a04a10f8SKris Kennaway 
1660ae1f160dSDag-Erling Smørgrav static void
1661ae1f160dSDag-Erling Smørgrav client_input_stdout_data(int type, u_int32_t seq, void *ctxt)
1662a04a10f8SKris Kennaway {
16631e8db6e2SBrian Feldman 	u_int data_len;
1664a04a10f8SKris Kennaway 	char *data = packet_get_string(&data_len);
1665ae1f160dSDag-Erling Smørgrav 	packet_check_eom();
1666a04a10f8SKris Kennaway 	buffer_append(&stdout_buffer, data, data_len);
1667a04a10f8SKris Kennaway 	memset(data, 0, data_len);
1668a04a10f8SKris Kennaway 	xfree(data);
1669a04a10f8SKris Kennaway }
1670ae1f160dSDag-Erling Smørgrav static void
1671ae1f160dSDag-Erling Smørgrav client_input_stderr_data(int type, u_int32_t seq, void *ctxt)
1672a04a10f8SKris Kennaway {
16731e8db6e2SBrian Feldman 	u_int data_len;
1674a04a10f8SKris Kennaway 	char *data = packet_get_string(&data_len);
1675ae1f160dSDag-Erling Smørgrav 	packet_check_eom();
1676a04a10f8SKris Kennaway 	buffer_append(&stderr_buffer, data, data_len);
1677a04a10f8SKris Kennaway 	memset(data, 0, data_len);
1678a04a10f8SKris Kennaway 	xfree(data);
1679a04a10f8SKris Kennaway }
1680ae1f160dSDag-Erling Smørgrav static void
1681ae1f160dSDag-Erling Smørgrav client_input_exit_status(int type, u_int32_t seq, void *ctxt)
1682a04a10f8SKris Kennaway {
1683a04a10f8SKris Kennaway 	exit_status = packet_get_int();
1684ae1f160dSDag-Erling Smørgrav 	packet_check_eom();
1685a04a10f8SKris Kennaway 	/* Acknowledge the exit. */
1686a04a10f8SKris Kennaway 	packet_start(SSH_CMSG_EXIT_CONFIRMATION);
1687a04a10f8SKris Kennaway 	packet_send();
1688a04a10f8SKris Kennaway 	/*
1689a04a10f8SKris Kennaway 	 * Must wait for packet to be sent since we are
1690a04a10f8SKris Kennaway 	 * exiting the loop.
1691a04a10f8SKris Kennaway 	 */
1692a04a10f8SKris Kennaway 	packet_write_wait();
1693a04a10f8SKris Kennaway 	/* Flag that we want to exit. */
1694a04a10f8SKris Kennaway 	quit_pending = 1;
1695a04a10f8SKris Kennaway }
1696efcad6b7SDag-Erling Smørgrav static void
1697efcad6b7SDag-Erling Smørgrav client_input_agent_open(int type, u_int32_t seq, void *ctxt)
1698efcad6b7SDag-Erling Smørgrav {
1699efcad6b7SDag-Erling Smørgrav 	Channel *c = NULL;
1700efcad6b7SDag-Erling Smørgrav 	int remote_id, sock;
1701efcad6b7SDag-Erling Smørgrav 
1702efcad6b7SDag-Erling Smørgrav 	/* Read the remote channel number from the message. */
1703efcad6b7SDag-Erling Smørgrav 	remote_id = packet_get_int();
1704efcad6b7SDag-Erling Smørgrav 	packet_check_eom();
1705efcad6b7SDag-Erling Smørgrav 
1706efcad6b7SDag-Erling Smørgrav 	/*
1707efcad6b7SDag-Erling Smørgrav 	 * Get a connection to the local authentication agent (this may again
1708efcad6b7SDag-Erling Smørgrav 	 * get forwarded).
1709efcad6b7SDag-Erling Smørgrav 	 */
1710efcad6b7SDag-Erling Smørgrav 	sock = ssh_get_authentication_socket();
1711efcad6b7SDag-Erling Smørgrav 
1712efcad6b7SDag-Erling Smørgrav 	/*
1713efcad6b7SDag-Erling Smørgrav 	 * If we could not connect the agent, send an error message back to
1714efcad6b7SDag-Erling Smørgrav 	 * the server. This should never happen unless the agent dies,
1715efcad6b7SDag-Erling Smørgrav 	 * because authentication forwarding is only enabled if we have an
1716efcad6b7SDag-Erling Smørgrav 	 * agent.
1717efcad6b7SDag-Erling Smørgrav 	 */
1718efcad6b7SDag-Erling Smørgrav 	if (sock >= 0) {
1719efcad6b7SDag-Erling Smørgrav 		c = channel_new("", SSH_CHANNEL_OPEN, sock, sock,
1720efcad6b7SDag-Erling Smørgrav 		    -1, 0, 0, 0, "authentication agent connection", 1);
1721efcad6b7SDag-Erling Smørgrav 		c->remote_id = remote_id;
1722efcad6b7SDag-Erling Smørgrav 		c->force_drain = 1;
1723efcad6b7SDag-Erling Smørgrav 	}
1724efcad6b7SDag-Erling Smørgrav 	if (c == NULL) {
1725efcad6b7SDag-Erling Smørgrav 		packet_start(SSH_MSG_CHANNEL_OPEN_FAILURE);
1726efcad6b7SDag-Erling Smørgrav 		packet_put_int(remote_id);
1727efcad6b7SDag-Erling Smørgrav 	} else {
1728efcad6b7SDag-Erling Smørgrav 		/* Send a confirmation to the remote host. */
1729efcad6b7SDag-Erling Smørgrav 		debug("Forwarding authentication connection.");
1730efcad6b7SDag-Erling Smørgrav 		packet_start(SSH_MSG_CHANNEL_OPEN_CONFIRMATION);
1731efcad6b7SDag-Erling Smørgrav 		packet_put_int(remote_id);
1732efcad6b7SDag-Erling Smørgrav 		packet_put_int(c->self);
1733efcad6b7SDag-Erling Smørgrav 	}
1734efcad6b7SDag-Erling Smørgrav 	packet_send();
1735efcad6b7SDag-Erling Smørgrav }
1736a04a10f8SKris Kennaway 
1737ae1f160dSDag-Erling Smørgrav static Channel *
17381e8db6e2SBrian Feldman client_request_forwarded_tcpip(const char *request_type, int rchan)
17391e8db6e2SBrian Feldman {
17401e8db6e2SBrian Feldman 	Channel *c = NULL;
17411e8db6e2SBrian Feldman 	char *listen_address, *originator_address;
1742cce7d346SDag-Erling Smørgrav 	u_short listen_port, originator_port;
17431e8db6e2SBrian Feldman 
17441e8db6e2SBrian Feldman 	/* Get rest of the packet */
17451e8db6e2SBrian Feldman 	listen_address = packet_get_string(NULL);
17461e8db6e2SBrian Feldman 	listen_port = packet_get_int();
17471e8db6e2SBrian Feldman 	originator_address = packet_get_string(NULL);
17481e8db6e2SBrian Feldman 	originator_port = packet_get_int();
1749ae1f160dSDag-Erling Smørgrav 	packet_check_eom();
17501e8db6e2SBrian Feldman 
1751d4af9e69SDag-Erling Smørgrav 	debug("client_request_forwarded_tcpip: listen %s port %d, "
1752d4af9e69SDag-Erling Smørgrav 	    "originator %s port %d", listen_address, listen_port,
1753d4af9e69SDag-Erling Smørgrav 	    originator_address, originator_port);
17541e8db6e2SBrian Feldman 
1755d4af9e69SDag-Erling Smørgrav 	c = channel_connect_by_listen_address(listen_port,
1756d4af9e69SDag-Erling Smørgrav 	    "forwarded-tcpip", originator_address);
1757d4af9e69SDag-Erling Smørgrav 
17581e8db6e2SBrian Feldman 	xfree(originator_address);
17591e8db6e2SBrian Feldman 	xfree(listen_address);
17601e8db6e2SBrian Feldman 	return c;
17611e8db6e2SBrian Feldman }
17621e8db6e2SBrian Feldman 
1763ae1f160dSDag-Erling Smørgrav static Channel *
17641e8db6e2SBrian Feldman client_request_x11(const char *request_type, int rchan)
17651e8db6e2SBrian Feldman {
17661e8db6e2SBrian Feldman 	Channel *c = NULL;
17671e8db6e2SBrian Feldman 	char *originator;
1768cce7d346SDag-Erling Smørgrav 	u_short originator_port;
1769ae1f160dSDag-Erling Smørgrav 	int sock;
17701e8db6e2SBrian Feldman 
17711e8db6e2SBrian Feldman 	if (!options.forward_x11) {
17721e8db6e2SBrian Feldman 		error("Warning: ssh server tried X11 forwarding.");
1773d4af9e69SDag-Erling Smørgrav 		error("Warning: this is probably a break-in attempt by a "
1774d4af9e69SDag-Erling Smørgrav 		    "malicious server.");
17751e8db6e2SBrian Feldman 		return NULL;
17761e8db6e2SBrian Feldman 	}
1777e2f6069cSDag-Erling Smørgrav 	if (x11_refuse_time != 0 && time(NULL) >= x11_refuse_time) {
1778e2f6069cSDag-Erling Smørgrav 		verbose("Rejected X11 connection after ForwardX11Timeout "
1779e2f6069cSDag-Erling Smørgrav 		    "expired");
1780e2f6069cSDag-Erling Smørgrav 		return NULL;
1781e2f6069cSDag-Erling Smørgrav 	}
17821e8db6e2SBrian Feldman 	originator = packet_get_string(NULL);
17831e8db6e2SBrian Feldman 	if (datafellows & SSH_BUG_X11FWD) {
17841e8db6e2SBrian Feldman 		debug2("buggy server: x11 request w/o originator_port");
17851e8db6e2SBrian Feldman 		originator_port = 0;
17861e8db6e2SBrian Feldman 	} else {
17871e8db6e2SBrian Feldman 		originator_port = packet_get_int();
17881e8db6e2SBrian Feldman 	}
1789ae1f160dSDag-Erling Smørgrav 	packet_check_eom();
17901e8db6e2SBrian Feldman 	/* XXX check permission */
17911e8db6e2SBrian Feldman 	debug("client_request_x11: request from %s %d", originator,
17921e8db6e2SBrian Feldman 	    originator_port);
1793ae1f160dSDag-Erling Smørgrav 	xfree(originator);
17941e8db6e2SBrian Feldman 	sock = x11_connect_display();
1795ae1f160dSDag-Erling Smørgrav 	if (sock < 0)
1796ae1f160dSDag-Erling Smørgrav 		return NULL;
179789986192SBrooks Davis 	if (options.hpn_disabled)
179889986192SBrooks Davis 		c = channel_new("x11", SSH_CHANNEL_X11_OPEN, sock, sock, -1,
179989986192SBrooks Davis 		    CHAN_TCP_WINDOW_DEFAULT, CHAN_X11_PACKET_DEFAULT,
180089986192SBrooks Davis 		    0, "x11", 1);
180189986192SBrooks Davis 	else
180289986192SBrooks Davis 		c = channel_new("x11", SSH_CHANNEL_X11_OPEN, sock, sock, -1,
180389986192SBrooks Davis 		    options.hpn_buffer_size, CHAN_X11_PACKET_DEFAULT,
180489986192SBrooks Davis 		    0, "x11", 1);
1805ae1f160dSDag-Erling Smørgrav 	c->force_drain = 1;
18061e8db6e2SBrian Feldman 	return c;
18071e8db6e2SBrian Feldman }
18081e8db6e2SBrian Feldman 
1809ae1f160dSDag-Erling Smørgrav static Channel *
18101e8db6e2SBrian Feldman client_request_agent(const char *request_type, int rchan)
18111e8db6e2SBrian Feldman {
18121e8db6e2SBrian Feldman 	Channel *c = NULL;
1813ae1f160dSDag-Erling Smørgrav 	int sock;
18141e8db6e2SBrian Feldman 
18151e8db6e2SBrian Feldman 	if (!options.forward_agent) {
18161e8db6e2SBrian Feldman 		error("Warning: ssh server tried agent forwarding.");
1817d4af9e69SDag-Erling Smørgrav 		error("Warning: this is probably a break-in attempt by a "
1818d4af9e69SDag-Erling Smørgrav 		    "malicious server.");
18191e8db6e2SBrian Feldman 		return NULL;
18201e8db6e2SBrian Feldman 	}
18211e8db6e2SBrian Feldman 	sock = ssh_get_authentication_socket();
1822ae1f160dSDag-Erling Smørgrav 	if (sock < 0)
1823ae1f160dSDag-Erling Smørgrav 		return NULL;
182489986192SBrooks Davis 	if (options.hpn_disabled)
1825ae1f160dSDag-Erling Smørgrav 		c = channel_new("authentication agent connection",
18261e8db6e2SBrian Feldman 		    SSH_CHANNEL_OPEN, sock, sock, -1,
182789986192SBrooks Davis 		    CHAN_X11_WINDOW_DEFAULT, CHAN_TCP_WINDOW_DEFAULT, 0,
182889986192SBrooks Davis 		    "authentication agent connection", 1);
182989986192SBrooks Davis 	else
183089986192SBrooks Davis 		c = channel_new("authentication agent connection",
183189986192SBrooks Davis 		    SSH_CHANNEL_OPEN, sock, sock, -1,
183289986192SBrooks Davis 		    options.hpn_buffer_size, options.hpn_buffer_size, 0,
1833d95e11bfSDag-Erling Smørgrav 		    "authentication agent connection", 1);
1834ae1f160dSDag-Erling Smørgrav 	c->force_drain = 1;
18351e8db6e2SBrian Feldman 	return c;
18361e8db6e2SBrian Feldman }
18371e8db6e2SBrian Feldman 
1838d4af9e69SDag-Erling Smørgrav int
1839d4af9e69SDag-Erling Smørgrav client_request_tun_fwd(int tun_mode, int local_tun, int remote_tun)
1840d4af9e69SDag-Erling Smørgrav {
1841d4af9e69SDag-Erling Smørgrav 	Channel *c;
1842d4af9e69SDag-Erling Smørgrav 	int fd;
1843d4af9e69SDag-Erling Smørgrav 
1844d4af9e69SDag-Erling Smørgrav 	if (tun_mode == SSH_TUNMODE_NO)
1845d4af9e69SDag-Erling Smørgrav 		return 0;
1846d4af9e69SDag-Erling Smørgrav 
1847d4af9e69SDag-Erling Smørgrav 	if (!compat20) {
1848cce7d346SDag-Erling Smørgrav 		error("Tunnel forwarding is not supported for protocol 1");
1849d4af9e69SDag-Erling Smørgrav 		return -1;
1850d4af9e69SDag-Erling Smørgrav 	}
1851d4af9e69SDag-Erling Smørgrav 
1852d4af9e69SDag-Erling Smørgrav 	debug("Requesting tun unit %d in mode %d", local_tun, tun_mode);
1853d4af9e69SDag-Erling Smørgrav 
1854d4af9e69SDag-Erling Smørgrav 	/* Open local tunnel device */
1855d4af9e69SDag-Erling Smørgrav 	if ((fd = tun_open(local_tun, tun_mode)) == -1) {
1856d4af9e69SDag-Erling Smørgrav 		error("Tunnel device open failed.");
1857d4af9e69SDag-Erling Smørgrav 		return -1;
1858d4af9e69SDag-Erling Smørgrav 	}
1859d4af9e69SDag-Erling Smørgrav 
186089986192SBrooks Davis 	if (options.hpn_disabled)
1861d4af9e69SDag-Erling Smørgrav 		c = channel_new("tun", SSH_CHANNEL_OPENING, fd, fd, -1,
186289986192SBrooks Davis 		    CHAN_TCP_WINDOW_DEFAULT, CHAN_TCP_PACKET_DEFAULT,
186389986192SBrooks Davis 		    0, "tun", 1);
186489986192SBrooks Davis 	else
186589986192SBrooks Davis 		c = channel_new("tun", SSH_CHANNEL_OPENING, fd, fd, -1,
186689986192SBrooks Davis 		    options.hpn_buffer_size, CHAN_TCP_PACKET_DEFAULT,
186789986192SBrooks Davis 		    0, "tun", 1);
1868d4af9e69SDag-Erling Smørgrav 	c->datagram = 1;
1869d4af9e69SDag-Erling Smørgrav 
1870d4af9e69SDag-Erling Smørgrav #if defined(SSH_TUN_FILTER)
1871d4af9e69SDag-Erling Smørgrav 	if (options.tun_open == SSH_TUNMODE_POINTOPOINT)
1872d4af9e69SDag-Erling Smørgrav 		channel_register_filter(c->self, sys_tun_infilter,
1873d4af9e69SDag-Erling Smørgrav 		    sys_tun_outfilter, NULL, NULL);
1874d4af9e69SDag-Erling Smørgrav #endif
1875d4af9e69SDag-Erling Smørgrav 
1876d4af9e69SDag-Erling Smørgrav 	packet_start(SSH2_MSG_CHANNEL_OPEN);
1877d4af9e69SDag-Erling Smørgrav 	packet_put_cstring("tun@openssh.com");
1878d4af9e69SDag-Erling Smørgrav 	packet_put_int(c->self);
1879d4af9e69SDag-Erling Smørgrav 	packet_put_int(c->local_window_max);
1880d4af9e69SDag-Erling Smørgrav 	packet_put_int(c->local_maxpacket);
1881d4af9e69SDag-Erling Smørgrav 	packet_put_int(tun_mode);
1882d4af9e69SDag-Erling Smørgrav 	packet_put_int(remote_tun);
1883d4af9e69SDag-Erling Smørgrav 	packet_send();
1884d4af9e69SDag-Erling Smørgrav 
1885d4af9e69SDag-Erling Smørgrav 	return 0;
1886d4af9e69SDag-Erling Smørgrav }
1887d4af9e69SDag-Erling Smørgrav 
1888a04a10f8SKris Kennaway /* XXXX move to generic input handler */
1889ae1f160dSDag-Erling Smørgrav static void
1890ae1f160dSDag-Erling Smørgrav client_input_channel_open(int type, u_int32_t seq, void *ctxt)
1891a04a10f8SKris Kennaway {
1892a04a10f8SKris Kennaway 	Channel *c = NULL;
1893a04a10f8SKris Kennaway 	char *ctype;
1894a04a10f8SKris Kennaway 	int rchan;
1895ee21a45fSDag-Erling Smørgrav 	u_int rmaxpack, rwindow, len;
1896a04a10f8SKris Kennaway 
1897a04a10f8SKris Kennaway 	ctype = packet_get_string(&len);
1898a04a10f8SKris Kennaway 	rchan = packet_get_int();
1899a04a10f8SKris Kennaway 	rwindow = packet_get_int();
1900a04a10f8SKris Kennaway 	rmaxpack = packet_get_int();
1901a04a10f8SKris Kennaway 
1902a04a10f8SKris Kennaway 	debug("client_input_channel_open: ctype %s rchan %d win %d max %d",
1903a04a10f8SKris Kennaway 	    ctype, rchan, rwindow, rmaxpack);
1904a04a10f8SKris Kennaway 
19051e8db6e2SBrian Feldman 	if (strcmp(ctype, "forwarded-tcpip") == 0) {
19061e8db6e2SBrian Feldman 		c = client_request_forwarded_tcpip(ctype, rchan);
19071e8db6e2SBrian Feldman 	} else if (strcmp(ctype, "x11") == 0) {
19081e8db6e2SBrian Feldman 		c = client_request_x11(ctype, rchan);
19091e8db6e2SBrian Feldman 	} else if (strcmp(ctype, "auth-agent@openssh.com") == 0) {
19101e8db6e2SBrian Feldman 		c = client_request_agent(ctype, rchan);
1911a04a10f8SKris Kennaway 	}
1912a04a10f8SKris Kennaway /* XXX duplicate : */
1913a04a10f8SKris Kennaway 	if (c != NULL) {
1914a04a10f8SKris Kennaway 		debug("confirm %s", ctype);
1915a04a10f8SKris Kennaway 		c->remote_id = rchan;
1916a04a10f8SKris Kennaway 		c->remote_window = rwindow;
1917a04a10f8SKris Kennaway 		c->remote_maxpacket = rmaxpack;
1918ae1f160dSDag-Erling Smørgrav 		if (c->type != SSH_CHANNEL_CONNECTING) {
1919a04a10f8SKris Kennaway 			packet_start(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
1920a04a10f8SKris Kennaway 			packet_put_int(c->remote_id);
1921a04a10f8SKris Kennaway 			packet_put_int(c->self);
1922a04a10f8SKris Kennaway 			packet_put_int(c->local_window);
1923a04a10f8SKris Kennaway 			packet_put_int(c->local_maxpacket);
1924a04a10f8SKris Kennaway 			packet_send();
1925ae1f160dSDag-Erling Smørgrav 		}
1926a04a10f8SKris Kennaway 	} else {
1927a04a10f8SKris Kennaway 		debug("failure %s", ctype);
1928a04a10f8SKris Kennaway 		packet_start(SSH2_MSG_CHANNEL_OPEN_FAILURE);
1929a04a10f8SKris Kennaway 		packet_put_int(rchan);
1930a04a10f8SKris Kennaway 		packet_put_int(SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED);
1931ae1f160dSDag-Erling Smørgrav 		if (!(datafellows & SSH_BUG_OPENFAILURE)) {
1932ae1f160dSDag-Erling Smørgrav 			packet_put_cstring("open failed");
1933a04a10f8SKris Kennaway 			packet_put_cstring("");
1934ae1f160dSDag-Erling Smørgrav 		}
1935a04a10f8SKris Kennaway 		packet_send();
1936a04a10f8SKris Kennaway 	}
1937a04a10f8SKris Kennaway 	xfree(ctype);
1938a04a10f8SKris Kennaway }
1939ae1f160dSDag-Erling Smørgrav static void
1940ae1f160dSDag-Erling Smørgrav client_input_channel_req(int type, u_int32_t seq, void *ctxt)
19411e8db6e2SBrian Feldman {
19421e8db6e2SBrian Feldman 	Channel *c = NULL;
1943d74d50a8SDag-Erling Smørgrav 	int exitval, id, reply, success = 0;
19441e8db6e2SBrian Feldman 	char *rtype;
19451e8db6e2SBrian Feldman 
19461e8db6e2SBrian Feldman 	id = packet_get_int();
19471e8db6e2SBrian Feldman 	rtype = packet_get_string(NULL);
19481e8db6e2SBrian Feldman 	reply = packet_get_char();
19491e8db6e2SBrian Feldman 
19501e8db6e2SBrian Feldman 	debug("client_input_channel_req: channel %d rtype %s reply %d",
19511e8db6e2SBrian Feldman 	    id, rtype, reply);
19521e8db6e2SBrian Feldman 
1953d74d50a8SDag-Erling Smørgrav 	if (id == -1) {
1954d74d50a8SDag-Erling Smørgrav 		error("client_input_channel_req: request for channel -1");
1955d74d50a8SDag-Erling Smørgrav 	} else if ((c = channel_lookup(id)) == NULL) {
1956d4af9e69SDag-Erling Smørgrav 		error("client_input_channel_req: channel %d: "
1957d4af9e69SDag-Erling Smørgrav 		    "unknown channel", id);
1958d4af9e69SDag-Erling Smørgrav 	} else if (strcmp(rtype, "eow@openssh.com") == 0) {
1959d4af9e69SDag-Erling Smørgrav 		packet_check_eom();
1960d4af9e69SDag-Erling Smørgrav 		chan_rcvd_eow(c);
19611e8db6e2SBrian Feldman 	} else if (strcmp(rtype, "exit-status") == 0) {
1962d74d50a8SDag-Erling Smørgrav 		exitval = packet_get_int();
1963b15c8340SDag-Erling Smørgrav 		if (c->ctl_chan != -1) {
1964b15c8340SDag-Erling Smørgrav 			mux_exit_message(c, exitval);
1965b15c8340SDag-Erling Smørgrav 			success = 1;
1966b15c8340SDag-Erling Smørgrav 		} else if (id == session_ident) {
1967b15c8340SDag-Erling Smørgrav 			/* Record exit value of local session */
19681e8db6e2SBrian Feldman 			success = 1;
1969d74d50a8SDag-Erling Smørgrav 			exit_status = exitval;
1970d74d50a8SDag-Erling Smørgrav 		} else {
1971b15c8340SDag-Erling Smørgrav 			/* Probably for a mux channel that has already closed */
1972b15c8340SDag-Erling Smørgrav 			debug("%s: no sink for exit-status on channel %d",
1973b15c8340SDag-Erling Smørgrav 			    __func__, id);
1974d74d50a8SDag-Erling Smørgrav 		}
1975ae1f160dSDag-Erling Smørgrav 		packet_check_eom();
19761e8db6e2SBrian Feldman 	}
19774a421b63SDag-Erling Smørgrav 	if (reply && c != NULL) {
19781e8db6e2SBrian Feldman 		packet_start(success ?
19791e8db6e2SBrian Feldman 		    SSH2_MSG_CHANNEL_SUCCESS : SSH2_MSG_CHANNEL_FAILURE);
1980cce7d346SDag-Erling Smørgrav 		packet_put_int(c->remote_id);
19811e8db6e2SBrian Feldman 		packet_send();
19821e8db6e2SBrian Feldman 	}
19831e8db6e2SBrian Feldman 	xfree(rtype);
19841e8db6e2SBrian Feldman }
1985ae1f160dSDag-Erling Smørgrav static void
1986ae1f160dSDag-Erling Smørgrav client_input_global_request(int type, u_int32_t seq, void *ctxt)
1987ae1f160dSDag-Erling Smørgrav {
1988ae1f160dSDag-Erling Smørgrav 	char *rtype;
1989ae1f160dSDag-Erling Smørgrav 	int want_reply;
1990ae1f160dSDag-Erling Smørgrav 	int success = 0;
1991a04a10f8SKris Kennaway 
1992ae1f160dSDag-Erling Smørgrav 	rtype = packet_get_string(NULL);
1993ae1f160dSDag-Erling Smørgrav 	want_reply = packet_get_char();
1994efcad6b7SDag-Erling Smørgrav 	debug("client_input_global_request: rtype %s want_reply %d",
1995efcad6b7SDag-Erling Smørgrav 	    rtype, want_reply);
1996ae1f160dSDag-Erling Smørgrav 	if (want_reply) {
1997ae1f160dSDag-Erling Smørgrav 		packet_start(success ?
1998ae1f160dSDag-Erling Smørgrav 		    SSH2_MSG_REQUEST_SUCCESS : SSH2_MSG_REQUEST_FAILURE);
1999ae1f160dSDag-Erling Smørgrav 		packet_send();
2000ae1f160dSDag-Erling Smørgrav 		packet_write_wait();
2001ae1f160dSDag-Erling Smørgrav 	}
2002ae1f160dSDag-Erling Smørgrav 	xfree(rtype);
2003ae1f160dSDag-Erling Smørgrav }
2004ae1f160dSDag-Erling Smørgrav 
2005d74d50a8SDag-Erling Smørgrav void
2006d74d50a8SDag-Erling Smørgrav client_session2_setup(int id, int want_tty, int want_subsystem,
2007d4af9e69SDag-Erling Smørgrav     const char *term, struct termios *tiop, int in_fd, Buffer *cmd, char **env)
2008d74d50a8SDag-Erling Smørgrav {
2009d74d50a8SDag-Erling Smørgrav 	int len;
20105e8dbd04SDag-Erling Smørgrav 	Channel *c = NULL;
2011d74d50a8SDag-Erling Smørgrav 
2012d74d50a8SDag-Erling Smørgrav 	debug2("%s: id %d", __func__, id);
2013d74d50a8SDag-Erling Smørgrav 
20145e8dbd04SDag-Erling Smørgrav 	if ((c = channel_lookup(id)) == NULL)
20155e8dbd04SDag-Erling Smørgrav 		fatal("client_session2_setup: channel %d: unknown channel", id);
20165e8dbd04SDag-Erling Smørgrav 
20174a421b63SDag-Erling Smørgrav 	packet_set_interactive(want_tty,
20184a421b63SDag-Erling Smørgrav 	    options.ip_qos_interactive, options.ip_qos_bulk);
20194a421b63SDag-Erling Smørgrav 
2020d74d50a8SDag-Erling Smørgrav 	if (want_tty) {
2021d74d50a8SDag-Erling Smørgrav 		struct winsize ws;
2022d74d50a8SDag-Erling Smørgrav 
2023d74d50a8SDag-Erling Smørgrav 		/* Store window size in the packet. */
2024d74d50a8SDag-Erling Smørgrav 		if (ioctl(in_fd, TIOCGWINSZ, &ws) < 0)
2025d74d50a8SDag-Erling Smørgrav 			memset(&ws, 0, sizeof(ws));
2026d74d50a8SDag-Erling Smørgrav 
2027d4af9e69SDag-Erling Smørgrav 		channel_request_start(id, "pty-req", 1);
2028*e146993eSDag-Erling Smørgrav 		client_expect_confirm(id, "PTY allocation", CONFIRM_TTY);
2029d74d50a8SDag-Erling Smørgrav 		packet_put_cstring(term != NULL ? term : "");
2030761efaa7SDag-Erling Smørgrav 		packet_put_int((u_int)ws.ws_col);
2031761efaa7SDag-Erling Smørgrav 		packet_put_int((u_int)ws.ws_row);
2032761efaa7SDag-Erling Smørgrav 		packet_put_int((u_int)ws.ws_xpixel);
2033761efaa7SDag-Erling Smørgrav 		packet_put_int((u_int)ws.ws_ypixel);
2034d4af9e69SDag-Erling Smørgrav 		if (tiop == NULL)
2035d4af9e69SDag-Erling Smørgrav 			tiop = get_saved_tio();
2036d4af9e69SDag-Erling Smørgrav 		tty_make_modes(-1, tiop);
2037d74d50a8SDag-Erling Smørgrav 		packet_send();
2038d74d50a8SDag-Erling Smørgrav 		/* XXX wait for reply */
20395e8dbd04SDag-Erling Smørgrav 		c->client_tty = 1;
2040d74d50a8SDag-Erling Smørgrav 	}
2041d74d50a8SDag-Erling Smørgrav 
2042d74d50a8SDag-Erling Smørgrav 	/* Transfer any environment variables from client to server */
2043d74d50a8SDag-Erling Smørgrav 	if (options.num_send_env != 0 && env != NULL) {
2044d74d50a8SDag-Erling Smørgrav 		int i, j, matched;
2045d74d50a8SDag-Erling Smørgrav 		char *name, *val;
2046d74d50a8SDag-Erling Smørgrav 
2047d74d50a8SDag-Erling Smørgrav 		debug("Sending environment.");
2048d74d50a8SDag-Erling Smørgrav 		for (i = 0; env[i] != NULL; i++) {
2049d74d50a8SDag-Erling Smørgrav 			/* Split */
2050d74d50a8SDag-Erling Smørgrav 			name = xstrdup(env[i]);
2051d74d50a8SDag-Erling Smørgrav 			if ((val = strchr(name, '=')) == NULL) {
2052021d409fSDag-Erling Smørgrav 				xfree(name);
2053d74d50a8SDag-Erling Smørgrav 				continue;
2054d74d50a8SDag-Erling Smørgrav 			}
2055d74d50a8SDag-Erling Smørgrav 			*val++ = '\0';
2056d74d50a8SDag-Erling Smørgrav 
2057d74d50a8SDag-Erling Smørgrav 			matched = 0;
2058d74d50a8SDag-Erling Smørgrav 			for (j = 0; j < options.num_send_env; j++) {
2059d74d50a8SDag-Erling Smørgrav 				if (match_pattern(name, options.send_env[j])) {
2060d74d50a8SDag-Erling Smørgrav 					matched = 1;
2061d74d50a8SDag-Erling Smørgrav 					break;
2062d74d50a8SDag-Erling Smørgrav 				}
2063d74d50a8SDag-Erling Smørgrav 			}
2064d74d50a8SDag-Erling Smørgrav 			if (!matched) {
2065d74d50a8SDag-Erling Smørgrav 				debug3("Ignored env %s", name);
2066021d409fSDag-Erling Smørgrav 				xfree(name);
2067d74d50a8SDag-Erling Smørgrav 				continue;
2068d74d50a8SDag-Erling Smørgrav 			}
2069d74d50a8SDag-Erling Smørgrav 
2070d74d50a8SDag-Erling Smørgrav 			debug("Sending env %s = %s", name, val);
2071d74d50a8SDag-Erling Smørgrav 			channel_request_start(id, "env", 0);
2072d74d50a8SDag-Erling Smørgrav 			packet_put_cstring(name);
2073d74d50a8SDag-Erling Smørgrav 			packet_put_cstring(val);
2074d74d50a8SDag-Erling Smørgrav 			packet_send();
2075021d409fSDag-Erling Smørgrav 			xfree(name);
2076d74d50a8SDag-Erling Smørgrav 		}
2077d74d50a8SDag-Erling Smørgrav 	}
2078d74d50a8SDag-Erling Smørgrav 
2079d74d50a8SDag-Erling Smørgrav 	len = buffer_len(cmd);
2080d74d50a8SDag-Erling Smørgrav 	if (len > 0) {
2081d74d50a8SDag-Erling Smørgrav 		if (len > 900)
2082d74d50a8SDag-Erling Smørgrav 			len = 900;
2083d74d50a8SDag-Erling Smørgrav 		if (want_subsystem) {
2084d4af9e69SDag-Erling Smørgrav 			debug("Sending subsystem: %.*s",
2085d4af9e69SDag-Erling Smørgrav 			    len, (u_char*)buffer_ptr(cmd));
2086d4af9e69SDag-Erling Smørgrav 			channel_request_start(id, "subsystem", 1);
2087*e146993eSDag-Erling Smørgrav 			client_expect_confirm(id, "subsystem", CONFIRM_CLOSE);
2088d74d50a8SDag-Erling Smørgrav 		} else {
2089d4af9e69SDag-Erling Smørgrav 			debug("Sending command: %.*s",
2090d4af9e69SDag-Erling Smørgrav 			    len, (u_char*)buffer_ptr(cmd));
2091d4af9e69SDag-Erling Smørgrav 			channel_request_start(id, "exec", 1);
2092*e146993eSDag-Erling Smørgrav 			client_expect_confirm(id, "exec", CONFIRM_CLOSE);
2093d74d50a8SDag-Erling Smørgrav 		}
2094d74d50a8SDag-Erling Smørgrav 		packet_put_string(buffer_ptr(cmd), buffer_len(cmd));
2095d74d50a8SDag-Erling Smørgrav 		packet_send();
2096d74d50a8SDag-Erling Smørgrav 	} else {
2097d4af9e69SDag-Erling Smørgrav 		channel_request_start(id, "shell", 1);
2098*e146993eSDag-Erling Smørgrav 		client_expect_confirm(id, "shell", CONFIRM_CLOSE);
2099d74d50a8SDag-Erling Smørgrav 		packet_send();
2100d74d50a8SDag-Erling Smørgrav 	}
2101d74d50a8SDag-Erling Smørgrav }
2102d74d50a8SDag-Erling Smørgrav 
2103ae1f160dSDag-Erling Smørgrav static void
21041e8db6e2SBrian Feldman client_init_dispatch_20(void)
2105a04a10f8SKris Kennaway {
2106a04a10f8SKris Kennaway 	dispatch_init(&dispatch_protocol_error);
2107545d5ecaSDag-Erling Smørgrav 
2108a04a10f8SKris Kennaway 	dispatch_set(SSH2_MSG_CHANNEL_CLOSE, &channel_input_oclose);
2109a04a10f8SKris Kennaway 	dispatch_set(SSH2_MSG_CHANNEL_DATA, &channel_input_data);
2110a04a10f8SKris Kennaway 	dispatch_set(SSH2_MSG_CHANNEL_EOF, &channel_input_ieof);
2111a04a10f8SKris Kennaway 	dispatch_set(SSH2_MSG_CHANNEL_EXTENDED_DATA, &channel_input_extended_data);
2112a04a10f8SKris Kennaway 	dispatch_set(SSH2_MSG_CHANNEL_OPEN, &client_input_channel_open);
2113a04a10f8SKris Kennaway 	dispatch_set(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);
2114a04a10f8SKris Kennaway 	dispatch_set(SSH2_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);
21151e8db6e2SBrian Feldman 	dispatch_set(SSH2_MSG_CHANNEL_REQUEST, &client_input_channel_req);
2116a04a10f8SKris Kennaway 	dispatch_set(SSH2_MSG_CHANNEL_WINDOW_ADJUST, &channel_input_window_adjust);
2117d4af9e69SDag-Erling Smørgrav 	dispatch_set(SSH2_MSG_CHANNEL_SUCCESS, &channel_input_status_confirm);
2118d4af9e69SDag-Erling Smørgrav 	dispatch_set(SSH2_MSG_CHANNEL_FAILURE, &channel_input_status_confirm);
2119ae1f160dSDag-Erling Smørgrav 	dispatch_set(SSH2_MSG_GLOBAL_REQUEST, &client_input_global_request);
21201e8db6e2SBrian Feldman 
21211e8db6e2SBrian Feldman 	/* rekeying */
21221e8db6e2SBrian Feldman 	dispatch_set(SSH2_MSG_KEXINIT, &kex_input_kexinit);
2123545d5ecaSDag-Erling Smørgrav 
2124545d5ecaSDag-Erling Smørgrav 	/* global request reply messages */
2125545d5ecaSDag-Erling Smørgrav 	dispatch_set(SSH2_MSG_REQUEST_FAILURE, &client_global_request_reply);
2126545d5ecaSDag-Erling Smørgrav 	dispatch_set(SSH2_MSG_REQUEST_SUCCESS, &client_global_request_reply);
2127a04a10f8SKris Kennaway }
2128d4af9e69SDag-Erling Smørgrav 
2129ae1f160dSDag-Erling Smørgrav static void
21301e8db6e2SBrian Feldman client_init_dispatch_13(void)
2131a04a10f8SKris Kennaway {
2132a04a10f8SKris Kennaway 	dispatch_init(NULL);
2133a04a10f8SKris Kennaway 	dispatch_set(SSH_MSG_CHANNEL_CLOSE, &channel_input_close);
2134a04a10f8SKris Kennaway 	dispatch_set(SSH_MSG_CHANNEL_CLOSE_CONFIRMATION, &channel_input_close_confirmation);
2135a04a10f8SKris Kennaway 	dispatch_set(SSH_MSG_CHANNEL_DATA, &channel_input_data);
2136a04a10f8SKris Kennaway 	dispatch_set(SSH_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);
2137a04a10f8SKris Kennaway 	dispatch_set(SSH_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);
2138a04a10f8SKris Kennaway 	dispatch_set(SSH_MSG_PORT_OPEN, &channel_input_port_open);
2139a04a10f8SKris Kennaway 	dispatch_set(SSH_SMSG_EXITSTATUS, &client_input_exit_status);
2140a04a10f8SKris Kennaway 	dispatch_set(SSH_SMSG_STDERR_DATA, &client_input_stderr_data);
2141a04a10f8SKris Kennaway 	dispatch_set(SSH_SMSG_STDOUT_DATA, &client_input_stdout_data);
21424899dde7SBrian Feldman 
21434899dde7SBrian Feldman 	dispatch_set(SSH_SMSG_AGENT_OPEN, options.forward_agent ?
2144efcad6b7SDag-Erling Smørgrav 	    &client_input_agent_open : &deny_input_open);
21454899dde7SBrian Feldman 	dispatch_set(SSH_SMSG_X11_OPEN, options.forward_x11 ?
21465b9b2fafSBrian Feldman 	    &x11_input_open : &deny_input_open);
2147a04a10f8SKris Kennaway }
2148d4af9e69SDag-Erling Smørgrav 
2149ae1f160dSDag-Erling Smørgrav static void
21501e8db6e2SBrian Feldman client_init_dispatch_15(void)
2151a04a10f8SKris Kennaway {
2152a04a10f8SKris Kennaway 	client_init_dispatch_13();
2153a04a10f8SKris Kennaway 	dispatch_set(SSH_MSG_CHANNEL_CLOSE, &channel_input_ieof);
2154a04a10f8SKris Kennaway 	dispatch_set(SSH_MSG_CHANNEL_CLOSE_CONFIRMATION, & channel_input_oclose);
2155a04a10f8SKris Kennaway }
2156d4af9e69SDag-Erling Smørgrav 
2157ae1f160dSDag-Erling Smørgrav static void
21581e8db6e2SBrian Feldman client_init_dispatch(void)
2159a04a10f8SKris Kennaway {
2160a04a10f8SKris Kennaway 	if (compat20)
2161a04a10f8SKris Kennaway 		client_init_dispatch_20();
2162a04a10f8SKris Kennaway 	else if (compat13)
2163a04a10f8SKris Kennaway 		client_init_dispatch_13();
2164a04a10f8SKris Kennaway 	else
2165a04a10f8SKris Kennaway 		client_init_dispatch_15();
2166a04a10f8SKris Kennaway }
2167efcad6b7SDag-Erling Smørgrav 
2168*e146993eSDag-Erling Smørgrav void
2169*e146993eSDag-Erling Smørgrav client_stop_mux(void)
2170*e146993eSDag-Erling Smørgrav {
2171*e146993eSDag-Erling Smørgrav 	if (options.control_path != NULL && muxserver_sock != -1)
2172*e146993eSDag-Erling Smørgrav 		unlink(options.control_path);
2173*e146993eSDag-Erling Smørgrav 	/*
2174*e146993eSDag-Erling Smørgrav 	 * If we are in persist mode, signal that we should close when all
2175*e146993eSDag-Erling Smørgrav 	 * active channels are closed.
2176*e146993eSDag-Erling Smørgrav 	 */
2177*e146993eSDag-Erling Smørgrav 	if (options.control_persist) {
2178*e146993eSDag-Erling Smørgrav 		session_closed = 1;
2179*e146993eSDag-Erling Smørgrav 		setproctitle("[stopped mux]");
2180*e146993eSDag-Erling Smørgrav 	}
2181*e146993eSDag-Erling Smørgrav }
2182*e146993eSDag-Erling Smørgrav 
2183efcad6b7SDag-Erling Smørgrav /* client specific fatal cleanup */
2184efcad6b7SDag-Erling Smørgrav void
2185efcad6b7SDag-Erling Smørgrav cleanup_exit(int i)
2186efcad6b7SDag-Erling Smørgrav {
2187*e146993eSDag-Erling Smørgrav 	leave_raw_mode(options.request_tty == REQUEST_TTY_FORCE);
2188efcad6b7SDag-Erling Smørgrav 	leave_non_blocking();
2189d4af9e69SDag-Erling Smørgrav 	if (options.control_path != NULL && muxserver_sock != -1)
2190d74d50a8SDag-Erling Smørgrav 		unlink(options.control_path);
21914a421b63SDag-Erling Smørgrav 	ssh_kill_proxy_command();
2192efcad6b7SDag-Erling Smørgrav 	_exit(i);
2193efcad6b7SDag-Erling Smørgrav }
2194