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

Diff for /src/usr.bin/ssh/channels.c between version 1.72 and 1.72.2.2

version 1.72, 2000/10/27 07:48:22 version 1.72.2.2, 2001/02/19 17:18:44
Line 42 
Line 42 
 #include "includes.h"  #include "includes.h"
 RCSID("$OpenBSD$");  RCSID("$OpenBSD$");
   
   #include <openssl/rsa.h>
   #include <openssl/dsa.h>
   
 #include "ssh.h"  #include "ssh.h"
   #include "ssh1.h"
   #include "ssh2.h"
 #include "packet.h"  #include "packet.h"
 #include "xmalloc.h"  #include "xmalloc.h"
 #include "buffer.h"  #include "buffer.h"
 #include "uidswap.h"  #include "uidswap.h"
 #include "readconf.h"  #include "log.h"
 #include "servconf.h"  #include "misc.h"
   
 #include "channels.h"  #include "channels.h"
 #include "nchan.h"  #include "nchan.h"
 #include "compat.h"  #include "compat.h"
   #include "canohost.h"
 #include "ssh2.h"  
   
 #include <openssl/rsa.h>  
 #include <openssl/dsa.h>  
 #include "key.h"  #include "key.h"
 #include "authfd.h"  #include "authfd.h"
   
Line 84 
Line 84 
  * Maximum file descriptor value used in any of the channels.  This is   * Maximum file descriptor value used in any of the channels.  This is
  * updated in channel_allocate.   * updated in channel_allocate.
  */   */
 static int channel_max_fd_value = 0;  static int channel_max_fd = 0;
   
 /* Name and directory of socket for authentication agent forwarding. */  /* Name and directory of socket for authentication agent forwarding. */
 static char *channel_forwarded_auth_socket_name = NULL;  static char *channel_forwarded_auth_socket_name = NULL;
Line 95 
Line 95 
   
 /* Saved X11 authentication data.  This is the real data. */  /* Saved X11 authentication data.  This is the real data. */
 char *x11_saved_data = NULL;  char *x11_saved_data = NULL;
 unsigned int x11_saved_data_len = 0;  u_int x11_saved_data_len = 0;
   
 /*  /*
  * Fake X11 authentication data.  This is what the server will be sending us;   * Fake X11 authentication data.  This is what the server will be sending us;
  * we should replace any occurrences of this by the real data.   * we should replace any occurrences of this by the real data.
  */   */
 char *x11_fake_data = NULL;  char *x11_fake_data = NULL;
 unsigned int x11_fake_data_len;  u_int x11_fake_data_len;
   
 /*  /*
  * Data structure for storing which hosts are permitted for forward requests.   * Data structure for storing which hosts are permitted for forward requests.
Line 130 
Line 130 
 /* This is set to true if both sides support SSH_PROTOFLAG_HOST_IN_FWD_OPEN. */  /* This is set to true if both sides support SSH_PROTOFLAG_HOST_IN_FWD_OPEN. */
 static int have_hostname_in_open = 0;  static int have_hostname_in_open = 0;
   
   /* AF_UNSPEC or AF_INET or AF_INET6 */
   extern int IPv4or6;
   
 /* Sets specific protocol options. */  /* Sets specific protocol options. */
   
 void  void
