[BACK]Return to clientloop.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/clientloop.c between version 1.105.2.2 and 1.106

version 1.105.2.2, 2004/03/04 18:18:15 version 1.106, 2003/04/01 10:10:23
Line 89 
Line 89 
 /* Flag indicating that stdin should be redirected from /dev/null. */  /* Flag indicating that stdin should be redirected from /dev/null. */
 extern int stdin_null_flag;  extern int stdin_null_flag;
   
 /* Flag indicating that no shell has been requested */  
 extern int no_shell_flag;  
   
 /*  /*
  * Name of the host we are connecting to.  This is the name given on the   * Name of the host we are connecting to.  This is the name given on the
  * command line, or the HostName specified for the user-supplied name in a   * command line, or the HostName specified for the user-supplied name in a
Line 127 
Line 124 
 static int connection_out;      /* Connection to server (output). */  static int connection_out;      /* Connection to server (output). */
 static int need_rekeying;       /* Set to non-zero if rekeying is requested. */  static int need_rekeying;       /* Set to non-zero if rekeying is requested. */
 static int session_closed = 0;  /* In SSH2: login session closed. */  static int session_closed = 0;  /* In SSH2: login session closed. */
 static int server_alive_timeouts = 0;  
   
 static void client_init_dispatch(void);  static void client_init_dispatch(void);
 int     session_ident = -1;  int     session_ident = -1;
Line 143 
Line 139 
         if (in_non_blocking_mode) {          if (in_non_blocking_mode) {
                 (void) fcntl(fileno(stdin), F_SETFL, 0);                  (void) fcntl(fileno(stdin), F_SETFL, 0);
                 in_non_blocking_mode = 0;                  in_non_blocking_mode = 0;
                   fatal_remove_cleanup((void (*) (void *)) leave_non_blocking, NULL);
         }          }
 }  }
   
Line 153 
Line 150 
 {  {
         in_non_blocking_mode = 1;          in_non_blocking_mode = 1;
         (void) fcntl(fileno(stdin), F_SETFL, O_NONBLOCK);          (void) fcntl(fileno(stdin), F_SETFL, O_NONBLOCK);
           fatal_add_cleanup((void (*) (void *)) leave_non_blocking, NULL);
 }  }
   
 /*  /*
Line 314 
Line 312 
         }          }
 }  }
   
 static void  
 client_global_request_reply(int type, u_int32_t seq, void *ctxt)  
 {  
         server_alive_timeouts = 0;  
         client_global_request_reply_fwd(type, seq, ctxt);  
 }  
   
 static void  
 server_alive_check(void)  
 {  
         if (++server_alive_timeouts > options.server_alive_count_max)  
                 packet_disconnect("Timeout, server not responding.");  
         packet_start(SSH2_MSG_GLOBAL_REQUEST);  
         packet_put_cstring("keepalive@openssh.com");  
         packet_put_char(1);     /* boolean: want reply */  
         packet_send();  
 }  
   
 /*  /*
  * Waits until the client can do something (some data becomes available on   * Waits until the client can do something (some data becomes available on
  * one of the file descriptors).   * one of the file descriptors).
Line 341 
Line 321 
 client_wait_until_can_do_something(fd_set **readsetp, fd_set **writesetp,  client_wait_until_can_do_something(fd_set **readsetp, fd_set **writesetp,
     int *maxfdp, int *nallocp, int rekeying)      int *maxfdp, int *nallocp, int rekeying)
 {  {
         struct timeval tv, *tvp;  
         int ret;  
   
         /* Add any selections by the channel mechanism. */          /* Add any selections by the channel mechanism. */
         channel_prepare_select(readsetp, writesetp, maxfdp, nallocp, rekeying);          channel_prepare_select(readsetp, writesetp, maxfdp, nallocp, rekeying);
   
