openssh/clientloop.c

   1 /*
   2  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   3  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   4  *                    All rights reserved
   5  * The main loop for the interactive session (client side).
   6  *
   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  *
  13  *
  14  * Copyright (c) 1999 Theo de Raadt.  All rights reserved.
  15  *
  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.
  35  *
  36  *
  37  * SSH2 support added by Markus Friedl.
  38  * Copyright (c) 1999, 2000, 2001 Markus Friedl.  All rights reserved.
  39  *
  40  * Redistribution and use in source and binary forms, with or without
  41  * modification, are permitted provided that the following conditions
  42  * are met:
  43  * 1. Redistributions of source code must retain the above copyright
  44  *    notice, this list of conditions and the following disclaimer.
  45  * 2. Redistributions in binary form must reproduce the above copyright
  46  *    notice, this list of conditions and the following disclaimer in the
  47  *    documentation and/or other materials provided with the distribution.
  48  *
  49  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  50  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  51  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  52  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  53  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  54  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  55  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  56  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  57  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  58  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  59  */
  60
  61 #include "includes.h"
  62 RCSID("$OpenBSD: clientloop.c,v 1.96 2002/02/06 14:55:15 markus Exp $");
  63
  64 #include "ssh.h"
  65 #include "ssh1.h"
  66 #include "ssh2.h"
  67 #include "xmalloc.h"
  68 #include "packet.h"
  69 #include "buffer.h"
  70 #include "compat.h"
  71 #include "channels.h"
  72 #include "dispatch.h"
  73 #include "buffer.h"
  74 #include "bufaux.h"
  75 #include "key.h"
  76 #include "kex.h"
  77 #include "log.h"
  78 #include "readconf.h"
  79 #include "clientloop.h"
  80 #include "authfd.h"
  81 #include "atomicio.h"
  82 #include "sshtty.h"
  83 #include "misc.h"
  84
  85 /* import options */
  86 extern Options options;
  87
  88 /* Flag indicating that stdin should be redirected from /dev/null. */
  89 extern int stdin_null_flag;
  90
  91 /*
  92  * Name of the host we are connecting to.  This is the name given on the
  93  * command line, or the HostName specified for the user-supplied name in a
  94  * configuration file.
  95  */
  96 extern char *host;
  97
  98 /*
  99  * Flag to indicate that we have received a window change signal which has
 100  * not yet been processed.  This will cause a message indicating the new
 101  * window size to be sent to the server a little later.  This is volatile
 102  * because this is updated in a signal handler.
 103  */
 104 static volatile sig_atomic_t received_window_change_signal = 0;
 105 static volatile sig_atomic_t received_signal = 0;
 106
 107 /* Flag indicating whether the user\'s terminal is in non-blocking mode. */
 108 static int in_non_blocking_mode = 0;
 109
 110 /* Common data for the client loop code. */
 111 static int quit_pending;        /* Set to non-zero to quit the client loop. */
 112 static int escape_char;         /* Escape character. */
 113 static int escape_pending;      /* Last character was the escape character */
 114 static int last_was_cr;         /* Last character was a newline. */
 115 static int exit_status;         /* Used to store the exit status of the command. */
 116 static int stdin_eof;           /* EOF has been encountered on standard error. */
 117 static Buffer stdin_buffer;     /* Buffer for stdin data. */
 118 static Buffer stdout_buffer;    /* Buffer for stdout data. */
 119 static Buffer stderr_buffer;    /* Buffer for stderr data. */
 120 static u_long stdin_bytes, stdout_bytes, stderr_bytes;
 121 static u_int buffer_high;/* Soft max buffer size. */
 122 static int connection_in;       /* Connection to server (input). */
 123 static int connection_out;      /* Connection to server (output). */
 124 static int need_rekeying;       /* Set to non-zero if rekeying is requested. */
 125 static int session_closed = 0;  /* In SSH2: login session closed. */
 126
 127 static void client_init_dispatch(void);
 128 int     session_ident = -1;
 129
 130 /*XXX*/
 131 extern Kex *xxx_kex;
 132
 133 /* Restores stdin to blocking mode. */
 134
 135 static void
 136 leave_non_blocking(void)
 137 {
 138         if (in_non_blocking_mode) {
 139                 (void) fcntl(fileno(stdin), F_SETFL, 0);
 140                 in_non_blocking_mode = 0;
 141                 fatal_remove_cleanup((void (*) (void *)) leave_non_blocking, NULL);
 142         }
 143 }
 144
 145 /* Puts stdin terminal in non-blocking mode. */
 146
 147 static void
 148 enter_non_blocking(void)
 149 {
 150         in_non_blocking_mode = 1;
 151         (void) fcntl(fileno(stdin), F_SETFL, O_NONBLOCK);
 152         fatal_add_cleanup((void (*) (void *)) leave_non_blocking, NULL);
 153 }
 154
 155 /*
 156  * Signal handler for the window change signal (SIGWINCH).  This just sets a
 157  * flag indicating that the window has changed.
 158  */
 159
 160 static void
 161 window_change_handler(int sig)
 162 {
 163         received_window_change_signal = 1;
 164         signal(SIGWINCH, window_change_handler);
 165 }
 166
 167 /*
 168  * Signal handler for signals that cause the program to terminate.  These
 169  * signals must be trapped to restore terminal modes.
 170  */
 171
 172 static void
 173 signal_handler(int sig)
 174 {
 175         received_signal = sig;
 176         quit_pending = 1;
 177 }
 178
 179 /*
 180  * Returns current time in seconds from Jan 1, 1970 with the maximum
 181  * available resolution.
 182  */
 183
 184 static double
 185 get_current_time(void)
 186 {
 187         struct timeval tv;
 188         gettimeofday(&tv, NULL);
 189         return (double) tv.tv_sec + (double) tv.tv_usec / 1000000.0;
 190 }
 191
 192 /*
 193  * This is called when the interactive is entered.  This checks if there is
 194  * an EOF coming on stdin.  We must check this explicitly, as select() does
 195  * not appear to wake up when redirecting from /dev/null.
 196  */
 197
 198 static void
 199 client_check_initial_eof_on_stdin(void)
 200 {
 201         int len;
 202         char buf[1];
 203
 204         /*
 205          * If standard input is to be "redirected from /dev/null", we simply
 206          * mark that we have seen an EOF and send an EOF message to the
 207          * server. Otherwise, we try to read a single character; it appears
 208          * that for some files, such /dev/null, select() never wakes up for
 209          * read for this descriptor, which means that we never get EOF.  This
 210          * way we will get the EOF if stdin comes from /dev/null or similar.
 211          */
 212         if (stdin_null_flag) {
 213                 /* Fake EOF on stdin. */
 214                 debug("Sending eof.");
 215                 stdin_eof = 1;
 216                 packet_start(SSH_CMSG_EOF);
 217                 packet_send();
 218         } else {
 219                 enter_non_blocking();
 220
 221                 /* Check for immediate EOF on stdin. */
 222                 len = read(fileno(stdin), buf, 1);
 223                 if (len == 0) {
 224                         /* EOF.  Record that we have seen it and send EOF to server. */
 225                         debug("Sending eof.");
 226                         stdin_eof = 1;
 227                         packet_start(SSH_CMSG_EOF);
 228                         packet_send();
 229                 } else if (len > 0) {
 230                         /*
 231                          * Got data.  We must store the data in the buffer,
 232                          * and also process it as an escape character if
 233                          * appropriate.
 234                          */
 235                         if ((u_char) buf[0] == escape_char)
 236                                 escape_pending = 1;
 237                         else
 238                                 buffer_append(&stdin_buffer, buf, 1);
 239                 }
 240                 leave_non_blocking();
 241         }
 242 }
 243
 244
 245 /*
 246  * Make packets from buffered stdin data, and buffer them for sending to the
 247  * connection.
 248  */
 249
 250 static void
 251 client_make_packets_from_stdin_data(void)
 252 {
 253         u_int len;
 254
 255         /* Send buffered stdin data to the server. */
 256         while (buffer_len(&stdin_buffer) > 0 &&
 257             packet_not_very_much_data_to_write()) {
 258                 len = buffer_len(&stdin_buffer);
 259                 /* Keep the packets at reasonable size. */
 260                 if (len > packet_get_maxsize())
 261                         len = packet_get_maxsize();
 262                 packet_start(SSH_CMSG_STDIN_DATA);
 263                 packet_put_string(buffer_ptr(&stdin_buffer), len);
 264                 packet_send();
 265                 buffer_consume(&stdin_buffer, len);
 266                 stdin_bytes += len;
 267                 /* If we have a pending EOF, send it now. */
 268                 if (stdin_eof && buffer_len(&stdin_buffer) == 0) {
 269                         packet_start(SSH_CMSG_EOF);
 270                         packet_send();
 271                 }
 272         }
 273 }
 274
 275 /*
 276  * Checks if the client window has changed, and sends a packet about it to
 277  * the server if so.  The actual change is detected elsewhere (by a software
 278  * interrupt on Unix); this just checks the flag and sends a message if
 279  * appropriate.
 280  */
 281
 282 static void
 283 client_check_window_change(void)
 284 {
 285         struct winsize ws;
 286
 287         if (! received_window_change_signal)
 288                 return;
 289         /** XXX race */
 290         received_window_change_signal = 0;
 291
 292         if (ioctl(fileno(stdin), TIOCGWINSZ, &ws) < 0)
 293                 return;
 294
 295         debug2("client_check_window_change: changed");
 296
 297         if (compat20) {
 298                 channel_request_start(session_ident, "window-change", 0);
 299                 packet_put_int(ws.ws_col);
 300                 packet_put_int(ws.ws_row);
 301                 packet_put_int(ws.ws_xpixel);
 302                 packet_put_int(ws.ws_ypixel);
 303                 packet_send();
 304         } else {
 305                 packet_start(SSH_CMSG_WINDOW_SIZE);
 306                 packet_put_int(ws.ws_row);
 307                 packet_put_int(ws.ws_col);
 308                 packet_put_int(ws.ws_xpixel);
 309                 packet_put_int(ws.ws_ypixel);
 310                 packet_send();
 311         }
 312 }
 313
 314 /*
 315  * Waits until the client can do something (some data becomes available on
 316  * one of the file descriptors).
 317  */
 318
 319 static void
 320 client_wait_until_can_do_something(fd_set **readsetp, fd_set **writesetp,
 321     int *maxfdp, int *nallocp, int rekeying)
 322 {
 323         /* Add any selections by the channel mechanism. */
 324         channel_prepare_select(readsetp, writesetp, maxfdp, nallocp, rekeying);
 325
 326         if (!compat20) {
 327                 /* Read from the connection, unless our buffers are full. */
 328                 if (buffer_len(&stdout_buffer) < buffer_high &&
 329                     buffer_len(&stderr_buffer) < buffer_high &&
 330                     channel_not_very_much_buffered_data())
 331                         FD_SET(connection_in, *readsetp);
 332                 /*
 333                  * Read from stdin, unless we have seen EOF or have very much
 334                  * buffered data to send to the server.
 335                  */
 336                 if (!stdin_eof && packet_not_very_much_data_to_write())
 337                         FD_SET(fileno(stdin), *readsetp);
 338
 339                 /* Select stdout/stderr if have data in buffer. */
 340                 if (buffer_len(&stdout_buffer) > 0)
 341                         FD_SET(fileno(stdout), *writesetp);
 342                 if (buffer_len(&stderr_buffer) > 0)
 343                         FD_SET(fileno(stderr), *writesetp);
 344         } else {
 345                 /* channel_prepare_select could have closed the last channel */
 346                 if (session_closed && !channel_still_open() &&
 347                     !packet_have_data_to_write()) {
 348                         /* clear mask since we did not call select() */
 349                         memset(*readsetp, 0, *nallocp);
 350                         memset(*writesetp, 0, *nallocp);
 351                         return;
 352                 } else {
 353                         FD_SET(connection_in, *readsetp);
 354                 }
 355         }
 356
 357         /* Select server connection if have data to write to the server. */
 358         if (packet_have_data_to_write())
 359                 FD_SET(connection_out, *writesetp);
 360
 361         /*
 362          * Wait for something to happen.  This will suspend the process until
 363          * some selected descriptor can be read, written, or has some other
 364          * event pending. Note: if you want to implement SSH_MSG_IGNORE
 365          * messages to fool traffic analysis, this might be the place to do
 366          * it: just have a random timeout for the select, and send a random
 367          * SSH_MSG_IGNORE packet when the timeout expires.
 368          */
 369
 370         if (select((*maxfdp)+1, *readsetp, *writesetp, NULL, NULL) < 0) {
 371                 char buf[100];
 372
 373                 /*
 374                  * We have to clear the select masks, because we return.
 375                  * We have to return, because the mainloop checks for the flags
 376                  * set by the signal handlers.
 377                  */
 378                 memset(*readsetp, 0, *nallocp);
 379                 memset(*writesetp, 0, *nallocp);
 380
 381                 if (errno == EINTR)
 382                         return;
 383                 /* Note: we might still have data in the buffers. */
 384                 snprintf(buf, sizeof buf, "select: %s\r\n", strerror(errno));
 385                 buffer_append(&stderr_buffer, buf, strlen(buf));
 386                 quit_pending = 1;
 387         }
 388 }
 389
 390 static void
 391 client_suspend_self(Buffer *bin, Buffer *bout, Buffer *berr)
 392 {
 393         struct winsize oldws, newws;
 394
 395         /* Flush stdout and stderr buffers. */
 396         if (buffer_len(bout) > 0)
 397                 atomicio(write, fileno(stdout), buffer_ptr(bout), buffer_len(bout));
 398         if (buffer_len(berr) > 0)
 399                 atomicio(write, fileno(stderr), buffer_ptr(berr), buffer_len(berr));
 400
 401         leave_raw_mode();
 402
 403         /*
 404          * Free (and clear) the buffer to reduce the amount of data that gets
 405          * written to swap.
 406          */
 407         buffer_free(bin);
 408         buffer_free(bout);
 409         buffer_free(berr);
 410
 411         /* Save old window size. */
 412         ioctl(fileno(stdin), TIOCGWINSZ, &oldws);
 413
 414         /* Send the suspend signal to the program itself. */
 415         kill(getpid(), SIGTSTP);
 416
 417         /* Check if the window size has changed. */
 418         if (ioctl(fileno(stdin), TIOCGWINSZ, &newws) >= 0 &&
 419             (oldws.ws_row != newws.ws_row ||
 420             oldws.ws_col != newws.ws_col ||
 421             oldws.ws_xpixel != newws.ws_xpixel ||
 422             oldws.ws_ypixel != newws.ws_ypixel))
 423                 received_window_change_signal = 1;
 424
 425         /* OK, we have been continued by the user. Reinitialize buffers. */
 426         buffer_init(bin);
 427         buffer_init(bout);
 428         buffer_init(berr);
 429
 430         enter_raw_mode();
 431 }
 432
 433 static void
 434 client_process_net_input(fd_set * readset)
 435 {
 436         int len;
 437         char buf[8192];
 438
 439         /*
 440          * Read input from the server, and add any such data to the buffer of
 441          * the packet subsystem.
 442          */
 443         if (FD_ISSET(connection_in, readset)) {
 444                 /* Read as much as possible. */
 445                 len = read(connection_in, buf, sizeof(buf));
 446                 if (len == 0) {
 447                         /* Received EOF.  The remote host has closed the connection. */
 448                         snprintf(buf, sizeof buf, "Connection to %.300s closed by remote host.\r\n",
 449                                  host);
 450                         buffer_append(&stderr_buffer, buf, strlen(buf));
 451                         quit_pending = 1;
 452                         return;
 453                 }
 454                 /*
 455                  * There is a kernel bug on Solaris that causes select to
 456                  * sometimes wake up even though there is no data available.
 457                  */
 458                 if (len < 0 && (errno == EAGAIN || errno == EINTR))
 459                         len = 0;
 460
 461                 if (len < 0) {
 462                         /* An error has encountered.  Perhaps there is a network problem. */
 463                         snprintf(buf, sizeof buf, "Read from remote host %.300s: %.100s\r\n",
 464                                  host, strerror(errno));
 465                         buffer_append(&stderr_buffer, buf, strlen(buf));
 466                         quit_pending = 1;
 467                         return;
 468                 }
 469                 packet_process_incoming(buf, len);
 470         }
 471 }
 472
 473 /* process the characters one by one */
 474 static int
 475 process_escapes(Buffer *bin, Buffer *bout, Buffer *berr, char *buf, int len)
 476 {
 477         char string[1024];
 478         pid_t pid;
 479         int bytes = 0;
 480         u_int i;
 481         u_char ch;
 482         char *s;
 483
 484         for (i = 0; i < len; i++) {
 485                 /* Get one character at a time. */
 486                 ch = buf[i];
 487
 488                 if (escape_pending) {
 489                         /* We have previously seen an escape character. */
 490                         /* Clear the flag now. */
 491                         escape_pending = 0;
 492
 493                         /* Process the escaped character. */
 494                         switch (ch) {
 495                         case '.':
 496                                 /* Terminate the connection. */
 497                                 snprintf(string, sizeof string, "%c.\r\n", escape_char);
 498                                 buffer_append(berr, string, strlen(string));
 499
 500                                 quit_pending = 1;
 501                                 return -1;
 502
 503                         case 'Z' - 64:
 504                                 /* Suspend the program. */
 505                                 /* Print a message to that effect to the user. */
 506                                 snprintf(string, sizeof string, "%c^Z [suspend ssh]\r\n", escape_char);
 507                                 buffer_append(berr, string, strlen(string));
 508
 509                                 /* Restore terminal modes and suspend. */
 510                                 client_suspend_self(bin, bout, berr);
 511
 512                                 /* We have been continued. */
 513                                 continue;
 514
 515                         case 'R':
 516                                 if (compat20) {
 517                                         if (datafellows & SSH_BUG_NOREKEY)
 518                                                 log("Server does not support re-keying");
 519                                         else
 520                                                 need_rekeying = 1;
 521                                 }
 522                                 continue;
 523
 524                         case '&':
 525                                 /*
 526                                  * Detach the program (continue to serve connections,
 527                                  * but put in background and no more new connections).
 528                                  */
 529                                 /* Restore tty modes. */
 530                                 leave_raw_mode();
 531
 532                                 /* Stop listening for new connections. */
 533                                 channel_stop_listening();
 534
 535                                 snprintf(string, sizeof string,
 536                                     "%c& [backgrounded]\n", escape_char);
 537                                 buffer_append(berr, string, strlen(string));
 538
 539                                 /* Fork into background. */
 540                                 pid = fork();
 541                                 if (pid < 0) {
 542                                         error("fork: %.100s", strerror(errno));
 543                                         continue;
 544                                 }
 545                                 if (pid != 0) { /* This is the parent. */
 546                                         /* The parent just exits. */
 547                                         exit(0);
 548                                 }
 549                                 /* The child continues serving connections. */
 550                                 if (compat20) {
 551                                         buffer_append(bin, "\004", 1);
 552                                         /* fake EOF on stdin */
 553                                         return -1;
 554                                 } else if (!stdin_eof) {
 555                                         /*
 556                                          * Sending SSH_CMSG_EOF alone does not always appear
 557                                          * to be enough.  So we try to send an EOF character
 558                                          * first.
 559                                          */
 560                                         packet_start(SSH_CMSG_STDIN_DATA);
 561                                         packet_put_string("\004", 1);
 562                                         packet_send();
 563                                         /* Close stdin. */
 564                                         stdin_eof = 1;
 565                                         if (buffer_len(bin) == 0) {
 566                                                 packet_start(SSH_CMSG_EOF);
 567                                                 packet_send();
 568                                         }
 569                                 }
 570                                 continue;
 571
 572                         case '?':
 573                                 snprintf(string, sizeof string,
 574 "%c?\r\n\
 575 Supported escape sequences:\r\n\
 576 ~.  - terminate connection\r\n\
 577 ~R  - Request rekey (SSH protocol 2 only)\r\n\
 578 ~^Z - suspend ssh\r\n\
 579 ~#  - list forwarded connections\r\n\
 580 ~&  - background ssh (when waiting for connections to terminate)\r\n\
 581 ~?  - this message\r\n\
 582 ~~  - send the escape character by typing it twice\r\n\
 583 (Note that escapes are only recognized immediately after newline.)\r\n",
 584                                          escape_char);
 585                                 buffer_append(berr, string, strlen(string));
 586                                 continue;
 587
 588                         case '#':
 589                                 snprintf(string, sizeof string, "%c#\r\n", escape_char);
 590                                 buffer_append(berr, string, strlen(string));
 591                                 s = channel_open_message();
 592                                 buffer_append(berr, s, strlen(s));
 593                                 xfree(s);
 594                                 continue;
 595
 596                         default:
 597                                 if (ch != escape_char) {
 598                                         buffer_put_char(bin, escape_char);
 599                                         bytes++;
 600                                 }
 601                                 /* Escaped characters fall through here */
 602                                 break;
 603                         }
 604                 } else {
 605                         /*
 606                          * The previous character was not an escape char. Check if this
 607                          * is an escape.
 608                          */
 609                         if (last_was_cr && ch == escape_char) {
 610                                 /* It is. Set the flag and continue to next character. */
 611                                 escape_pending = 1;
 612                                 continue;
 613                         }
 614                 }
 615
 616                 /*
 617                  * Normal character.  Record whether it was a newline,
 618                  * and append it to the buffer.
 619                  */
 620                 last_was_cr = (ch == '\r' || ch == '\n');
 621                 buffer_put_char(bin, ch);
 622                 bytes++;
 623         }
 624         return bytes;
 625 }
 626
 627 static void
 628 client_process_input(fd_set * readset)
 629 {
 630         int len;
 631         char buf[8192];
 632
 633         /* Read input from stdin. */
 634         if (FD_ISSET(fileno(stdin), readset)) {
 635                 /* Read as much as possible. */
 636                 len = read(fileno(stdin), buf, sizeof(buf));
 637                 if (len < 0 && (errno == EAGAIN || errno == EINTR))
 638                         return;         /* we'll try again later */
 639                 if (len <= 0) {
 640                         /*
 641                          * Received EOF or error.  They are treated
 642                          * similarly, except that an error message is printed
 643                          * if it was an error condition.
 644                          */
 645                         if (len < 0) {
 646                                 snprintf(buf, sizeof buf, "read: %.100s\r\n", strerror(errno));
 647                                 buffer_append(&stderr_buffer, buf, strlen(buf));
 648                         }
 649                         /* Mark that we have seen EOF. */
 650                         stdin_eof = 1;
 651                         /*
 652                          * Send an EOF message to the server unless there is
 653                          * data in the buffer.  If there is data in the
 654                          * buffer, no message will be sent now.  Code
 655                          * elsewhere will send the EOF when the buffer
 656                          * becomes empty if stdin_eof is set.
 657                          */
 658                         if (buffer_len(&stdin_buffer) == 0) {
 659                                 packet_start(SSH_CMSG_EOF);
 660                                 packet_send();
 661                         }
 662                 } else if (escape_char == SSH_ESCAPECHAR_NONE) {
 663                         /*
 664                          * Normal successful read, and no escape character.
 665                          * Just append the data to buffer.
 666                          */
 667                         buffer_append(&stdin_buffer, buf, len);
 668                 } else {
 669                         /*
 670                          * Normal, successful read.  But we have an escape character
 671                          * and have to process the characters one by one.
 672                          */
 673                         if (process_escapes(&stdin_buffer, &stdout_buffer,
 674                             &stderr_buffer, buf, len) == -1)
 675                                 return;
 676                 }
 677         }
 678 }
 679
 680 static void
 681 client_process_output(fd_set * writeset)
 682 {
 683         int len;
 684         char buf[100];
 685
 686         /* Write buffered output to stdout. */
 687         if (FD_ISSET(fileno(stdout), writeset)) {
 688                 /* Write as much data as possible. */
 689                 len = write(fileno(stdout), buffer_ptr(&stdout_buffer),
 690                     buffer_len(&stdout_buffer));
 691                 if (len <= 0) {
 692                         if (errno == EINTR || errno == EAGAIN)
 693                                 len = 0;
 694                         else {
 695                                 /*
 696                                  * An error or EOF was encountered.  Put an
 697                                  * error message to stderr buffer.
 698                                  */
 699                                 snprintf(buf, sizeof buf, "write stdout: %.50s\r\n", strerror(errno));
 700                                 buffer_append(&stderr_buffer, buf, strlen(buf));
 701                                 quit_pending = 1;
 702                                 return;
 703                         }
 704                 }
 705                 /* Consume printed data from the buffer. */
 706                 buffer_consume(&stdout_buffer, len);
 707                 stdout_bytes += len;
 708         }
 709         /* Write buffered output to stderr. */
 710         if (FD_ISSET(fileno(stderr), writeset)) {
 711                 /* Write as much data as possible. */
 712                 len = write(fileno(stderr), buffer_ptr(&stderr_buffer),
 713                     buffer_len(&stderr_buffer));
 714                 if (len <= 0) {
 715                         if (errno == EINTR || errno == EAGAIN)
 716                                 len = 0;
 717                         else {
 718                                 /* EOF or error, but can't even print error message. */
 719                                 quit_pending = 1;
 720                                 return;
 721                         }
 722                 }
 723                 /* Consume printed characters from the buffer. */
 724                 buffer_consume(&stderr_buffer, len);
 725                 stderr_bytes += len;
 726         }
 727 }
 728
 729 /*
 730  * Get packets from the connection input buffer, and process them as long as
 731  * there are packets available.
 732  *
 733  * Any unknown packets received during the actual
 734  * session cause the session to terminate.  This is
 735  * intended to make debugging easier since no
 736  * confirmations are sent.  Any compatible protocol
 737  * extensions must be negotiated during the
 738  * preparatory phase.
 739  */
 740
 741 static void
 742 client_process_buffered_input_packets(void)
 743 {
 744         dispatch_run(DISPATCH_NONBLOCK, &quit_pending, compat20 ? xxx_kex : NULL);
 745 }
 746
 747 /* scan buf[] for '~' before sending data to the peer */
 748
 749 static int
 750 simple_escape_filter(Channel *c, char *buf, int len)
 751 {
 752         /* XXX we assume c->extended is writeable */
 753         return process_escapes(&c->input, &c->output, &c->extended, buf, len);
 754 }
 755
 756 static void
 757 client_channel_closed(int id, void *arg)
 758 {
 759         if (id != session_ident)
 760                 error("client_channel_closed: id %d != session_ident %d",
 761                     id, session_ident);
 762         channel_cancel_cleanup(id);
 763         session_closed = 1;
 764         if (in_raw_mode())
 765                 leave_raw_mode();
 766 }
 767
 768 /*
 769  * Implements the interactive session with the server.  This is called after
 770  * the user has been authenticated, and a command has been started on the
 771  * remote host.  If escape_char != SSH_ESCAPECHAR_NONE, it is the character
 772  * used as an escape character for terminating or suspending the session.
 773  */
 774
 775 int
 776 client_loop(int have_pty, int escape_char_arg, int ssh2_chan_id)
 777 {
 778         fd_set *readset = NULL, *writeset = NULL;
 779         double start_time, total_time;
 780         int max_fd = 0, max_fd2 = 0, len, rekeying = 0, nalloc = 0;
 781         char buf[100];
 782
 783         debug("Entering interactive session.");
 784
 785         start_time = get_current_time();
 786
 787         /* Initialize variables. */
 788         escape_pending = 0;
 789         last_was_cr = 1;
 790         exit_status = -1;
 791         stdin_eof = 0;
 792         buffer_high = 64 * 1024;
 793         connection_in = packet_get_connection_in();
 794         connection_out = packet_get_connection_out();
 795         max_fd = MAX(connection_in, connection_out);
 796
 797         if (!compat20) {
 798                 /* enable nonblocking unless tty */
 799                 if (!isatty(fileno(stdin)))
 800                         set_nonblock(fileno(stdin));
 801                 if (!isatty(fileno(stdout)))
 802                         set_nonblock(fileno(stdout));
 803                 if (!isatty(fileno(stderr)))
 804                         set_nonblock(fileno(stderr));
 805                 max_fd = MAX(max_fd, fileno(stdin));
 806                 max_fd = MAX(max_fd, fileno(stdout));
 807                 max_fd = MAX(max_fd, fileno(stderr));
 808         }
 809         stdin_bytes = 0;
 810         stdout_bytes = 0;
 811         stderr_bytes = 0;
 812         quit_pending = 0;
 813         escape_char = escape_char_arg;
 814
 815         /* Initialize buffers. */
 816         buffer_init(&stdin_buffer);
 817         buffer_init(&stdout_buffer);
 818         buffer_init(&stderr_buffer);
 819
 820         client_init_dispatch();
 821
 822         /* Set signal handlers to restore non-blocking mode.  */
 823         signal(SIGINT, signal_handler);
 824         signal(SIGQUIT, signal_handler);
 825         signal(SIGTERM, signal_handler);
 826         if (have_pty)
 827                 signal(SIGWINCH, window_change_handler);
 828
 829         if (have_pty)
 830                 enter_raw_mode();
 831
 832         if (compat20) {
 833                 session_ident = ssh2_chan_id;
 834                 if (escape_char != SSH_ESCAPECHAR_NONE)
 835                         channel_register_filter(session_ident,
 836                             simple_escape_filter);
 837                 if (session_ident != -1)
 838                         channel_register_cleanup(session_ident,
 839                             client_channel_closed);
 840         } else {
 841                 /* Check if we should immediately send eof on stdin. */
 842                 client_check_initial_eof_on_stdin();
 843         }
 844
 845         /* Main loop of the client for the interactive session mode. */
 846         while (!quit_pending) {
 847
 848                 /* Process buffered packets sent by the server. */
 849                 client_process_buffered_input_packets();
 850
 851                 if (compat20 && session_closed && !channel_still_open())
 852                         break;
 853
 854                 rekeying = (xxx_kex != NULL && !xxx_kex->done);
 855
 856                 if (rekeying) {
 857                         debug("rekeying in progress");
 858                 } else {
 859                         /*
 860                          * Make packets of buffered stdin data, and buffer
 861                          * them for sending to the server.
 862                          */
 863                         if (!compat20)
 864                                 client_make_packets_from_stdin_data();
 865
 866                         /*
 867                          * Make packets from buffered channel data, and
 868                          * enqueue them for sending to the server.
 869                          */
 870                         if (packet_not_very_much_data_to_write())
 871                                 channel_output_poll();
 872
 873                         /*
 874                          * Check if the window size has changed, and buffer a
 875                          * message about it to the server if so.
 876                          */
 877                         client_check_window_change();
 878
 879                         if (quit_pending)
 880                                 break;
 881                 }
 882                 /*
 883                  * Wait until we have something to do (something becomes
 884                  * available on one of the descriptors).
 885                  */
 886                 max_fd2 = max_fd;
 887                 client_wait_until_can_do_something(&readset, &writeset,
 888                     &max_fd2, &nalloc, rekeying);
 889
 890                 if (quit_pending)
 891                         break;
 892
 893                 /* Do channel operations unless rekeying in progress. */
 894                 if (!rekeying) {
 895                         channel_after_select(readset, writeset);
 896
 897                         if (need_rekeying) {
 898                                 debug("user requests rekeying");
 899                                 xxx_kex->done = 0;
 900                                 kex_send_kexinit(xxx_kex);
 901                                 need_rekeying = 0;
 902                         }
 903                 }
 904
 905                 /* Buffer input from the connection.  */
 906                 client_process_net_input(readset);
 907
 908                 if (quit_pending)
 909                         break;
 910
 911                 if (!compat20) {
 912                         /* Buffer data from stdin */
 913                         client_process_input(readset);
 914                         /*
 915                          * Process output to stdout and stderr.  Output to
 916                          * the connection is processed elsewhere (above).
 917                          */
 918                         client_process_output(writeset);
 919                 }
 920
 921                 /* Send as much buffered packet data as possible to the sender. */
 922                 if (FD_ISSET(connection_out, writeset))
 923                         packet_write_poll();
 924         }
 925         if (readset)
 926                 xfree(readset);
 927         if (writeset)
 928                 xfree(writeset);
 929
 930         /* Terminate the session. */
 931
 932         /* Stop watching for window change. */
 933         if (have_pty)
 934                 signal(SIGWINCH, SIG_DFL);
 935
 936         channel_free_all();
 937
 938         if (have_pty)
 939                 leave_raw_mode();
 940
 941         /* restore blocking io */
 942         if (!isatty(fileno(stdin)))
 943                 unset_nonblock(fileno(stdin));
 944         if (!isatty(fileno(stdout)))
 945                 unset_nonblock(fileno(stdout));
 946         if (!isatty(fileno(stderr)))
 947                 unset_nonblock(fileno(stderr));
 948
 949         if (received_signal) {
 950                 if (in_non_blocking_mode)       /* XXX */
 951                         leave_non_blocking();
 952                 fatal("Killed by signal %d.", (int) received_signal);
 953         }
 954
 955         /*
 956          * In interactive mode (with pseudo tty) display a message indicating
 957          * that the connection has been closed.
 958          */
 959         if (have_pty && options.log_level != SYSLOG_LEVEL_QUIET) {
 960                 snprintf(buf, sizeof buf, "Connection to %.64s closed.\r\n", host);
 961                 buffer_append(&stderr_buffer, buf, strlen(buf));
 962         }
 963
 964         /* Output any buffered data for stdout. */
 965         while (buffer_len(&stdout_buffer) > 0) {
 966                 len = write(fileno(stdout), buffer_ptr(&stdout_buffer),
 967                     buffer_len(&stdout_buffer));
 968                 if (len <= 0) {
 969                         error("Write failed flushing stdout buffer.");
 970                         break;
 971                 }
 972                 buffer_consume(&stdout_buffer, len);
 973                 stdout_bytes += len;
 974         }
 975
 976         /* Output any buffered data for stderr. */
 977         while (buffer_len(&stderr_buffer) > 0) {
 978                 len = write(fileno(stderr), buffer_ptr(&stderr_buffer),
 979                     buffer_len(&stderr_buffer));
 980                 if (len <= 0) {
 981                         error("Write failed flushing stderr buffer.");
 982                         break;
 983                 }
 984                 buffer_consume(&stderr_buffer, len);
 985                 stderr_bytes += len;
 986         }
 987
 988         /* Clear and free any buffers. */
 989         memset(buf, 0, sizeof(buf));
 990         buffer_free(&stdin_buffer);
 991         buffer_free(&stdout_buffer);
 992         buffer_free(&stderr_buffer);
 993
 994         /* Report bytes transferred, and transfer rates. */
 995         total_time = get_current_time() - start_time;
 996         debug("Transferred: stdin %lu, stdout %lu, stderr %lu bytes in %.1f seconds",
 997             stdin_bytes, stdout_bytes, stderr_bytes, total_time);
 998         if (total_time > 0)
 999                 debug("Bytes per second: stdin %.1f, stdout %.1f, stderr %.1f",
1000                     stdin_bytes / total_time, stdout_bytes / total_time,
1001                     stderr_bytes / total_time);
1002
1003         /* Return the exit status of the program. */
1004         debug("Exit status %d", exit_status);
1005         return exit_status;
1006 }
1007
1008 /*********/
1009
1010 static void
1011 client_input_stdout_data(int type, u_int32_t seq, void *ctxt)
1012 {
1013         u_int data_len;
1014         char *data = packet_get_string(&data_len);
1015         packet_check_eom();
1016         buffer_append(&stdout_buffer, data, data_len);
1017         memset(data, 0, data_len);
1018         xfree(data);
1019 }
1020 static void
1021 client_input_stderr_data(int type, u_int32_t seq, void *ctxt)
1022 {
1023         u_int data_len;
1024         char *data = packet_get_string(&data_len);
1025         packet_check_eom();
1026         buffer_append(&stderr_buffer, data, data_len);
1027         memset(data, 0, data_len);
1028         xfree(data);
1029 }
1030 static void
1031 client_input_exit_status(int type, u_int32_t seq, void *ctxt)
1032 {
1033         exit_status = packet_get_int();
1034         packet_check_eom();
1035         /* Acknowledge the exit. */
1036         packet_start(SSH_CMSG_EXIT_CONFIRMATION);
1037         packet_send();
1038         /*
1039          * Must wait for packet to be sent since we are
1040          * exiting the loop.
1041          */
1042         packet_write_wait();
1043         /* Flag that we want to exit. */
1044         quit_pending = 1;
1045 }
1046
1047 static Channel *
1048 client_request_forwarded_tcpip(const char *request_type, int rchan)
1049 {
1050         Channel* c = NULL;
1051         char *listen_address, *originator_address;
1052         int listen_port, originator_port;
1053         int sock;
1054
1055         /* Get rest of the packet */
1056         listen_address = packet_get_string(NULL);
1057         listen_port = packet_get_int();
1058         originator_address = packet_get_string(NULL);
1059         originator_port = packet_get_int();
1060         packet_check_eom();
1061
1062         debug("client_request_forwarded_tcpip: listen %s port %d, originator %s port %d",
1063             listen_address, listen_port, originator_address, originator_port);
1064
1065         sock = channel_connect_by_listen_address(listen_port);
1066         if (sock < 0) {
1067                 xfree(originator_address);
1068                 xfree(listen_address);
1069                 return NULL;
1070         }
1071         c = channel_new("forwarded-tcpip",
1072             SSH_CHANNEL_CONNECTING, sock, sock, -1,
1073             CHAN_TCP_WINDOW_DEFAULT, CHAN_TCP_WINDOW_DEFAULT, 0,
1074             xstrdup(originator_address), 1);
1075         xfree(originator_address);
1076         xfree(listen_address);
1077         return c;
1078 }
1079
1080 static Channel*
1081 client_request_x11(const char *request_type, int rchan)
1082 {
1083         Channel *c = NULL;
1084         char *originator;
1085         int originator_port;
1086         int sock;
1087
1088         if (!options.forward_x11) {
1089                 error("Warning: ssh server tried X11 forwarding.");
1090                 error("Warning: this is probably a break in attempt by a malicious server.");
1091                 return NULL;
1092         }
1093         originator = packet_get_string(NULL);
1094         if (datafellows & SSH_BUG_X11FWD) {
1095                 debug2("buggy server: x11 request w/o originator_port");
1096                 originator_port = 0;
1097         } else {
1098                 originator_port = packet_get_int();
1099         }
1100         packet_check_eom();
1101         /* XXX check permission */
1102         debug("client_request_x11: request from %s %d", originator,
1103             originator_port);
1104         xfree(originator);
1105         sock = x11_connect_display();
1106         if (sock < 0)
1107                 return NULL;
1108         c = channel_new("x11",
1109             SSH_CHANNEL_X11_OPEN, sock, sock, -1,
1110             CHAN_TCP_WINDOW_DEFAULT, CHAN_X11_PACKET_DEFAULT, 0,
1111             xstrdup("x11"), 1);
1112         c->force_drain = 1;
1113         return c;
1114 }
1115
1116 static Channel*
1117 client_request_agent(const char *request_type, int rchan)
1118 {
1119         Channel *c = NULL;
1120         int sock;
1121
1122         if (!options.forward_agent) {
1123                 error("Warning: ssh server tried agent forwarding.");
1124                 error("Warning: this is probably a break in attempt by a malicious server.");
1125                 return NULL;
1126         }
1127         sock =  ssh_get_authentication_socket();
1128         if (sock < 0)
1129                 return NULL;
1130         c = channel_new("authentication agent connection",
1131             SSH_CHANNEL_OPEN, sock, sock, -1,
1132             CHAN_X11_WINDOW_DEFAULT, CHAN_TCP_WINDOW_DEFAULT, 0,
1133             xstrdup("authentication agent connection"), 1);
1134         c->force_drain = 1;
1135         return c;
1136 }
1137
1138 /* XXXX move to generic input handler */
1139 static void
1140 client_input_channel_open(int type, u_int32_t seq, void *ctxt)
1141 {
1142         Channel *c = NULL;
1143         char *ctype;
1144         u_int len;
1145         int rchan;
1146         int rmaxpack;
1147         int rwindow;
1148
1149         ctype = packet_get_string(&len);
1150         rchan = packet_get_int();
1151         rwindow = packet_get_int();
1152         rmaxpack = packet_get_int();
1153
1154         debug("client_input_channel_open: ctype %s rchan %d win %d max %d",
1155             ctype, rchan, rwindow, rmaxpack);
1156
1157         if (strcmp(ctype, "forwarded-tcpip") == 0) {
1158                 c = client_request_forwarded_tcpip(ctype, rchan);
1159         } else if (strcmp(ctype, "x11") == 0) {
1160                 c = client_request_x11(ctype, rchan);
1161         } else if (strcmp(ctype, "auth-agent@openssh.com") == 0) {
1162                 c = client_request_agent(ctype, rchan);
1163         }
1164 /* XXX duplicate : */
1165         if (c != NULL) {
1166                 debug("confirm %s", ctype);
1167                 c->remote_id = rchan;
1168                 c->remote_window = rwindow;
1169                 c->remote_maxpacket = rmaxpack;
1170                 if (c->type != SSH_CHANNEL_CONNECTING) {
1171                         packet_start(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION);
1172                         packet_put_int(c->remote_id);
1173                         packet_put_int(c->self);
1174                         packet_put_int(c->local_window);
1175                         packet_put_int(c->local_maxpacket);
1176                         packet_send();
1177                 }
1178         } else {
1179                 debug("failure %s", ctype);
1180                 packet_start(SSH2_MSG_CHANNEL_OPEN_FAILURE);
1181                 packet_put_int(rchan);
1182                 packet_put_int(SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED);
1183                 if (!(datafellows & SSH_BUG_OPENFAILURE)) {
1184                         packet_put_cstring("open failed");
1185                         packet_put_cstring("");
1186                 }
1187                 packet_send();
1188         }
1189         xfree(ctype);
1190 }
1191 static void
1192 client_input_channel_req(int type, u_int32_t seq, void *ctxt)
1193 {
1194         Channel *c = NULL;
1195         int id, reply, success = 0;
1196         char *rtype;
1197
1198         id = packet_get_int();
1199         rtype = packet_get_string(NULL);
1200         reply = packet_get_char();
1201
1202         debug("client_input_channel_req: channel %d rtype %s reply %d",
1203             id, rtype, reply);
1204
1205         if (session_ident == -1) {
1206                 error("client_input_channel_req: no channel %d", session_ident);
1207         } else if (id != session_ident) {
1208                 error("client_input_channel_req: channel %d: wrong channel: %d",
1209                     session_ident, id);
1210         }
1211         c = channel_lookup(id);
1212         if (c == NULL) {
1213                 error("client_input_channel_req: channel %d: unknown channel", id);
1214         } else if (strcmp(rtype, "exit-status") == 0) {
1215                 success = 1;
1216                 exit_status = packet_get_int();
1217                 packet_check_eom();
1218         }
1219         if (reply) {
1220                 packet_start(success ?
1221                     SSH2_MSG_CHANNEL_SUCCESS : SSH2_MSG_CHANNEL_FAILURE);
1222                 packet_put_int(c->remote_id);
1223                 packet_send();
1224         }
1225         xfree(rtype);
1226 }
1227 static void
1228 client_input_global_request(int type, u_int32_t seq, void *ctxt)
1229 {
1230         char *rtype;
1231         int want_reply;
1232         int success = 0;
1233
1234         rtype = packet_get_string(NULL);
1235         want_reply = packet_get_char();
1236         debug("client_input_global_request: rtype %s want_reply %d", rtype, want_reply);
1237         if (want_reply) {
1238                 packet_start(success ?
1239                     SSH2_MSG_REQUEST_SUCCESS : SSH2_MSG_REQUEST_FAILURE);
1240                 packet_send();
1241                 packet_write_wait();
1242         }
1243         xfree(rtype);
1244 }
1245
1246 static void
1247 client_init_dispatch_20(void)
1248 {
1249         dispatch_init(&dispatch_protocol_error);
1250         dispatch_set(SSH2_MSG_CHANNEL_CLOSE, &channel_input_oclose);
1251         dispatch_set(SSH2_MSG_CHANNEL_DATA, &channel_input_data);
1252         dispatch_set(SSH2_MSG_CHANNEL_EOF, &channel_input_ieof);
1253         dispatch_set(SSH2_MSG_CHANNEL_EXTENDED_DATA, &channel_input_extended_data);
1254         dispatch_set(SSH2_MSG_CHANNEL_OPEN, &client_input_channel_open);
1255         dispatch_set(SSH2_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);
1256         dispatch_set(SSH2_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);
1257         dispatch_set(SSH2_MSG_CHANNEL_REQUEST, &client_input_channel_req);
1258         dispatch_set(SSH2_MSG_CHANNEL_WINDOW_ADJUST, &channel_input_window_adjust);
1259         dispatch_set(SSH2_MSG_GLOBAL_REQUEST, &client_input_global_request);
1260
1261         /* rekeying */
1262         dispatch_set(SSH2_MSG_KEXINIT, &kex_input_kexinit);
1263 }
1264 static void
1265 client_init_dispatch_13(void)
1266 {
1267         dispatch_init(NULL);
1268         dispatch_set(SSH_MSG_CHANNEL_CLOSE, &channel_input_close);
1269         dispatch_set(SSH_MSG_CHANNEL_CLOSE_CONFIRMATION, &channel_input_close_confirmation);
1270         dispatch_set(SSH_MSG_CHANNEL_DATA, &channel_input_data);
1271         dispatch_set(SSH_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);
1272         dispatch_set(SSH_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);
1273         dispatch_set(SSH_MSG_PORT_OPEN, &channel_input_port_open);
1274         dispatch_set(SSH_SMSG_EXITSTATUS, &client_input_exit_status);
1275         dispatch_set(SSH_SMSG_STDERR_DATA, &client_input_stderr_data);
1276         dispatch_set(SSH_SMSG_STDOUT_DATA, &client_input_stdout_data);
1277
1278         dispatch_set(SSH_SMSG_AGENT_OPEN, options.forward_agent ?
1279             &auth_input_open_request : &deny_input_open);
1280         dispatch_set(SSH_SMSG_X11_OPEN, options.forward_x11 ?
1281             &x11_input_open : &deny_input_open);
1282 }
1283 static void
1284 client_init_dispatch_15(void)
1285 {
1286         client_init_dispatch_13();
1287         dispatch_set(SSH_MSG_CHANNEL_CLOSE, &channel_input_ieof);
1288         dispatch_set(SSH_MSG_CHANNEL_CLOSE_CONFIRMATION, & channel_input_oclose);
1289 }
1290 static void
1291 client_init_dispatch(void)
1292 {
1293         if (compat20)
1294                 client_init_dispatch_20();
1295         else if (compat13)
1296                 client_init_dispatch_13();
1297         else
1298                 client_init_dispatch_15();
1299 }