Line 178 
Line 181 
     int extusage, int nonblock)      int extusage, int nonblock)
 {  {
         /* Update the maximum file descriptor value. */          /* Update the maximum file descriptor value. */
         if (rfd > channel_max_fd_value)          channel_max_fd = MAX(channel_max_fd, rfd);
                 channel_max_fd_value = rfd;          channel_max_fd = MAX(channel_max_fd, wfd);
         if (wfd > channel_max_fd_value)          channel_max_fd = MAX(channel_max_fd, efd);
                 channel_max_fd_value = wfd;  
         if (efd > channel_max_fd_value)  
                 channel_max_fd_value = efd;  
         /* XXX set close-on-exec -markus */          /* XXX set close-on-exec -markus */
   
         c->rfd = rfd;          c->rfd = rfd;
Line 192 
Line 193 
         c->efd = efd;          c->efd = efd;
         c->extended_usage = extusage;          c->extended_usage = extusage;
   
           /* XXX ugly hack: nonblock is only set by the server */
           if (nonblock && isatty(c->rfd)) {
                   debug("channel: %d: rfd %d isatty", c->self, c->rfd);
                   c->isatty = 1;
                   if (!isatty(c->wfd)) {
                           error("channel: %d: wfd %d is not a tty?",
                               c->self, c->wfd);
                   }
           } else {
                   c->isatty = 0;
           }
   
         /* enable nonblocking mode */          /* enable nonblocking mode */
         if (nonblock) {          if (nonblock) {
                 if (rfd != -1)                  if (rfd != -1)
Line 307 
Line 320 
 channel_free(int id)  channel_free(int id)
 {  {
         Channel *c = channel_lookup(id);          Channel *c = channel_lookup(id);
           char *s = channel_open_message();
   
         if (c == NULL)          if (c == NULL)
                 packet_disconnect("channel free: bad local channel %d", id);                  packet_disconnect("channel free: bad local channel %d", id);
         debug("channel_free: channel %d: status: %s", id, channel_open_message());          debug("channel_free: channel %d: status: %s", id, s);
           xfree(s);
   
         if (c->dettach_user != NULL) {          if (c->dettach_user != NULL) {
                 debug("channel_free: channel %d: dettaching channel user", id);                  debug("channel_free: channel %d: dettaching channel user", id);
                 c->dettach_user(c->self, NULL);                  c->dettach_user(c->self, NULL);
Line 346 
Line 363 
 }  }
   
 void  void
   channel_pre_connecting(Channel *c, fd_set * readset, fd_set * writeset)
   {
           debug3("channel %d: waiting for connection", c->self);
           FD_SET(c->sock, writeset);
   }
   
   void
 channel_pre_open_13(Channel *c, fd_set * readset, fd_set * writeset)  channel_pre_open_13(Channel *c, fd_set * readset, fd_set * writeset)
 {  {
         if (buffer_len(&c->input) < packet_get_maxsize())          if (buffer_len(&c->input) < packet_get_maxsize())
Line 429 
Line 453 
 int  int
 x11_open_helper(Channel *c)  x11_open_helper(Channel *c)
 {  {
         unsigned char *ucp;          u_char *ucp;
         unsigned int proto_len, data_len;          u_int proto_len, data_len;
   
         /* Check if the fixed size part of the packet is in buffer. */          /* Check if the fixed size part of the packet is in buffer. */
         if (buffer_len(&c->output) < 12)          if (buffer_len(&c->output) < 12)
                 return 0;                  return 0;
   
         /* Parse the lengths of variable-length fields. */          /* Parse the lengths of variable-length fields. */
         ucp = (unsigned char *) buffer_ptr(&c->output);          ucp = (u_char *) buffer_ptr(&c->output);
         if (ucp[0] == 0x42) {   /* Byte order MSB first. */          if (ucp[0] == 0x42) {   /* Byte order MSB first. */
                 proto_len = 256 * ucp[6] + ucp[7];                  proto_len = 256 * ucp[6] + ucp[7];
                 data_len = 256 * ucp[8] + ucp[9];                  data_len = 256 * ucp[8] + ucp[9];
Line 534 
Line 558 
         struct sockaddr addr;          struct sockaddr addr;
         int newsock, newch;          int newsock, newch;
         socklen_t addrlen;          socklen_t addrlen;
         char buf[16384], *remote_hostname;          char buf[16384], *remote_ipaddr;
         int remote_port;          int remote_port;
   
         if (FD_ISSET(c->sock, readset)) {          if (FD_ISSET(c->sock, readset)) {
Line 545 
Line 569 
                         error("accept: %.100s", strerror(errno));                          error("accept: %.100s", strerror(errno));
                         return;                          return;
                 }                  }
                 remote_hostname = get_remote_hostname(newsock);                  remote_ipaddr = get_peer_ipaddr(newsock);
                 remote_port = get_peer_port(newsock);                  remote_port = get_peer_port(newsock);
                 snprintf(buf, sizeof buf, "X11 connection from %.200s port %d",                  snprintf(buf, sizeof buf, "X11 connection from %.200s port %d",
                     remote_hostname, remote_port);                      remote_ipaddr, remote_port);
   
                 newch = channel_new("x11",                  newch = channel_new("x11",
                     SSH_CHANNEL_OPENING, newsock, newsock, -1,                      SSH_CHANNEL_OPENING, newsock, newsock, -1,
Line 560 
Line 584 
                         packet_put_int(newch);                          packet_put_int(newch);
                         packet_put_int(c->local_window_max);                          packet_put_int(c->local_window_max);
                         packet_put_int(c->local_maxpacket);                          packet_put_int(c->local_maxpacket);
                         /* originator host and port */                          /* originator ipaddr and port */
                         packet_put_cstring(remote_hostname);                          packet_put_cstring(remote_ipaddr);
                         if (datafellows & SSH_BUG_X11FWD) {                          if (datafellows & SSH_BUG_X11FWD) {
                                 debug("ssh2 x11 bug compat mode");                                  debug("ssh2 x11 bug compat mode");
                         } else {                          } else {
Line 575 
Line 599 
                                 packet_put_string(buf, strlen(buf));                                  packet_put_string(buf, strlen(buf));
                         packet_send();                          packet_send();
                 }                  }
                 xfree(remote_hostname);                  xfree(remote_ipaddr);
         }          }
 }  }
   
Line 588 
Line 612 
         struct sockaddr addr;          struct sockaddr addr;
         int newsock, newch;          int newsock, newch;
         socklen_t addrlen;          socklen_t addrlen;
         char buf[1024], *remote_hostname;          char buf[1024], *remote_ipaddr, *rtype;
         int remote_port;          int remote_port;
   
           rtype = (c->type == SSH_CHANNEL_RPORT_LISTENER) ?
               "forwarded-tcpip" : "direct-tcpip";
   
         if (FD_ISSET(c->sock, readset)) {          if (FD_ISSET(c->sock, readset)) {
                 debug("Connection to port %d forwarding "                  debug("Connection to port %d forwarding "
                     "to %.100s port %d requested.",                      "to %.100s port %d requested.",
Line 601 
Line 628 
                         error("accept: %.100s", strerror(errno));                          error("accept: %.100s", strerror(errno));
                         return;                          return;
                 }                  }
                 remote_hostname = get_remote_hostname(newsock);                  remote_ipaddr = get_peer_ipaddr(newsock);
                 remote_port = get_peer_port(newsock);                  remote_port = get_peer_port(newsock);
                 snprintf(buf, sizeof buf,                  snprintf(buf, sizeof buf,
                     "listen port %d for %.100s port %d, "                      "listen port %d for %.100s port %d, "
                     "connect from %.200s port %d",                      "connect from %.200s port %d",
                     c->listening_port, c->path, c->host_port,                      c->listening_port, c->path, c->host_port,
                     remote_hostname, remote_port);                      remote_ipaddr, remote_port);
                 newch = channel_new("direct-tcpip",  
                   newch = channel_new(rtype,
                     SSH_CHANNEL_OPENING, newsock, newsock, -1,                      SSH_CHANNEL_OPENING, newsock, newsock, -1,
                     c->local_window_max, c->local_maxpacket,                      c->local_window_max, c->local_maxpacket,
                     0, xstrdup(buf), 1);                      0, xstrdup(buf), 1);
                 if (compat20) {                  if (compat20) {
                         packet_start(SSH2_MSG_CHANNEL_OPEN);                          packet_start(SSH2_MSG_CHANNEL_OPEN);
                         packet_put_cstring("direct-tcpip");                          packet_put_cstring(rtype);
                         packet_put_int(newch);                          packet_put_int(newch);
                         packet_put_int(c->local_window_max);                          packet_put_int(c->local_window_max);
                         packet_put_int(c->local_maxpacket);                          packet_put_int(c->local_maxpacket);
                         /* target host and port */                          if (c->type == SSH_CHANNEL_RPORT_LISTENER) {
                         packet_put_string(c->path, strlen(c->path));                                  /* listen address, port */
                         packet_put_int(c->host_port);                                  packet_put_string(c->path, strlen(c->path));
                                   packet_put_int(c->listening_port);
                           } else {
                                   /* target host, port */
                                   packet_put_string(c->path, strlen(c->path));
                                   packet_put_int(c->host_port);
                           }
                         /* originator host and port */                          /* originator host and port */
                         packet_put_cstring(remote_hostname);                          packet_put_cstring(remote_ipaddr);
                         packet_put_int(remote_port);                          packet_put_int(remote_port);
                         packet_send();                          packet_send();
                 } else {                  } else {
Line 635 
Line 669 
                         }                          }
                         packet_send();                          packet_send();
                 }                  }
                 xfree(remote_hostname);                  xfree(remote_ipaddr);
         }          }
 }  }
   
Line 657 
Line 691 
                         error("accept from auth socket: %.100s", strerror(errno));                          error("accept from auth socket: %.100s", strerror(errno));
                         return;                          return;
                 }                  }
                 newch = channel_allocate(SSH_CHANNEL_OPENING, newsock,                  newch = channel_new("accepted auth socket",
                     xstrdup("accepted auth socket"));                      SSH_CHANNEL_OPENING, newsock, newsock, -1,
                 packet_start(SSH_SMSG_AGENT_OPEN);                      c->local_window_max, c->local_maxpacket,
                 packet_put_int(newch);                      0, xstrdup("accepted auth socket"), 1);
                   if (compat20) {
                           packet_start(SSH2_MSG_CHANNEL_OPEN);
                           packet_put_cstring("auth-agent@openssh.com");
                           packet_put_int(newch);
                           packet_put_int(c->local_window_max);
                           packet_put_int(c->local_maxpacket);
                   } else {
                           packet_start(SSH_SMSG_AGENT_OPEN);
                           packet_put_int(newch);
                   }
                 packet_send();                  packet_send();
         }          }
 }  }
   
   void
   channel_post_connecting(Channel *c, fd_set * readset, fd_set * writeset)
   {
           if (FD_ISSET(c->sock, writeset)) {
                   int err = 0;
                   int sz = sizeof(err);
                   c->type = SSH_CHANNEL_OPEN;
                   if (getsockopt(c->sock, SOL_SOCKET, SO_ERROR, (char *)&err, &sz) < 0) {
                           debug("getsockopt SO_ERROR failed");
                   } else {
                           if (err == 0) {
                                   debug("channel %d: connected)", c->self);
                           } else {
                                   debug("channel %d: not connected: %s",
                                       c->self, strerror(err));
                                   chan_read_failed(c);
                                   chan_write_failed(c);
                           }
                   }
           }
   }
   
 int  int
 channel_handle_rfd(Channel *c, fd_set * readset, fd_set * writeset)  channel_handle_rfd(Channel *c, fd_set * readset, fd_set * writeset)
 {  {
Line 722 
Line 788 
                         }                          }
                         return -1;                          return -1;
                 }                  }
                   if (compat20 && c->isatty) {
                           struct termios tio;
                           if (tcgetattr(c->wfd, &tio) == 0 &&
                               !(tio.c_lflag & ECHO) && (tio.c_lflag & ICANON)) {
                                   /*
                                    * Simulate echo to reduce the impact of
                                    * traffic analysis.
                                    */
                                   packet_start(SSH2_MSG_IGNORE);
                                   memset(buffer_ptr(&c->output), 0, len);
                                   packet_put_string(buffer_ptr(&c->output), len);
                                   packet_send();
                           }
                   }
                 buffer_consume(&c->output, len);                  buffer_consume(&c->output, len);
                 if (compat20 && len > 0) {                  if (compat20 && len > 0) {
                         c->local_consumed += len;                          c->local_consumed += len;
Line 820 
Line 900 
         channel_pre[SSH_CHANNEL_OPEN] =                 &channel_pre_open_20;          channel_pre[SSH_CHANNEL_OPEN] =                 &channel_pre_open_20;
         channel_pre[SSH_CHANNEL_X11_OPEN] =             &channel_pre_x11_open;          channel_pre[SSH_CHANNEL_X11_OPEN] =             &channel_pre_x11_open;
         channel_pre[SSH_CHANNEL_PORT_LISTENER] =        &channel_pre_listener;          channel_pre[SSH_CHANNEL_PORT_LISTENER] =        &channel_pre_listener;
           channel_pre[SSH_CHANNEL_RPORT_LISTENER] =       &channel_pre_listener;
         channel_pre[SSH_CHANNEL_X11_LISTENER] =         &channel_pre_listener;          channel_pre[SSH_CHANNEL_X11_LISTENER] =         &channel_pre_listener;
           channel_pre[SSH_CHANNEL_AUTH_SOCKET] =          &channel_pre_listener;
           channel_pre[SSH_CHANNEL_CONNECTING] =           &channel_pre_connecting;
   
         channel_post[SSH_CHANNEL_OPEN] =                &channel_post_open_2;          channel_post[SSH_CHANNEL_OPEN] =                &channel_post_open_2;
         channel_post[SSH_CHANNEL_PORT_LISTENER] =       &channel_post_port_listener;          channel_post[SSH_CHANNEL_PORT_LISTENER] =       &channel_post_port_listener;
           channel_post[SSH_CHANNEL_RPORT_LISTENER] =      &channel_post_port_listener;
         channel_post[SSH_CHANNEL_X11_LISTENER] =        &channel_post_x11_listener;          channel_post[SSH_CHANNEL_X11_LISTENER] =        &channel_post_x11_listener;
           channel_post[SSH_CHANNEL_AUTH_SOCKET] =         &channel_post_auth_listener;
           channel_post[SSH_CHANNEL_CONNECTING] =          &channel_post_connecting;
 }  }
   
 void  void
