blob: 7e373f01bc59c030b41867b8c7e5664d2127e108 [file] [log] [blame]
Damien Miller985a4482006-10-24 03:02:41 +10001/* $OpenBSD: serverloop.c,v 1.145 2006/10/11 12:38:03 markus Exp $ */
Damien Millerd4a8b7e1999-10-27 13:42:43 +10002/*
Damien Miller95def091999-11-25 00:26:21 +11003 * Author: Tatu Ylonen <ylo@cs.hut.fi>
4 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
5 * All rights reserved
Damien Miller95def091999-11-25 00:26:21 +11006 * Server main loop for handling the interactive session.
Damien Millere4340be2000-09-16 13:29:08 +11007 *
8 * As far as I am concerned, the code I have written for this software
9 * can be used freely for any purpose. Any derived versions of this
10 * software must be clearly marked as such, and if the derived work is
11 * incompatible with the protocol description in the RFC file, it must be
12 * called by a name other than "ssh" or "Secure Shell".
13 *
Damien Millerefb4afe2000-04-12 18:45:05 +100014 * SSH2 support by Markus Friedl.
Ben Lindstrom44697232001-07-04 03:32:30 +000015 * Copyright (c) 2000, 2001 Markus Friedl. All rights reserved.
Damien Millere4340be2000-09-16 13:29:08 +110016 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions
19 * are met:
20 * 1. Redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer.
22 * 2. Redistributions in binary form must reproduce the above copyright
23 * notice, this list of conditions and the following disclaimer in the
24 * documentation and/or other materials provided with the distribution.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
27 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
28 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
29 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
30 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
31 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
35 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Damien Millerefb4afe2000-04-12 18:45:05 +100036 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100037
38#include "includes.h"
Damien Miller9cf6d072006-03-15 11:29:24 +110039
40#include <sys/types.h>
Damien Miller8dbffe72006-08-05 11:02:17 +100041#include <sys/param.h>
Damien Miller9cf6d072006-03-15 11:29:24 +110042#include <sys/wait.h>
Damien Miller8ec8c3e2006-07-10 20:35:38 +100043#include <sys/socket.h>
Damien Miller9aec9192006-08-05 10:57:45 +100044#ifdef HAVE_SYS_TIME_H
45# include <sys/time.h>
46#endif
Damien Miller8ec8c3e2006-07-10 20:35:38 +100047
48#include <netinet/in.h>
Damien Miller99bd21e2006-03-15 11:11:28 +110049
Darren Tucker39972492006-07-12 22:22:46 +100050#include <errno.h>
Damien Miller57cf6382006-07-10 21:13:46 +100051#include <fcntl.h>
Damien Miller9f2abc42006-07-10 20:53:08 +100052#include <pwd.h>
Damien Miller6ff3cad2006-03-15 11:52:09 +110053#include <signal.h>
Damien Millere3476ed2006-07-24 14:13:33 +100054#include <string.h>
Damien Miller99bd21e2006-03-15 11:11:28 +110055#include <termios.h>
Damien Miller1cdde6f2006-07-24 14:07:35 +100056#include <unistd.h>
Damien Millerd7834352006-08-05 12:39:39 +100057#include <stdarg.h>
Damien Miller69b69aa2000-10-28 14:19:58 +110058
Damien Millerd4a8b7e1999-10-27 13:42:43 +100059#include "xmalloc.h"
Damien Millerd4a8b7e1999-10-27 13:42:43 +100060#include "packet.h"
61#include "buffer.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000062#include "log.h"
Damien Millerd4a8b7e1999-10-27 13:42:43 +100063#include "servconf.h"
Damien Miller16aed052002-09-22 01:26:27 +100064#include "canohost.h"
Ben Lindstromd95c09c2001-02-18 19:13:33 +000065#include "sshpty.h"
Ben Lindstromc7637672001-06-09 00:36:26 +000066#include "channels.h"
Damien Millerb38eff82000-04-01 11:09:21 +100067#include "compat.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000068#include "ssh1.h"
Damien Millerefb4afe2000-04-12 18:45:05 +100069#include "ssh2.h"
Damien Millerd7834352006-08-05 12:39:39 +100070#include "key.h"
71#include "cipher.h"
72#include "kex.h"
73#include "hostfile.h"
Ben Lindstromdb65e8f2001-01-19 04:26:52 +000074#include "auth.h"
Damien Millerefb4afe2000-04-12 18:45:05 +100075#include "session.h"
Damien Millerb38eff82000-04-01 11:09:21 +100076#include "dispatch.h"
Damien Millerf6d9e222000-06-18 14:50:44 +100077#include "auth-options.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000078#include "serverloop.h"
79#include "misc.h"
Damien Millerd4a8b7e1999-10-27 13:42:43 +100080
Damien Miller50a41ed2000-10-16 12:14:42 +110081extern ServerOptions options;
82
Ben Lindstrom8ac91062001-04-04 17:57:54 +000083/* XXX */
84extern Kex *xxx_kex;
Darren Tucker3e33cec2003-10-02 16:12:36 +100085extern Authctxt *the_authctxt;
Damien Miller24ecf612005-11-05 15:16:52 +110086extern int use_privsep;
Ben Lindstrom8ac91062001-04-04 17:57:54 +000087
Damien Millerd4a8b7e1999-10-27 13:42:43 +100088static Buffer stdin_buffer; /* Buffer for stdin data. */
89static Buffer stdout_buffer; /* Buffer for stdout data. */
90static Buffer stderr_buffer; /* Buffer for stderr data. */
91static int fdin; /* Descriptor for stdin (for writing) */
92static int fdout; /* Descriptor for stdout (for reading);
93 May be same number as fdin. */
94static int fderr; /* Descriptor for stderr. May be -1. */
95static long stdin_bytes = 0; /* Number of bytes written to stdin. */
96static long stdout_bytes = 0; /* Number of stdout bytes sent to client. */
97static long stderr_bytes = 0; /* Number of stderr bytes sent to client. */
98static long fdout_bytes = 0; /* Number of stdout bytes read from program. */
99static int stdin_eof = 0; /* EOF message received from client. */
100static int fdout_eof = 0; /* EOF encountered reading from fdout. */
101static int fderr_eof = 0; /* EOF encountered readung from fderr. */
Damien Miller225736c2001-02-19 21:51:08 +1100102static int fdin_is_tty = 0; /* fdin points to a tty. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000103static int connection_in; /* Connection to client (input). */
104static int connection_out; /* Connection to client (output). */
Ben Lindstrome34ab4c2001-04-07 01:12:11 +0000105static int connection_closed = 0; /* Connection to client closed. */
106static u_int buffer_high; /* "Soft" max buffer size. */
Damien Miller8c3902a2001-10-10 15:01:40 +1000107static int client_alive_timeouts = 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000108
Damien Miller5428f641999-11-25 11:54:57 +1100109/*
110 * This SIGCHLD kludge is used to detect when the child exits. The server
111 * will exit after that, as soon as forwarded connections have terminated.
112 */
Ben Lindstrombba81212001-06-25 05:01:22 +0000113
Ben Lindstrom5e71c542001-12-06 16:48:14 +0000114static volatile sig_atomic_t child_terminated = 0; /* The child has terminated. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000115
Damien Miller24ecf612005-11-05 15:16:52 +1100116/* Cleanup on signals (!use_privsep case only) */
117static volatile sig_atomic_t received_sigterm = 0;
118
Ben Lindstrombba81212001-06-25 05:01:22 +0000119/* prototypes */
120static void server_init_dispatch(void);
Damien Millerb38eff82000-04-01 11:09:21 +1000121
Damien Millerf6681a32001-12-21 14:53:11 +1100122/*
123 * we write to this pipe if a SIGCHLD is caught in order to avoid
124 * the race between select() and child_terminated
125 */
126static int notify_pipe[2];
127static void
128notify_setup(void)
129{
130 if (pipe(notify_pipe) < 0) {
131 error("pipe(notify_pipe) failed %s", strerror(errno));
132 } else if ((fcntl(notify_pipe[0], F_SETFD, 1) == -1) ||
133 (fcntl(notify_pipe[1], F_SETFD, 1) == -1)) {
134 error("fcntl(notify_pipe, F_SETFD) failed %s", strerror(errno));
135 close(notify_pipe[0]);
136 close(notify_pipe[1]);
137 } else {
138 set_nonblock(notify_pipe[0]);
139 set_nonblock(notify_pipe[1]);
140 return;
141 }
142 notify_pipe[0] = -1; /* read end */
143 notify_pipe[1] = -1; /* write end */
144}
145static void
146notify_parent(void)
147{
148 if (notify_pipe[1] != -1)
149 write(notify_pipe[1], "", 1);
150}
151static void
152notify_prepare(fd_set *readset)
153{
154 if (notify_pipe[0] != -1)
155 FD_SET(notify_pipe[0], readset);
156}
157static void
158notify_done(fd_set *readset)
159{
160 char c;
161
162 if (notify_pipe[0] != -1 && FD_ISSET(notify_pipe[0], readset))
163 while (read(notify_pipe[0], &c, 1) != -1)
164 debug2("notify_done: reading");
165}
166
Damien Millerf0b15df2006-03-26 13:59:20 +1100167/*ARGSUSED*/
Ben Lindstrombba81212001-06-25 05:01:22 +0000168static void
Damien Miller95def091999-11-25 00:26:21 +1100169sigchld_handler(int sig)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000170{
Damien Miller95def091999-11-25 00:26:21 +1100171 int save_errno = errno;
Damien Millerefb4afe2000-04-12 18:45:05 +1000172 child_terminated = 1;
Tim Rice81ed5182002-09-25 17:38:46 -0700173#ifndef _UNICOS
Ben Lindstromec46e0b2001-06-09 01:27:31 +0000174 mysignal(SIGCHLD, sigchld_handler);
Tim Rice81ed5182002-09-25 17:38:46 -0700175#endif
Damien Millerf6681a32001-12-21 14:53:11 +1100176 notify_parent();
Damien Millerefb4afe2000-04-12 18:45:05 +1000177 errno = save_errno;
178}
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000179
Damien Millerf0b15df2006-03-26 13:59:20 +1100180/*ARGSUSED*/
Damien Miller24ecf612005-11-05 15:16:52 +1100181static void
182sigterm_handler(int sig)
183{
184 received_sigterm = sig;
185}
186
Damien Miller95def091999-11-25 00:26:21 +1100187/*
Damien Miller95def091999-11-25 00:26:21 +1100188 * Make packets from buffered stderr data, and buffer it for sending
189 * to the client.
190 */
Ben Lindstrombba81212001-06-25 05:01:22 +0000191static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +0000192make_packets_from_stderr_data(void)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000193{
Darren Tucker502d3842003-06-28 12:38:01 +1000194 u_int len;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000195
Damien Miller95def091999-11-25 00:26:21 +1100196 /* Send buffered stderr data to the client. */
197 while (buffer_len(&stderr_buffer) > 0 &&
Damien Miller037a0dc1999-12-07 15:38:31 +1100198 packet_not_very_much_data_to_write()) {
Damien Miller95def091999-11-25 00:26:21 +1100199 len = buffer_len(&stderr_buffer);
200 if (packet_is_interactive()) {
201 if (len > 512)
202 len = 512;
203 } else {
204 /* Keep the packets at reasonable size. */
205 if (len > packet_get_maxsize())
206 len = packet_get_maxsize();
207 }
208 packet_start(SSH_SMSG_STDERR_DATA);
209 packet_put_string(buffer_ptr(&stderr_buffer), len);
210 packet_send();
211 buffer_consume(&stderr_buffer, len);
212 stderr_bytes += len;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000213 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000214}
215
Damien Miller95def091999-11-25 00:26:21 +1100216/*
217 * Make packets from buffered stdout data, and buffer it for sending to the
218 * client.
219 */
Ben Lindstrombba81212001-06-25 05:01:22 +0000220static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +0000221make_packets_from_stdout_data(void)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000222{
Darren Tucker502d3842003-06-28 12:38:01 +1000223 u_int len;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000224
Damien Miller95def091999-11-25 00:26:21 +1100225 /* Send buffered stdout data to the client. */
226 while (buffer_len(&stdout_buffer) > 0 &&
Damien Miller037a0dc1999-12-07 15:38:31 +1100227 packet_not_very_much_data_to_write()) {
Damien Miller95def091999-11-25 00:26:21 +1100228 len = buffer_len(&stdout_buffer);
229 if (packet_is_interactive()) {
230 if (len > 512)
231 len = 512;
232 } else {
233 /* Keep the packets at reasonable size. */
234 if (len > packet_get_maxsize())
Kevin Stevesef4eea92001-02-05 12:42:17 +0000235 len = packet_get_maxsize();
Damien Miller95def091999-11-25 00:26:21 +1100236 }
237 packet_start(SSH_SMSG_STDOUT_DATA);
238 packet_put_string(buffer_ptr(&stdout_buffer), len);
239 packet_send();
240 buffer_consume(&stdout_buffer, len);
241 stdout_bytes += len;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000242 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000243}
244
Damien Miller8c3902a2001-10-10 15:01:40 +1000245static void
246client_alive_check(void)
247{
Damien Millerb5820f42003-12-17 16:27:32 +1100248 int channel_id;
Damien Miller056cf732002-01-22 23:21:39 +1100249
Damien Miller8c3902a2001-10-10 15:01:40 +1000250 /* timeout, check to see how many we have had */
Damien Miller985a4482006-10-24 03:02:41 +1000251 if (++client_alive_timeouts > options.client_alive_count_max) {
252 logit("Timeout, client not responding.");
253 cleanup_exit(255);
254 }
Damien Miller8c3902a2001-10-10 15:01:40 +1000255
Damien Miller8c3902a2001-10-10 15:01:40 +1000256 /*
Damien Millerb5820f42003-12-17 16:27:32 +1100257 * send a bogus global/channel request with "wantreply",
Damien Miller8c3902a2001-10-10 15:01:40 +1000258 * we should get back a failure
259 */
Damien Millerb5820f42003-12-17 16:27:32 +1100260 if ((channel_id = channel_find_open()) == -1) {
261 packet_start(SSH2_MSG_GLOBAL_REQUEST);
262 packet_put_cstring("keepalive@openssh.com");
263 packet_put_char(1); /* boolean: want reply */
264 } else {
265 channel_request_start(channel_id, "keepalive@openssh.com", 1);
266 }
Damien Miller8c3902a2001-10-10 15:01:40 +1000267 packet_send();
268}
269
Damien Miller95def091999-11-25 00:26:21 +1100270/*
271 * Sleep in select() until we can do something. This will initialize the
272 * select masks. Upon return, the masks will indicate which descriptors
273 * have data or can accept data. Optionally, a maximum time can be specified
274 * for the duration of the wait (0 = infinite).
275 */
Ben Lindstrombba81212001-06-25 05:01:22 +0000276static void
Damien Miller5e953212001-01-30 09:14:00 +1100277wait_until_can_do_something(fd_set **readsetp, fd_set **writesetp, int *maxfdp,
Darren Tuckerc7a6fc42004-08-13 21:18:00 +1000278 u_int *nallocp, u_int max_time_milliseconds)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000279{
Damien Miller95def091999-11-25 00:26:21 +1100280 struct timeval tv, *tvp;
281 int ret;
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000282 int client_alive_scheduled = 0;
Damien Millere42bd242007-01-29 10:16:28 +1100283 int program_alive_scheduled = 0;
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000284
285 /*
Damien Miller9f0f5c62001-12-21 14:45:46 +1100286 * if using client_alive, set the max timeout accordingly,
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000287 * and indicate that this particular timeout was for client
288 * alive by setting the client_alive_scheduled flag.
289 *
290 * this could be randomized somewhat to make traffic
Damien Miller9f0f5c62001-12-21 14:45:46 +1100291 * analysis more difficult, but we're not doing it yet.
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000292 */
Ben Lindstrom36857f62001-07-18 15:48:57 +0000293 if (compat20 &&
294 max_time_milliseconds == 0 && options.client_alive_interval) {
Ben Lindstrom2f0304c2001-04-29 19:49:14 +0000295 client_alive_scheduled = 1;
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000296 max_time_milliseconds = options.client_alive_interval * 1000;
Ben Lindstrom36857f62001-07-18 15:48:57 +0000297 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000298
Damien Miller5e953212001-01-30 09:14:00 +1100299 /* Allocate and update select() masks for channel descriptors. */
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000300 channel_prepare_select(readsetp, writesetp, maxfdp, nallocp, 0);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000301
Damien Millerefb4afe2000-04-12 18:45:05 +1000302 if (compat20) {
Damien Milleraf5f2e62001-10-10 15:01:16 +1000303#if 0
Damien Millere247cc42000-05-07 12:03:14 +1000304 /* wrong: bad condition XXX */
Damien Millerefb4afe2000-04-12 18:45:05 +1000305 if (channel_not_very_much_buffered_data())
Damien Milleraf5f2e62001-10-10 15:01:16 +1000306#endif
307 FD_SET(connection_in, *readsetp);
Damien Millerefb4afe2000-04-12 18:45:05 +1000308 } else {
Damien Millerb1715dc2000-05-30 13:44:51 +1000309 /*
310 * Read packets from the client unless we have too much
311 * buffered stdin or channel data.
312 */
313 if (buffer_len(&stdin_buffer) < buffer_high &&
Damien Millerefb4afe2000-04-12 18:45:05 +1000314 channel_not_very_much_buffered_data())
Damien Miller5e953212001-01-30 09:14:00 +1100315 FD_SET(connection_in, *readsetp);
Damien Millerb1715dc2000-05-30 13:44:51 +1000316 /*
317 * If there is not too much data already buffered going to
318 * the client, try to get some more data from the program.
319 */
320 if (packet_not_very_much_data_to_write()) {
Damien Millere42bd242007-01-29 10:16:28 +1100321 program_alive_scheduled = child_terminated;
Damien Millerb1715dc2000-05-30 13:44:51 +1000322 if (!fdout_eof)
Damien Miller5e953212001-01-30 09:14:00 +1100323 FD_SET(fdout, *readsetp);
Damien Millerb1715dc2000-05-30 13:44:51 +1000324 if (!fderr_eof)
Damien Miller5e953212001-01-30 09:14:00 +1100325 FD_SET(fderr, *readsetp);
Damien Millerb1715dc2000-05-30 13:44:51 +1000326 }
327 /*
328 * If we have buffered data, try to write some of that data
329 * to the program.
330 */
331 if (fdin != -1 && buffer_len(&stdin_buffer) > 0)
Damien Miller5e953212001-01-30 09:14:00 +1100332 FD_SET(fdin, *writesetp);
Damien Millerefb4afe2000-04-12 18:45:05 +1000333 }
Damien Millerf6681a32001-12-21 14:53:11 +1100334 notify_prepare(*readsetp);
Damien Miller95def091999-11-25 00:26:21 +1100335
Damien Miller5428f641999-11-25 11:54:57 +1100336 /*
337 * If we have buffered packet data going to the client, mark that
338 * descriptor.
339 */
Damien Miller95def091999-11-25 00:26:21 +1100340 if (packet_have_data_to_write())
Damien Miller5e953212001-01-30 09:14:00 +1100341 FD_SET(connection_out, *writesetp);
Damien Miller95def091999-11-25 00:26:21 +1100342
Damien Miller5428f641999-11-25 11:54:57 +1100343 /*
344 * If child has terminated and there is enough buffer space to read
345 * from it, then read as much as is available and exit.
346 */
Damien Miller95def091999-11-25 00:26:21 +1100347 if (child_terminated && packet_not_very_much_data_to_write())
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000348 if (max_time_milliseconds == 0 || client_alive_scheduled)
Damien Miller95def091999-11-25 00:26:21 +1100349 max_time_milliseconds = 100;
350
351 if (max_time_milliseconds == 0)
352 tvp = NULL;
353 else {
354 tv.tv_sec = max_time_milliseconds / 1000;
355 tv.tv_usec = 1000 * (max_time_milliseconds % 1000);
356 tvp = &tv;
357 }
358
359 /* Wait for something to happen, or the timeout to expire. */
Damien Miller5e953212001-01-30 09:14:00 +1100360 ret = select((*maxfdp)+1, *readsetp, *writesetp, NULL, tvp);
Damien Miller95def091999-11-25 00:26:21 +1100361
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000362 if (ret == -1) {
Damien Miller79faeff2001-11-12 11:06:32 +1100363 memset(*readsetp, 0, *nallocp);
364 memset(*writesetp, 0, *nallocp);
Damien Miller95def091999-11-25 00:26:21 +1100365 if (errno != EINTR)
366 error("select: %.100s", strerror(errno));
Damien Millere42bd242007-01-29 10:16:28 +1100367 } else {
368 if (ret == 0 && client_alive_scheduled)
369 client_alive_check();
370 if (!compat20 && program_alive_scheduled && fdin_is_tty) {
371 if (!fdout_eof)
372 FD_SET(fdout, *readsetp);
373 if (!fderr_eof)
374 FD_SET(fderr, *readsetp);
375 }
376 }
Damien Millerf6681a32001-12-21 14:53:11 +1100377
378 notify_done(*readsetp);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000379}
380
Damien Miller95def091999-11-25 00:26:21 +1100381/*
382 * Processes input from the client and the program. Input data is stored
383 * in buffers and processed later.
384 */
Ben Lindstrombba81212001-06-25 05:01:22 +0000385static void
Damien Miller90fdfaf2006-03-26 14:25:37 +1100386process_input(fd_set *readset)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000387{
Damien Miller95def091999-11-25 00:26:21 +1100388 int len;
389 char buf[16384];
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000390
Damien Miller95def091999-11-25 00:26:21 +1100391 /* Read and buffer any input data from the client. */
392 if (FD_ISSET(connection_in, readset)) {
393 len = read(connection_in, buf, sizeof(buf));
394 if (len == 0) {
Damien Miller16aed052002-09-22 01:26:27 +1000395 verbose("Connection closed by %.100s",
396 get_remote_ipaddr());
Ben Lindstrome34ab4c2001-04-07 01:12:11 +0000397 connection_closed = 1;
398 if (compat20)
399 return;
Darren Tucker3e33cec2003-10-02 16:12:36 +1000400 cleanup_exit(255);
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000401 } else if (len < 0) {
402 if (errno != EINTR && errno != EAGAIN) {
Damien Miller16aed052002-09-22 01:26:27 +1000403 verbose("Read error from remote host "
404 "%.100s: %.100s",
405 get_remote_ipaddr(), strerror(errno));
Darren Tucker3e33cec2003-10-02 16:12:36 +1000406 cleanup_exit(255);
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000407 }
408 } else {
409 /* Buffer any received data. */
410 packet_process_incoming(buf, len);
Damien Miller95def091999-11-25 00:26:21 +1100411 }
Damien Miller95def091999-11-25 00:26:21 +1100412 }
Damien Millerefb4afe2000-04-12 18:45:05 +1000413 if (compat20)
414 return;
415
Damien Miller95def091999-11-25 00:26:21 +1100416 /* Read and buffer any available stdout data from the program. */
417 if (!fdout_eof && FD_ISSET(fdout, readset)) {
Darren Tucker9afe1152006-06-23 21:24:12 +1000418 errno = 0;
Damien Miller95def091999-11-25 00:26:21 +1100419 len = read(fdout, buf, sizeof(buf));
Damien Millere42bd242007-01-29 10:16:28 +1100420 if (len < 0 && (errno == EINTR ||
421 (errno == EAGAIN && !child_terminated))) {
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000422 /* do nothing */
Darren Tucker03890e42006-06-24 16:58:45 +1000423#ifndef PTY_ZEROREAD
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000424 } else if (len <= 0) {
Darren Tucker9afe1152006-06-23 21:24:12 +1000425#else
Darren Tucker144e8d62006-06-25 08:25:25 +1000426 } else if ((!isatty(fdout) && len <= 0) ||
427 (isatty(fdout) && (len < 0 || (len == 0 && errno != 0)))) {
Darren Tucker9afe1152006-06-23 21:24:12 +1000428#endif
Damien Miller95def091999-11-25 00:26:21 +1100429 fdout_eof = 1;
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000430 } else {
Damien Miller95def091999-11-25 00:26:21 +1100431 buffer_append(&stdout_buffer, buf, len);
432 fdout_bytes += len;
433 }
434 }
435 /* Read and buffer any available stderr data from the program. */
436 if (!fderr_eof && FD_ISSET(fderr, readset)) {
Darren Tucker9afe1152006-06-23 21:24:12 +1000437 errno = 0;
Damien Miller95def091999-11-25 00:26:21 +1100438 len = read(fderr, buf, sizeof(buf));
Damien Millere42bd242007-01-29 10:16:28 +1100439 if (len < 0 && (errno == EINTR ||
440 (errno == EAGAIN && !child_terminated))) {
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000441 /* do nothing */
Darren Tucker03890e42006-06-24 16:58:45 +1000442#ifndef PTY_ZEROREAD
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000443 } else if (len <= 0) {
Darren Tucker9afe1152006-06-23 21:24:12 +1000444#else
Darren Tucker144e8d62006-06-25 08:25:25 +1000445 } else if ((!isatty(fderr) && len <= 0) ||
446 (isatty(fderr) && (len < 0 || (len == 0 && errno != 0)))) {
Darren Tucker9afe1152006-06-23 21:24:12 +1000447#endif
Damien Miller95def091999-11-25 00:26:21 +1100448 fderr_eof = 1;
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000449 } else {
Damien Miller95def091999-11-25 00:26:21 +1100450 buffer_append(&stderr_buffer, buf, len);
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000451 }
Damien Miller95def091999-11-25 00:26:21 +1100452 }
453}
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000454
Damien Miller95def091999-11-25 00:26:21 +1100455/*
456 * Sends data from internal buffers to client program stdin.
457 */
Ben Lindstrombba81212001-06-25 05:01:22 +0000458static void
Damien Miller90fdfaf2006-03-26 14:25:37 +1100459process_output(fd_set *writeset)
Damien Miller95def091999-11-25 00:26:21 +1100460{
Ben Lindstromaa630de2001-02-10 23:44:47 +0000461 struct termios tio;
Ben Lindstrom6d218f42001-09-18 05:53:12 +0000462 u_char *data;
463 u_int dlen;
Damien Miller95def091999-11-25 00:26:21 +1100464 int len;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000465
Damien Miller95def091999-11-25 00:26:21 +1100466 /* Write buffered data to program stdin. */
Damien Millerefb4afe2000-04-12 18:45:05 +1000467 if (!compat20 && fdin != -1 && FD_ISSET(fdin, writeset)) {
Ben Lindstrom6d218f42001-09-18 05:53:12 +0000468 data = buffer_ptr(&stdin_buffer);
469 dlen = buffer_len(&stdin_buffer);
470 len = write(fdin, data, dlen);
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000471 if (len < 0 && (errno == EINTR || errno == EAGAIN)) {
472 /* do nothing */
473 } else if (len <= 0) {
Damien Millerb38eff82000-04-01 11:09:21 +1000474 if (fdin != fdout)
Damien Miller95def091999-11-25 00:26:21 +1100475 close(fdin);
476 else
477 shutdown(fdin, SHUT_WR); /* We will no longer send. */
Damien Miller95def091999-11-25 00:26:21 +1100478 fdin = -1;
479 } else {
Ben Lindstromaa630de2001-02-10 23:44:47 +0000480 /* Successful write. */
Ben Lindstrom6d218f42001-09-18 05:53:12 +0000481 if (fdin_is_tty && dlen >= 1 && data[0] != '\r' &&
482 tcgetattr(fdin, &tio) == 0 &&
Damien Miller79438cc2001-02-16 12:34:57 +1100483 !(tio.c_lflag & ECHO) && (tio.c_lflag & ICANON)) {
Kevin Stevesb7f036f2001-02-15 17:27:15 +0000484 /*
485 * Simulate echo to reduce the impact of
486 * traffic analysis
487 */
Ben Lindstrome229b252001-03-05 06:28:06 +0000488 packet_send_ignore(len);
Ben Lindstromaa630de2001-02-10 23:44:47 +0000489 packet_send();
490 }
491 /* Consume the data from the buffer. */
Damien Miller95def091999-11-25 00:26:21 +1100492 buffer_consume(&stdin_buffer, len);
493 /* Update the count of bytes written to the program. */
494 stdin_bytes += len;
495 }
496 }
497 /* Send any buffered packet data to the client. */
498 if (FD_ISSET(connection_out, writeset))
499 packet_write_poll();
500}
501
502/*
503 * Wait until all buffered output has been sent to the client.
504 * This is used when the program terminates.
505 */
Ben Lindstrombba81212001-06-25 05:01:22 +0000506static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +0000507drain_output(void)
Damien Miller95def091999-11-25 00:26:21 +1100508{
509 /* Send any buffered stdout data to the client. */
510 if (buffer_len(&stdout_buffer) > 0) {
511 packet_start(SSH_SMSG_STDOUT_DATA);
512 packet_put_string(buffer_ptr(&stdout_buffer),
513 buffer_len(&stdout_buffer));
514 packet_send();
515 /* Update the count of sent bytes. */
516 stdout_bytes += buffer_len(&stdout_buffer);
517 }
518 /* Send any buffered stderr data to the client. */
519 if (buffer_len(&stderr_buffer) > 0) {
520 packet_start(SSH_SMSG_STDERR_DATA);
521 packet_put_string(buffer_ptr(&stderr_buffer),
522 buffer_len(&stderr_buffer));
523 packet_send();
524 /* Update the count of sent bytes. */
525 stderr_bytes += buffer_len(&stderr_buffer);
526 }
527 /* Wait until all buffered data has been written to the client. */
528 packet_write_wait();
529}
530
Ben Lindstrombba81212001-06-25 05:01:22 +0000531static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +0000532process_buffered_input_packets(void)
Damien Millerb38eff82000-04-01 11:09:21 +1000533{
Ben Lindstrom8ac91062001-04-04 17:57:54 +0000534 dispatch_run(DISPATCH_NONBLOCK, NULL, compat20 ? xxx_kex : NULL);
Damien Millerb38eff82000-04-01 11:09:21 +1000535}
536
Damien Miller95def091999-11-25 00:26:21 +1100537/*
538 * Performs the interactive session. This handles data transmission between
539 * the client and the program. Note that the notion of stdin, stdout, and
540 * stderr in this function is sort of reversed: this function writes to
541 * stdin (of the child program), and reads from stdout and stderr (of the
542 * child program).
543 */
Damien Miller4af51302000-04-16 11:18:38 +1000544void
Damien Miller166fca82000-04-20 07:42:21 +1000545server_loop(pid_t pid, int fdin_arg, int fdout_arg, int fderr_arg)
Damien Miller95def091999-11-25 00:26:21 +1100546{
Damien Miller5e953212001-01-30 09:14:00 +1100547 fd_set *readset = NULL, *writeset = NULL;
Darren Tuckerc7a6fc42004-08-13 21:18:00 +1000548 int max_fd = 0;
549 u_int nalloc = 0;
Damien Miller166fca82000-04-20 07:42:21 +1000550 int wait_status; /* Status returned by wait(). */
551 pid_t wait_pid; /* pid returned by wait(). */
Damien Miller95def091999-11-25 00:26:21 +1100552 int waiting_termination = 0; /* Have displayed waiting close message. */
Ben Lindstrom46c16222000-12-22 01:43:59 +0000553 u_int max_time_milliseconds;
554 u_int previous_stdout_buffer_bytes;
555 u_int stdout_buffer_bytes;
Damien Miller95def091999-11-25 00:26:21 +1100556 int type;
557
558 debug("Entering interactive session.");
559
560 /* Initialize the SIGCHLD kludge. */
Damien Miller95def091999-11-25 00:26:21 +1100561 child_terminated = 0;
Kevin Stevese26a1552001-07-26 17:51:49 +0000562 mysignal(SIGCHLD, sigchld_handler);
Damien Miller95def091999-11-25 00:26:21 +1100563
Damien Miller24ecf612005-11-05 15:16:52 +1100564 if (!use_privsep) {
565 signal(SIGTERM, sigterm_handler);
566 signal(SIGINT, sigterm_handler);
567 signal(SIGQUIT, sigterm_handler);
568 }
569
Damien Miller95def091999-11-25 00:26:21 +1100570 /* Initialize our global variables. */
571 fdin = fdin_arg;
572 fdout = fdout_arg;
573 fderr = fderr_arg;
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000574
575 /* nonblocking IO */
576 set_nonblock(fdin);
577 set_nonblock(fdout);
Damien Miller7d6656c2000-05-20 15:22:36 +1000578 /* we don't have stderr for interactive terminal sessions, see below */
579 if (fderr != -1)
580 set_nonblock(fderr);
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000581
Damien Miller225736c2001-02-19 21:51:08 +1100582 if (!(datafellows & SSH_BUG_IGNOREMSG) && isatty(fdin))
583 fdin_is_tty = 1;
584
Damien Miller95def091999-11-25 00:26:21 +1100585 connection_in = packet_get_connection_in();
586 connection_out = packet_get_connection_out();
587
Damien Millerf6681a32001-12-21 14:53:11 +1100588 notify_setup();
589
Damien Miller95def091999-11-25 00:26:21 +1100590 previous_stdout_buffer_bytes = 0;
591
592 /* Set approximate I/O buffer size. */
593 if (packet_is_interactive())
594 buffer_high = 4096;
595 else
596 buffer_high = 64 * 1024;
597
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000598#if 0
Damien Miller95def091999-11-25 00:26:21 +1100599 /* Initialize max_fd to the maximum of the known file descriptors. */
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000600 max_fd = MAX(connection_in, connection_out);
601 max_fd = MAX(max_fd, fdin);
602 max_fd = MAX(max_fd, fdout);
Damien Miller5e953212001-01-30 09:14:00 +1100603 if (fderr != -1)
604 max_fd = MAX(max_fd, fderr);
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000605#endif
Damien Miller95def091999-11-25 00:26:21 +1100606
607 /* Initialize Initialize buffers. */
608 buffer_init(&stdin_buffer);
609 buffer_init(&stdout_buffer);
610 buffer_init(&stderr_buffer);
611
Damien Miller5428f641999-11-25 11:54:57 +1100612 /*
613 * If we have no separate fderr (which is the case when we have a pty
614 * - there we cannot make difference between data sent to stdout and
615 * stderr), indicate that we have seen an EOF from stderr. This way
Damien Miller788f2122005-11-05 15:14:59 +1100616 * we don't need to check the descriptor everywhere.
Damien Miller5428f641999-11-25 11:54:57 +1100617 */
Damien Miller95def091999-11-25 00:26:21 +1100618 if (fderr == -1)
619 fderr_eof = 1;
620
Damien Millerb38eff82000-04-01 11:09:21 +1000621 server_init_dispatch();
622
Damien Miller95def091999-11-25 00:26:21 +1100623 /* Main loop of the server for the interactive session mode. */
624 for (;;) {
Damien Miller95def091999-11-25 00:26:21 +1100625
626 /* Process buffered packets from the client. */
627 process_buffered_input_packets();
628
Damien Miller5428f641999-11-25 11:54:57 +1100629 /*
630 * If we have received eof, and there is no more pending
631 * input data, cause a real eof by closing fdin.
632 */
Damien Miller95def091999-11-25 00:26:21 +1100633 if (stdin_eof && fdin != -1 && buffer_len(&stdin_buffer) == 0) {
Damien Millerb38eff82000-04-01 11:09:21 +1000634 if (fdin != fdout)
Damien Miller95def091999-11-25 00:26:21 +1100635 close(fdin);
636 else
637 shutdown(fdin, SHUT_WR); /* We will no longer send. */
Damien Miller95def091999-11-25 00:26:21 +1100638 fdin = -1;
639 }
Damien Miller5428f641999-11-25 11:54:57 +1100640 /* Make packets from buffered stderr data to send to the client. */
Damien Miller95def091999-11-25 00:26:21 +1100641 make_packets_from_stderr_data();
642
Damien Miller5428f641999-11-25 11:54:57 +1100643 /*
644 * Make packets from buffered stdout data to send to the
645 * client. If there is very little to send, this arranges to
646 * not send them now, but to wait a short while to see if we
647 * are getting more data. This is necessary, as some systems
648 * wake up readers from a pty after each separate character.
649 */
Damien Miller95def091999-11-25 00:26:21 +1100650 max_time_milliseconds = 0;
651 stdout_buffer_bytes = buffer_len(&stdout_buffer);
652 if (stdout_buffer_bytes != 0 && stdout_buffer_bytes < 256 &&
653 stdout_buffer_bytes != previous_stdout_buffer_bytes) {
654 /* try again after a while */
655 max_time_milliseconds = 10;
656 } else {
657 /* Send it now. */
658 make_packets_from_stdout_data();
659 }
660 previous_stdout_buffer_bytes = buffer_len(&stdout_buffer);
661
662 /* Send channel data to the client. */
663 if (packet_not_very_much_data_to_write())
664 channel_output_poll();
665
Damien Miller5428f641999-11-25 11:54:57 +1100666 /*
667 * Bail out of the loop if the program has closed its output
668 * descriptors, and we have no more data to send to the
669 * client, and there is no pending buffered data.
670 */
Damien Miller43dc8da2000-11-29 15:55:17 +1100671 if (fdout_eof && fderr_eof && !packet_have_data_to_write() &&
672 buffer_len(&stdout_buffer) == 0 && buffer_len(&stderr_buffer) == 0) {
Damien Miller95def091999-11-25 00:26:21 +1100673 if (!channel_still_open())
Damien Millerb38eff82000-04-01 11:09:21 +1000674 break;
Damien Miller95def091999-11-25 00:26:21 +1100675 if (!waiting_termination) {
676 const char *s = "Waiting for forwarded connections to terminate...\r\n";
677 char *cp;
678 waiting_termination = 1;
679 buffer_append(&stderr_buffer, s, strlen(s));
680
681 /* Display list of open channels. */
682 cp = channel_open_message();
683 buffer_append(&stderr_buffer, cp, strlen(cp));
684 xfree(cp);
685 }
686 }
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000687 max_fd = MAX(connection_in, connection_out);
688 max_fd = MAX(max_fd, fdin);
689 max_fd = MAX(max_fd, fdout);
690 max_fd = MAX(max_fd, fderr);
Damien Millerf6681a32001-12-21 14:53:11 +1100691 max_fd = MAX(max_fd, notify_pipe[0]);
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000692
Damien Miller95def091999-11-25 00:26:21 +1100693 /* Sleep in select() until we can do something. */
Damien Miller5e953212001-01-30 09:14:00 +1100694 wait_until_can_do_something(&readset, &writeset, &max_fd,
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000695 &nalloc, max_time_milliseconds);
Damien Miller95def091999-11-25 00:26:21 +1100696
Damien Miller24ecf612005-11-05 15:16:52 +1100697 if (received_sigterm) {
698 logit("Exiting on signal %d", received_sigterm);
699 /* Clean up sessions, utmp, etc. */
700 cleanup_exit(255);
701 }
702
Damien Miller95def091999-11-25 00:26:21 +1100703 /* Process any channel events. */
Damien Miller5e953212001-01-30 09:14:00 +1100704 channel_after_select(readset, writeset);
Damien Miller95def091999-11-25 00:26:21 +1100705
706 /* Process input from the client and from program stdout/stderr. */
Damien Miller5e953212001-01-30 09:14:00 +1100707 process_input(readset);
Damien Miller95def091999-11-25 00:26:21 +1100708
709 /* Process output to the client and to program stdin. */
Damien Miller5e953212001-01-30 09:14:00 +1100710 process_output(writeset);
Damien Miller95def091999-11-25 00:26:21 +1100711 }
Damien Miller5e953212001-01-30 09:14:00 +1100712 if (readset)
713 xfree(readset);
714 if (writeset)
715 xfree(writeset);
Damien Miller95def091999-11-25 00:26:21 +1100716
Damien Miller95def091999-11-25 00:26:21 +1100717 /* Cleanup and termination code. */
718
719 /* Wait until all output has been sent to the client. */
720 drain_output();
721
722 debug("End of interactive session; stdin %ld, stdout (read %ld, sent %ld), stderr %ld bytes.",
Damien Miller9f0f5c62001-12-21 14:45:46 +1100723 stdin_bytes, fdout_bytes, stdout_bytes, stderr_bytes);
Damien Miller95def091999-11-25 00:26:21 +1100724
725 /* Free and clear the buffers. */
726 buffer_free(&stdin_buffer);
727 buffer_free(&stdout_buffer);
728 buffer_free(&stderr_buffer);
729
730 /* Close the file descriptors. */
731 if (fdout != -1)
732 close(fdout);
733 fdout = -1;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000734 fdout_eof = 1;
Damien Miller95def091999-11-25 00:26:21 +1100735 if (fderr != -1)
736 close(fderr);
737 fderr = -1;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000738 fderr_eof = 1;
Damien Miller95def091999-11-25 00:26:21 +1100739 if (fdin != -1)
740 close(fdin);
741 fdin = -1;
742
Ben Lindstrom601e4362001-06-21 03:19:23 +0000743 channel_free_all();
Damien Miller95def091999-11-25 00:26:21 +1100744
Damien Miller95def091999-11-25 00:26:21 +1100745 /* We no longer want our SIGCHLD handler to be called. */
Kevin Stevese26a1552001-07-26 17:51:49 +0000746 mysignal(SIGCHLD, SIG_DFL);
Damien Miller95def091999-11-25 00:26:21 +1100747
Ben Lindstrom47fd8112002-04-02 20:48:19 +0000748 while ((wait_pid = waitpid(-1, &wait_status, 0)) < 0)
749 if (errno != EINTR)
750 packet_disconnect("wait: %.100s", strerror(errno));
751 if (wait_pid != pid)
Ben Lindstromce0f6342002-06-11 16:42:49 +0000752 error("Strange, wait returned pid %ld, expected %ld",
753 (long)wait_pid, (long)pid);
Ben Lindstromec46e0b2001-06-09 01:27:31 +0000754
Damien Miller95def091999-11-25 00:26:21 +1100755 /* Check if it exited normally. */
756 if (WIFEXITED(wait_status)) {
757 /* Yes, normal exit. Get exit status and send it to the client. */
758 debug("Command exited with status %d.", WEXITSTATUS(wait_status));
759 packet_start(SSH_SMSG_EXITSTATUS);
760 packet_put_int(WEXITSTATUS(wait_status));
761 packet_send();
762 packet_write_wait();
763
Damien Miller5428f641999-11-25 11:54:57 +1100764 /*
765 * Wait for exit confirmation. Note that there might be
766 * other packets coming before it; however, the program has
767 * already died so we just ignore them. The client is
768 * supposed to respond with the confirmation when it receives
769 * the exit status.
770 */
Damien Miller95def091999-11-25 00:26:21 +1100771 do {
Damien Millerdff50992002-01-22 23:16:32 +1100772 type = packet_read();
Damien Miller95def091999-11-25 00:26:21 +1100773 }
774 while (type != SSH_CMSG_EXIT_CONFIRMATION);
775
776 debug("Received exit confirmation.");
777 return;
778 }
779 /* Check if the program terminated due to a signal. */
780 if (WIFSIGNALED(wait_status))
781 packet_disconnect("Command terminated on signal %d.",
782 WTERMSIG(wait_status));
783
784 /* Some weird exit cause. Just exit. */
785 packet_disconnect("wait returned status %04x.", wait_status);
786 /* NOTREACHED */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000787}
Damien Millerb38eff82000-04-01 11:09:21 +1000788
Damien Miller3ec27592001-10-12 11:35:04 +1000789static void
790collect_children(void)
791{
792 pid_t pid;
793 sigset_t oset, nset;
794 int status;
795
796 /* block SIGCHLD while we check for dead children */
797 sigemptyset(&nset);
798 sigaddset(&nset, SIGCHLD);
799 sigprocmask(SIG_BLOCK, &nset, &oset);
800 if (child_terminated) {
Damien Millerec04f362006-03-15 12:01:34 +1100801 debug("Received SIGCHLD.");
Ben Lindstrom47fd8112002-04-02 20:48:19 +0000802 while ((pid = waitpid(-1, &status, WNOHANG)) > 0 ||
803 (pid < 0 && errno == EINTR))
804 if (pid > 0)
805 session_close_by_pid(pid, status);
Damien Miller3ec27592001-10-12 11:35:04 +1000806 child_terminated = 0;
807 }
808 sigprocmask(SIG_SETMASK, &oset, NULL);
809}
810
Damien Miller4af51302000-04-16 11:18:38 +1000811void
Ben Lindstrombddd5512001-07-04 04:53:53 +0000812server_loop2(Authctxt *authctxt)
Damien Millerefb4afe2000-04-12 18:45:05 +1000813{
Damien Miller5e953212001-01-30 09:14:00 +1100814 fd_set *readset = NULL, *writeset = NULL;
Damien Miller3ec27592001-10-12 11:35:04 +1000815 int rekeying = 0, max_fd, nalloc = 0;
Damien Millerefb4afe2000-04-12 18:45:05 +1000816
817 debug("Entering interactive session for SSH2.");
818
Ben Lindstromec46e0b2001-06-09 01:27:31 +0000819 mysignal(SIGCHLD, sigchld_handler);
Damien Millerefb4afe2000-04-12 18:45:05 +1000820 child_terminated = 0;
821 connection_in = packet_get_connection_in();
822 connection_out = packet_get_connection_out();
Damien Miller5e953212001-01-30 09:14:00 +1100823
Damien Miller24ecf612005-11-05 15:16:52 +1100824 if (!use_privsep) {
825 signal(SIGTERM, sigterm_handler);
826 signal(SIGINT, sigterm_handler);
827 signal(SIGQUIT, sigterm_handler);
828 }
829
Damien Millerf6681a32001-12-21 14:53:11 +1100830 notify_setup();
831
Damien Miller5e953212001-01-30 09:14:00 +1100832 max_fd = MAX(connection_in, connection_out);
Damien Millerf6681a32001-12-21 14:53:11 +1100833 max_fd = MAX(max_fd, notify_pipe[0]);
834
Damien Millerefb4afe2000-04-12 18:45:05 +1000835 server_init_dispatch();
836
837 for (;;) {
838 process_buffered_input_packets();
Ben Lindstrom8e312f32001-04-04 23:50:21 +0000839
Ben Lindstroma3700052001-04-05 23:26:32 +0000840 rekeying = (xxx_kex != NULL && !xxx_kex->done);
Ben Lindstrom8e312f32001-04-04 23:50:21 +0000841
Ben Lindstrom8e312f32001-04-04 23:50:21 +0000842 if (!rekeying && packet_not_very_much_data_to_write())
Damien Millerefb4afe2000-04-12 18:45:05 +1000843 channel_output_poll();
Ben Lindstrom8e312f32001-04-04 23:50:21 +0000844 wait_until_can_do_something(&readset, &writeset, &max_fd,
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000845 &nalloc, 0);
Damien Miller52b77be2001-10-10 15:14:37 +1000846
Damien Miller24ecf612005-11-05 15:16:52 +1100847 if (received_sigterm) {
848 logit("Exiting on signal %d", received_sigterm);
849 /* Clean up sessions, utmp, etc. */
850 cleanup_exit(255);
851 }
852
Damien Miller3ec27592001-10-12 11:35:04 +1000853 collect_children();
Damien Millera5539d22003-04-09 20:50:06 +1000854 if (!rekeying) {
Ben Lindstrom8e312f32001-04-04 23:50:21 +0000855 channel_after_select(readset, writeset);
Damien Millera5539d22003-04-09 20:50:06 +1000856 if (packet_need_rekeying()) {
857 debug("need rekeying");
858 xxx_kex->done = 0;
859 kex_send_kexinit(xxx_kex);
860 }
861 }
Damien Miller5e953212001-01-30 09:14:00 +1100862 process_input(readset);
Ben Lindstrome34ab4c2001-04-07 01:12:11 +0000863 if (connection_closed)
864 break;
Damien Miller5e953212001-01-30 09:14:00 +1100865 process_output(writeset);
Damien Millerefb4afe2000-04-12 18:45:05 +1000866 }
Damien Miller3ec27592001-10-12 11:35:04 +1000867 collect_children();
868
Damien Miller5e953212001-01-30 09:14:00 +1100869 if (readset)
870 xfree(readset);
871 if (writeset)
872 xfree(writeset);
873
Damien Miller52b77be2001-10-10 15:14:37 +1000874 /* free all channels, no more reads and writes */
875 channel_free_all();
Ben Lindstrom4983d5e2001-07-04 05:17:40 +0000876
Damien Miller3ec27592001-10-12 11:35:04 +1000877 /* free remaining sessions, e.g. remove wtmp entries */
Ben Lindstrom7a2073c2002-03-22 02:30:41 +0000878 session_destroy_all(NULL);
Damien Millerefb4afe2000-04-12 18:45:05 +1000879}
880
Ben Lindstrombba81212001-06-25 05:01:22 +0000881static void
Damien Millerb5820f42003-12-17 16:27:32 +1100882server_input_keep_alive(int type, u_int32_t seq, void *ctxt)
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000883{
Damien Millerb5820f42003-12-17 16:27:32 +1100884 debug("Got %d/%u for keepalive", type, seq);
Damien Miller9f0f5c62001-12-21 14:45:46 +1100885 /*
Ben Lindstrom2f0304c2001-04-29 19:49:14 +0000886 * reset timeout, since we got a sane answer from the client.
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000887 * even if this was generated by something other than
888 * the bogus CHANNEL_REQUEST we send for keepalives.
889 */
Damien Miller9f0f5c62001-12-21 14:45:46 +1100890 client_alive_timeouts = 0;
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000891}
892
Ben Lindstrombba81212001-06-25 05:01:22 +0000893static void
Damien Miller630d6f42002-01-22 23:17:30 +1100894server_input_stdin_data(int type, u_int32_t seq, void *ctxt)
Damien Millerb38eff82000-04-01 11:09:21 +1000895{
896 char *data;
Ben Lindstrom46c16222000-12-22 01:43:59 +0000897 u_int data_len;
Damien Millerb38eff82000-04-01 11:09:21 +1000898
899 /* Stdin data from the client. Append it to the buffer. */
900 /* Ignore any data if the client has closed stdin. */
901 if (fdin == -1)
902 return;
903 data = packet_get_string(&data_len);
Damien Miller48b03fc2002-01-22 23:11:40 +1100904 packet_check_eom();
Damien Millerb38eff82000-04-01 11:09:21 +1000905 buffer_append(&stdin_buffer, data, data_len);
906 memset(data, 0, data_len);
907 xfree(data);
908}
909
Ben Lindstrombba81212001-06-25 05:01:22 +0000910static void
Damien Miller630d6f42002-01-22 23:17:30 +1100911server_input_eof(int type, u_int32_t seq, void *ctxt)
Damien Millerb38eff82000-04-01 11:09:21 +1000912{
913 /*
914 * Eof from the client. The stdin descriptor to the
915 * program will be closed when all buffered data has
916 * drained.
917 */
918 debug("EOF received for stdin.");
Damien Miller48b03fc2002-01-22 23:11:40 +1100919 packet_check_eom();
Damien Millerb38eff82000-04-01 11:09:21 +1000920 stdin_eof = 1;
921}
922
Ben Lindstrombba81212001-06-25 05:01:22 +0000923static void
Damien Miller630d6f42002-01-22 23:17:30 +1100924server_input_window_size(int type, u_int32_t seq, void *ctxt)
Damien Millerb38eff82000-04-01 11:09:21 +1000925{
Damien Miller71a73672006-03-26 14:04:36 +1100926 u_int row = packet_get_int();
927 u_int col = packet_get_int();
928 u_int xpixel = packet_get_int();
929 u_int ypixel = packet_get_int();
Damien Millerb38eff82000-04-01 11:09:21 +1000930
931 debug("Window change received.");
Damien Miller48b03fc2002-01-22 23:11:40 +1100932 packet_check_eom();
Damien Millerb38eff82000-04-01 11:09:21 +1000933 if (fdin != -1)
934 pty_change_window_size(fdin, row, col, xpixel, ypixel);
935}
936
Ben Lindstrombba81212001-06-25 05:01:22 +0000937static Channel *
Damien Millerfb1310e2004-01-21 11:02:50 +1100938server_request_direct_tcpip(void)
Damien Millerefb4afe2000-04-12 18:45:05 +1000939{
Ben Lindstrom99c73b32001-05-05 04:09:47 +0000940 Channel *c;
941 int sock;
Damien Miller4af51302000-04-16 11:18:38 +1000942 char *target, *originator;
943 int target_port, originator_port;
Damien Millerefb4afe2000-04-12 18:45:05 +1000944
Damien Miller4af51302000-04-16 11:18:38 +1000945 target = packet_get_string(NULL);
946 target_port = packet_get_int();
Damien Millerefb4afe2000-04-12 18:45:05 +1000947 originator = packet_get_string(NULL);
948 originator_port = packet_get_int();
Damien Miller48b03fc2002-01-22 23:11:40 +1100949 packet_check_eom();
Damien Millerb1715dc2000-05-30 13:44:51 +1000950
Damien Miller0bc1bd82000-11-13 22:57:25 +1100951 debug("server_request_direct_tcpip: originator %s port %d, target %s port %d",
Damien Miller0dc1bef2005-07-17 17:22:45 +1000952 originator, originator_port, target, target_port);
Damien Millerf6d9e222000-06-18 14:50:44 +1000953
Damien Millerefb4afe2000-04-12 18:45:05 +1000954 /* XXX check permission */
Damien Miller4af51302000-04-16 11:18:38 +1000955 sock = channel_connect_to(target, target_port);
956 xfree(target);
Damien Millerefb4afe2000-04-12 18:45:05 +1000957 xfree(originator);
958 if (sock < 0)
Damien Miller0bc1bd82000-11-13 22:57:25 +1100959 return NULL;
Damien Millerfb1310e2004-01-21 11:02:50 +1100960 c = channel_new("direct-tcpip", SSH_CHANNEL_CONNECTING,
Damien Millere4340be2000-09-16 13:29:08 +1100961 sock, sock, -1, CHAN_TCP_WINDOW_DEFAULT,
Damien Millerb1ca8bb2003-05-14 13:45:42 +1000962 CHAN_TCP_PACKET_DEFAULT, 0, "direct-tcpip", 1);
Ben Lindstrom99c73b32001-05-05 04:09:47 +0000963 return c;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100964}
965
Ben Lindstrombba81212001-06-25 05:01:22 +0000966static Channel *
Damien Millerd27b9472005-12-13 19:29:02 +1100967server_request_tun(void)
968{
969 Channel *c = NULL;
Damien Miller7b58e802005-12-13 19:33:19 +1100970 int mode, tun;
971 int sock;
Damien Millerd27b9472005-12-13 19:29:02 +1100972
Damien Miller7b58e802005-12-13 19:33:19 +1100973 mode = packet_get_int();
974 switch (mode) {
975 case SSH_TUNMODE_POINTOPOINT:
976 case SSH_TUNMODE_ETHERNET:
977 break;
978 default:
979 packet_send_debug("Unsupported tunnel device mode.");
980 return NULL;
981 }
982 if ((options.permit_tun & mode) == 0) {
983 packet_send_debug("Server has rejected tunnel device "
984 "forwarding");
Damien Millerd27b9472005-12-13 19:29:02 +1100985 return NULL;
986 }
987
988 tun = packet_get_int();
Darren Tucker0d0e8f02005-12-20 16:08:42 +1100989 if (forced_tun_device != -1) {
Damien Millerf0b15df2006-03-26 13:59:20 +1100990 if (tun != SSH_TUNID_ANY && forced_tun_device != tun)
Damien Millerd27b9472005-12-13 19:29:02 +1100991 goto done;
992 tun = forced_tun_device;
993 }
Damien Miller7b58e802005-12-13 19:33:19 +1100994 sock = tun_open(tun, mode);
Damien Millerd27b9472005-12-13 19:29:02 +1100995 if (sock < 0)
996 goto done;
997 c = channel_new("tun", SSH_CHANNEL_OPEN, sock, sock, -1,
998 CHAN_TCP_WINDOW_DEFAULT, CHAN_TCP_PACKET_DEFAULT, 0, "tun", 1);
999 c->datagram = 1;
Damien Miller598bbc22005-12-31 16:33:36 +11001000#if defined(SSH_TUN_FILTER)
1001 if (mode == SSH_TUNMODE_POINTOPOINT)
1002 channel_register_filter(c->self, sys_tun_infilter,
1003 sys_tun_outfilter);
1004#endif
Damien Millerd27b9472005-12-13 19:29:02 +11001005
1006 done:
1007 if (c == NULL)
1008 packet_send_debug("Failed to open the tunnel device.");
1009 return c;
1010}
1011
1012static Channel *
Damien Millerfb1310e2004-01-21 11:02:50 +11001013server_request_session(void)
Damien Miller0bc1bd82000-11-13 22:57:25 +11001014{
Ben Lindstrom99c73b32001-05-05 04:09:47 +00001015 Channel *c;
Damien Miller0bc1bd82000-11-13 22:57:25 +11001016
1017 debug("input_session_request");
Damien Miller48b03fc2002-01-22 23:11:40 +11001018 packet_check_eom();
Damien Miller0bc1bd82000-11-13 22:57:25 +11001019 /*
1020 * A server session has no fd to read or write until a
1021 * CHANNEL_REQUEST for a shell is made, so we set the type to
1022 * SSH_CHANNEL_LARVAL. Additionally, a callback for handling all
1023 * CHANNEL_REQUEST messages is registered.
1024 */
Damien Millerfb1310e2004-01-21 11:02:50 +11001025 c = channel_new("session", SSH_CHANNEL_LARVAL,
Ben Lindstrom99c73b32001-05-05 04:09:47 +00001026 -1, -1, -1, /*window size*/0, CHAN_SES_PACKET_DEFAULT,
Damien Millerb1ca8bb2003-05-14 13:45:42 +10001027 0, "server-session", 1);
Darren Tucker3e33cec2003-10-02 16:12:36 +10001028 if (session_open(the_authctxt, c->self) != 1) {
Ben Lindstrom99c73b32001-05-05 04:09:47 +00001029 debug("session open failed, free channel %d", c->self);
1030 channel_free(c);
1031 return NULL;
1032 }
Damien Miller39eda6e2005-11-05 14:52:50 +11001033 channel_register_cleanup(c->self, session_close_by_channel, 0);
Ben Lindstrom99c73b32001-05-05 04:09:47 +00001034 return c;
Damien Millerefb4afe2000-04-12 18:45:05 +10001035}
1036
Ben Lindstrombba81212001-06-25 05:01:22 +00001037static void
Damien Miller630d6f42002-01-22 23:17:30 +11001038server_input_channel_open(int type, u_int32_t seq, void *ctxt)
Damien Millerefb4afe2000-04-12 18:45:05 +10001039{
1040 Channel *c = NULL;
1041 char *ctype;
Damien Millerefb4afe2000-04-12 18:45:05 +10001042 int rchan;
Ben Lindstrom4fed2be2002-06-25 23:17:36 +00001043 u_int rmaxpack, rwindow, len;
Damien Millerefb4afe2000-04-12 18:45:05 +10001044
1045 ctype = packet_get_string(&len);
1046 rchan = packet_get_int();
1047 rwindow = packet_get_int();
1048 rmaxpack = packet_get_int();
1049
Damien Miller62cee002000-09-23 17:15:56 +11001050 debug("server_input_channel_open: ctype %s rchan %d win %d max %d",
Damien Millerefb4afe2000-04-12 18:45:05 +10001051 ctype, rchan, rwindow, rmaxpack);
1052
1053 if (strcmp(ctype, "session") == 0) {
Damien Millerfb1310e2004-01-21 11:02:50 +11001054 c = server_request_session();
Damien Millerefb4afe2000-04-12 18:45:05 +10001055 } else if (strcmp(ctype, "direct-tcpip") == 0) {
Damien Millerfb1310e2004-01-21 11:02:50 +11001056 c = server_request_direct_tcpip();
Damien Millerd27b9472005-12-13 19:29:02 +11001057 } else if (strcmp(ctype, "tun@openssh.com") == 0) {
1058 c = server_request_tun();
Damien Millerefb4afe2000-04-12 18:45:05 +10001059 }
1060 if (c != NULL) {
Damien Miller0bc1bd82000-11-13 22:57:25 +11001061 debug("server_input_channel_open: confirm %s", ctype);
Damien Millerefb4afe2000-04-12 18:45:05 +10001062 c->remote_id = rchan;
1063 c->remote_window = rwindow;
1064 c->remote_maxpacket = rmaxpack;
Ben Lindstrom69128662001-05-08 20:07:39 +00001065 if (c->type != SSH_CHANNEL_CONNECTING) {
1066 packet_start(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
1067 packet_put_int(c->remote_id);
1068 packet_put_int(c->self);
1069 packet_put_int(c->local_window);
1070 packet_put_int(c->local_maxpacket);
1071 packet_send();
1072 }
Damien Millerefb4afe2000-04-12 18:45:05 +10001073 } else {
Damien Miller0bc1bd82000-11-13 22:57:25 +11001074 debug("server_input_channel_open: failure %s", ctype);
Damien Millerefb4afe2000-04-12 18:45:05 +10001075 packet_start(SSH2_MSG_CHANNEL_OPEN_FAILURE);
1076 packet_put_int(rchan);
1077 packet_put_int(SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED);
Ben Lindstromf3436742001-04-29 19:52:00 +00001078 if (!(datafellows & SSH_BUG_OPENFAILURE)) {
Ben Lindstrom69128662001-05-08 20:07:39 +00001079 packet_put_cstring("open failed");
Ben Lindstromf3436742001-04-29 19:52:00 +00001080 packet_put_cstring("");
1081 }
Damien Millerefb4afe2000-04-12 18:45:05 +10001082 packet_send();
1083 }
1084 xfree(ctype);
1085}
1086
Ben Lindstrombba81212001-06-25 05:01:22 +00001087static void
Damien Miller630d6f42002-01-22 23:17:30 +11001088server_input_global_request(int type, u_int32_t seq, void *ctxt)
Damien Miller0bc1bd82000-11-13 22:57:25 +11001089{
1090 char *rtype;
1091 int want_reply;
1092 int success = 0;
1093
1094 rtype = packet_get_string(NULL);
1095 want_reply = packet_get_char();
1096 debug("server_input_global_request: rtype %s want_reply %d", rtype, want_reply);
Kevin Stevesef4eea92001-02-05 12:42:17 +00001097
Ben Lindstrom7bb8b492001-03-17 00:47:54 +00001098 /* -R style forwarding */
Damien Miller0bc1bd82000-11-13 22:57:25 +11001099 if (strcmp(rtype, "tcpip-forward") == 0) {
1100 struct passwd *pw;
1101 char *listen_address;
1102 u_short listen_port;
1103
Darren Tucker3e33cec2003-10-02 16:12:36 +10001104 pw = the_authctxt->pw;
Damien Miller4bb1dd32003-11-18 22:01:25 +11001105 if (pw == NULL || !the_authctxt->valid)
Damien Miller3e3b5142003-11-17 21:13:40 +11001106 fatal("server_input_global_request: no/invalid user");
Damien Miller9fc7c692003-06-04 22:50:54 +10001107 listen_address = packet_get_string(NULL);
Damien Miller0bc1bd82000-11-13 22:57:25 +11001108 listen_port = (u_short)packet_get_int();
1109 debug("server_input_global_request: tcpip-forward listen %s port %d",
1110 listen_address, listen_port);
1111
1112 /* check permissions */
1113 if (!options.allow_tcp_forwarding ||
Ben Lindstrom99a4e142002-07-09 14:06:40 +00001114 no_port_forwarding_flag
1115#ifndef NO_IPPORT_RESERVED_CONCEPT
1116 || (listen_port < IPPORT_RESERVED && pw->pw_uid != 0)
1117#endif
Damien Millerb6f72f52005-07-17 17:26:43 +10001118 ) {
Damien Miller0bc1bd82000-11-13 22:57:25 +11001119 success = 0;
1120 packet_send_debug("Server has disabled port forwarding.");
1121 } else {
1122 /* Start listening on the port */
Damien Millerb16461c2002-01-22 23:29:22 +11001123 success = channel_setup_remote_fwd_listener(
1124 listen_address, listen_port, options.gateway_ports);
Damien Miller0bc1bd82000-11-13 22:57:25 +11001125 }
1126 xfree(listen_address);
Darren Tuckere7066df2004-05-24 10:18:05 +10001127 } else if (strcmp(rtype, "cancel-tcpip-forward") == 0) {
1128 char *cancel_address;
1129 u_short cancel_port;
1130
1131 cancel_address = packet_get_string(NULL);
1132 cancel_port = (u_short)packet_get_int();
1133 debug("%s: cancel-tcpip-forward addr %s port %d", __func__,
1134 cancel_address, cancel_port);
1135
1136 success = channel_cancel_rport_listener(cancel_address,
1137 cancel_port);
Damien Miller6f98a1f2006-03-26 13:51:08 +11001138 xfree(cancel_address);
Damien Miller0bc1bd82000-11-13 22:57:25 +11001139 }
1140 if (want_reply) {
1141 packet_start(success ?
1142 SSH2_MSG_REQUEST_SUCCESS : SSH2_MSG_REQUEST_FAILURE);
1143 packet_send();
1144 packet_write_wait();
1145 }
1146 xfree(rtype);
1147}
Damien Miller4f7becb2006-03-26 14:10:14 +11001148
Damien Millerc7ef63d2002-02-05 12:21:42 +11001149static void
1150server_input_channel_req(int type, u_int32_t seq, void *ctxt)
1151{
1152 Channel *c;
1153 int id, reply, success = 0;
1154 char *rtype;
1155
1156 id = packet_get_int();
1157 rtype = packet_get_string(NULL);
1158 reply = packet_get_char();
1159
1160 debug("server_input_channel_req: channel %d request %s reply %d",
1161 id, rtype, reply);
1162
1163 if ((c = channel_lookup(id)) == NULL)
1164 packet_disconnect("server_input_channel_req: "
1165 "unknown channel %d", id);
1166 if (c->type == SSH_CHANNEL_LARVAL || c->type == SSH_CHANNEL_OPEN)
1167 success = session_input_channel_req(c, rtype);
1168 if (reply) {
1169 packet_start(success ?
1170 SSH2_MSG_CHANNEL_SUCCESS : SSH2_MSG_CHANNEL_FAILURE);
1171 packet_put_int(c->remote_id);
1172 packet_send();
1173 }
1174 xfree(rtype);
1175}
Damien Miller0bc1bd82000-11-13 22:57:25 +11001176
Ben Lindstrombba81212001-06-25 05:01:22 +00001177static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +00001178server_init_dispatch_20(void)
Damien Millerefb4afe2000-04-12 18:45:05 +10001179{
1180 debug("server_init_dispatch_20");
1181 dispatch_init(&dispatch_protocol_error);
1182 dispatch_set(SSH2_MSG_CHANNEL_CLOSE, &channel_input_oclose);
1183 dispatch_set(SSH2_MSG_CHANNEL_DATA, &channel_input_data);
1184 dispatch_set(SSH2_MSG_CHANNEL_EOF, &channel_input_ieof);
1185 dispatch_set(SSH2_MSG_CHANNEL_EXTENDED_DATA, &channel_input_extended_data);
1186 dispatch_set(SSH2_MSG_CHANNEL_OPEN, &server_input_channel_open);
1187 dispatch_set(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);
1188 dispatch_set(SSH2_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);
Damien Millerc7ef63d2002-02-05 12:21:42 +11001189 dispatch_set(SSH2_MSG_CHANNEL_REQUEST, &server_input_channel_req);
Damien Millerefb4afe2000-04-12 18:45:05 +10001190 dispatch_set(SSH2_MSG_CHANNEL_WINDOW_ADJUST, &channel_input_window_adjust);
Damien Miller0bc1bd82000-11-13 22:57:25 +11001191 dispatch_set(SSH2_MSG_GLOBAL_REQUEST, &server_input_global_request);
Ben Lindstrom5744dc42001-04-13 23:28:01 +00001192 /* client_alive */
Damien Millerb5820f42003-12-17 16:27:32 +11001193 dispatch_set(SSH2_MSG_CHANNEL_FAILURE, &server_input_keep_alive);
1194 dispatch_set(SSH2_MSG_REQUEST_SUCCESS, &server_input_keep_alive);
1195 dispatch_set(SSH2_MSG_REQUEST_FAILURE, &server_input_keep_alive);
Ben Lindstrom8ac91062001-04-04 17:57:54 +00001196 /* rekeying */
1197 dispatch_set(SSH2_MSG_KEXINIT, &kex_input_kexinit);
Damien Millerefb4afe2000-04-12 18:45:05 +10001198}
Ben Lindstrombba81212001-06-25 05:01:22 +00001199static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +00001200server_init_dispatch_13(void)
Damien Millerb38eff82000-04-01 11:09:21 +10001201{
1202 debug("server_init_dispatch_13");
1203 dispatch_init(NULL);
1204 dispatch_set(SSH_CMSG_EOF, &server_input_eof);
1205 dispatch_set(SSH_CMSG_STDIN_DATA, &server_input_stdin_data);
1206 dispatch_set(SSH_CMSG_WINDOW_SIZE, &server_input_window_size);
1207 dispatch_set(SSH_MSG_CHANNEL_CLOSE, &channel_input_close);
1208 dispatch_set(SSH_MSG_CHANNEL_CLOSE_CONFIRMATION, &channel_input_close_confirmation);
1209 dispatch_set(SSH_MSG_CHANNEL_DATA, &channel_input_data);
1210 dispatch_set(SSH_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);
1211 dispatch_set(SSH_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);
1212 dispatch_set(SSH_MSG_PORT_OPEN, &channel_input_port_open);
1213}
Ben Lindstrombba81212001-06-25 05:01:22 +00001214static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +00001215server_init_dispatch_15(void)
Damien Millerb38eff82000-04-01 11:09:21 +10001216{
1217 server_init_dispatch_13();
1218 debug("server_init_dispatch_15");
1219 dispatch_set(SSH_MSG_CHANNEL_CLOSE, &channel_input_ieof);
1220 dispatch_set(SSH_MSG_CHANNEL_CLOSE_CONFIRMATION, &channel_input_oclose);
1221}
Ben Lindstrombba81212001-06-25 05:01:22 +00001222static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +00001223server_init_dispatch(void)
Damien Millerb38eff82000-04-01 11:09:21 +10001224{
Damien Millerefb4afe2000-04-12 18:45:05 +10001225 if (compat20)
1226 server_init_dispatch_20();
1227 else if (compat13)
Damien Millerb38eff82000-04-01 11:09:21 +10001228 server_init_dispatch_13();
1229 else
1230 server_init_dispatch_15();
1231}