Line 385 
Line 362 
         /*          /*
          * Wait for something to happen.  This will suspend the process until           * Wait for something to happen.  This will suspend the process until
          * some selected descriptor can be read, written, or has some other           * some selected descriptor can be read, written, or has some other
          * event pending.           * event pending. Note: if you want to implement SSH_MSG_IGNORE
            * messages to fool traffic analysis, this might be the place to do
            * it: just have a random timeout for the select, and send a random
            * SSH_MSG_IGNORE packet when the timeout expires.
          */           */
   
         if (options.server_alive_interval == 0 || !compat20)          if (select((*maxfdp)+1, *readsetp, *writesetp, NULL, NULL) < 0) {
                 tvp = NULL;  
         else {  
                 tv.tv_sec = options.server_alive_interval;  
                 tv.tv_usec = 0;  
                 tvp = &tv;  
         }  
         ret = select((*maxfdp)+1, *readsetp, *writesetp, NULL, tvp);  
         if (ret < 0) {  
                 char buf[100];                  char buf[100];
   
                 /*                  /*
Line 413 
Line 385 
                 snprintf(buf, sizeof buf, "select: %s\r\n", strerror(errno));                  snprintf(buf, sizeof buf, "select: %s\r\n", strerror(errno));
                 buffer_append(&stderr_buffer, buf, strlen(buf));                  buffer_append(&stderr_buffer, buf, strlen(buf));
                 quit_pending = 1;                  quit_pending = 1;
         } else if (ret == 0)          }
                 server_alive_check();  
 }  }
   
 static void  static void
Line 424 
Line 395 
   
         /* Flush stdout and stderr buffers. */          /* Flush stdout and stderr buffers. */
         if (buffer_len(bout) > 0)          if (buffer_len(bout) > 0)
                 atomicio(vwrite, fileno(stdout), buffer_ptr(bout), buffer_len(bout));                  atomicio(write, fileno(stdout), buffer_ptr(bout), buffer_len(bout));
         if (buffer_len(berr) > 0)          if (buffer_len(berr) > 0)
                 atomicio(vwrite, fileno(stderr), buffer_ptr(berr), buffer_len(berr));                  atomicio(write, fileno(stderr), buffer_ptr(berr), buffer_len(berr));
   
         leave_raw_mode();          leave_raw_mode();
   
Line 519 
Line 490 
         if (*s == 0)          if (*s == 0)
                 goto out;                  goto out;
         if (strlen(s) < 2 || s[0] != '-' || !(s[1] == 'L' || s[1] == 'R')) {          if (strlen(s) < 2 || s[0] != '-' || !(s[1] == 'L' || s[1] == 'R')) {
                 logit("Invalid command.");                  log("Invalid command.");
                 goto out;                  goto out;
         }          }
         if (s[1] == 'L')          if (s[1] == 'L')
                 local = 1;                  local = 1;
         if (!local && !compat20) {          if (!local && !compat20) {
                 logit("Not supported for SSH protocol version 1.");                  log("Not supported for SSH protocol version 1.");
                 goto out;                  goto out;
         }          }
         s += 2;          s += 2;
Line 536 
Line 507 
             sfwd_port, buf, sfwd_host_port) != 3 &&              sfwd_port, buf, sfwd_host_port) != 3 &&
             sscanf(s, "%5[0-9]/%255[^/]/%5[0-9]",              sscanf(s, "%5[0-9]/%255[^/]/%5[0-9]",
             sfwd_port, buf, sfwd_host_port) != 3) {              sfwd_port, buf, sfwd_host_port) != 3) {
                 logit("Bad forwarding specification.");                  log("Bad forwarding specification.");
                 goto out;                  goto out;
         }          }
         if ((fwd_port = a2port(sfwd_port)) == 0 ||          if ((fwd_port = a2port(sfwd_port)) == 0 ||
             (fwd_host_port = a2port(sfwd_host_port)) == 0) {              (fwd_host_port = a2port(sfwd_host_port)) == 0) {
                 logit("Bad forwarding port(s).");                  log("Bad forwarding port(s).");
                 goto out;                  goto out;
         }          }
         if (local) {          if (local) {
                 if (channel_setup_local_fwd_listener(fwd_port, buf,                  if (channel_setup_local_fwd_listener(fwd_port, buf,
                     fwd_host_port, options.gateway_ports) < 0) {                      fwd_host_port, options.gateway_ports) < 0) {
                         logit("Port forwarding failed.");                          log("Port forwarding failed.");
                         goto out;                          goto out;
                 }                  }
         } else          } else
                 channel_request_remote_forwarding(fwd_port, buf,                  channel_request_remote_forwarding(fwd_port, buf,
                     fwd_host_port);                      fwd_host_port);
         logit("Forwarding port.");          log("Forwarding port.");
 out:  out:
         signal(SIGINT, handler);          signal(SIGINT, handler);
         enter_raw_mode();          enter_raw_mode();