Line 837 
Line 923 
         channel_pre[SSH_CHANNEL_AUTH_SOCKET] =          &channel_pre_listener;          channel_pre[SSH_CHANNEL_AUTH_SOCKET] =          &channel_pre_listener;
         channel_pre[SSH_CHANNEL_INPUT_DRAINING] =       &channel_pre_input_draining;          channel_pre[SSH_CHANNEL_INPUT_DRAINING] =       &channel_pre_input_draining;
         channel_pre[SSH_CHANNEL_OUTPUT_DRAINING] =      &channel_pre_output_draining;          channel_pre[SSH_CHANNEL_OUTPUT_DRAINING] =      &channel_pre_output_draining;
           channel_pre[SSH_CHANNEL_CONNECTING] =           &channel_pre_connecting;
   
         channel_post[SSH_CHANNEL_OPEN] =                &channel_post_open_1;          channel_post[SSH_CHANNEL_OPEN] =                &channel_post_open_1;
         channel_post[SSH_CHANNEL_X11_LISTENER] =        &channel_post_x11_listener;          channel_post[SSH_CHANNEL_X11_LISTENER] =        &channel_post_x11_listener;
         channel_post[SSH_CHANNEL_PORT_LISTENER] =       &channel_post_port_listener;          channel_post[SSH_CHANNEL_PORT_LISTENER] =       &channel_post_port_listener;
         channel_post[SSH_CHANNEL_AUTH_SOCKET] =         &channel_post_auth_listener;          channel_post[SSH_CHANNEL_AUTH_SOCKET] =         &channel_post_auth_listener;
         channel_post[SSH_CHANNEL_OUTPUT_DRAINING] =     &channel_post_output_drain_13;          channel_post[SSH_CHANNEL_OUTPUT_DRAINING] =     &channel_post_output_drain_13;
           channel_post[SSH_CHANNEL_CONNECTING] =          &channel_post_connecting;
 }  }
   
 void  void
