blob: b08fcfd92d853a3cf1e3507882878feaea73277e [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
5 * Created: Sun Sep 10 00:30:37 1995 ylo
6 * Server main loop for handling the interactive session.
7 */
Damien Millerefb4afe2000-04-12 18:45:05 +10008/*
9 * SSH2 support by Markus Friedl.
10 * Copyright (c) 2000 Markus Friedl. All rights reserved.
11 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100012
13#include "includes.h"
14#include "xmalloc.h"
15#include "ssh.h"
16#include "packet.h"
17#include "buffer.h"
18#include "servconf.h"
19#include "pty.h"
Damien Millerb38eff82000-04-01 11:09:21 +100020#include "channels.h"
21
22#include "compat.h"
Damien Millerefb4afe2000-04-12 18:45:05 +100023#include "ssh2.h"
24#include "session.h"
Damien Millerb38eff82000-04-01 11:09:21 +100025#include "dispatch.h"
Damien Millerd4a8b7e1999-10-27 13:42:43 +100026
27static Buffer stdin_buffer; /* Buffer for stdin data. */
28static Buffer stdout_buffer; /* Buffer for stdout data. */
29static Buffer stderr_buffer; /* Buffer for stderr data. */
30static int fdin; /* Descriptor for stdin (for writing) */
31static int fdout; /* Descriptor for stdout (for reading);
32 May be same number as fdin. */
33static int fderr; /* Descriptor for stderr. May be -1. */
34static long stdin_bytes = 0; /* Number of bytes written to stdin. */
35static long stdout_bytes = 0; /* Number of stdout bytes sent to client. */
36static long stderr_bytes = 0; /* Number of stderr bytes sent to client. */
37static long fdout_bytes = 0; /* Number of stdout bytes read from program. */
38static int stdin_eof = 0; /* EOF message received from client. */
39static int fdout_eof = 0; /* EOF encountered reading from fdout. */
40static int fderr_eof = 0; /* EOF encountered readung from fderr. */
41static int connection_in; /* Connection to client (input). */
42static int connection_out; /* Connection to client (output). */
43static unsigned int buffer_high;/* "Soft" max buffer size. */
44static int max_fd; /* Max file descriptor number for select(). */
45
Damien Miller5428f641999-11-25 11:54:57 +110046/*
47 * This SIGCHLD kludge is used to detect when the child exits. The server
48 * will exit after that, as soon as forwarded connections have terminated.
Damien Millerb284b542000-01-17 20:55:18 +110049 *
50 * After SIGCHLD child_has_selected is set to 1 after the first pass
51 * through the wait_until_can_do_something() select(). This ensures
52 * that the child's output gets a chance to drain before it is yanked.
Damien Miller5428f641999-11-25 11:54:57 +110053 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100054
Damien Miller166fca82000-04-20 07:42:21 +100055static pid_t child_pid; /* Pid of the child. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100056static volatile int child_terminated; /* The child has terminated. */
Damien Millerb284b542000-01-17 20:55:18 +110057static volatile int child_has_selected; /* Child has had chance to drain. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100058static volatile int child_wait_status; /* Status from wait(). */
59
Damien Millerb38eff82000-04-01 11:09:21 +100060void server_init_dispatch(void);
61
Damien Miller4af51302000-04-16 11:18:38 +100062void
Damien Miller95def091999-11-25 00:26:21 +110063sigchld_handler(int sig)
Damien Millerd4a8b7e1999-10-27 13:42:43 +100064{
Damien Miller95def091999-11-25 00:26:21 +110065 int save_errno = errno;
Damien Miller166fca82000-04-20 07:42:21 +100066 pid_t wait_pid;
67
Damien Miller95def091999-11-25 00:26:21 +110068 debug("Received SIGCHLD.");
69 wait_pid = wait((int *) &child_wait_status);
70 if (wait_pid != -1) {
71 if (wait_pid != child_pid)
72 error("Strange, got SIGCHLD and wait returned pid %d but child is %d",
73 wait_pid, child_pid);
74 if (WIFEXITED(child_wait_status) ||
75 WIFSIGNALED(child_wait_status))
76 child_terminated = 1;
Damien Millerb284b542000-01-17 20:55:18 +110077 child_has_selected = 0;
Damien Miller95def091999-11-25 00:26:21 +110078 }
79 signal(SIGCHLD, sigchld_handler);
80 errno = save_errno;
Damien Millerd4a8b7e1999-10-27 13:42:43 +100081}
Damien Miller4af51302000-04-16 11:18:38 +100082void
Damien Millerefb4afe2000-04-12 18:45:05 +100083sigchld_handler2(int sig)
84{
85 int save_errno = errno;
86 debug("Received SIGCHLD.");
87 child_terminated = 1;
Damien Millerefb4afe2000-04-12 18:45:05 +100088 errno = save_errno;
89}
Damien Millerd4a8b7e1999-10-27 13:42:43 +100090
Damien Miller95def091999-11-25 00:26:21 +110091/*
Damien Miller95def091999-11-25 00:26:21 +110092 * Make packets from buffered stderr data, and buffer it for sending
93 * to the client.
94 */
Damien Miller4af51302000-04-16 11:18:38 +100095void
Damien Miller95def091999-11-25 00:26:21 +110096make_packets_from_stderr_data()
Damien Millerd4a8b7e1999-10-27 13:42:43 +100097{
Damien Miller95def091999-11-25 00:26:21 +110098 int len;
Damien Millerd4a8b7e1999-10-27 13:42:43 +100099
Damien Miller95def091999-11-25 00:26:21 +1100100 /* Send buffered stderr data to the client. */
101 while (buffer_len(&stderr_buffer) > 0 &&
Damien Miller037a0dc1999-12-07 15:38:31 +1100102 packet_not_very_much_data_to_write()) {
Damien Miller95def091999-11-25 00:26:21 +1100103 len = buffer_len(&stderr_buffer);
104 if (packet_is_interactive()) {
105 if (len > 512)
106 len = 512;
107 } else {
108 /* Keep the packets at reasonable size. */
109 if (len > packet_get_maxsize())
110 len = packet_get_maxsize();
111 }
112 packet_start(SSH_SMSG_STDERR_DATA);
113 packet_put_string(buffer_ptr(&stderr_buffer), len);
114 packet_send();
115 buffer_consume(&stderr_buffer, len);
116 stderr_bytes += len;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000117 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000118}
119
Damien Miller95def091999-11-25 00:26:21 +1100120/*
121 * Make packets from buffered stdout data, and buffer it for sending to the
122 * client.
123 */
Damien Miller4af51302000-04-16 11:18:38 +1000124void
Damien Miller95def091999-11-25 00:26:21 +1100125make_packets_from_stdout_data()
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000126{
Damien Miller95def091999-11-25 00:26:21 +1100127 int len;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000128
Damien Miller95def091999-11-25 00:26:21 +1100129 /* Send buffered stdout data to the client. */
130 while (buffer_len(&stdout_buffer) > 0 &&
Damien Miller037a0dc1999-12-07 15:38:31 +1100131 packet_not_very_much_data_to_write()) {
Damien Miller95def091999-11-25 00:26:21 +1100132 len = buffer_len(&stdout_buffer);
133 if (packet_is_interactive()) {
134 if (len > 512)
135 len = 512;
136 } else {
137 /* Keep the packets at reasonable size. */
138 if (len > packet_get_maxsize())
139 len = packet_get_maxsize();
140 }
141 packet_start(SSH_SMSG_STDOUT_DATA);
142 packet_put_string(buffer_ptr(&stdout_buffer), len);
143 packet_send();
144 buffer_consume(&stdout_buffer, len);
145 stdout_bytes += len;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000146 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000147}
148
Damien Miller95def091999-11-25 00:26:21 +1100149/*
150 * Sleep in select() until we can do something. This will initialize the
151 * select masks. Upon return, the masks will indicate which descriptors
152 * have data or can accept data. Optionally, a maximum time can be specified
153 * for the duration of the wait (0 = infinite).
154 */
Damien Miller4af51302000-04-16 11:18:38 +1000155void
Damien Miller95def091999-11-25 00:26:21 +1100156wait_until_can_do_something(fd_set * readset, fd_set * writeset,
157 unsigned int max_time_milliseconds)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000158{
Damien Miller95def091999-11-25 00:26:21 +1100159 struct timeval tv, *tvp;
160 int ret;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000161
Damien Miller95def091999-11-25 00:26:21 +1100162 /* When select fails we restart from here. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000163retry_select:
164
Damien Miller95def091999-11-25 00:26:21 +1100165 /* Initialize select() masks. */
166 FD_ZERO(readset);
Damien Millerb1715dc2000-05-30 13:44:51 +1000167 FD_ZERO(writeset);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000168
Damien Millerefb4afe2000-04-12 18:45:05 +1000169 if (compat20) {
Damien Millere247cc42000-05-07 12:03:14 +1000170 /* wrong: bad condition XXX */
Damien Millerefb4afe2000-04-12 18:45:05 +1000171 if (channel_not_very_much_buffered_data())
172 FD_SET(connection_in, readset);
173 } else {
Damien Millerb1715dc2000-05-30 13:44:51 +1000174 /*
175 * Read packets from the client unless we have too much
176 * buffered stdin or channel data.
177 */
178 if (buffer_len(&stdin_buffer) < buffer_high &&
Damien Millerefb4afe2000-04-12 18:45:05 +1000179 channel_not_very_much_buffered_data())
180 FD_SET(connection_in, readset);
Damien Millerb1715dc2000-05-30 13:44:51 +1000181 /*
182 * If there is not too much data already buffered going to
183 * the client, try to get some more data from the program.
184 */
185 if (packet_not_very_much_data_to_write()) {
186 if (!fdout_eof)
187 FD_SET(fdout, readset);
188 if (!fderr_eof)
189 FD_SET(fderr, readset);
190 }
191 /*
192 * If we have buffered data, try to write some of that data
193 * to the program.
194 */
195 if (fdin != -1 && buffer_len(&stdin_buffer) > 0)
196 FD_SET(fdin, writeset);
Damien Millerefb4afe2000-04-12 18:45:05 +1000197 }
Damien Miller95def091999-11-25 00:26:21 +1100198 /* Set masks for channel descriptors. */
199 channel_prepare_select(readset, writeset);
200
Damien Miller5428f641999-11-25 11:54:57 +1100201 /*
202 * If we have buffered packet data going to the client, mark that
203 * descriptor.
204 */
Damien Miller95def091999-11-25 00:26:21 +1100205 if (packet_have_data_to_write())
206 FD_SET(connection_out, writeset);
207
Damien Miller95def091999-11-25 00:26:21 +1100208 /* Update the maximum descriptor number if appropriate. */
209 if (channel_max_fd() > max_fd)
210 max_fd = channel_max_fd();
211
Damien Miller5428f641999-11-25 11:54:57 +1100212 /*
213 * If child has terminated and there is enough buffer space to read
214 * from it, then read as much as is available and exit.
215 */
Damien Miller95def091999-11-25 00:26:21 +1100216 if (child_terminated && packet_not_very_much_data_to_write())
217 if (max_time_milliseconds == 0)
218 max_time_milliseconds = 100;
219
220 if (max_time_milliseconds == 0)
221 tvp = NULL;
222 else {
223 tv.tv_sec = max_time_milliseconds / 1000;
224 tv.tv_usec = 1000 * (max_time_milliseconds % 1000);
225 tvp = &tv;
226 }
Damien Millerefb4afe2000-04-12 18:45:05 +1000227 if (tvp!=NULL)
228 debug("tvp!=NULL kid %d mili %d", child_terminated, max_time_milliseconds);
Damien Miller95def091999-11-25 00:26:21 +1100229
230 /* Wait for something to happen, or the timeout to expire. */
231 ret = select(max_fd + 1, readset, writeset, NULL, tvp);
232
233 if (ret < 0) {
234 if (errno != EINTR)
235 error("select: %.100s", strerror(errno));
236 else
237 goto retry_select;
238 }
Damien Millerb284b542000-01-17 20:55:18 +1100239
240 if (child_terminated)
241 child_has_selected = 1;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000242}
243
Damien Miller95def091999-11-25 00:26:21 +1100244/*
245 * Processes input from the client and the program. Input data is stored
246 * in buffers and processed later.
247 */
Damien Miller4af51302000-04-16 11:18:38 +1000248void
Damien Miller95def091999-11-25 00:26:21 +1100249process_input(fd_set * readset)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000250{
Damien Miller95def091999-11-25 00:26:21 +1100251 int len;
252 char buf[16384];
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000253
Damien Miller95def091999-11-25 00:26:21 +1100254 /* Read and buffer any input data from the client. */
255 if (FD_ISSET(connection_in, readset)) {
256 len = read(connection_in, buf, sizeof(buf));
257 if (len == 0) {
258 verbose("Connection closed by remote host.");
259 fatal_cleanup();
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000260 } else if (len < 0) {
261 if (errno != EINTR && errno != EAGAIN) {
262 verbose("Read error from remote host: %.100s", strerror(errno));
263 fatal_cleanup();
264 }
265 } else {
266 /* Buffer any received data. */
267 packet_process_incoming(buf, len);
Damien Miller95def091999-11-25 00:26:21 +1100268 }
Damien Miller95def091999-11-25 00:26:21 +1100269 }
Damien Millerefb4afe2000-04-12 18:45:05 +1000270 if (compat20)
271 return;
272
Damien Miller95def091999-11-25 00:26:21 +1100273 /* Read and buffer any available stdout data from the program. */
274 if (!fdout_eof && FD_ISSET(fdout, readset)) {
275 len = read(fdout, buf, sizeof(buf));
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000276 if (len < 0 && (errno == EINTR || errno == EAGAIN)) {
277 /* do nothing */
278 } else if (len <= 0) {
Damien Miller95def091999-11-25 00:26:21 +1100279 fdout_eof = 1;
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000280 } else {
Damien Miller95def091999-11-25 00:26:21 +1100281 buffer_append(&stdout_buffer, buf, len);
282 fdout_bytes += len;
283 }
284 }
285 /* Read and buffer any available stderr data from the program. */
286 if (!fderr_eof && FD_ISSET(fderr, readset)) {
287 len = read(fderr, buf, sizeof(buf));
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000288 if (len < 0 && (errno == EINTR || errno == EAGAIN)) {
289 /* do nothing */
290 } else if (len <= 0) {
Damien Miller95def091999-11-25 00:26:21 +1100291 fderr_eof = 1;
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000292 } else {
Damien Miller95def091999-11-25 00:26:21 +1100293 buffer_append(&stderr_buffer, buf, len);
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000294 }
Damien Miller95def091999-11-25 00:26:21 +1100295 }
296}
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000297
Damien Miller95def091999-11-25 00:26:21 +1100298/*
299 * Sends data from internal buffers to client program stdin.
300 */
Damien Miller4af51302000-04-16 11:18:38 +1000301void
Damien Miller95def091999-11-25 00:26:21 +1100302process_output(fd_set * writeset)
303{
304 int len;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000305
Damien Miller95def091999-11-25 00:26:21 +1100306 /* Write buffered data to program stdin. */
Damien Millerefb4afe2000-04-12 18:45:05 +1000307 if (!compat20 && fdin != -1 && FD_ISSET(fdin, writeset)) {
Damien Miller95def091999-11-25 00:26:21 +1100308 len = write(fdin, buffer_ptr(&stdin_buffer),
Damien Miller037a0dc1999-12-07 15:38:31 +1100309 buffer_len(&stdin_buffer));
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000310 if (len < 0 && (errno == EINTR || errno == EAGAIN)) {
311 /* do nothing */
312 } else if (len <= 0) {
Damien Miller95def091999-11-25 00:26:21 +1100313#ifdef USE_PIPES
314 close(fdin);
315#else
Damien Millerb38eff82000-04-01 11:09:21 +1000316 if (fdin != fdout)
Damien Miller95def091999-11-25 00:26:21 +1100317 close(fdin);
318 else
319 shutdown(fdin, SHUT_WR); /* We will no longer send. */
320#endif
321 fdin = -1;
322 } else {
323 /* Successful write. Consume the data from the buffer. */
324 buffer_consume(&stdin_buffer, len);
325 /* Update the count of bytes written to the program. */
326 stdin_bytes += len;
327 }
328 }
329 /* Send any buffered packet data to the client. */
330 if (FD_ISSET(connection_out, writeset))
331 packet_write_poll();
332}
333
334/*
335 * Wait until all buffered output has been sent to the client.
336 * This is used when the program terminates.
337 */
Damien Miller4af51302000-04-16 11:18:38 +1000338void
Damien Miller95def091999-11-25 00:26:21 +1100339drain_output()
340{
341 /* Send any buffered stdout data to the client. */
342 if (buffer_len(&stdout_buffer) > 0) {
343 packet_start(SSH_SMSG_STDOUT_DATA);
344 packet_put_string(buffer_ptr(&stdout_buffer),
345 buffer_len(&stdout_buffer));
346 packet_send();
347 /* Update the count of sent bytes. */
348 stdout_bytes += buffer_len(&stdout_buffer);
349 }
350 /* Send any buffered stderr data to the client. */
351 if (buffer_len(&stderr_buffer) > 0) {
352 packet_start(SSH_SMSG_STDERR_DATA);
353 packet_put_string(buffer_ptr(&stderr_buffer),
354 buffer_len(&stderr_buffer));
355 packet_send();
356 /* Update the count of sent bytes. */
357 stderr_bytes += buffer_len(&stderr_buffer);
358 }
359 /* Wait until all buffered data has been written to the client. */
360 packet_write_wait();
361}
362
Damien Miller4af51302000-04-16 11:18:38 +1000363void
Damien Millerb38eff82000-04-01 11:09:21 +1000364process_buffered_input_packets()
365{
366 dispatch_run(DISPATCH_NONBLOCK, NULL);
367}
368
Damien Miller95def091999-11-25 00:26:21 +1100369/*
370 * Performs the interactive session. This handles data transmission between
371 * the client and the program. Note that the notion of stdin, stdout, and
372 * stderr in this function is sort of reversed: this function writes to
373 * stdin (of the child program), and reads from stdout and stderr (of the
374 * child program).
375 */
Damien Miller4af51302000-04-16 11:18:38 +1000376void
Damien Miller166fca82000-04-20 07:42:21 +1000377server_loop(pid_t pid, int fdin_arg, int fdout_arg, int fderr_arg)
Damien Miller95def091999-11-25 00:26:21 +1100378{
Damien Millerb1715dc2000-05-30 13:44:51 +1000379 fd_set readset, writeset;
Damien Miller166fca82000-04-20 07:42:21 +1000380 int wait_status; /* Status returned by wait(). */
381 pid_t wait_pid; /* pid returned by wait(). */
Damien Miller95def091999-11-25 00:26:21 +1100382 int waiting_termination = 0; /* Have displayed waiting close message. */
383 unsigned int max_time_milliseconds;
384 unsigned int previous_stdout_buffer_bytes;
385 unsigned int stdout_buffer_bytes;
386 int type;
387
388 debug("Entering interactive session.");
389
390 /* Initialize the SIGCHLD kludge. */
391 child_pid = pid;
392 child_terminated = 0;
Damien Millerb284b542000-01-17 20:55:18 +1100393 child_has_selected = 0;
Damien Miller95def091999-11-25 00:26:21 +1100394 signal(SIGCHLD, sigchld_handler);
395
396 /* Initialize our global variables. */
397 fdin = fdin_arg;
398 fdout = fdout_arg;
399 fderr = fderr_arg;
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000400
401 /* nonblocking IO */
402 set_nonblock(fdin);
403 set_nonblock(fdout);
Damien Miller7d6656c2000-05-20 15:22:36 +1000404 /* we don't have stderr for interactive terminal sessions, see below */
405 if (fderr != -1)
406 set_nonblock(fderr);
Damien Millerdcb6ecd2000-05-17 22:34:22 +1000407
Damien Miller95def091999-11-25 00:26:21 +1100408 connection_in = packet_get_connection_in();
409 connection_out = packet_get_connection_out();
410
411 previous_stdout_buffer_bytes = 0;
412
413 /* Set approximate I/O buffer size. */
414 if (packet_is_interactive())
415 buffer_high = 4096;
416 else
417 buffer_high = 64 * 1024;
418
419 /* Initialize max_fd to the maximum of the known file descriptors. */
420 max_fd = fdin;
421 if (fdout > max_fd)
422 max_fd = fdout;
423 if (fderr != -1 && fderr > max_fd)
424 max_fd = fderr;
425 if (connection_in > max_fd)
426 max_fd = connection_in;
427 if (connection_out > max_fd)
428 max_fd = connection_out;
429
430 /* Initialize Initialize buffers. */
431 buffer_init(&stdin_buffer);
432 buffer_init(&stdout_buffer);
433 buffer_init(&stderr_buffer);
434
Damien Miller5428f641999-11-25 11:54:57 +1100435 /*
436 * If we have no separate fderr (which is the case when we have a pty
437 * - there we cannot make difference between data sent to stdout and
438 * stderr), indicate that we have seen an EOF from stderr. This way
439 * we don\'t need to check the descriptor everywhere.
440 */
Damien Miller95def091999-11-25 00:26:21 +1100441 if (fderr == -1)
442 fderr_eof = 1;
443
Damien Millerb38eff82000-04-01 11:09:21 +1000444 server_init_dispatch();
445
Damien Miller95def091999-11-25 00:26:21 +1100446 /* Main loop of the server for the interactive session mode. */
447 for (;;) {
Damien Miller95def091999-11-25 00:26:21 +1100448
449 /* Process buffered packets from the client. */
450 process_buffered_input_packets();
451
Damien Miller5428f641999-11-25 11:54:57 +1100452 /*
453 * If we have received eof, and there is no more pending
454 * input data, cause a real eof by closing fdin.
455 */
Damien Miller95def091999-11-25 00:26:21 +1100456 if (stdin_eof && fdin != -1 && buffer_len(&stdin_buffer) == 0) {
457#ifdef USE_PIPES
458 close(fdin);
459#else
Damien Millerb38eff82000-04-01 11:09:21 +1000460 if (fdin != fdout)
Damien Miller95def091999-11-25 00:26:21 +1100461 close(fdin);
462 else
463 shutdown(fdin, SHUT_WR); /* We will no longer send. */
464#endif
465 fdin = -1;
466 }
Damien Miller5428f641999-11-25 11:54:57 +1100467 /* Make packets from buffered stderr data to send to the client. */
Damien Miller95def091999-11-25 00:26:21 +1100468 make_packets_from_stderr_data();
469
Damien Miller5428f641999-11-25 11:54:57 +1100470 /*
471 * Make packets from buffered stdout data to send to the
472 * client. If there is very little to send, this arranges to
473 * not send them now, but to wait a short while to see if we
474 * are getting more data. This is necessary, as some systems
475 * wake up readers from a pty after each separate character.
476 */
Damien Miller95def091999-11-25 00:26:21 +1100477 max_time_milliseconds = 0;
478 stdout_buffer_bytes = buffer_len(&stdout_buffer);
479 if (stdout_buffer_bytes != 0 && stdout_buffer_bytes < 256 &&
480 stdout_buffer_bytes != previous_stdout_buffer_bytes) {
481 /* try again after a while */
482 max_time_milliseconds = 10;
483 } else {
484 /* Send it now. */
485 make_packets_from_stdout_data();
486 }
487 previous_stdout_buffer_bytes = buffer_len(&stdout_buffer);
488
489 /* Send channel data to the client. */
490 if (packet_not_very_much_data_to_write())
491 channel_output_poll();
492
Damien Miller5428f641999-11-25 11:54:57 +1100493 /*
494 * Bail out of the loop if the program has closed its output
495 * descriptors, and we have no more data to send to the
496 * client, and there is no pending buffered data.
497 */
Damien Millerb284b542000-01-17 20:55:18 +1100498 if (((fdout_eof && fderr_eof) ||
499 (child_terminated && child_has_selected)) &&
500 !packet_have_data_to_write() &&
501 (buffer_len(&stdout_buffer) == 0) &&
502 (buffer_len(&stderr_buffer) == 0)) {
Damien Miller95def091999-11-25 00:26:21 +1100503 if (!channel_still_open())
Damien Millerb38eff82000-04-01 11:09:21 +1000504 break;
Damien Miller95def091999-11-25 00:26:21 +1100505 if (!waiting_termination) {
506 const char *s = "Waiting for forwarded connections to terminate...\r\n";
507 char *cp;
508 waiting_termination = 1;
509 buffer_append(&stderr_buffer, s, strlen(s));
510
511 /* Display list of open channels. */
512 cp = channel_open_message();
513 buffer_append(&stderr_buffer, cp, strlen(cp));
514 xfree(cp);
515 }
516 }
517 /* Sleep in select() until we can do something. */
518 wait_until_can_do_something(&readset, &writeset,
519 max_time_milliseconds);
520
521 /* Process any channel events. */
522 channel_after_select(&readset, &writeset);
523
524 /* Process input from the client and from program stdout/stderr. */
525 process_input(&readset);
526
527 /* Process output to the client and to program stdin. */
528 process_output(&writeset);
529 }
530
Damien Miller95def091999-11-25 00:26:21 +1100531 /* Cleanup and termination code. */
532
533 /* Wait until all output has been sent to the client. */
534 drain_output();
535
536 debug("End of interactive session; stdin %ld, stdout (read %ld, sent %ld), stderr %ld bytes.",
537 stdin_bytes, fdout_bytes, stdout_bytes, stderr_bytes);
538
539 /* Free and clear the buffers. */
540 buffer_free(&stdin_buffer);
541 buffer_free(&stdout_buffer);
542 buffer_free(&stderr_buffer);
543
544 /* Close the file descriptors. */
545 if (fdout != -1)
546 close(fdout);
547 fdout = -1;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000548 fdout_eof = 1;
Damien Miller95def091999-11-25 00:26:21 +1100549 if (fderr != -1)
550 close(fderr);
551 fderr = -1;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000552 fderr_eof = 1;
Damien Miller95def091999-11-25 00:26:21 +1100553 if (fdin != -1)
554 close(fdin);
555 fdin = -1;
556
557 /* Stop listening for channels; this removes unix domain sockets. */
558 channel_stop_listening();
559
560 /* Wait for the child to exit. Get its exit status. */
561 wait_pid = wait(&wait_status);
562 if (wait_pid < 0) {
563 /*
564 * It is possible that the wait was handled by SIGCHLD
565 * handler. This may result in either: this call
566 * returning with EINTR, or: this call returning ECHILD.
567 */
568 if (child_terminated)
569 wait_status = child_wait_status;
570 else
571 packet_disconnect("wait: %.100s", strerror(errno));
572 } else {
573 /* Check if it matches the process we forked. */
574 if (wait_pid != pid)
575 error("Strange, wait returned pid %d, expected %d",
Damien Milleraae6c611999-12-06 11:47:28 +1100576 wait_pid, pid);
Damien Miller95def091999-11-25 00:26:21 +1100577 }
578
579 /* We no longer want our SIGCHLD handler to be called. */
580 signal(SIGCHLD, SIG_DFL);
581
582 /* Check if it exited normally. */
583 if (WIFEXITED(wait_status)) {
584 /* Yes, normal exit. Get exit status and send it to the client. */
585 debug("Command exited with status %d.", WEXITSTATUS(wait_status));
586 packet_start(SSH_SMSG_EXITSTATUS);
587 packet_put_int(WEXITSTATUS(wait_status));
588 packet_send();
589 packet_write_wait();
590
Damien Miller5428f641999-11-25 11:54:57 +1100591 /*
592 * Wait for exit confirmation. Note that there might be
593 * other packets coming before it; however, the program has
594 * already died so we just ignore them. The client is
595 * supposed to respond with the confirmation when it receives
596 * the exit status.
597 */
Damien Miller95def091999-11-25 00:26:21 +1100598 do {
599 int plen;
600 type = packet_read(&plen);
601 }
602 while (type != SSH_CMSG_EXIT_CONFIRMATION);
603
604 debug("Received exit confirmation.");
605 return;
606 }
607 /* Check if the program terminated due to a signal. */
608 if (WIFSIGNALED(wait_status))
609 packet_disconnect("Command terminated on signal %d.",
610 WTERMSIG(wait_status));
611
612 /* Some weird exit cause. Just exit. */
613 packet_disconnect("wait returned status %04x.", wait_status);
614 /* NOTREACHED */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000615}
Damien Millerb38eff82000-04-01 11:09:21 +1000616
Damien Miller4af51302000-04-16 11:18:38 +1000617void
Damien Millerefb4afe2000-04-12 18:45:05 +1000618server_loop2(void)
619{
620 fd_set readset, writeset;
621 int had_channel = 0;
622 int status;
623 pid_t pid;
624
625 debug("Entering interactive session for SSH2.");
626
627 signal(SIGCHLD, sigchld_handler2);
628 child_terminated = 0;
629 connection_in = packet_get_connection_in();
630 connection_out = packet_get_connection_out();
631 max_fd = connection_in;
632 if (connection_out > max_fd)
633 max_fd = connection_out;
634 server_init_dispatch();
635
636 for (;;) {
637 process_buffered_input_packets();
638 if (!had_channel && channel_still_open())
639 had_channel = 1;
640 if (had_channel && !channel_still_open()) {
641 debug("!channel_still_open.");
642 break;
643 }
644 if (packet_not_very_much_data_to_write())
645 channel_output_poll();
646 wait_until_can_do_something(&readset, &writeset, 0);
647 if (child_terminated) {
648 while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
649 session_close_by_pid(pid, status);
650 child_terminated = 0;
Damien Millerfda78d92000-05-20 15:33:44 +1000651 signal(SIGCHLD, sigchld_handler2);
Damien Millerefb4afe2000-04-12 18:45:05 +1000652 }
653 channel_after_select(&readset, &writeset);
654 process_input(&readset);
655 process_output(&writeset);
656 }
657 signal(SIGCHLD, SIG_DFL);
658 while ((pid = waitpid(-1, &status, WNOHANG)) > 0)
659 session_close_by_pid(pid, status);
660 channel_stop_listening();
661}
662
Damien Millerb38eff82000-04-01 11:09:21 +1000663void
664server_input_stdin_data(int type, int plen)
665{
666 char *data;
667 unsigned int data_len;
668
669 /* Stdin data from the client. Append it to the buffer. */
670 /* Ignore any data if the client has closed stdin. */
671 if (fdin == -1)
672 return;
673 data = packet_get_string(&data_len);
674 packet_integrity_check(plen, (4 + data_len), type);
675 buffer_append(&stdin_buffer, data, data_len);
676 memset(data, 0, data_len);
677 xfree(data);
678}
679
680void
681server_input_eof(int type, int plen)
682{
683 /*
684 * Eof from the client. The stdin descriptor to the
685 * program will be closed when all buffered data has
686 * drained.
687 */
688 debug("EOF received for stdin.");
689 packet_integrity_check(plen, 0, type);
690 stdin_eof = 1;
691}
692
693void
694server_input_window_size(int type, int plen)
695{
696 int row = packet_get_int();
697 int col = packet_get_int();
698 int xpixel = packet_get_int();
699 int ypixel = packet_get_int();
700
701 debug("Window change received.");
702 packet_integrity_check(plen, 4 * 4, type);
703 if (fdin != -1)
704 pty_change_window_size(fdin, row, col, xpixel, ypixel);
705}
706
Damien Millerefb4afe2000-04-12 18:45:05 +1000707int
708input_direct_tcpip(void)
709{
710 int sock;
Damien Miller4af51302000-04-16 11:18:38 +1000711 char *target, *originator;
712 int target_port, originator_port;
Damien Millerefb4afe2000-04-12 18:45:05 +1000713
Damien Miller4af51302000-04-16 11:18:38 +1000714 target = packet_get_string(NULL);
715 target_port = packet_get_int();
Damien Millerefb4afe2000-04-12 18:45:05 +1000716 originator = packet_get_string(NULL);
717 originator_port = packet_get_int();
Damien Miller4af51302000-04-16 11:18:38 +1000718 packet_done();
Damien Millerb1715dc2000-05-30 13:44:51 +1000719
720 debug("open direct-tcpip: from %s port %d to %s port %d",
721 originator, originator_port, target, target_port);
Damien Millerefb4afe2000-04-12 18:45:05 +1000722 /* XXX check permission */
Damien Miller4af51302000-04-16 11:18:38 +1000723 sock = channel_connect_to(target, target_port);
724 xfree(target);
Damien Millerefb4afe2000-04-12 18:45:05 +1000725 xfree(originator);
726 if (sock < 0)
727 return -1;
728 return channel_new("direct-tcpip", SSH_CHANNEL_OPEN,
729 sock, sock, -1, 4*1024, 32*1024, 0, xstrdup("direct-tcpip"));
730}
731
Damien Miller4af51302000-04-16 11:18:38 +1000732void
Damien Millerefb4afe2000-04-12 18:45:05 +1000733server_input_channel_open(int type, int plen)
734{
735 Channel *c = NULL;
736 char *ctype;
737 int id;
738 unsigned int len;
739 int rchan;
740 int rmaxpack;
741 int rwindow;
742
743 ctype = packet_get_string(&len);
744 rchan = packet_get_int();
745 rwindow = packet_get_int();
746 rmaxpack = packet_get_int();
747
Damien Millereba71ba2000-04-29 23:57:08 +1000748 debug("channel_input_open: ctype %s rchan %d win %d max %d",
Damien Millerefb4afe2000-04-12 18:45:05 +1000749 ctype, rchan, rwindow, rmaxpack);
750
751 if (strcmp(ctype, "session") == 0) {
752 debug("open session");
Damien Miller4af51302000-04-16 11:18:38 +1000753 packet_done();
Damien Millerefb4afe2000-04-12 18:45:05 +1000754 /*
755 * A server session has no fd to read or write
756 * until a CHANNEL_REQUEST for a shell is made,
757 * so we set the type to SSH_CHANNEL_LARVAL.
758 * Additionally, a callback for handling all
759 * CHANNEL_REQUEST messages is registered.
760 */
761 id = channel_new(ctype, SSH_CHANNEL_LARVAL,
762 -1, -1, -1, 0, 32*1024, 0, xstrdup("server-session"));
763 if (session_open(id) == 1) {
764 channel_register_callback(id, SSH2_MSG_CHANNEL_REQUEST,
765 session_input_channel_req, (void *)0);
766 channel_register_cleanup(id, session_close_by_channel);
767 c = channel_lookup(id);
768 } else {
769 debug("session open failed, free channel %d", id);
770 channel_free(id);
771 }
772 } else if (strcmp(ctype, "direct-tcpip") == 0) {
Damien Millerefb4afe2000-04-12 18:45:05 +1000773 id = input_direct_tcpip();
774 if (id >= 0)
775 c = channel_lookup(id);
776 }
777 if (c != NULL) {
778 debug("confirm %s", ctype);
779 c->remote_id = rchan;
780 c->remote_window = rwindow;
781 c->remote_maxpacket = rmaxpack;
782
783 packet_start(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
784 packet_put_int(c->remote_id);
785 packet_put_int(c->self);
786 packet_put_int(c->local_window);
787 packet_put_int(c->local_maxpacket);
788 packet_send();
789 } else {
790 debug("failure %s", ctype);
791 packet_start(SSH2_MSG_CHANNEL_OPEN_FAILURE);
792 packet_put_int(rchan);
793 packet_put_int(SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED);
794 packet_put_cstring("bla bla");
795 packet_put_cstring("");
796 packet_send();
797 }
798 xfree(ctype);
799}
800
Damien Miller4af51302000-04-16 11:18:38 +1000801void
Damien Millerefb4afe2000-04-12 18:45:05 +1000802server_init_dispatch_20()
803{
804 debug("server_init_dispatch_20");
805 dispatch_init(&dispatch_protocol_error);
806 dispatch_set(SSH2_MSG_CHANNEL_CLOSE, &channel_input_oclose);
807 dispatch_set(SSH2_MSG_CHANNEL_DATA, &channel_input_data);
808 dispatch_set(SSH2_MSG_CHANNEL_EOF, &channel_input_ieof);
809 dispatch_set(SSH2_MSG_CHANNEL_EXTENDED_DATA, &channel_input_extended_data);
810 dispatch_set(SSH2_MSG_CHANNEL_OPEN, &server_input_channel_open);
811 dispatch_set(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);
812 dispatch_set(SSH2_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);
813 dispatch_set(SSH2_MSG_CHANNEL_REQUEST, &channel_input_channel_request);
814 dispatch_set(SSH2_MSG_CHANNEL_WINDOW_ADJUST, &channel_input_window_adjust);
815}
Damien Miller4af51302000-04-16 11:18:38 +1000816void
Damien Millerb38eff82000-04-01 11:09:21 +1000817server_init_dispatch_13()
818{
819 debug("server_init_dispatch_13");
820 dispatch_init(NULL);
821 dispatch_set(SSH_CMSG_EOF, &server_input_eof);
822 dispatch_set(SSH_CMSG_STDIN_DATA, &server_input_stdin_data);
823 dispatch_set(SSH_CMSG_WINDOW_SIZE, &server_input_window_size);
824 dispatch_set(SSH_MSG_CHANNEL_CLOSE, &channel_input_close);
825 dispatch_set(SSH_MSG_CHANNEL_CLOSE_CONFIRMATION, &channel_input_close_confirmation);
826 dispatch_set(SSH_MSG_CHANNEL_DATA, &channel_input_data);
827 dispatch_set(SSH_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);
828 dispatch_set(SSH_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);
829 dispatch_set(SSH_MSG_PORT_OPEN, &channel_input_port_open);
830}
Damien Miller4af51302000-04-16 11:18:38 +1000831void
Damien Millerb38eff82000-04-01 11:09:21 +1000832server_init_dispatch_15()
833{
834 server_init_dispatch_13();
835 debug("server_init_dispatch_15");
836 dispatch_set(SSH_MSG_CHANNEL_CLOSE, &channel_input_ieof);
837 dispatch_set(SSH_MSG_CHANNEL_CLOSE_CONFIRMATION, &channel_input_oclose);
838}
Damien Miller4af51302000-04-16 11:18:38 +1000839void
Damien Millerb38eff82000-04-01 11:09:21 +1000840server_init_dispatch()
841{
Damien Millerefb4afe2000-04-12 18:45:05 +1000842 if (compat20)
843 server_init_dispatch_20();
844 else if (compat13)
Damien Millerb38eff82000-04-01 11:09:21 +1000845 server_init_dispatch_13();
846 else
847 server_init_dispatch_15();
848}