Line 603 
Line 574 
                                 /* We have been continued. */                                  /* We have been continued. */
                                 continue;                                  continue;
   
                         case 'B':  
                                 if (compat20) {  
                                         snprintf(string, sizeof string,  
                                             "%cB\r\n", escape_char);  
                                         buffer_append(berr, string,  
                                             strlen(string));  
                                         channel_request_start(session_ident,  
                                             "break", 0);  
                                         packet_put_int(1000);  
                                         packet_send();  
                                 }  
                                 continue;  
   
                         case 'R':                          case 'R':
                                 if (compat20) {                                  if (compat20) {
                                         if (datafellows & SSH_BUG_NOREKEY)                                          if (datafellows & SSH_BUG_NOREKEY)
                                                 logit("Server does not support re-keying");                                                  log("Server does not support re-keying");
                                         else                                          else
                                                 need_rekeying = 1;                                                  need_rekeying = 1;
                                 }                                  }
Line 678 
Line 636 
 "%c?\r\n\  "%c?\r\n\
 Supported escape sequences:\r\n\  Supported escape sequences:\r\n\
 %c.  - terminate connection\r\n\  %c.  - terminate connection\r\n\
 %cB  - send a BREAK to the remote system\r\n\  
 %cC  - open a command line\r\n\  %cC  - open a command line\r\n\
 %cR  - Request rekey (SSH protocol 2 only)\r\n\  %cR  - Request rekey (SSH protocol 2 only)\r\n\
 %c^Z - suspend ssh\r\n\  %c^Z - suspend ssh\r\n\
Line 689 
Line 646 
 (Note that escapes are only recognized immediately after newline.)\r\n",  (Note that escapes are only recognized immediately after newline.)\r\n",
                                     escape_char, escape_char, escape_char, escape_char,                                      escape_char, escape_char, escape_char, escape_char,
                                     escape_char, escape_char, escape_char, escape_char,                                      escape_char, escape_char, escape_char, escape_char,
                                     escape_char, escape_char, escape_char);                                      escape_char, escape_char);
                                 buffer_append(berr, string, strlen(string));                                  buffer_append(berr, string, strlen(string));
                                 continue;                                  continue;
   
Line 873 
Line 830 
                     id, session_ident);                      id, session_ident);
         channel_cancel_cleanup(id);          channel_cancel_cleanup(id);
         session_closed = 1;          session_closed = 1;
         leave_raw_mode();          if (in_raw_mode())
                   leave_raw_mode();
 }  }
   
 /*  /*
Line 1062 
Line 1020 
         if (!isatty(fileno(stderr)))          if (!isatty(fileno(stderr)))
                 unset_nonblock(fileno(stderr));                  unset_nonblock(fileno(stderr));
   
         /*          if (received_signal) {
          * If there was no shell or command requested, there will be no remote                  if (in_non_blocking_mode)       /* XXX */
          * exit status to be returned.  In that case, clear error code if the                          leave_non_blocking();
          * connection was deliberately terminated at this end.                  fatal("Killed by signal %d.", (int) received_signal);
          */  
         if (no_shell_flag && received_signal == SIGTERM) {  
                 received_signal = 0;  
                 exit_status = 0;  
         }          }
   
         if (received_signal)  
                 fatal("Killed by signal %d.", (int) received_signal);  
   
         /*          /*
          * In interactive mode (with pseudo tty) display a message indicating           * In interactive mode (with pseudo tty) display a message indicating
          * that the connection has been closed.           * that the connection has been closed.
Line 1166 
Line 1117 
         /* Flag that we want to exit. */          /* Flag that we want to exit. */
         quit_pending = 1;          quit_pending = 1;
 }  }
 static void  
 client_input_agent_open(int type, u_int32_t seq, void *ctxt)  
 {  
         Channel *c = NULL;  
         int remote_id, sock;  
   
         /* Read the remote channel number from the message. */  
         remote_id = packet_get_int();  
         packet_check_eom();  
   
         /*  
          * Get a connection to the local authentication agent (this may again  
          * get forwarded).  
          */  
         sock = ssh_get_authentication_socket();  
   
         /*  
          * If we could not connect the agent, send an error message back to  
          * the server. This should never happen unless the agent dies,  
          * because authentication forwarding is only enabled if we have an  
          * agent.  
          */  
         if (sock >= 0) {  
                 c = channel_new("", SSH_CHANNEL_OPEN, sock, sock,  
                     -1, 0, 0, 0, "authentication agent connection", 1);  
                 c->remote_id = remote_id;  
                 c->force_drain = 1;  
         }  
         if (c == NULL) {  
                 packet_start(SSH_MSG_CHANNEL_OPEN_FAILURE);  
                 packet_put_int(remote_id);  
         } else {  
                 /* Send a confirmation to the remote host. */  
                 debug("Forwarding authentication connection.");  
                 packet_start(SSH_MSG_CHANNEL_OPEN_CONFIRMATION);  
                 packet_put_int(remote_id);  
                 packet_put_int(c->self);  
         }  
         packet_send();  
 }  
   
 static Channel *  static Channel *
 client_request_forwarded_tcpip(const char *request_type, int rchan)  client_request_forwarded_tcpip(const char *request_type, int rchan)
 {  {
Line 1234 
Line 1145 
         c = channel_new("forwarded-tcpip",          c = channel_new("forwarded-tcpip",
             SSH_CHANNEL_CONNECTING, sock, sock, -1,              SSH_CHANNEL_CONNECTING, sock, sock, -1,
             CHAN_TCP_WINDOW_DEFAULT, CHAN_TCP_WINDOW_DEFAULT, 0,              CHAN_TCP_WINDOW_DEFAULT, CHAN_TCP_WINDOW_DEFAULT, 0,
             originator_address, 1);              xstrdup(originator_address), 1);
         xfree(originator_address);          xfree(originator_address);
         xfree(listen_address);          xfree(listen_address);
         return c;          return c;
Line 1270 
Line 1181 
                 return NULL;                  return NULL;
         c = channel_new("x11",          c = channel_new("x11",
             SSH_CHANNEL_X11_OPEN, sock, sock, -1,              SSH_CHANNEL_X11_OPEN, sock, sock, -1,
             CHAN_TCP_WINDOW_DEFAULT, CHAN_X11_PACKET_DEFAULT, 0, "x11", 1);              CHAN_TCP_WINDOW_DEFAULT, CHAN_X11_PACKET_DEFAULT, 0,
               xstrdup("x11"), 1);
         c->force_drain = 1;          c->force_drain = 1;
         return c;          return c;
 }  }
