blob: fd1154157ed0f8cb34d9ff50c2eae6d5cb698937 [file] [log] [blame]
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001/*
Damien Miller95def091999-11-25 00:26:21 +11002 * Author: Tatu Ylonen <ylo@cs.hut.fi>
3 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
4 * All rights reserved
Damien Miller95def091999-11-25 00:26:21 +11005 * Server main loop for handling the interactive session.
Damien Millere4340be2000-09-16 13:29:08 +11006 *
7 * As far as I am concerned, the code I have written for this software
8 * can be used freely for any purpose. Any derived versions of this
9 * software must be clearly marked as such, and if the derived work is
10 * incompatible with the protocol description in the RFC file, it must be
11 * called by a name other than "ssh" or "Secure Shell".
12 *
Damien Millerefb4afe2000-04-12 18:45:05 +100013 * SSH2 support by Markus Friedl.
Ben Lindstrom44697232001-07-04 03:32:30 +000014 * Copyright (c) 2000, 2001 Markus Friedl. All rights reserved.
Damien Millere4340be2000-09-16 13:29:08 +110015 *
16 * Redistribution and use in source and binary forms, with or without
17 * modification, are permitted provided that the following conditions
18 * are met:
19 * 1. Redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer.
21 * 2. Redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
26 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
28 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
29 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
30 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
34 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Damien Millerefb4afe2000-04-12 18:45:05 +100035 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100036
37#include "includes.h"
Ben Lindstrom5e71c542001-12-06 16:48:14 +000038RCSID("$OpenBSD: serverloop.c,v 1.84 2001/11/22 12:34:22 markus Exp $");
Damien Miller69b69aa2000-10-28 14:19:58 +110039
Damien Millerd4a8b7e1999-10-27 13:42:43 +100040#include "xmalloc.h"
Damien Millerd4a8b7e1999-10-27 13:42:43 +100041#include "packet.h"
42#include "buffer.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000043#include "log.h"
Damien Millerd4a8b7e1999-10-27 13:42:43 +100044#include "servconf.h"
Ben Lindstromd95c09c2001-02-18 19:13:33 +000045#include "sshpty.h"
Ben Lindstromc7637672001-06-09 00:36:26 +000046#include "channels.h"
Damien Millerb38eff82000-04-01 11:09:21 +100047#include "compat.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000048#include "ssh1.h"
Damien Millerefb4afe2000-04-12 18:45:05 +100049#include "ssh2.h"
Ben Lindstromdb65e8f2001-01-19 04:26:52 +000050#include "auth.h"
Damien Millerefb4afe2000-04-12 18:45:05 +100051#include "session.h"
Damien Millerb38eff82000-04-01 11:09:21 +100052#include "dispatch.h"
Damien Millerf6d9e222000-06-18 14:50:44 +100053#include "auth-options.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000054#include "serverloop.h"
55#include "misc.h"
Ben Lindstrom8ac91062001-04-04 17:57:54 +000056#include "kex.h"
Damien Millerd4a8b7e1999-10-27 13:42:43 +100057
Damien Miller50a41ed2000-10-16 12:14:42 +110058extern ServerOptions options;
59
Ben Lindstrom8ac91062001-04-04 17:57:54 +000060/* XXX */
61extern Kex *xxx_kex;
Ben Lindstrombddd5512001-07-04 04:53:53 +000062static Authctxt *xxx_authctxt;
Ben Lindstrom8ac91062001-04-04 17:57:54 +000063
Damien Millerd4a8b7e1999-10-27 13:42:43 +100064static Buffer stdin_buffer; /* Buffer for stdin data. */
65static Buffer stdout_buffer; /* Buffer for stdout data. */
66static Buffer stderr_buffer; /* Buffer for stderr data. */
67static int fdin; /* Descriptor for stdin (for writing) */
68static int fdout; /* Descriptor for stdout (for reading);
69 May be same number as fdin. */
70static int fderr; /* Descriptor for stderr. May be -1. */
71static long stdin_bytes = 0; /* Number of bytes written to stdin. */
72static long stdout_bytes = 0; /* Number of stdout bytes sent to client. */
73static long stderr_bytes = 0; /* Number of stderr bytes sent to client. */
74static long fdout_bytes = 0; /* Number of stdout bytes read from program. */
75static int stdin_eof = 0; /* EOF message received from client. */
76static int fdout_eof = 0; /* EOF encountered reading from fdout. */
77static int fderr_eof = 0; /* EOF encountered readung from fderr. */
Damien Miller225736c2001-02-19 21:51:08 +110078static int fdin_is_tty = 0; /* fdin points to a tty. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100079static int connection_in; /* Connection to client (input). */
80static int connection_out; /* Connection to client (output). */
Ben Lindstrome34ab4c2001-04-07 01:12:11 +000081static int connection_closed = 0; /* Connection to client closed. */
82static u_int buffer_high; /* "Soft" max buffer size. */
Damien Miller8c3902a2001-10-10 15:01:40 +100083static int client_alive_timeouts = 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +100084
Damien Miller5428f641999-11-25 11:54:57 +110085/*
86 * This SIGCHLD kludge is used to detect when the child exits. The server
87 * will exit after that, as soon as forwarded connections have terminated.
88 */
Ben Lindstrombba81212001-06-25 05:01:22 +000089
Ben Lindstrom5e71c542001-12-06 16:48:14 +000090static volatile sig_atomic_t child_terminated = 0; /* The child has terminated. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100091
Ben Lindstrombba81212001-06-25 05:01:22 +000092/* prototypes */
93static void server_init_dispatch(void);
Damien Millerb38eff82000-04-01 11:09:21 +100094
Ben Lindstrombba81212001-06-25 05:01:22 +000095static void
Damien Miller95def091999-11-25 00:26:21 +110096sigchld_handler(int sig)
Damien Millerd4a8b7e1999-10-27 13:42:43 +100097{
Damien Miller95def091999-11-25 00:26:21 +110098 int save_errno = errno;
Damien Millerefb4afe2000-04-12 18:45:05 +100099 debug("Received SIGCHLD.");
100 child_terminated = 1;
Ben Lindstromec46e0b2001-06-09 01:27:31 +0000101 mysignal(SIGCHLD, sigchld_handler);
Damien Millerefb4afe2000-04-12 18:45:05 +1000102 errno = save_errno;
103}
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000104
Damien Miller95def091999-11-25 00:26:21 +1100105/*
Damien Miller95def091999-11-25 00:26:21 +1100106 * Make packets from buffered stderr data, and buffer it for sending
107 * to the client.
108 */
Ben Lindstrombba81212001-06-25 05:01:22 +0000109static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +0000110make_packets_from_stderr_data(void)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000111{
Damien Miller95def091999-11-25 00:26:21 +1100112 int len;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000113
Damien Miller95def091999-11-25 00:26:21 +1100114 /* Send buffered stderr data to the client. */
115 while (buffer_len(&stderr_buffer) > 0 &&
Damien Miller037a0dc1999-12-07 15:38:31 +1100116 packet_not_very_much_data_to_write()) {
Damien Miller95def091999-11-25 00:26:21 +1100117 len = buffer_len(&stderr_buffer);
118 if (packet_is_interactive()) {
119 if (len > 512)
120 len = 512;
121 } else {
122 /* Keep the packets at reasonable size. */
123 if (len > packet_get_maxsize())
124 len = packet_get_maxsize();
125 }
126 packet_start(SSH_SMSG_STDERR_DATA);
127 packet_put_string(buffer_ptr(&stderr_buffer), len);
128 packet_send();
129 buffer_consume(&stderr_buffer, len);
130 stderr_bytes += len;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000131 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000132}
133
Damien Miller95def091999-11-25 00:26:21 +1100134/*
135 * Make packets from buffered stdout data, and buffer it for sending to the
136 * client.
137 */
Ben Lindstrombba81212001-06-25 05:01:22 +0000138static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +0000139make_packets_from_stdout_data(void)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000140{
Damien Miller95def091999-11-25 00:26:21 +1100141 int len;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000142
Damien Miller95def091999-11-25 00:26:21 +1100143 /* Send buffered stdout data to the client. */
144 while (buffer_len(&stdout_buffer) > 0 &&
Damien Miller037a0dc1999-12-07 15:38:31 +1100145 packet_not_very_much_data_to_write()) {
Damien Miller95def091999-11-25 00:26:21 +1100146 len = buffer_len(&stdout_buffer);
147 if (packet_is_interactive()) {
148 if (len > 512)
149 len = 512;
150 } else {
151 /* Keep the packets at reasonable size. */
152 if (len > packet_get_maxsize())
Kevin Stevesef4eea92001-02-05 12:42:17 +0000153 len = packet_get_maxsize();
Damien Miller95def091999-11-25 00:26:21 +1100154 }
155 packet_start(SSH_SMSG_STDOUT_DATA);
156 packet_put_string(buffer_ptr(&stdout_buffer), len);
157 packet_send();
158 buffer_consume(&stdout_buffer, len);
159 stdout_bytes += len;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000160 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000161}
162
Damien Miller8c3902a2001-10-10 15:01:40 +1000163static void
164client_alive_check(void)
165{
166 int id;
167
168 /* timeout, check to see how many we have had */
169 if (++client_alive_timeouts > options.client_alive_count_max)
170 packet_disconnect("Timeout, your session not responding.");
171
172 id = channel_find_open();
173 if (id == -1)
174 packet_disconnect("No open channels after timeout!");
175 /*
176 * send a bogus channel request with "wantreply",
177 * we should get back a failure
178 */
179 channel_request_start(id, "keepalive@openssh.com", 1);
180 packet_send();
181}
182
Damien Miller95def091999-11-25 00:26:21 +1100183/*
184 * Sleep in select() until we can do something. This will initialize the
185 * select masks. Upon return, the masks will indicate which descriptors
186 * have data or can accept data. Optionally, a maximum time can be specified
187 * for the duration of the wait (0 = infinite).
188 */
Ben Lindstrombba81212001-06-25 05:01:22 +0000189static void
Damien Miller5e953212001-01-30 09:14:00 +1100190wait_until_can_do_something(fd_set **readsetp, fd_set **writesetp, int *maxfdp,
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000191 int *nallocp, u_int max_time_milliseconds)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000192{
Damien Miller95def091999-11-25 00:26:21 +1100193 struct timeval tv, *tvp;
194 int ret;
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000195 int client_alive_scheduled = 0;
196
197 /*
198 * if using client_alive, set the max timeout accordingly,
199 * and indicate that this particular timeout was for client
200 * alive by setting the client_alive_scheduled flag.
201 *
202 * this could be randomized somewhat to make traffic
203 * analysis more difficult, but we're not doing it yet.
204 */
Ben Lindstrom36857f62001-07-18 15:48:57 +0000205 if (compat20 &&
206 max_time_milliseconds == 0 && options.client_alive_interval) {
Ben Lindstrom2f0304c2001-04-29 19:49:14 +0000207 client_alive_scheduled = 1;
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000208 max_time_milliseconds = options.client_alive_interval * 1000;
Ben Lindstrom36857f62001-07-18 15:48:57 +0000209 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000210
Damien Miller5e953212001-01-30 09:14:00 +1100211 /* Allocate and update select() masks for channel descriptors. */
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000212 channel_prepare_select(readsetp, writesetp, maxfdp, nallocp, 0);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000213
Damien Millerefb4afe2000-04-12 18:45:05 +1000214 if (compat20) {
Damien Milleraf5f2e62001-10-10 15:01:16 +1000215#if 0
Damien Millere247cc42000-05-07 12:03:14 +1000216 /* wrong: bad condition XXX */
Damien Millerefb4afe2000-04-12 18:45:05 +1000217 if (channel_not_very_much_buffered_data())
Damien Milleraf5f2e62001-10-10 15:01:16 +1000218#endif
219 FD_SET(connection_in, *readsetp);
Damien Millerefb4afe2000-04-12 18:45:05 +1000220 } else {
Damien Millerb1715dc2000-05-30 13:44:51 +1000221 /*
222 * Read packets from the client unless we have too much
223 * buffered stdin or channel data.
224 */
225 if (buffer_len(&stdin_buffer) < buffer_high &&
Damien Millerefb4afe2000-04-12 18:45:05 +1000226 channel_not_very_much_buffered_data())
Damien Miller5e953212001-01-30 09:14:00 +1100227 FD_SET(connection_in, *readsetp);
Damien Millerb1715dc2000-05-30 13:44:51 +1000228 /*
229 * If there is not too much data already buffered going to
230 * the client, try to get some more data from the program.
231 */
232 if (packet_not_very_much_data_to_write()) {
233 if (!fdout_eof)
Damien Miller5e953212001-01-30 09:14:00 +1100234 FD_SET(fdout, *readsetp);
Damien Millerb1715dc2000-05-30 13:44:51 +1000235 if (!fderr_eof)
Damien Miller5e953212001-01-30 09:14:00 +1100236 FD_SET(fderr, *readsetp);
Damien Millerb1715dc2000-05-30 13:44:51 +1000237 }
238 /*
239 * If we have buffered data, try to write some of that data
240 * to the program.
241 */
242 if (fdin != -1 && buffer_len(&stdin_buffer) > 0)
Damien Miller5e953212001-01-30 09:14:00 +1100243 FD_SET(fdin, *writesetp);
Damien Millerefb4afe2000-04-12 18:45:05 +1000244 }
Damien Miller95def091999-11-25 00:26:21 +1100245
Damien Miller5428f641999-11-25 11:54:57 +1100246 /*
247 * If we have buffered packet data going to the client, mark that
248 * descriptor.
249 */
Damien Miller95def091999-11-25 00:26:21 +1100250 if (packet_have_data_to_write())
Damien Miller5e953212001-01-30 09:14:00 +1100251 FD_SET(connection_out, *writesetp);
Damien Miller95def091999-11-25 00:26:21 +1100252
Damien Miller5428f641999-11-25 11:54:57 +1100253 /*
254 * If child has terminated and there is enough buffer space to read
255 * from it, then read as much as is available and exit.
256 */
Damien Miller95def091999-11-25 00:26:21 +1100257 if (child_terminated && packet_not_very_much_data_to_write())
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000258 if (max_time_milliseconds == 0 || client_alive_scheduled)
Damien Miller95def091999-11-25 00:26:21 +1100259 max_time_milliseconds = 100;
260
261 if (max_time_milliseconds == 0)
262 tvp = NULL;
263 else {
264 tv.tv_sec = max_time_milliseconds / 1000;
265 tv.tv_usec = 1000 * (max_time_milliseconds % 1000);
266 tvp = &tv;
267 }
Damien Millerefb4afe2000-04-12 18:45:05 +1000268 if (tvp!=NULL)
Ben Lindstromf4c73112001-03-05 05:58:23 +0000269 debug3("tvp!=NULL kid %d mili %d", child_terminated, max_time_milliseconds);
Damien Miller95def091999-11-25 00:26:21 +1100270
271 /* Wait for something to happen, or the timeout to expire. */
Damien Miller5e953212001-01-30 09:14:00 +1100272 ret = select((*maxfdp)+1, *readsetp, *writesetp, NULL, tvp);
Damien Miller95def091999-11-25 00:26:21 +1100273
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000274 if (ret == -1) {
Damien Miller79faeff2001-11-12 11:06:32 +1100275 memset(*readsetp, 0, *nallocp);
276 memset(*writesetp, 0, *nallocp);
Damien Miller95def091999-11-25 00:26:21 +1100277 if (errno != EINTR)
278 error("select: %.100s", strerror(errno));
Damien Miller3ec27592001-10-12 11:35:04 +1000279 } else if (ret == 0 && client_alive_scheduled)
Damien Miller8c3902a2001-10-10 15:01:40 +1000280 client_alive_check();
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000281}
282
Damien Miller95def091999-11-25 00:26:21 +1100283/*
284 * Processes input from the client and the program. Input data is stored
285 * in buffers and processed later.
286 */
Ben Lindstrombba81212001-06-25 05:01:22 +0000287static void
Damien Miller95def091999-11-25 00:26:21 +1100288process_input(fd_set * readset)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000289{
Damien Miller95def091999-11-25 00:26:21 +1100290 int len;
291 char buf[16384];
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000292
Damien Miller95def091999-11-25 00:26:21 +1100293 /* Read and buffer any input data from the client. */
294 if (FD_ISSET(connection_in, readset)) {
295 len = read(connection_in, buf, sizeof(buf));
296 if (len == 0) {
297 verbose("Connection closed by remote host.");
Ben Lindstrome34ab4c2001-04-07 01:12:11 +0000298 connection_closed = 1;
299 if (compat20)
300 return;
Damien Miller95def091999-11-25 00:26:21 +1100301 fatal_cleanup();
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000302 } else if (len < 0) {
303 if (errno != EINTR && errno != EAGAIN) {
304 verbose("Read error from remote host: %.100s", strerror(errno));
305 fatal_cleanup();
306 }
307 } else {
308 /* Buffer any received data. */
309 packet_process_incoming(buf, len);
Damien Miller95def091999-11-25 00:26:21 +1100310 }
Damien Miller95def091999-11-25 00:26:21 +1100311 }
Damien Millerefb4afe2000-04-12 18:45:05 +1000312 if (compat20)
313 return;
314
Damien Miller95def091999-11-25 00:26:21 +1100315 /* Read and buffer any available stdout data from the program. */
316 if (!fdout_eof && FD_ISSET(fdout, readset)) {
317 len = read(fdout, buf, sizeof(buf));
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000318 if (len < 0 && (errno == EINTR || errno == EAGAIN)) {
319 /* do nothing */
320 } else if (len <= 0) {
Damien Miller95def091999-11-25 00:26:21 +1100321 fdout_eof = 1;
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000322 } else {
Damien Miller95def091999-11-25 00:26:21 +1100323 buffer_append(&stdout_buffer, buf, len);
324 fdout_bytes += len;
325 }
326 }
327 /* Read and buffer any available stderr data from the program. */
328 if (!fderr_eof && FD_ISSET(fderr, readset)) {
329 len = read(fderr, buf, sizeof(buf));
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000330 if (len < 0 && (errno == EINTR || errno == EAGAIN)) {
331 /* do nothing */
332 } else if (len <= 0) {
Damien Miller95def091999-11-25 00:26:21 +1100333 fderr_eof = 1;
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000334 } else {
Damien Miller95def091999-11-25 00:26:21 +1100335 buffer_append(&stderr_buffer, buf, len);
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000336 }
Damien Miller95def091999-11-25 00:26:21 +1100337 }
338}
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000339
Damien Miller95def091999-11-25 00:26:21 +1100340/*
341 * Sends data from internal buffers to client program stdin.
342 */
Ben Lindstrombba81212001-06-25 05:01:22 +0000343static void
Damien Miller95def091999-11-25 00:26:21 +1100344process_output(fd_set * writeset)
345{
Ben Lindstromaa630de2001-02-10 23:44:47 +0000346 struct termios tio;
Ben Lindstrom6d218f42001-09-18 05:53:12 +0000347 u_char *data;
348 u_int dlen;
Damien Miller95def091999-11-25 00:26:21 +1100349 int len;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000350
Damien Miller95def091999-11-25 00:26:21 +1100351 /* Write buffered data to program stdin. */
Damien Millerefb4afe2000-04-12 18:45:05 +1000352 if (!compat20 && fdin != -1 && FD_ISSET(fdin, writeset)) {
Ben Lindstrom6d218f42001-09-18 05:53:12 +0000353 data = buffer_ptr(&stdin_buffer);
354 dlen = buffer_len(&stdin_buffer);
355 len = write(fdin, data, dlen);
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000356 if (len < 0 && (errno == EINTR || errno == EAGAIN)) {
357 /* do nothing */
358 } else if (len <= 0) {
Damien Miller95def091999-11-25 00:26:21 +1100359#ifdef USE_PIPES
360 close(fdin);
361#else
Damien Millerb38eff82000-04-01 11:09:21 +1000362 if (fdin != fdout)
Damien Miller95def091999-11-25 00:26:21 +1100363 close(fdin);
364 else
365 shutdown(fdin, SHUT_WR); /* We will no longer send. */
366#endif
367 fdin = -1;
368 } else {
Ben Lindstromaa630de2001-02-10 23:44:47 +0000369 /* Successful write. */
Ben Lindstrom6d218f42001-09-18 05:53:12 +0000370 if (fdin_is_tty && dlen >= 1 && data[0] != '\r' &&
371 tcgetattr(fdin, &tio) == 0 &&
Damien Miller79438cc2001-02-16 12:34:57 +1100372 !(tio.c_lflag & ECHO) && (tio.c_lflag & ICANON)) {
Kevin Stevesb7f036f2001-02-15 17:27:15 +0000373 /*
374 * Simulate echo to reduce the impact of
375 * traffic analysis
376 */
Ben Lindstrome229b252001-03-05 06:28:06 +0000377 packet_send_ignore(len);
Ben Lindstromaa630de2001-02-10 23:44:47 +0000378 packet_send();
379 }
380 /* Consume the data from the buffer. */
Damien Miller95def091999-11-25 00:26:21 +1100381 buffer_consume(&stdin_buffer, len);
382 /* Update the count of bytes written to the program. */
383 stdin_bytes += len;
384 }
385 }
386 /* Send any buffered packet data to the client. */
387 if (FD_ISSET(connection_out, writeset))
388 packet_write_poll();
389}
390
391/*
392 * Wait until all buffered output has been sent to the client.
393 * This is used when the program terminates.
394 */
Ben Lindstrombba81212001-06-25 05:01:22 +0000395static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +0000396drain_output(void)
Damien Miller95def091999-11-25 00:26:21 +1100397{
398 /* Send any buffered stdout data to the client. */
399 if (buffer_len(&stdout_buffer) > 0) {
400 packet_start(SSH_SMSG_STDOUT_DATA);
401 packet_put_string(buffer_ptr(&stdout_buffer),
402 buffer_len(&stdout_buffer));
403 packet_send();
404 /* Update the count of sent bytes. */
405 stdout_bytes += buffer_len(&stdout_buffer);
406 }
407 /* Send any buffered stderr data to the client. */
408 if (buffer_len(&stderr_buffer) > 0) {
409 packet_start(SSH_SMSG_STDERR_DATA);
410 packet_put_string(buffer_ptr(&stderr_buffer),
411 buffer_len(&stderr_buffer));
412 packet_send();
413 /* Update the count of sent bytes. */
414 stderr_bytes += buffer_len(&stderr_buffer);
415 }
416 /* Wait until all buffered data has been written to the client. */
417 packet_write_wait();
418}
419
Ben Lindstrombba81212001-06-25 05:01:22 +0000420static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +0000421process_buffered_input_packets(void)
Damien Millerb38eff82000-04-01 11:09:21 +1000422{
Ben Lindstrom8ac91062001-04-04 17:57:54 +0000423 dispatch_run(DISPATCH_NONBLOCK, NULL, compat20 ? xxx_kex : NULL);
Damien Millerb38eff82000-04-01 11:09:21 +1000424}
425
Damien Miller95def091999-11-25 00:26:21 +1100426/*
427 * Performs the interactive session. This handles data transmission between
428 * the client and the program. Note that the notion of stdin, stdout, and
429 * stderr in this function is sort of reversed: this function writes to
430 * stdin (of the child program), and reads from stdout and stderr (of the
431 * child program).
432 */
Damien Miller4af51302000-04-16 11:18:38 +1000433void
Damien Miller166fca82000-04-20 07:42:21 +1000434server_loop(pid_t pid, int fdin_arg, int fdout_arg, int fderr_arg)
Damien Miller95def091999-11-25 00:26:21 +1100435{
Damien Miller5e953212001-01-30 09:14:00 +1100436 fd_set *readset = NULL, *writeset = NULL;
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000437 int max_fd = 0, nalloc = 0;
Damien Miller166fca82000-04-20 07:42:21 +1000438 int wait_status; /* Status returned by wait(). */
439 pid_t wait_pid; /* pid returned by wait(). */
Damien Miller95def091999-11-25 00:26:21 +1100440 int waiting_termination = 0; /* Have displayed waiting close message. */
Ben Lindstrom46c16222000-12-22 01:43:59 +0000441 u_int max_time_milliseconds;
442 u_int previous_stdout_buffer_bytes;
443 u_int stdout_buffer_bytes;
Damien Miller95def091999-11-25 00:26:21 +1100444 int type;
445
446 debug("Entering interactive session.");
447
448 /* Initialize the SIGCHLD kludge. */
Damien Miller95def091999-11-25 00:26:21 +1100449 child_terminated = 0;
Kevin Stevese26a1552001-07-26 17:51:49 +0000450 mysignal(SIGCHLD, sigchld_handler);
Damien Miller95def091999-11-25 00:26:21 +1100451
452 /* Initialize our global variables. */
453 fdin = fdin_arg;
454 fdout = fdout_arg;
455 fderr = fderr_arg;
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000456
457 /* nonblocking IO */
458 set_nonblock(fdin);
459 set_nonblock(fdout);
Damien Miller7d6656c2000-05-20 15:22:36 +1000460 /* we don't have stderr for interactive terminal sessions, see below */
461 if (fderr != -1)
462 set_nonblock(fderr);
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000463
Damien Miller225736c2001-02-19 21:51:08 +1100464 if (!(datafellows & SSH_BUG_IGNOREMSG) && isatty(fdin))
465 fdin_is_tty = 1;
466
Damien Miller95def091999-11-25 00:26:21 +1100467 connection_in = packet_get_connection_in();
468 connection_out = packet_get_connection_out();
469
470 previous_stdout_buffer_bytes = 0;
471
472 /* Set approximate I/O buffer size. */
473 if (packet_is_interactive())
474 buffer_high = 4096;
475 else
476 buffer_high = 64 * 1024;
477
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000478#if 0
Damien Miller95def091999-11-25 00:26:21 +1100479 /* Initialize max_fd to the maximum of the known file descriptors. */
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000480 max_fd = MAX(connection_in, connection_out);
481 max_fd = MAX(max_fd, fdin);
482 max_fd = MAX(max_fd, fdout);
Damien Miller5e953212001-01-30 09:14:00 +1100483 if (fderr != -1)
484 max_fd = MAX(max_fd, fderr);
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000485#endif
Damien Miller95def091999-11-25 00:26:21 +1100486
487 /* Initialize Initialize buffers. */
488 buffer_init(&stdin_buffer);
489 buffer_init(&stdout_buffer);
490 buffer_init(&stderr_buffer);
491
Damien Miller5428f641999-11-25 11:54:57 +1100492 /*
493 * If we have no separate fderr (which is the case when we have a pty
494 * - there we cannot make difference between data sent to stdout and
495 * stderr), indicate that we have seen an EOF from stderr. This way
496 * we don\'t need to check the descriptor everywhere.
497 */
Damien Miller95def091999-11-25 00:26:21 +1100498 if (fderr == -1)
499 fderr_eof = 1;
500
Damien Millerb38eff82000-04-01 11:09:21 +1000501 server_init_dispatch();
502
Damien Miller95def091999-11-25 00:26:21 +1100503 /* Main loop of the server for the interactive session mode. */
504 for (;;) {
Damien Miller95def091999-11-25 00:26:21 +1100505
506 /* Process buffered packets from the client. */
507 process_buffered_input_packets();
508
Damien Miller5428f641999-11-25 11:54:57 +1100509 /*
510 * If we have received eof, and there is no more pending
511 * input data, cause a real eof by closing fdin.
512 */
Damien Miller95def091999-11-25 00:26:21 +1100513 if (stdin_eof && fdin != -1 && buffer_len(&stdin_buffer) == 0) {
514#ifdef USE_PIPES
515 close(fdin);
516#else
Damien Millerb38eff82000-04-01 11:09:21 +1000517 if (fdin != fdout)
Damien Miller95def091999-11-25 00:26:21 +1100518 close(fdin);
519 else
520 shutdown(fdin, SHUT_WR); /* We will no longer send. */
521#endif
522 fdin = -1;
523 }
Damien Miller5428f641999-11-25 11:54:57 +1100524 /* Make packets from buffered stderr data to send to the client. */
Damien Miller95def091999-11-25 00:26:21 +1100525 make_packets_from_stderr_data();
526
Damien Miller5428f641999-11-25 11:54:57 +1100527 /*
528 * Make packets from buffered stdout data to send to the
529 * client. If there is very little to send, this arranges to
530 * not send them now, but to wait a short while to see if we
531 * are getting more data. This is necessary, as some systems
532 * wake up readers from a pty after each separate character.
533 */
Damien Miller95def091999-11-25 00:26:21 +1100534 max_time_milliseconds = 0;
535 stdout_buffer_bytes = buffer_len(&stdout_buffer);
536 if (stdout_buffer_bytes != 0 && stdout_buffer_bytes < 256 &&
537 stdout_buffer_bytes != previous_stdout_buffer_bytes) {
538 /* try again after a while */
539 max_time_milliseconds = 10;
540 } else {
541 /* Send it now. */
542 make_packets_from_stdout_data();
543 }
544 previous_stdout_buffer_bytes = buffer_len(&stdout_buffer);
545
546 /* Send channel data to the client. */
547 if (packet_not_very_much_data_to_write())
548 channel_output_poll();
549
Damien Miller5428f641999-11-25 11:54:57 +1100550 /*
551 * Bail out of the loop if the program has closed its output
552 * descriptors, and we have no more data to send to the
553 * client, and there is no pending buffered data.
554 */
Damien Miller43dc8da2000-11-29 15:55:17 +1100555 if (fdout_eof && fderr_eof && !packet_have_data_to_write() &&
556 buffer_len(&stdout_buffer) == 0 && buffer_len(&stderr_buffer) == 0) {
Damien Miller95def091999-11-25 00:26:21 +1100557 if (!channel_still_open())
Damien Millerb38eff82000-04-01 11:09:21 +1000558 break;
Damien Miller95def091999-11-25 00:26:21 +1100559 if (!waiting_termination) {
560 const char *s = "Waiting for forwarded connections to terminate...\r\n";
561 char *cp;
562 waiting_termination = 1;
563 buffer_append(&stderr_buffer, s, strlen(s));
564
565 /* Display list of open channels. */
566 cp = channel_open_message();
567 buffer_append(&stderr_buffer, cp, strlen(cp));
568 xfree(cp);
569 }
570 }
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000571 max_fd = MAX(connection_in, connection_out);
572 max_fd = MAX(max_fd, fdin);
573 max_fd = MAX(max_fd, fdout);
574 max_fd = MAX(max_fd, fderr);
575
Damien Miller95def091999-11-25 00:26:21 +1100576 /* Sleep in select() until we can do something. */
Damien Miller5e953212001-01-30 09:14:00 +1100577 wait_until_can_do_something(&readset, &writeset, &max_fd,
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000578 &nalloc, max_time_milliseconds);
Damien Miller95def091999-11-25 00:26:21 +1100579
580 /* Process any channel events. */
Damien Miller5e953212001-01-30 09:14:00 +1100581 channel_after_select(readset, writeset);
Damien Miller95def091999-11-25 00:26:21 +1100582
583 /* Process input from the client and from program stdout/stderr. */
Damien Miller5e953212001-01-30 09:14:00 +1100584 process_input(readset);
Damien Miller95def091999-11-25 00:26:21 +1100585
586 /* Process output to the client and to program stdin. */
Damien Miller5e953212001-01-30 09:14:00 +1100587 process_output(writeset);
Damien Miller95def091999-11-25 00:26:21 +1100588 }
Damien Miller5e953212001-01-30 09:14:00 +1100589 if (readset)
590 xfree(readset);
591 if (writeset)
592 xfree(writeset);
Damien Miller95def091999-11-25 00:26:21 +1100593
Damien Miller95def091999-11-25 00:26:21 +1100594 /* Cleanup and termination code. */
595
596 /* Wait until all output has been sent to the client. */
597 drain_output();
598
599 debug("End of interactive session; stdin %ld, stdout (read %ld, sent %ld), stderr %ld bytes.",
600 stdin_bytes, fdout_bytes, stdout_bytes, stderr_bytes);
601
602 /* Free and clear the buffers. */
603 buffer_free(&stdin_buffer);
604 buffer_free(&stdout_buffer);
605 buffer_free(&stderr_buffer);
606
607 /* Close the file descriptors. */
608 if (fdout != -1)
609 close(fdout);
610 fdout = -1;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000611 fdout_eof = 1;
Damien Miller95def091999-11-25 00:26:21 +1100612 if (fderr != -1)
613 close(fderr);
614 fderr = -1;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000615 fderr_eof = 1;
Damien Miller95def091999-11-25 00:26:21 +1100616 if (fdin != -1)
617 close(fdin);
618 fdin = -1;
619
Ben Lindstrom601e4362001-06-21 03:19:23 +0000620 channel_free_all();
Damien Miller95def091999-11-25 00:26:21 +1100621
Damien Miller95def091999-11-25 00:26:21 +1100622 /* We no longer want our SIGCHLD handler to be called. */
Kevin Stevese26a1552001-07-26 17:51:49 +0000623 mysignal(SIGCHLD, SIG_DFL);
Damien Miller95def091999-11-25 00:26:21 +1100624
Ben Lindstromec46e0b2001-06-09 01:27:31 +0000625 wait_pid = waitpid(-1, &wait_status, child_terminated ? WNOHANG : 0);
626 if (wait_pid == -1)
627 packet_disconnect("wait: %.100s", strerror(errno));
628 else if (wait_pid != pid)
629 error("Strange, wait returned pid %d, expected %d",
630 wait_pid, pid);
631
Damien Miller95def091999-11-25 00:26:21 +1100632 /* Check if it exited normally. */
633 if (WIFEXITED(wait_status)) {
634 /* Yes, normal exit. Get exit status and send it to the client. */
635 debug("Command exited with status %d.", WEXITSTATUS(wait_status));
636 packet_start(SSH_SMSG_EXITSTATUS);
637 packet_put_int(WEXITSTATUS(wait_status));
638 packet_send();
639 packet_write_wait();
640
Damien Miller5428f641999-11-25 11:54:57 +1100641 /*
642 * Wait for exit confirmation. Note that there might be
643 * other packets coming before it; however, the program has
644 * already died so we just ignore them. The client is
645 * supposed to respond with the confirmation when it receives
646 * the exit status.
647 */
Damien Miller95def091999-11-25 00:26:21 +1100648 do {
649 int plen;
650 type = packet_read(&plen);
651 }
652 while (type != SSH_CMSG_EXIT_CONFIRMATION);
653
654 debug("Received exit confirmation.");
655 return;
656 }
657 /* Check if the program terminated due to a signal. */
658 if (WIFSIGNALED(wait_status))
659 packet_disconnect("Command terminated on signal %d.",
660 WTERMSIG(wait_status));
661
662 /* Some weird exit cause. Just exit. */
663 packet_disconnect("wait returned status %04x.", wait_status);
664 /* NOTREACHED */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000665}
Damien Millerb38eff82000-04-01 11:09:21 +1000666
Damien Miller3ec27592001-10-12 11:35:04 +1000667static void
668collect_children(void)
669{
670 pid_t pid;
671 sigset_t oset, nset;
672 int status;
673
674 /* block SIGCHLD while we check for dead children */
675 sigemptyset(&nset);
676 sigaddset(&nset, SIGCHLD);
677 sigprocmask(SIG_BLOCK, &nset, &oset);
678 if (child_terminated) {
679 while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
680 session_close_by_pid(pid, status);
681 child_terminated = 0;
682 }
683 sigprocmask(SIG_SETMASK, &oset, NULL);
684}
685
Damien Miller4af51302000-04-16 11:18:38 +1000686void
Ben Lindstrombddd5512001-07-04 04:53:53 +0000687server_loop2(Authctxt *authctxt)
Damien Millerefb4afe2000-04-12 18:45:05 +1000688{
Damien Miller5e953212001-01-30 09:14:00 +1100689 fd_set *readset = NULL, *writeset = NULL;
Damien Miller3ec27592001-10-12 11:35:04 +1000690 int rekeying = 0, max_fd, nalloc = 0;
Damien Millerefb4afe2000-04-12 18:45:05 +1000691
692 debug("Entering interactive session for SSH2.");
693
Ben Lindstromec46e0b2001-06-09 01:27:31 +0000694 mysignal(SIGCHLD, sigchld_handler);
Damien Millerefb4afe2000-04-12 18:45:05 +1000695 child_terminated = 0;
696 connection_in = packet_get_connection_in();
697 connection_out = packet_get_connection_out();
Damien Miller5e953212001-01-30 09:14:00 +1100698
699 max_fd = MAX(connection_in, connection_out);
Ben Lindstrombddd5512001-07-04 04:53:53 +0000700 xxx_authctxt = authctxt;
Damien Miller5e953212001-01-30 09:14:00 +1100701
Damien Millerefb4afe2000-04-12 18:45:05 +1000702 server_init_dispatch();
703
704 for (;;) {
705 process_buffered_input_packets();
Ben Lindstrom8e312f32001-04-04 23:50:21 +0000706
Ben Lindstroma3700052001-04-05 23:26:32 +0000707 rekeying = (xxx_kex != NULL && !xxx_kex->done);
Ben Lindstrom8e312f32001-04-04 23:50:21 +0000708
Ben Lindstrom8e312f32001-04-04 23:50:21 +0000709 if (!rekeying && packet_not_very_much_data_to_write())
Damien Millerefb4afe2000-04-12 18:45:05 +1000710 channel_output_poll();
Ben Lindstrom8e312f32001-04-04 23:50:21 +0000711 wait_until_can_do_something(&readset, &writeset, &max_fd,
Ben Lindstrom16d29d52001-07-18 16:01:46 +0000712 &nalloc, 0);
Damien Miller52b77be2001-10-10 15:14:37 +1000713
Damien Miller3ec27592001-10-12 11:35:04 +1000714 collect_children();
Ben Lindstrom8e312f32001-04-04 23:50:21 +0000715 if (!rekeying)
716 channel_after_select(readset, writeset);
Damien Miller5e953212001-01-30 09:14:00 +1100717 process_input(readset);
Ben Lindstrome34ab4c2001-04-07 01:12:11 +0000718 if (connection_closed)
719 break;
Damien Miller5e953212001-01-30 09:14:00 +1100720 process_output(writeset);
Damien Millerefb4afe2000-04-12 18:45:05 +1000721 }
Damien Miller3ec27592001-10-12 11:35:04 +1000722 collect_children();
723
Damien Miller5e953212001-01-30 09:14:00 +1100724 if (readset)
725 xfree(readset);
726 if (writeset)
727 xfree(writeset);
728
Damien Miller52b77be2001-10-10 15:14:37 +1000729 /* free all channels, no more reads and writes */
730 channel_free_all();
Ben Lindstrom4983d5e2001-07-04 05:17:40 +0000731
Damien Miller3ec27592001-10-12 11:35:04 +1000732 /* free remaining sessions, e.g. remove wtmp entries */
733 session_destroy_all();
Damien Millerefb4afe2000-04-12 18:45:05 +1000734}
735
Ben Lindstrombba81212001-06-25 05:01:22 +0000736static void
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000737server_input_channel_failure(int type, int plen, void *ctxt)
738{
739 debug("Got CHANNEL_FAILURE for keepalive");
740 /*
Ben Lindstrom2f0304c2001-04-29 19:49:14 +0000741 * reset timeout, since we got a sane answer from the client.
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000742 * even if this was generated by something other than
743 * the bogus CHANNEL_REQUEST we send for keepalives.
744 */
745 client_alive_timeouts = 0;
746}
747
748
Ben Lindstrombba81212001-06-25 05:01:22 +0000749static void
Damien Miller62cee002000-09-23 17:15:56 +1100750server_input_stdin_data(int type, int plen, void *ctxt)
Damien Millerb38eff82000-04-01 11:09:21 +1000751{
752 char *data;
Ben Lindstrom46c16222000-12-22 01:43:59 +0000753 u_int data_len;
Damien Millerb38eff82000-04-01 11:09:21 +1000754
755 /* Stdin data from the client. Append it to the buffer. */
756 /* Ignore any data if the client has closed stdin. */
757 if (fdin == -1)
758 return;
759 data = packet_get_string(&data_len);
760 packet_integrity_check(plen, (4 + data_len), type);
761 buffer_append(&stdin_buffer, data, data_len);
762 memset(data, 0, data_len);
763 xfree(data);
764}
765
Ben Lindstrombba81212001-06-25 05:01:22 +0000766static void
Damien Miller62cee002000-09-23 17:15:56 +1100767server_input_eof(int type, int plen, void *ctxt)
Damien Millerb38eff82000-04-01 11:09:21 +1000768{
769 /*
770 * Eof from the client. The stdin descriptor to the
771 * program will be closed when all buffered data has
772 * drained.
773 */
774 debug("EOF received for stdin.");
775 packet_integrity_check(plen, 0, type);
776 stdin_eof = 1;
777}
778
Ben Lindstrombba81212001-06-25 05:01:22 +0000779static void
Damien Miller62cee002000-09-23 17:15:56 +1100780server_input_window_size(int type, int plen, void *ctxt)
Damien Millerb38eff82000-04-01 11:09:21 +1000781{
782 int row = packet_get_int();
783 int col = packet_get_int();
784 int xpixel = packet_get_int();
785 int ypixel = packet_get_int();
786
787 debug("Window change received.");
788 packet_integrity_check(plen, 4 * 4, type);
789 if (fdin != -1)
790 pty_change_window_size(fdin, row, col, xpixel, ypixel);
791}
792
Ben Lindstrombba81212001-06-25 05:01:22 +0000793static Channel *
Damien Miller0bc1bd82000-11-13 22:57:25 +1100794server_request_direct_tcpip(char *ctype)
Damien Millerefb4afe2000-04-12 18:45:05 +1000795{
Ben Lindstrom99c73b32001-05-05 04:09:47 +0000796 Channel *c;
797 int sock;
Damien Miller4af51302000-04-16 11:18:38 +1000798 char *target, *originator;
799 int target_port, originator_port;
Damien Millerefb4afe2000-04-12 18:45:05 +1000800
Damien Miller4af51302000-04-16 11:18:38 +1000801 target = packet_get_string(NULL);
802 target_port = packet_get_int();
Damien Millerefb4afe2000-04-12 18:45:05 +1000803 originator = packet_get_string(NULL);
804 originator_port = packet_get_int();
Damien Miller4af51302000-04-16 11:18:38 +1000805 packet_done();
Damien Millerb1715dc2000-05-30 13:44:51 +1000806
Damien Miller0bc1bd82000-11-13 22:57:25 +1100807 debug("server_request_direct_tcpip: originator %s port %d, target %s port %d",
Damien Millerb1715dc2000-05-30 13:44:51 +1000808 originator, originator_port, target, target_port);
Damien Millerf6d9e222000-06-18 14:50:44 +1000809
Damien Millerefb4afe2000-04-12 18:45:05 +1000810 /* XXX check permission */
Damien Miller4af51302000-04-16 11:18:38 +1000811 sock = channel_connect_to(target, target_port);
812 xfree(target);
Damien Millerefb4afe2000-04-12 18:45:05 +1000813 xfree(originator);
814 if (sock < 0)
Damien Miller0bc1bd82000-11-13 22:57:25 +1100815 return NULL;
Ben Lindstrom99c73b32001-05-05 04:09:47 +0000816 c = channel_new(ctype, SSH_CHANNEL_CONNECTING,
Damien Millere4340be2000-09-16 13:29:08 +1100817 sock, sock, -1, CHAN_TCP_WINDOW_DEFAULT,
Damien Miller69b69aa2000-10-28 14:19:58 +1100818 CHAN_TCP_PACKET_DEFAULT, 0, xstrdup("direct-tcpip"), 1);
Ben Lindstrom99c73b32001-05-05 04:09:47 +0000819 if (c == NULL) {
820 error("server_request_direct_tcpip: channel_new failed");
821 close(sock);
822 }
823 return c;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100824}
825
Ben Lindstrombba81212001-06-25 05:01:22 +0000826static Channel *
Damien Miller0bc1bd82000-11-13 22:57:25 +1100827server_request_session(char *ctype)
828{
Ben Lindstrom99c73b32001-05-05 04:09:47 +0000829 Channel *c;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100830
831 debug("input_session_request");
832 packet_done();
833 /*
834 * A server session has no fd to read or write until a
835 * CHANNEL_REQUEST for a shell is made, so we set the type to
836 * SSH_CHANNEL_LARVAL. Additionally, a callback for handling all
837 * CHANNEL_REQUEST messages is registered.
838 */
Ben Lindstrom99c73b32001-05-05 04:09:47 +0000839 c = channel_new(ctype, SSH_CHANNEL_LARVAL,
840 -1, -1, -1, /*window size*/0, CHAN_SES_PACKET_DEFAULT,
Damien Miller0bc1bd82000-11-13 22:57:25 +1100841 0, xstrdup("server-session"), 1);
Ben Lindstrom99c73b32001-05-05 04:09:47 +0000842 if (c == NULL) {
843 error("server_request_session: channel_new failed");
844 return NULL;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100845 }
Ben Lindstrombddd5512001-07-04 04:53:53 +0000846 if (session_open(xxx_authctxt, c->self) != 1) {
Ben Lindstrom99c73b32001-05-05 04:09:47 +0000847 debug("session open failed, free channel %d", c->self);
848 channel_free(c);
849 return NULL;
850 }
851 channel_register_callback(c->self, SSH2_MSG_CHANNEL_REQUEST,
852 session_input_channel_req, (void *)0);
853 channel_register_cleanup(c->self, session_close_by_channel);
854 return c;
Damien Millerefb4afe2000-04-12 18:45:05 +1000855}
856
Ben Lindstrombba81212001-06-25 05:01:22 +0000857static void
Damien Miller62cee002000-09-23 17:15:56 +1100858server_input_channel_open(int type, int plen, void *ctxt)
Damien Millerefb4afe2000-04-12 18:45:05 +1000859{
860 Channel *c = NULL;
861 char *ctype;
Ben Lindstrom46c16222000-12-22 01:43:59 +0000862 u_int len;
Damien Millerefb4afe2000-04-12 18:45:05 +1000863 int rchan;
864 int rmaxpack;
865 int rwindow;
866
867 ctype = packet_get_string(&len);
868 rchan = packet_get_int();
869 rwindow = packet_get_int();
870 rmaxpack = packet_get_int();
871
Damien Miller62cee002000-09-23 17:15:56 +1100872 debug("server_input_channel_open: ctype %s rchan %d win %d max %d",
Damien Millerefb4afe2000-04-12 18:45:05 +1000873 ctype, rchan, rwindow, rmaxpack);
874
875 if (strcmp(ctype, "session") == 0) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100876 c = server_request_session(ctype);
Damien Millerefb4afe2000-04-12 18:45:05 +1000877 } else if (strcmp(ctype, "direct-tcpip") == 0) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100878 c = server_request_direct_tcpip(ctype);
Damien Millerefb4afe2000-04-12 18:45:05 +1000879 }
880 if (c != NULL) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100881 debug("server_input_channel_open: confirm %s", ctype);
Damien Millerefb4afe2000-04-12 18:45:05 +1000882 c->remote_id = rchan;
883 c->remote_window = rwindow;
884 c->remote_maxpacket = rmaxpack;
Ben Lindstrom69128662001-05-08 20:07:39 +0000885 if (c->type != SSH_CHANNEL_CONNECTING) {
886 packet_start(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
887 packet_put_int(c->remote_id);
888 packet_put_int(c->self);
889 packet_put_int(c->local_window);
890 packet_put_int(c->local_maxpacket);
891 packet_send();
892 }
Damien Millerefb4afe2000-04-12 18:45:05 +1000893 } else {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100894 debug("server_input_channel_open: failure %s", ctype);
Damien Millerefb4afe2000-04-12 18:45:05 +1000895 packet_start(SSH2_MSG_CHANNEL_OPEN_FAILURE);
896 packet_put_int(rchan);
897 packet_put_int(SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED);
Ben Lindstromf3436742001-04-29 19:52:00 +0000898 if (!(datafellows & SSH_BUG_OPENFAILURE)) {
Ben Lindstrom69128662001-05-08 20:07:39 +0000899 packet_put_cstring("open failed");
Ben Lindstromf3436742001-04-29 19:52:00 +0000900 packet_put_cstring("");
901 }
Damien Millerefb4afe2000-04-12 18:45:05 +1000902 packet_send();
903 }
904 xfree(ctype);
905}
906
Ben Lindstrombba81212001-06-25 05:01:22 +0000907static void
Damien Miller0bc1bd82000-11-13 22:57:25 +1100908server_input_global_request(int type, int plen, void *ctxt)
909{
910 char *rtype;
911 int want_reply;
912 int success = 0;
913
914 rtype = packet_get_string(NULL);
915 want_reply = packet_get_char();
916 debug("server_input_global_request: rtype %s want_reply %d", rtype, want_reply);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000917
Ben Lindstrom7bb8b492001-03-17 00:47:54 +0000918 /* -R style forwarding */
Damien Miller0bc1bd82000-11-13 22:57:25 +1100919 if (strcmp(rtype, "tcpip-forward") == 0) {
920 struct passwd *pw;
921 char *listen_address;
922 u_short listen_port;
923
924 pw = auth_get_user();
925 if (pw == NULL)
926 fatal("server_input_global_request: no user");
927 listen_address = packet_get_string(NULL); /* XXX currently ignored */
928 listen_port = (u_short)packet_get_int();
929 debug("server_input_global_request: tcpip-forward listen %s port %d",
930 listen_address, listen_port);
931
932 /* check permissions */
933 if (!options.allow_tcp_forwarding ||
934 no_port_forwarding_flag ||
935 (listen_port < IPPORT_RESERVED && pw->pw_uid != 0)) {
936 success = 0;
937 packet_send_debug("Server has disabled port forwarding.");
938 } else {
939 /* Start listening on the port */
Kevin Steves12057502001-02-05 14:54:34 +0000940 success = channel_request_forwarding(
Damien Miller0bc1bd82000-11-13 22:57:25 +1100941 listen_address, listen_port,
942 /*unspec host_to_connect*/ "<unspec host>",
943 /*unspec port_to_connect*/ 0,
944 options.gateway_ports, /*remote*/ 1);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100945 }
946 xfree(listen_address);
947 }
948 if (want_reply) {
949 packet_start(success ?
950 SSH2_MSG_REQUEST_SUCCESS : SSH2_MSG_REQUEST_FAILURE);
951 packet_send();
952 packet_write_wait();
953 }
954 xfree(rtype);
955}
956
Ben Lindstrombba81212001-06-25 05:01:22 +0000957static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +0000958server_init_dispatch_20(void)
Damien Millerefb4afe2000-04-12 18:45:05 +1000959{
960 debug("server_init_dispatch_20");
961 dispatch_init(&dispatch_protocol_error);
962 dispatch_set(SSH2_MSG_CHANNEL_CLOSE, &channel_input_oclose);
963 dispatch_set(SSH2_MSG_CHANNEL_DATA, &channel_input_data);
964 dispatch_set(SSH2_MSG_CHANNEL_EOF, &channel_input_ieof);
965 dispatch_set(SSH2_MSG_CHANNEL_EXTENDED_DATA, &channel_input_extended_data);
966 dispatch_set(SSH2_MSG_CHANNEL_OPEN, &server_input_channel_open);
967 dispatch_set(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);
968 dispatch_set(SSH2_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);
969 dispatch_set(SSH2_MSG_CHANNEL_REQUEST, &channel_input_channel_request);
970 dispatch_set(SSH2_MSG_CHANNEL_WINDOW_ADJUST, &channel_input_window_adjust);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100971 dispatch_set(SSH2_MSG_GLOBAL_REQUEST, &server_input_global_request);
Ben Lindstrom5744dc42001-04-13 23:28:01 +0000972 /* client_alive */
973 dispatch_set(SSH2_MSG_CHANNEL_FAILURE, &server_input_channel_failure);
Ben Lindstrom8ac91062001-04-04 17:57:54 +0000974 /* rekeying */
975 dispatch_set(SSH2_MSG_KEXINIT, &kex_input_kexinit);
Damien Millerefb4afe2000-04-12 18:45:05 +1000976}
Ben Lindstrombba81212001-06-25 05:01:22 +0000977static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +0000978server_init_dispatch_13(void)
Damien Millerb38eff82000-04-01 11:09:21 +1000979{
980 debug("server_init_dispatch_13");
981 dispatch_init(NULL);
982 dispatch_set(SSH_CMSG_EOF, &server_input_eof);
983 dispatch_set(SSH_CMSG_STDIN_DATA, &server_input_stdin_data);
984 dispatch_set(SSH_CMSG_WINDOW_SIZE, &server_input_window_size);
985 dispatch_set(SSH_MSG_CHANNEL_CLOSE, &channel_input_close);
986 dispatch_set(SSH_MSG_CHANNEL_CLOSE_CONFIRMATION, &channel_input_close_confirmation);
987 dispatch_set(SSH_MSG_CHANNEL_DATA, &channel_input_data);
988 dispatch_set(SSH_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);
989 dispatch_set(SSH_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);
990 dispatch_set(SSH_MSG_PORT_OPEN, &channel_input_port_open);
991}
Ben Lindstrombba81212001-06-25 05:01:22 +0000992static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +0000993server_init_dispatch_15(void)
Damien Millerb38eff82000-04-01 11:09:21 +1000994{
995 server_init_dispatch_13();
996 debug("server_init_dispatch_15");
997 dispatch_set(SSH_MSG_CHANNEL_CLOSE, &channel_input_ieof);
998 dispatch_set(SSH_MSG_CHANNEL_CLOSE_CONFIRMATION, &channel_input_oclose);
999}
Ben Lindstrombba81212001-06-25 05:01:22 +00001000static void
Ben Lindstrom31ca54a2001-02-09 02:11:24 +00001001server_init_dispatch(void)
Damien Millerb38eff82000-04-01 11:09:21 +10001002{
Damien Millerefb4afe2000-04-12 18:45:05 +10001003 if (compat20)
1004 server_init_dispatch_20();
1005 else if (compat13)
Damien Millerb38eff82000-04-01 11:09:21 +10001006 server_init_dispatch_13();
1007 else
1008 server_init_dispatch_15();
1009}