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