Line 853 
Line 941 
         channel_pre[SSH_CHANNEL_X11_LISTENER] =         &channel_pre_listener;          channel_pre[SSH_CHANNEL_X11_LISTENER] =         &channel_pre_listener;
         channel_pre[SSH_CHANNEL_PORT_LISTENER] =        &channel_pre_listener;          channel_pre[SSH_CHANNEL_PORT_LISTENER] =        &channel_pre_listener;
         channel_pre[SSH_CHANNEL_AUTH_SOCKET] =          &channel_pre_listener;          channel_pre[SSH_CHANNEL_AUTH_SOCKET] =          &channel_pre_listener;
           channel_pre[SSH_CHANNEL_CONNECTING] =           &channel_pre_connecting;
   
         channel_post[SSH_CHANNEL_X11_LISTENER] =        &channel_post_x11_listener;          channel_post[SSH_CHANNEL_X11_LISTENER] =        &channel_post_x11_listener;
         channel_post[SSH_CHANNEL_PORT_LISTENER] =       &channel_post_port_listener;          channel_post[SSH_CHANNEL_PORT_LISTENER] =       &channel_post_port_listener;
         channel_post[SSH_CHANNEL_AUTH_SOCKET] =         &channel_post_auth_listener;          channel_post[SSH_CHANNEL_AUTH_SOCKET] =         &channel_post_auth_listener;
         channel_post[SSH_CHANNEL_OPEN] =                &channel_post_open_1;          channel_post[SSH_CHANNEL_OPEN] =                &channel_post_open_1;
           channel_post[SSH_CHANNEL_CONNECTING] =          &channel_post_connecting;
 }  }
   
 void  void
Line 899 
Line 989 
 }  }
   
 void  void
 channel_prepare_select(fd_set * readset, fd_set * writeset)  channel_prepare_select(fd_set **readsetp, fd_set **writesetp, int *maxfdp)
 {  {
         channel_handler(channel_pre, readset, writeset);          int n;
           u_int sz;
   
           n = MAX(*maxfdp, channel_max_fd);
   
           sz = howmany(n+1, NFDBITS) * sizeof(fd_mask);
           if (*readsetp == NULL || n > *maxfdp) {
                   if (*readsetp)
                           xfree(*readsetp);
                   if (*writesetp)
                           xfree(*writesetp);
                   *readsetp = xmalloc(sz);
                   *writesetp = xmalloc(sz);
                   *maxfdp = n;
           }
           memset(*readsetp, 0, sz);
           memset(*writesetp, 0, sz);
   
           channel_handler(channel_pre, *readsetp, *writesetp);
 }  }
   
 void  void