Line 1292 
Line 1204 
         c = channel_new("authentication agent connection",          c = channel_new("authentication agent connection",
             SSH_CHANNEL_OPEN, sock, sock, -1,              SSH_CHANNEL_OPEN, sock, sock, -1,
             CHAN_X11_WINDOW_DEFAULT, CHAN_TCP_WINDOW_DEFAULT, 0,              CHAN_X11_WINDOW_DEFAULT, CHAN_TCP_WINDOW_DEFAULT, 0,
             "authentication agent connection", 1);              xstrdup("authentication agent connection"), 1);
         c->force_drain = 1;          c->force_drain = 1;
         return c;          return c;
 }  }
Line 1393 
Line 1305 
   
         rtype = packet_get_string(NULL);          rtype = packet_get_string(NULL);
         want_reply = packet_get_char();          want_reply = packet_get_char();
         debug("client_input_global_request: rtype %s want_reply %d",          debug("client_input_global_request: rtype %s want_reply %d", rtype, want_reply);
             rtype, want_reply);  
         if (want_reply) {          if (want_reply) {
                 packet_start(success ?                  packet_start(success ?
                     SSH2_MSG_REQUEST_SUCCESS : SSH2_MSG_REQUEST_FAILURE);                      SSH2_MSG_REQUEST_SUCCESS : SSH2_MSG_REQUEST_FAILURE);
Line 1442 
Line 1353 
         dispatch_set(SSH_SMSG_STDOUT_DATA, &client_input_stdout_data);          dispatch_set(SSH_SMSG_STDOUT_DATA, &client_input_stdout_data);
   
         dispatch_set(SSH_SMSG_AGENT_OPEN, options.forward_agent ?          dispatch_set(SSH_SMSG_AGENT_OPEN, options.forward_agent ?
             &client_input_agent_open : &deny_input_open);              &auth_input_open_request : &deny_input_open);
         dispatch_set(SSH_SMSG_X11_OPEN, options.forward_x11 ?          dispatch_set(SSH_SMSG_X11_OPEN, options.forward_x11 ?
             &x11_input_open : &deny_input_open);              &x11_input_open : &deny_input_open);
 }  }
Line 1462 
Line 1373 
                 client_init_dispatch_13();                  client_init_dispatch_13();
         else          else
                 client_init_dispatch_15();                  client_init_dispatch_15();
 }  
   
 /* client specific fatal cleanup */  
 void  
 cleanup_exit(int i)  
 {  
         leave_raw_mode();  
         leave_non_blocking();  
         _exit(i);  
 }  }
Legend:
Removed from v.1.105.2.2  
changed lines
  Added in v.1.106