]> andersk Git - openssh.git/blame - clientloop.c
Changed name of directory in tarball
[openssh.git] / clientloop.c
CommitLineData
8efc0c15 1/*
2
3clientloop.c
4
5Author: Tatu Ylonen <ylo@cs.hut.fi>
6
7Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
8 All rights reserved
9
10
11Created: Sat Sep 23 12:23:57 1995 ylo
12
13The main loop for the interactive session (client side).
14
15*/
16
17#include "includes.h"
18RCSID("$Id$");
19
20#include "xmalloc.h"
21#include "ssh.h"
22#include "packet.h"
23#include "buffer.h"
24#include "authfd.h"
25
26/* Flag indicating whether quiet mode is on. */
27extern int quiet_flag;
28
29/* Flag indicating that stdin should be redirected from /dev/null. */
30extern int stdin_null_flag;
31
32/* Name of the host we are connecting to. This is the name given on the
33 command line, or the HostName specified for the user-supplied name
34 in a configuration file. */
35extern char *host;
36
37/* Flag to indicate that we have received a window change signal which has
38 not yet been processed. This will cause a message indicating the new
39 window size to be sent to the server a little later. This is volatile
40 because this is updated in a signal handler. */
41static volatile int received_window_change_signal = 0;
42
43/* Terminal modes, as saved by enter_raw_mode. */
44static struct termios saved_tio;
45
46/* Flag indicating whether we are in raw mode. This is used by enter_raw_mode
47 and leave_raw_mode. */
48static int in_raw_mode = 0;
49
50/* Flag indicating whether the user\'s terminal is in non-blocking mode. */
51static int in_non_blocking_mode = 0;
52
53/* Common data for the client loop code. */
54static int escape_pending; /* Last character was the escape character */
55static int last_was_cr; /* Last character was a newline. */
56static int exit_status; /* Used to store the exit status of the command. */
57static int stdin_eof; /* EOF has been encountered on standard error. */
58static Buffer stdin_buffer; /* Buffer for stdin data. */
59static Buffer stdout_buffer; /* Buffer for stdout data. */
60static Buffer stderr_buffer; /* Buffer for stderr data. */
61static unsigned int buffer_high; /* Soft max buffer size. */
62static int max_fd; /* Maximum file descriptor number in select(). */
63static int connection_in; /* Connection to server (input). */
64static int connection_out; /* Connection to server (output). */
65static unsigned long stdin_bytes, stdout_bytes, stderr_bytes;
66static int quit_pending; /* Set to non-zero to quit the client loop. */
67static int escape_char; /* Escape character. */
68
69/* Returns the user\'s terminal to normal mode if it had been put in raw
70 mode. */
71
72void leave_raw_mode()
73{
74 if (!in_raw_mode)
75 return;
76 in_raw_mode = 0;
77 if (tcsetattr(fileno(stdin), TCSADRAIN, &saved_tio) < 0)
78 perror("tcsetattr");
79
80 fatal_remove_cleanup((void (*)(void *))leave_raw_mode, NULL);
81}
82
83/* Puts the user\'s terminal in raw mode. */
84
85void enter_raw_mode()
86{
87 struct termios tio;
88
89 if (tcgetattr(fileno(stdin), &tio) < 0)
90 perror("tcgetattr");
91 saved_tio = tio;
92 tio.c_iflag |= IGNPAR;
93 tio.c_iflag &= ~(ISTRIP|INLCR|IGNCR|ICRNL|IXON|IXANY|IXOFF);
94 tio.c_lflag &= ~(ISIG|ICANON|ECHO|ECHOE|ECHOK|ECHONL);
95#ifdef IEXTEN
96 tio.c_lflag &= ~IEXTEN;
97#endif /* IEXTEN */
98 tio.c_oflag &= ~OPOST;
99 tio.c_cc[VMIN] = 1;
100 tio.c_cc[VTIME] = 0;
101 if (tcsetattr(fileno(stdin), TCSADRAIN, &tio) < 0)
102 perror("tcsetattr");
103 in_raw_mode = 1;
104
105 fatal_add_cleanup((void (*)(void *))leave_raw_mode, NULL);
106}
107
108/* Puts stdin terminal in non-blocking mode. */
109
110/* Restores stdin to blocking mode. */
111
112void leave_non_blocking()
113{
114 if (in_non_blocking_mode)
115 {
116 (void)fcntl(fileno(stdin), F_SETFL, 0);
117 in_non_blocking_mode = 0;
118 fatal_remove_cleanup((void (*)(void *))leave_non_blocking, NULL);
119 }
120}
121
122void enter_non_blocking()
123{
124 in_non_blocking_mode = 1;
125 (void)fcntl(fileno(stdin), F_SETFL, O_NONBLOCK);
126 fatal_add_cleanup((void (*)(void *))leave_non_blocking, NULL);
127}
128
129/* Signal handler for the window change signal (SIGWINCH). This just
130 sets a flag indicating that the window has changed. */
131
132void window_change_handler(int sig)
133{
134 received_window_change_signal = 1;
135 signal(SIGWINCH, window_change_handler);
136}
137
138/* Signal handler for signals that cause the program to terminate. These
139 signals must be trapped to restore terminal modes. */
140
141void signal_handler(int sig)
142{
143 if (in_raw_mode)
144 leave_raw_mode();
145 if (in_non_blocking_mode)
146 leave_non_blocking();
147 channel_stop_listening();
148 packet_close();
149 fatal("Killed by signal %d.", sig);
150}
151
152/* Returns current time in seconds from Jan 1, 1970 with the maximum available
153 resolution. */
154
155double get_current_time()
156{
157 struct timeval tv;
158 gettimeofday(&tv, NULL);
159 return (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
160}
161
162/* This is called when the interactive is entered. This checks if there
163 is an EOF coming on stdin. We must check this explicitly, as select()
164 does not appear to wake up when redirecting from /dev/null. */
165
166void client_check_initial_eof_on_stdin()
167{
168 int len;
169 char buf[1];
170
171 /* If standard input is to be "redirected from /dev/null", we simply
172 mark that we have seen an EOF and send an EOF message to the server.
173 Otherwise, we try to read a single character; it appears that for some
174 files, such /dev/null, select() never wakes up for read for this
175 descriptor, which means that we never get EOF. This way we will get
176 the EOF if stdin comes from /dev/null or similar. */
177 if (stdin_null_flag)
178 {
179 /* Fake EOF on stdin. */
180 debug("Sending eof.");
181 stdin_eof = 1;
182 packet_start(SSH_CMSG_EOF);
183 packet_send();
184 }
185 else
186 {
187 /* Enter non-blocking mode for stdin. */
188 enter_non_blocking();
189
190 /* Check for immediate EOF on stdin. */
191 len = read(fileno(stdin), buf, 1);
192 if (len == 0)
193 {
194 /* EOF. Record that we have seen it and send EOF to server. */
195 debug("Sending eof.");
196 stdin_eof = 1;
197 packet_start(SSH_CMSG_EOF);
198 packet_send();
199 }
200 else
201 if (len > 0)
202 {
203 /* Got data. We must store the data in the buffer, and also
204 process it as an escape character if appropriate. */
205 if ((unsigned char)buf[0] == escape_char)
206 escape_pending = 1;
207 else
208 {
209 buffer_append(&stdin_buffer, buf, 1);
210 stdin_bytes += 1;
211 }
212 }
213
214 /* Leave non-blocking mode. */
215 leave_non_blocking();
216 }
217}
218
219/* Get packets from the connection input buffer, and process them as long
220 as there are packets available. */
221
222void client_process_buffered_input_packets()
223{
224 int type;
225 char *data;
226 unsigned int data_len;
227 int payload_len;
228
229 /* Process any buffered packets from the server. */
230 while (!quit_pending && (type = packet_read_poll(&payload_len)) != SSH_MSG_NONE)
231 {
232 switch (type)
233 {
234
235 case SSH_SMSG_STDOUT_DATA:
236 data = packet_get_string(&data_len);
237 packet_integrity_check(payload_len, 4 + data_len, type);
238 buffer_append(&stdout_buffer, data, data_len);
239 stdout_bytes += data_len;
240 memset(data, 0, data_len);
241 xfree(data);
242 break;
243
244 case SSH_SMSG_STDERR_DATA:
245 data = packet_get_string(&data_len);
246 packet_integrity_check(payload_len, 4 + data_len, type);
247 buffer_append(&stderr_buffer, data, data_len);
248 stdout_bytes += data_len;
249 memset(data, 0, data_len);
250 xfree(data);
251 break;
252
253 case SSH_SMSG_EXITSTATUS:
254 packet_integrity_check(payload_len, 4, type);
255 exit_status = packet_get_int();
256 /* Acknowledge the exit. */
257 packet_start(SSH_CMSG_EXIT_CONFIRMATION);
258 packet_send();
259 /* Must wait for packet to be sent since we are exiting the
260 loop. */
261 packet_write_wait();
262 /* Flag that we want to exit. */
263 quit_pending = 1;
264 break;
265
266 case SSH_SMSG_X11_OPEN:
267 x11_input_open(payload_len);
268 break;
269
270 case SSH_MSG_PORT_OPEN:
271 channel_input_port_open(payload_len);
272 break;
273
274 case SSH_SMSG_AGENT_OPEN:
275 packet_integrity_check(payload_len, 4, type);
276 auth_input_open_request();
277 break;
278
279 case SSH_MSG_CHANNEL_OPEN_CONFIRMATION:
280 packet_integrity_check(payload_len, 4 + 4, type);
281 channel_input_open_confirmation();
282 break;
283
284 case SSH_MSG_CHANNEL_OPEN_FAILURE:
285 packet_integrity_check(payload_len, 4, type);
286 channel_input_open_failure();
287 break;
288
289 case SSH_MSG_CHANNEL_DATA:
290 channel_input_data(payload_len);
291 break;
292
293 case SSH_MSG_CHANNEL_CLOSE:
294 packet_integrity_check(payload_len, 4, type);
295 channel_input_close();
296 break;
297
298 case SSH_MSG_CHANNEL_CLOSE_CONFIRMATION:
299 packet_integrity_check(payload_len, 4, type);
300 channel_input_close_confirmation();
301 break;
302
303 default:
304 /* Any unknown packets received during the actual session
305 cause the session to terminate. This is intended to make
306 debugging easier since no confirmations are sent. Any
307 compatible protocol extensions must be negotiated during
308 the preparatory phase. */
309 packet_disconnect("Protocol error during session: type %d",
310 type);
311 }
312 }
313}
314
315/* Make packets from buffered stdin data, and buffer them for sending to
316 the connection. */
317
318void client_make_packets_from_stdin_data()
319{
320 unsigned int len;
321
322 /* Send buffered stdin data to the server. */
323 while (buffer_len(&stdin_buffer) > 0 &&
324 packet_not_very_much_data_to_write())
325 {
326 len = buffer_len(&stdin_buffer);
327 if (len > 32768)
328 len = 32768; /* Keep the packets at reasonable size. */
329 packet_start(SSH_CMSG_STDIN_DATA);
330 packet_put_string(buffer_ptr(&stdin_buffer), len);
331 packet_send();
332 buffer_consume(&stdin_buffer, len);
333 /* If we have a pending EOF, send it now. */
334 if (stdin_eof && buffer_len(&stdin_buffer) == 0)
335 {
336 packet_start(SSH_CMSG_EOF);
337 packet_send();
338 }
339 }
340}
341
342/* Checks if the client window has changed, and sends a packet about it to
343 the server if so. The actual change is detected elsewhere (by a software
344 interrupt on Unix); this just checks the flag and sends a message if
345 appropriate. */
346
347void client_check_window_change()
348{
349 /* Send possible window change message to the server. */
350 if (received_window_change_signal)
351 {
352 struct winsize ws;
353
354 /* Clear the window change indicator. */
355 received_window_change_signal = 0;
356
357 /* Read new window size. */
358 if (ioctl(fileno(stdin), TIOCGWINSZ, &ws) >= 0)
359 {
360 /* Successful, send the packet now. */
361 packet_start(SSH_CMSG_WINDOW_SIZE);
362 packet_put_int(ws.ws_row);
363 packet_put_int(ws.ws_col);
364 packet_put_int(ws.ws_xpixel);
365 packet_put_int(ws.ws_ypixel);
366 packet_send();
367 }
368 }
369}
370
371/* Waits until the client can do something (some data becomes available on
372 one of the file descriptors). */
373
374void client_wait_until_can_do_something(fd_set *readset, fd_set *writeset)
375{
376 /* Initialize select masks. */
377 FD_ZERO(readset);
378
379 /* Read from the connection, unless our buffers are full. */
380 if (buffer_len(&stdout_buffer) < buffer_high &&
381 buffer_len(&stderr_buffer) < buffer_high &&
382 channel_not_very_much_buffered_data())
383 FD_SET(connection_in, readset);
384
385 /* Read from stdin, unless we have seen EOF or have very much buffered
386 data to send to the server. */
387 if (!stdin_eof && packet_not_very_much_data_to_write())
388 FD_SET(fileno(stdin), readset);
389
390 FD_ZERO(writeset);
391
392 /* Add any selections by the channel mechanism. */
393 channel_prepare_select(readset, writeset);
394
395 /* Select server connection if have data to write to the server. */
396 if (packet_have_data_to_write())
397 FD_SET(connection_out, writeset);
398
399 /* Select stdout if have data in buffer. */
400 if (buffer_len(&stdout_buffer) > 0)
401 FD_SET(fileno(stdout), writeset);
402
403 /* Select stderr if have data in buffer. */
404 if (buffer_len(&stderr_buffer) > 0)
405 FD_SET(fileno(stderr), writeset);
406
407 /* Update maximum file descriptor number, if appropriate. */
408 if (channel_max_fd() > max_fd)
409 max_fd = channel_max_fd();
410
411 /* Wait for something to happen. This will suspend the process until
412 some selected descriptor can be read, written, or has some other
413 event pending. Note: if you want to implement SSH_MSG_IGNORE
414 messages to fool traffic analysis, this might be the place to do
415 it: just have a random timeout for the select, and send a random
416 SSH_MSG_IGNORE packet when the timeout expires. */
417 if (select(max_fd + 1, readset, writeset, NULL, NULL) < 0)
418 {
419 char buf[100];
420 /* Some systems fail to clear these automatically. */
421 FD_ZERO(readset);
422 FD_ZERO(writeset);
423 if (errno == EINTR)
424 return;
425 /* Note: we might still have data in the buffers. */
426 snprintf(buf, sizeof buf, "select: %s\r\n", strerror(errno));
427 buffer_append(&stderr_buffer, buf, strlen(buf));
428 stderr_bytes += strlen(buf);
429 quit_pending = 1;
430 }
431}
432
433void client_suspend_self()
434{
435 struct winsize oldws, newws;
436
437 /* Flush stdout and stderr buffers. */
438 if (buffer_len(&stdout_buffer) > 0)
439 write(fileno(stdout),
440 buffer_ptr(&stdout_buffer),
441 buffer_len(&stdout_buffer));
442 if (buffer_len(&stderr_buffer) > 0)
443 write(fileno(stderr),
444 buffer_ptr(&stderr_buffer),
445 buffer_len(&stderr_buffer));
446
447 /* Leave raw mode. */
448 leave_raw_mode();
449
450 /* Free (and clear) the buffer to reduce the
451 amount of data that gets written to swap. */
452 buffer_free(&stdin_buffer);
453 buffer_free(&stdout_buffer);
454 buffer_free(&stderr_buffer);
455
456 /* Save old window size. */
457 ioctl(fileno(stdin), TIOCGWINSZ, &oldws);
458
459 /* Send the suspend signal to the program
460 itself. */
461 kill(getpid(), SIGTSTP);
462
463 /* Check if the window size has changed. */
464 if (ioctl(fileno(stdin), TIOCGWINSZ, &newws) >= 0 &&
465 (oldws.ws_row != newws.ws_row || oldws.ws_col != newws.ws_col ||
466 oldws.ws_xpixel != newws.ws_xpixel ||
467 oldws.ws_ypixel != newws.ws_ypixel))
468 received_window_change_signal = 1;
469
470 /* OK, we have been continued by the user.
471 Reinitialize buffers. */
472 buffer_init(&stdin_buffer);
473 buffer_init(&stdout_buffer);
474 buffer_init(&stderr_buffer);
475
476 /* Re-enter raw mode. */
477 enter_raw_mode();
478}
479
480void client_process_input(fd_set *readset)
481{
482 int len, pid;
483 char buf[8192], *s;
484
485 /* Read input from the server, and add any such data to the buffer of the
486 packet subsystem. */
487 if (FD_ISSET(connection_in, readset))
488 {
489 /* Read as much as possible. */
490 len = read(connection_in, buf, sizeof(buf));
491 if (len == 0)
492 {
493 /* Received EOF. The remote host has closed the connection. */
494 snprintf(buf, sizeof buf, "Connection to %.300s closed by remote host.\r\n",
495 host);
496 buffer_append(&stderr_buffer, buf, strlen(buf));
497 stderr_bytes += strlen(buf);
498 quit_pending = 1;
499 return;
500 }
501
502 /* There is a kernel bug on Solaris that causes select to sometimes
503 wake up even though there is no data available. */
504 if (len < 0 && errno == EAGAIN)
505 len = 0;
506
507 if (len < 0)
508 {
509 /* An error has encountered. Perhaps there is a network
510 problem. */
511 snprintf(buf, sizeof buf, "Read from remote host %.300s: %.100s\r\n",
512 host, strerror(errno));
513 buffer_append(&stderr_buffer, buf, strlen(buf));
514 stderr_bytes += strlen(buf);
515 quit_pending = 1;
516 return;
517 }
518 packet_process_incoming(buf, len);
519 }
520
521 /* Read input from stdin. */
522 if (FD_ISSET(fileno(stdin), readset))
523 {
524 /* Read as much as possible. */
525 len = read(fileno(stdin), buf, sizeof(buf));
526 if (len <= 0)
527 {
528 /* Received EOF or error. They are treated similarly,
529 except that an error message is printed if it was
530 an error condition. */
531 if (len < 0)
532 {
533 snprintf(buf, sizeof buf, "read: %.100s\r\n", strerror(errno));
534 buffer_append(&stderr_buffer, buf, strlen(buf));
535 stderr_bytes += strlen(buf);
536 }
537 /* Mark that we have seen EOF. */
538 stdin_eof = 1;
539 /* Send an EOF message to the server unless there is data
540 in the buffer. If there is data in the buffer, no message
541 will be sent now. Code elsewhere will send the EOF
542 when the buffer becomes empty if stdin_eof is set. */
543 if (buffer_len(&stdin_buffer) == 0)
544 {
545 packet_start(SSH_CMSG_EOF);
546 packet_send();
547 }
548 }
549 else
550 if (escape_char == -1)
551 {
552 /* Normal successful read, and no escape character. Just
553 append the data to buffer. */
554 buffer_append(&stdin_buffer, buf, len);
555 stdin_bytes += len;
556 }
557 else
558 {
559 /* Normal, successful read. But we have an escape character
560 and have to process the characters one by one. */
561 unsigned int i;
562 for (i = 0; i < len; i++)
563 {
564 unsigned char ch;
565 /* Get one character at a time. */
566 ch = buf[i];
567
568 /* Check if we have a pending escape character. */
569 if (escape_pending)
570 {
571 /* We have previously seen an escape character. */
572 /* Clear the flag now. */
573 escape_pending = 0;
574 /* Process the escaped character. */
575 switch (ch)
576 {
577 case '.':
578 /* Terminate the connection. */
579 snprintf(buf, sizeof buf, "%c.\r\n", escape_char);
580 buffer_append(&stderr_buffer, buf, strlen(buf));
581 stderr_bytes += strlen(buf);
582 quit_pending = 1;
583 return;
584
585 case 'Z' - 64:
586 /* Suspend the program. */
587 /* Print a message to that effect to the user. */
588 snprintf(buf, sizeof buf, "%c^Z\r\n", escape_char);
589 buffer_append(&stderr_buffer, buf, strlen(buf));
590 stderr_bytes += strlen(buf);
591
592 /* Restore terminal modes and suspend. */
593 client_suspend_self();
594
595 /* We have been continued. */
596 continue;
597
598 case '&':
599 /* Detach the program (continue to serve connections,
600 but put in background and no more new
601 connections). */
602 if (!stdin_eof)
603 {
604 /* Sending SSH_CMSG_EOF alone does not always
605 appear to be enough. So we try to send an
606 EOF character first. */
607 packet_start(SSH_CMSG_STDIN_DATA);
608 packet_put_string("\004", 1);
609 packet_send();
610 /* Close stdin. */
611 stdin_eof = 1;
612 if (buffer_len(&stdin_buffer) == 0)
613 {
614 packet_start(SSH_CMSG_EOF);
615 packet_send();
616 }
617 }
618 /* Restore tty modes. */
619 leave_raw_mode();
620
621 /* Stop listening for new connections. */
622 channel_stop_listening();
623
624 printf("%c& [backgrounded]\n", escape_char);
625
626 /* Fork into background. */
627 pid = fork();
628 if (pid < 0)
629 {
630 error("fork: %.100s", strerror(errno));
631 continue;
632 }
633 if (pid != 0)
634 { /* This is the parent. */
635 /* The parent just exits. */
636 exit(0);
637 }
638
639 /* The child continues serving connections. */
640 continue;
641
642 case '?':
643 snprintf(buf, sizeof buf, "%c?\r\n\
644Supported escape sequences:\r\n\
645~. - terminate connection\r\n\
646~^Z - suspend ssh\r\n\
647~# - list forwarded connections\r\n\
648~& - background ssh (when waiting for connections to terminate)\r\n\
649~? - this message\r\n\
650~~ - send the escape character by typing it twice\r\n\
651(Note that escapes are only recognized immediately after newline.)\r\n",
652 escape_char);
653 buffer_append(&stderr_buffer, buf, strlen(buf));
654 continue;
655
656 case '#':
657 snprintf(buf, sizeof buf, "%c#\r\n", escape_char);
658 buffer_append(&stderr_buffer, buf, strlen(buf));
659 s = channel_open_message();
660 buffer_append(&stderr_buffer, s, strlen(s));
661 xfree(s);
662 continue;
663
664 default:
665 if (ch != escape_char)
666 {
667 /* Escape character followed by non-special
668 character. Append both to the input
669 buffer. */
670 buf[0] = escape_char;
671 buf[1] = ch;
672 buffer_append(&stdin_buffer, buf, 2);
673 stdin_bytes += 2;
674 continue;
675 }
676 /* Note that escape character typed twice falls through
677 here; the latter gets processed as a normal
678 character below. */
679 break;
680 }
681 }
682 else
683 {
684 /* The previous character was not an escape char.
685 Check if this is an escape. */
686 if (last_was_cr && ch == escape_char)
687 {
688 /* It is. Set the flag and continue to next
689 character. */
690 escape_pending = 1;
691 continue;
692 }
693 }
694
695 /* Normal character. Record whether it was a newline,
696 and append it to the buffer. */
697 last_was_cr = (ch == '\r' || ch == '\n');
698 buf[0] = ch;
699 buffer_append(&stdin_buffer, buf, 1);
700 stdin_bytes += 1;
701 continue;
702 }
703 }
704 }
705}
706
707void client_process_output(fd_set *writeset)
708{
709 int len;
710 char buf[100];
711
712 /* Write buffered output to stdout. */
713 if (FD_ISSET(fileno(stdout), writeset))
714 {
715 /* Write as much data as possible. */
716 len = write(fileno(stdout), buffer_ptr(&stdout_buffer),
717 buffer_len(&stdout_buffer));
718 if (len <= 0)
719 {
720 if (errno == EAGAIN)
721 len = 0;
722 else
723 {
724 /* An error or EOF was encountered. Put an error message
725 to stderr buffer. */
726 snprintf(buf, sizeof buf, "write stdout: %.50s\r\n", strerror(errno));
727 buffer_append(&stderr_buffer, buf, strlen(buf));
728 stderr_bytes += strlen(buf);
729 quit_pending = 1;
730 return;
731 }
732 }
733 /* Consume printed data from the buffer. */
734 buffer_consume(&stdout_buffer, len);
735 }
736
737 /* Write buffered output to stderr. */
738 if (FD_ISSET(fileno(stderr), writeset))
739 {
740 /* Write as much data as possible. */
741 len = write(fileno(stderr), buffer_ptr(&stderr_buffer),
742 buffer_len(&stderr_buffer));
743 if (len <= 0) {
744 if (errno == EAGAIN)
745 len = 0;
746 else
747 {
748 /* EOF or error, but can't even print error message. */
749 quit_pending = 1;
750 return;
751 }
752 }
753 /* Consume printed characters from the buffer. */
754 buffer_consume(&stderr_buffer, len);
755 }
756}
757
758/* Implements the interactive session with the server. This is called
759 after the user has been authenticated, and a command has been
760 started on the remote host. If escape_char != -1, it is the character
761 used as an escape character for terminating or suspending the
762 session. */
763
764int client_loop(int have_pty, int escape_char_arg)
765{
766 double start_time, total_time;
767 int len;
768 char buf[100];
769
770 debug("Entering interactive session.");
771
772 start_time = get_current_time();
773
774 /* Initialize variables. */
775 escape_pending = 0;
776 last_was_cr = 1;
777 exit_status = -1;
778 stdin_eof = 0;
779 buffer_high = 64 * 1024;
780 connection_in = packet_get_connection_in();
781 connection_out = packet_get_connection_out();
782 max_fd = connection_in;
783 if (connection_out > max_fd)
784 max_fd = connection_out;
785 stdin_bytes = 0;
786 stdout_bytes = 0;
787 stderr_bytes = 0;
788 quit_pending = 0;
789 escape_char = escape_char_arg;
790
791 /* Initialize buffers. */
792 buffer_init(&stdin_buffer);
793 buffer_init(&stdout_buffer);
794 buffer_init(&stderr_buffer);
795
796 /* Set signal handlers to restore non-blocking mode. */
797 signal(SIGINT, signal_handler);
798 signal(SIGQUIT, signal_handler);
799 signal(SIGTERM, signal_handler);
800 signal(SIGPIPE, SIG_IGN);
801 if (have_pty)
802 signal(SIGWINCH, window_change_handler);
803
804 /* Enter raw mode if have a pseudo terminal. */
805 if (have_pty)
806 enter_raw_mode();
807
808 /* Check if we should immediately send of on stdin. */
809 client_check_initial_eof_on_stdin();
810
811 /* Main loop of the client for the interactive session mode. */
812 while (!quit_pending)
813 {
814 fd_set readset, writeset;
815
816 /* Precess buffered packets sent by the server. */
817 client_process_buffered_input_packets();
818
819 /* Make packets of buffered stdin data, and buffer them for sending
820 to the server. */
821 client_make_packets_from_stdin_data();
822
823 /* Make packets from buffered channel data, and buffer them for sending
824 to the server. */
825 if (packet_not_very_much_data_to_write())
826 channel_output_poll();
827
828 /* Check if the window size has changed, and buffer a message about
829 it to the server if so. */
830 client_check_window_change();
831
832 if (quit_pending)
833 break;
834
835 /* Wait until we have something to do (something becomes available
836 on one of the descriptors). */
837 client_wait_until_can_do_something(&readset, &writeset);
838
839 if (quit_pending)
840 break;
841
842 /* Do channel operations. */
843 channel_after_select(&readset, &writeset);
844
845 /* Process input from the connection and from stdin. Buffer any data
846 that is available. */
847 client_process_input(&readset);
848
849 /* Process output to stdout and stderr. Output to the connection
850 is processed elsewhere (above). */
851 client_process_output(&writeset);
852
853 /* Send as much buffered packet data as possible to the sender. */
854 if (FD_ISSET(connection_out, &writeset))
855 packet_write_poll();
856 }
857
858 /* Terminate the session. */
859
860 /* Stop watching for window change. */
861 if (have_pty)
862 signal(SIGWINCH, SIG_DFL);
863
864 /* Stop listening for connections. */
865 channel_stop_listening();
866
867 /* In interactive mode (with pseudo tty) display a message indicating that
868 the connection has been closed. */
869 if (have_pty && !quiet_flag)
870 {
871 snprintf(buf, sizeof buf, "Connection to %.64s closed.\r\n", host);
872 buffer_append(&stderr_buffer, buf, strlen(buf));
873 stderr_bytes += strlen(buf);
874 }
875
876 /* Output any buffered data for stdout. */
877 while (buffer_len(&stdout_buffer) > 0)
878 {
879 len = write(fileno(stdout), buffer_ptr(&stdout_buffer),
880 buffer_len(&stdout_buffer));
881 if (len <= 0)
882 {
883 error("Write failed flushing stdout buffer.");
884 break;
885 }
886 buffer_consume(&stdout_buffer, len);
887 }
888
889 /* Output any buffered data for stderr. */
890 while (buffer_len(&stderr_buffer) > 0)
891 {
892 len = write(fileno(stderr), buffer_ptr(&stderr_buffer),
893 buffer_len(&stderr_buffer));
894 if (len <= 0)
895 {
896 error("Write failed flushing stderr buffer.");
897 break;
898 }
899 buffer_consume(&stderr_buffer, len);
900 }
901
902 /* Leave raw mode. */
903 if (have_pty)
904 leave_raw_mode();
905
906 /* Clear and free any buffers. */
907 memset(buf, 0, sizeof(buf));
908 buffer_free(&stdin_buffer);
909 buffer_free(&stdout_buffer);
910 buffer_free(&stderr_buffer);
911
912 /* Report bytes transferred, and transfer rates. */
913 total_time = get_current_time() - start_time;
914 debug("Transferred: stdin %lu, stdout %lu, stderr %lu bytes in %.1f seconds",
915 stdin_bytes, stdout_bytes, stderr_bytes, total_time);
916 if (total_time > 0)
917 debug("Bytes per second: stdin %.1f, stdout %.1f, stderr %.1f",
918 stdin_bytes / total_time, stdout_bytes / total_time,
919 stderr_bytes / total_time);
920
921 /* Return the exit status of the program. */
922 debug("Exit status %d", exit_status);
923 return exit_status;
924}
This page took 0.171517 seconds and 5 git commands to generate.