Line 910 
Line 1018 
         channel_handler(channel_post, readset, writeset);          channel_handler(channel_post, readset, writeset);
 }  }
   
 /* If there is data to send to the connection, send some of it now. */  /* If there is data to send to the connection, enqueue some of it now. */
   
 void  void
 channel_output_poll()  channel_output_poll()
Line 1007 
Line 1115 
 {  {
         int id;          int id;
         char *data;          char *data;
         unsigned int data_len;          u_int data_len;
         Channel *c;          Channel *c;
   
         /* Get the channel number and verify it. */          /* Get the channel number and verify it. */
Line 1053 
Line 1161 
         int id;          int id;
         int tcode;          int tcode;
         char *data;          char *data;
         unsigned int data_len;          u_int data_len;
         Channel *c;          Channel *c;
   
         /* Get the channel number and verify it. */          /* Get the channel number and verify it. */
Line 1096 
Line 1204 
 int  int
 channel_not_very_much_buffered_data()  channel_not_very_much_buffered_data()
 {  {
         unsigned int i;          u_int i;
         Channel *c;          Channel *c;
   
         for (i = 0; i < channels_alloc; i++) {          for (i = 0; i < channels_alloc; i++) {
Line 1235 
Line 1343 
 void  void
 channel_input_open_failure(int type, int plen, void *ctxt)  channel_input_open_failure(int type, int plen, void *ctxt)
 {  {
         int id;          int id, reason;
           char *msg = NULL, *lang = NULL;
         Channel *c;          Channel *c;
   
         if (!compat20)          if (!compat20)
Line 1248 
Line 1357 
                 packet_disconnect("Received open failure for "                  packet_disconnect("Received open failure for "
                     "non-opening channel %d.", id);                      "non-opening channel %d.", id);
         if (compat20) {          if (compat20) {
                 int reason = packet_get_int();                  reason = packet_get_int();
                 char *msg  = packet_get_string(NULL);                  if (packet_remaining() > 0) {
                 char *lang  = packet_get_string(NULL);                          msg  = packet_get_string(NULL);
                 log("channel_open_failure: %d: reason %d: %s", id, reason, msg);                          lang = packet_get_string(NULL);
                   }
                 packet_done();                  packet_done();
                 xfree(msg);                  log("channel_open_failure: %d: reason %d %s", id,
                 xfree(lang);                      reason, msg ? msg : "<no additional info>");
                   if (msg != NULL)
                           xfree(msg);
                   if (lang != NULL)
                           xfree(lang);
         }          }
         /* Free the channel.  This will also close the socket. */          /* Free the channel.  This will also close the socket. */
         channel_free(id);          channel_free(id);
Line 1322 
Line 1436 
                 switch (channels[i].type) {                  switch (channels[i].type) {
                 case SSH_CHANNEL_AUTH_SOCKET:                  case SSH_CHANNEL_AUTH_SOCKET:
                         close(channels[i].sock);                          close(channels[i].sock);
                         remove(channels[i].path);                          unlink(channels[i].path);
                         channel_free(i);                          channel_free(i);
                         break;                          break;
                 case SSH_CHANNEL_PORT_LISTENER:                  case SSH_CHANNEL_PORT_LISTENER:
                   case SSH_CHANNEL_RPORT_LISTENER:
                 case SSH_CHANNEL_X11_LISTENER:                  case SSH_CHANNEL_X11_LISTENER:
                         close(channels[i].sock);                          close(channels[i].sock);
                         channel_free(i);                          channel_free(i);
Line 1350 
Line 1465 
                         channel_close_fds(&channels[i]);                          channel_close_fds(&channels[i]);
 }  }
   
 /* Returns the maximum file descriptor number used by the channels. */  
   
 int  
 channel_max_fd()  
 {  
         return channel_max_fd_value;  
 }  
   
 /* Returns true if any channel is still open. */  /* Returns true if any channel is still open. */
   
 int  int
 channel_still_open()  channel_still_open()
 {  {
         unsigned int i;          u_int i;
         for (i = 0; i < channels_alloc; i++)          for (i = 0; i < channels_alloc; i++)
                 switch (channels[i].type) {                  switch (channels[i].type) {
                 case SSH_CHANNEL_FREE:                  case SSH_CHANNEL_FREE:
                 case SSH_CHANNEL_X11_LISTENER:                  case SSH_CHANNEL_X11_LISTENER:
                 case SSH_CHANNEL_PORT_LISTENER:                  case SSH_CHANNEL_PORT_LISTENER:
                   case SSH_CHANNEL_RPORT_LISTENER:
                 case SSH_CHANNEL_CLOSED:                  case SSH_CHANNEL_CLOSED:
                 case SSH_CHANNEL_AUTH_SOCKET:                  case SSH_CHANNEL_AUTH_SOCKET:
                   case SSH_CHANNEL_CONNECTING:    /* XXX ??? */
                         continue;                          continue;
                 case SSH_CHANNEL_LARVAL:                  case SSH_CHANNEL_LARVAL:
                         if (!compat20)                          if (!compat20)
Line 1414 
Line 1523 
                 case SSH_CHANNEL_FREE:                  case SSH_CHANNEL_FREE:
                 case SSH_CHANNEL_X11_LISTENER:                  case SSH_CHANNEL_X11_LISTENER:
                 case SSH_CHANNEL_PORT_LISTENER:                  case SSH_CHANNEL_PORT_LISTENER:
                   case SSH_CHANNEL_RPORT_LISTENER:
                 case SSH_CHANNEL_CLOSED:                  case SSH_CHANNEL_CLOSED:
                 case SSH_CHANNEL_AUTH_SOCKET:                  case SSH_CHANNEL_AUTH_SOCKET:
                         continue;                          continue;
                 case SSH_CHANNEL_LARVAL:                  case SSH_CHANNEL_LARVAL:
                 case SSH_CHANNEL_OPENING:                  case SSH_CHANNEL_OPENING:
                   case SSH_CHANNEL_CONNECTING:
                 case SSH_CHANNEL_OPEN:                  case SSH_CHANNEL_OPEN:
                 case SSH_CHANNEL_X11_OPEN:                  case SSH_CHANNEL_X11_OPEN:
                 case SSH_CHANNEL_INPUT_DRAINING:                  case SSH_CHANNEL_INPUT_DRAINING:
Line 1446 
Line 1557 
  * Initiate forwarding of connections to local port "port" through the secure   * Initiate forwarding of connections to local port "port" through the secure
  * channel to host:port from remote side.   * channel to host:port from remote side.
  */   */
   int
   channel_request_local_forwarding(u_short listen_port, const char *host_to_connect,
       u_short port_to_connect, int gateway_ports)
   {
           return channel_request_forwarding(
               NULL, listen_port,
               host_to_connect, port_to_connect,
               gateway_ports, /*remote_fwd*/ 0);
   }
   
 void  /*
 channel_request_local_forwarding(u_short port, const char *host,   * If 'remote_fwd' is true we have a '-R style' listener for protocol 2
                                  u_short host_port, int gateway_ports)   * (SSH_CHANNEL_RPORT_LISTENER).
    */
   int
   channel_request_forwarding(
       const char *listen_address, u_short listen_port,
       const char *host_to_connect, u_short port_to_connect,
       int gateway_ports, int remote_fwd)
 {  {
         int success, ch, sock, on = 1;          int success, ch, sock, on = 1, ctype;
         struct addrinfo hints, *ai, *aitop;          struct addrinfo hints, *ai, *aitop;
         char ntop[NI_MAXHOST], strport[NI_MAXSERV];          char ntop[NI_MAXHOST], strport[NI_MAXSERV];
           const char *host;
         struct linger linger;          struct linger linger;
   
         if (strlen(host) > sizeof(channels[0].path) - 1)          success = 0;
                 packet_disconnect("Forward host name too long.");  
   
           if (remote_fwd) {
                   host = listen_address;
                   ctype = SSH_CHANNEL_RPORT_LISTENER;
           } else {
                   host = host_to_connect;
                   ctype  =SSH_CHANNEL_PORT_LISTENER;
           }
   
           if (strlen(host) > sizeof(channels[0].path) - 1) {
                   error("Forward host name too long.");
                   return success;
           }
   
           /* XXX listen_address is currently ignored */
         /*          /*
          * getaddrinfo returns a loopback address if the hostname is           * getaddrinfo returns a loopback address if the hostname is
          * set to NULL and hints.ai_flags is not AI_PASSIVE           * set to NULL and hints.ai_flags is not AI_PASSIVE
Line 1467 
Line 1607 
         hints.ai_family = IPv4or6;          hints.ai_family = IPv4or6;
         hints.ai_flags = gateway_ports ? AI_PASSIVE : 0;          hints.ai_flags = gateway_ports ? AI_PASSIVE : 0;
         hints.ai_socktype = SOCK_STREAM;          hints.ai_socktype = SOCK_STREAM;
         snprintf(strport, sizeof strport, "%d", port);          snprintf(strport, sizeof strport, "%d", listen_port);
         if (getaddrinfo(NULL, strport, &hints, &aitop) != 0)          if (getaddrinfo(NULL, strport, &hints, &aitop) != 0)
                 packet_disconnect("getaddrinfo: fatal error");                  packet_disconnect("getaddrinfo: fatal error");
   
         success = 0;  
         for (ai = aitop; ai; ai = ai->ai_next) {          for (ai = aitop; ai; ai = ai->ai_next) {
                 if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6)                  if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6)
                         continue;                          continue;
                 if (getnameinfo(ai->ai_addr, ai->ai_addrlen, ntop, sizeof(ntop),                  if (getnameinfo(ai->ai_addr, ai->ai_addrlen, ntop, sizeof(ntop),
                     strport, sizeof(strport), NI_NUMERICHOST|NI_NUMERICSERV) != 0) {                      strport, sizeof(strport), NI_NUMERICHOST|NI_NUMERICSERV) != 0) {
                         error("channel_request_local_forwarding: getnameinfo failed");                          error("channel_request_forwarding: getnameinfo failed");
                         continue;                          continue;
                 }                  }
                 /* Create a port to listen for the host. */                  /* Create a port to listen for the host. */
Line 1511 
Line 1650 
                         continue;                          continue;
                 }                  }
                 /* Allocate a channel number for the socket. */                  /* Allocate a channel number for the socket. */
                 ch = channel_new(                  ch = channel_new("port listener", ctype, sock, sock, -1,
                     "port listener", SSH_CHANNEL_PORT_LISTENER,  
                     sock, sock, -1,  
                     CHAN_TCP_WINDOW_DEFAULT, CHAN_TCP_PACKET_DEFAULT,                      CHAN_TCP_WINDOW_DEFAULT, CHAN_TCP_PACKET_DEFAULT,
                     0, xstrdup("port listener"), 1);                      0, xstrdup("port listener"), 1);
                 strlcpy(channels[ch].path, host, sizeof(channels[ch].path));                  strlcpy(channels[ch].path, host, sizeof(channels[ch].path));
                 channels[ch].host_port = host_port;                  channels[ch].host_port = port_to_connect;
                 channels[ch].listening_port = port;                  channels[ch].listening_port = listen_port;
                 success = 1;                  success = 1;
         }          }
         if (success == 0)          if (success == 0)
                 packet_disconnect("cannot listen port: %d", port);                  error("channel_request_forwarding: cannot listen to port: %d",
                       listen_port);
         freeaddrinfo(aitop);          freeaddrinfo(aitop);
           return success;
 }  }
   
 /*  /*
Line 1532 
Line 1671 
  */   */
   
 void  void
 channel_request_remote_forwarding(u_short listen_port, const char *host_to_connect,  channel_request_remote_forwarding(u_short listen_port,
                                   u_short port_to_connect)      const char *host_to_connect, u_short port_to_connect)
 {  {
         int payload_len;          int payload_len, type, success = 0;
   
         /* Record locally that connection to this host/port is permitted. */          /* Record locally that connection to this host/port is permitted. */
         if (num_permitted_opens >= SSH_MAX_FORWARDS_PER_DIRECTION)          if (num_permitted_opens >= SSH_MAX_FORWARDS_PER_DIRECTION)
                 fatal("channel_request_remote_forwarding: too many forwards");                  fatal("channel_request_remote_forwarding: too many forwards");
   
         permitted_opens[num_permitted_opens].host_to_connect = xstrdup(host_to_connect);  
         permitted_opens[num_permitted_opens].port_to_connect = port_to_connect;  
         permitted_opens[num_permitted_opens].listen_port = listen_port;  
         num_permitted_opens++;  
   
         /* Send the forward request to the remote side. */          /* Send the forward request to the remote side. */
         if (compat20) {          if (compat20) {
                 const char *address_to_bind = "0.0.0.0";                  const char *address_to_bind = "0.0.0.0";
Line 1553 
Line 1688 
                 packet_put_char(0);                     /* boolean: want reply */                  packet_put_char(0);                     /* boolean: want reply */
                 packet_put_cstring(address_to_bind);                  packet_put_cstring(address_to_bind);
                 packet_put_int(listen_port);                  packet_put_int(listen_port);
                   packet_send();
                   packet_write_wait();
                   /* Assume that server accepts the request */
                   success = 1;
         } else {          } else {
                 packet_start(SSH_CMSG_PORT_FORWARD_REQUEST);                  packet_start(SSH_CMSG_PORT_FORWARD_REQUEST);
                 packet_put_int(listen_port);                  packet_put_int(listen_port);
Line 1560 
Line 1699 
                 packet_put_int(port_to_connect);                  packet_put_int(port_to_connect);
                 packet_send();                  packet_send();
                 packet_write_wait();                  packet_write_wait();
                 /*  
                  * Wait for response from the remote side.  It will send a disconnect                  /* Wait for response from the remote side. */
                  * message on failure, and we will never see it here.                  type = packet_read(&payload_len);
                  */                  switch (type) {
                 packet_read_expect(&payload_len, SSH_SMSG_SUCCESS);                  case SSH_SMSG_SUCCESS:
                           success = 1;
                           break;
                   case SSH_SMSG_FAILURE:
                           log("Warning: Server denied remote port forwarding.");
                           break;
                   default:
                           /* Unknown packet */
                           packet_disconnect("Protocol error for port forward request:"
                               "received packet type %d.", type);
                   }
         }          }
           if (success) {
                   permitted_opens[num_permitted_opens].host_to_connect = xstrdup(host_to_connect);
                   permitted_opens[num_permitted_opens].port_to_connect = port_to_connect;
                   permitted_opens[num_permitted_opens].listen_port = listen_port;
                   num_permitted_opens++;
           }
 }  }
   
 /*  /*
Line 1592 
Line 1747 
         if (port < IPPORT_RESERVED && !is_root)          if (port < IPPORT_RESERVED && !is_root)
                 packet_disconnect("Requested forwarding of port %d but user is not root.",                  packet_disconnect("Requested forwarding of port %d but user is not root.",
                                   port);                                    port);
         /*          /* Initiate forwarding */
          * Initiate forwarding,  
          */  
         channel_request_local_forwarding(port, hostname, host_port, gateway_ports);          channel_request_local_forwarding(port, hostname, host_port, gateway_ports);
   
         /* Free the argument string. */          /* Free the argument string. */
Line 1632 
Line 1785 
                         error("socket: %.100s", strerror(errno));                          error("socket: %.100s", strerror(errno));
                         continue;                          continue;
                 }                  }
                   if (fcntl(sock, F_SETFL, O_NONBLOCK) < 0)
                           fatal("connect_to: F_SETFL: %s", strerror(errno));
                 /* Connect to the host/port. */                  /* Connect to the host/port. */
                 if (connect(sock, ai->ai_addr, ai->ai_addrlen) < 0) {                  if (connect(sock, ai->ai_addr, ai->ai_addrlen) < 0 &&
                       errno != EINPROGRESS) {
                         error("connect %.100s port %s: %.100s", ntop, strport,                          error("connect %.100s port %s: %.100s", ntop, strport,
                             strerror(errno));                              strerror(errno));
                         close(sock);                          close(sock);
                         continue;       /* fail -- try next */                          continue;       /* fail -- try next */
                 }                  }
                 break; /* success */                  break; /* success */
   
         }          }
         freeaddrinfo(aitop);          freeaddrinfo(aitop);
         if (!ai) {          if (!ai) {
                 error("connect %.100s port %d: failed.", host, host_port);                  error("connect %.100s port %d: failed.", host, host_port);
                 return -1;                  return -1;
         }          }
         /* success */          /* success */
         return sock;          return sock;
 }  }
   int
   channel_connect_by_listen_adress(u_short listen_port)
   {
           int i;
           for (i = 0; i < num_permitted_opens; i++)
                   if (permitted_opens[i].listen_port == listen_port)
                           return channel_connect_to(
                               permitted_opens[i].host_to_connect,
                               permitted_opens[i].port_to_connect);
           error("WARNING: Server requests forwarding for unknown listen_port %d",
               listen_port);
           return -1;
   }
   
 /*  /*
  * This is called after receiving PORT_OPEN message.  This attempts to   * This is called after receiving PORT_OPEN message.  This attempts to
  * connect to the given host:port, and sends back CHANNEL_OPEN_CONFIRMATION   * connect to the given host:port, and sends back CHANNEL_OPEN_CONFIRMATION
Line 1662 
Line 1832 
         u_short host_port;          u_short host_port;
         char *host, *originator_string;          char *host, *originator_string;
         int remote_channel, sock = -1, newch, i, denied;          int remote_channel, sock = -1, newch, i, denied;
         unsigned int host_len, originator_len;          u_int host_len, originator_len;
   
         /* Get remote channel number. */          /* Get remote channel number. */
         remote_channel = packet_get_int();          remote_channel = packet_get_int();
Line 1705 
Line 1875 
         sock = denied ? -1 : channel_connect_to(host, host_port);          sock = denied ? -1 : channel_connect_to(host, host_port);
         if (sock > 0) {          if (sock > 0) {
                 /* Allocate a channel for this connection. */                  /* Allocate a channel for this connection. */
                 newch = channel_allocate(SSH_CHANNEL_OPEN, sock, originator_string);                  newch = channel_allocate(SSH_CHANNEL_CONNECTING,
                       sock, originator_string);
   /*XXX delay answer? */
                 channels[newch].remote_id = remote_channel;                  channels[newch].remote_id = remote_channel;
   
                 packet_start(SSH_MSG_CHANNEL_OPEN_CONFIRMATION);                  packet_start(SSH_MSG_CHANNEL_OPEN_CONFIRMATION);
Line 1775 
Line 1947 
                         if (num_socks == NUM_SOCKS)                          if (num_socks == NUM_SOCKS)
                                 break;                                  break;
                 }                  }
                   freeaddrinfo(aitop);
                 if (num_socks > 0)                  if (num_socks > 0)
                         break;                          break;
         }          }
Line 1818 
Line 1991 
   
 static  static
 int  int
 connect_local_xsocket(unsigned int dnr)  connect_local_xsocket(u_int dnr)
 {  {
         static const char *const x_sockets[] = {          static const char *const x_sockets[] = {
                 X_UNIX_PATH "%u",                  X_UNIX_PATH "%u",
Line 1951 
Line 2124 
 {  {
         int remote_channel, sock = 0, newch;          int remote_channel, sock = 0, newch;
         char *remote_host;          char *remote_host;
         unsigned int remote_len;          u_int remote_len;
   
         /* Get remote channel number. */          /* Get remote channel number. */
         remote_channel = packet_get_int();          remote_channel = packet_get_int();
Line 2022 
Line 2195 
 x11_request_forwarding_with_spoofing(int client_session_id,  x11_request_forwarding_with_spoofing(int client_session_id,
     const char *proto, const char *data)      const char *proto, const char *data)
 {  {
         unsigned int data_len = (unsigned int) strlen(data) / 2;          u_int data_len = (u_int) strlen(data) / 2;
         unsigned int i, value;          u_int i, value, len;
         char *new_data;          char *new_data;
         int screen_number;          int screen_number;
         const char *cp;          const char *cp;
Line 2061 
Line 2234 
         x11_fake_data_len = data_len;          x11_fake_data_len = data_len;
   
         /* Convert the fake data into hex. */          /* Convert the fake data into hex. */
         new_data = xmalloc(2 * data_len + 1);          len = 2 * data_len + 1;
           new_data = xmalloc(len);
         for (i = 0; i < data_len; i++)          for (i = 0; i < data_len; i++)
                 sprintf(new_data + 2 * i, "%02x", (unsigned char) x11_fake_data[i]);                  snprintf(new_data + 2 * i, len - 2 * i,
                       "%02x", (u_char) x11_fake_data[i]);
   
         /* Send the request packet. */          /* Send the request packet. */
         if (compat20) {          if (compat20) {
Line 2107 
Line 2282 
 void  void
 cleanup_socket(void)  cleanup_socket(void)
 {  {
         remove(channel_forwarded_auth_socket_name);          unlink(channel_forwarded_auth_socket_name);
         rmdir(channel_forwarded_auth_socket_dir);          rmdir(channel_forwarded_auth_socket_dir);
 }  }
   
Line 2174 
Line 2349 
                 packet_disconnect("listen: %.100s", strerror(errno));                  packet_disconnect("listen: %.100s", strerror(errno));
   
         /* Allocate a channel for the authentication agent socket. */          /* Allocate a channel for the authentication agent socket. */
         newch = channel_allocate(SSH_CHANNEL_AUTH_SOCKET, sock,          newch = channel_new("auth socket",
                                  xstrdup("auth socket"));              SSH_CHANNEL_AUTH_SOCKET, sock, sock, -1,
               CHAN_X11_WINDOW_DEFAULT, CHAN_X11_PACKET_DEFAULT,
               0, xstrdup("auth socket"), 1);
   
         strlcpy(channels[newch].path, channel_forwarded_auth_socket_name,          strlcpy(channels[newch].path, channel_forwarded_auth_socket_name,
             sizeof(channels[newch].path));              sizeof(channels[newch].path));
         return 1;          return 1;
Line 2305 
Line 2483 
         }          }
         c->dettach_user = NULL;          c->dettach_user = NULL;
 }  }
 void  void
 channel_register_filter(int id, channel_filter_fn *fn)  channel_register_filter(int id, channel_filter_fn *fn)
 {  {
         Channel *c = channel_lookup(id);          Channel *c = channel_lookup(id);
Legend:
Removed from v.1.72  
changed lines
  Added in v.1.72.2.2