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

Diff for /src/usr.bin/ssh/ssh.c between version 1.226.2.2 and 1.226.2.3

version 1.226.2.2, 2005/06/05 02:22:39 version 1.226.2.3, 2005/09/02 03:45:01
Line 145 
Line 145 
 int control_fd = -1;  int control_fd = -1;
   
 /* Multiplexing control command */  /* Multiplexing control command */
 static u_int mux_command = SSHMUX_COMMAND_OPEN;  static u_int mux_command = 0;
   
 /* Only used in control client mode */  /* Only used in control client mode */
 volatile sig_atomic_t control_client_terminate = 0;  volatile sig_atomic_t control_client_terminate = 0;
Line 185 
Line 185 
         int dummy;          int dummy;
         extern int optind, optreset;          extern int optind, optreset;
         extern char *optarg;          extern char *optarg;
           struct servent *sp;
         Forward fwd;          Forward fwd;
   
         /*          /*
Line 381 
Line 382 
                         }                          }
                         break;                          break;
                 case 'M':                  case 'M':
                         options.control_master =                          if (options.control_master == SSHCTL_MASTER_YES)
                             (options.control_master >= 1) ? 2 : 1;                                  options.control_master = SSHCTL_MASTER_ASK;
                           else
                                   options.control_master = SSHCTL_MASTER_YES;
                         break;                          break;
                 case 'p':                  case 'p':
                         options.port = a2port(optarg);                          options.port = a2port(optarg);
Line 431 
Line 434 
                                 fwd.listen_host = cleanhostname(fwd.listen_host);                                  fwd.listen_host = cleanhostname(fwd.listen_host);
                         } else {                          } else {
                                 fwd.listen_port = a2port(fwd.listen_host);                                  fwd.listen_port = a2port(fwd.listen_host);
                                 fwd.listen_host = "";                                  fwd.listen_host = NULL;
                         }                          }
   
                         if (fwd.listen_port == 0) {                          if (fwd.listen_port == 0) {
Line 545 
Line 548 
         if (no_tty_flag)          if (no_tty_flag)
                 tty_flag = 0;                  tty_flag = 0;
         /* Do not allocate a tty if stdin is not a tty. */          /* Do not allocate a tty if stdin is not a tty. */
         if (!isatty(fileno(stdin)) && !force_tty_flag) {          if ((!isatty(fileno(stdin)) || stdin_null_flag) && !force_tty_flag) {
                 if (tty_flag)                  if (tty_flag)
                         logit("Pseudo-terminal will not be allocated because stdin is not a terminal.");                          logit("Pseudo-terminal will not be allocated because stdin is not a terminal.");
                 tty_flag = 0;                  tty_flag = 0;
Line 597 
Line 600 
                                 *p = tolower(*p);                                  *p = tolower(*p);
         }          }
   
           /* Get default port if port has not been set. */
           if (options.port == 0) {
                   sp = getservbyname(SSH_SERVICE_NAME, "tcp");
                   options.port = sp ? ntohs(sp->s_port) : SSH_DEFAULT_PORT;
           }
   
         if (options.proxy_command != NULL &&          if (options.proxy_command != NULL &&
             strcmp(options.proxy_command, "none") == 0)              strcmp(options.proxy_command, "none") == 0)
                 options.proxy_command = NULL;                  options.proxy_command = NULL;
           if (options.control_path != NULL &&
               strcmp(options.control_path, "none") == 0)
                   options.control_path = NULL;
   
         if (options.control_path != NULL) {          if (options.control_path != NULL) {
                 options.control_path = tilde_expand_filename(                  snprintf(buf, sizeof(buf), "%d", options.port);
                    options.control_path, original_real_uid);                  cp = tilde_expand_filename(options.control_path,
                       original_real_uid);
                   options.control_path = percent_expand(cp, "p", buf, "h", host,
                       "r", options.user, (char *)NULL);
                   xfree(cp);
         }          }
         if (options.control_path != NULL && options.control_master == 0)          if (mux_command != 0 && options.control_path == NULL)
                 control_client(options.control_path); /* This doesn't return */                  fatal("No ControlPath specified for \"-O\" command");
           if (options.control_path != NULL)
                   control_client(options.control_path);
   
         /* Open a connection to the remote host. */          /* Open a connection to the remote host. */
         if (ssh_connect(host, &hostaddr, options.port,          if (ssh_connect(host, &hostaddr, options.port,
Line 731 
Line 749 
         return exit_status;          return exit_status;
 }  }
   
 #define SSH_X11_PROTO "MIT-MAGIC-COOKIE-1"  
   
 static void  static void
 x11_get_proto(char **_proto, char **_data)  
 {  
         char cmd[1024];  
         char line[512];  
         char xdisplay[512];  
         static char proto[512], data[512];  
         FILE *f;  
         int got_data = 0, generated = 0, do_unlink = 0, i;  
         char *display, *xauthdir, *xauthfile;  
         struct stat st;  
   
         xauthdir = xauthfile = NULL;  
         *_proto = proto;  
         *_data = data;  
         proto[0] = data[0] = '\0';  
   
         if (!options.xauth_location ||  
             (stat(options.xauth_location, &st) == -1)) {  
                 debug("No xauth program.");  
         } else {  
                 if ((display = getenv("DISPLAY")) == NULL) {  
                         debug("x11_get_proto: DISPLAY not set");  
                         return;  
                 }  
                 /*  
                  * Handle FamilyLocal case where $DISPLAY does  
                  * not match an authorization entry.  For this we  
                  * just try "xauth list unix:displaynum.screennum".  
                  * XXX: "localhost" match to determine FamilyLocal  
                  *      is not perfect.  
                  */  
                 if (strncmp(display, "localhost:", 10) == 0) {  
                         snprintf(xdisplay, sizeof(xdisplay), "unix:%s",  
                             display + 10);  
                         display = xdisplay;  
                 }  
                 if (options.forward_x11_trusted == 0) {  
                         xauthdir = xmalloc(MAXPATHLEN);  
                         xauthfile = xmalloc(MAXPATHLEN);  
                         strlcpy(xauthdir, "/tmp/ssh-XXXXXXXXXX", MAXPATHLEN);  
                         if (mkdtemp(xauthdir) != NULL) {  
                                 do_unlink = 1;  
                                 snprintf(xauthfile, MAXPATHLEN, "%s/xauthfile",  
                                     xauthdir);  
                                 snprintf(cmd, sizeof(cmd),  
                                     "%s -f %s generate %s " SSH_X11_PROTO  
                                     " untrusted timeout 1200 2>" _PATH_DEVNULL,  
                                     options.xauth_location, xauthfile, display);  
                                 debug2("x11_get_proto: %s", cmd);  
                                 if (system(cmd) == 0)  
                                         generated = 1;  
                         }  
                 }  
                 snprintf(cmd, sizeof(cmd),  
                     "%s %s%s list %s . 2>" _PATH_DEVNULL,  
                     options.xauth_location,  
                     generated ? "-f " : "" ,  
                     generated ? xauthfile : "",  
                     display);  
                 debug2("x11_get_proto: %s", cmd);  
                 f = popen(cmd, "r");  
                 if (f && fgets(line, sizeof(line), f) &&  
                     sscanf(line, "%*s %511s %511s", proto, data) == 2)  
                         got_data = 1;  
                 if (f)  
                         pclose(f);  
         }  
   
         if (do_unlink) {  
                 unlink(xauthfile);  
                 rmdir(xauthdir);  
         }  
         if (xauthdir)  
                 xfree(xauthdir);  
         if (xauthfile)  
                 xfree(xauthfile);  
   
         /*  
          * If we didn't get authentication data, just make up some  
          * data.  The forwarding code will check the validity of the  
          * response anyway, and substitute this data.  The X11  
          * server, however, will ignore this fake data and use  
          * whatever authentication mechanisms it was using otherwise  
          * for the local connection.  
          */  
         if (!got_data) {  
                 u_int32_t rnd = 0;  
   
                 logit("Warning: No xauth data; "  
                     "using fake authentication data for X11 forwarding.");  
                 strlcpy(proto, SSH_X11_PROTO, sizeof proto);  
                 for (i = 0; i < 16; i++) {  
                         if (i % 4 == 0)  
                                 rnd = arc4random();  
                         snprintf(data + 2 * i, sizeof data - 2 * i, "%02x",  
                             rnd & 0xff);  
                         rnd >>= 8;  
                 }  
         }  
 }  
   
 static void  
 ssh_init_forwarding(void)  ssh_init_forwarding(void)
 {  {
         int success = 0;          int success = 0;
Line 865 
Line 779 
         for (i = 0; i < options.num_remote_forwards; i++) {          for (i = 0; i < options.num_remote_forwards; i++) {
                 debug("Remote connections from %.200s:%d forwarded to "                  debug("Remote connections from %.200s:%d forwarded to "
                     "local address %.200s:%d",                      "local address %.200s:%d",
                       (options.remote_forwards[i].listen_host == NULL) ?
                       (options.gateway_ports ? "*" : "LOCALHOST") :
                     options.remote_forwards[i].listen_host,                      options.remote_forwards[i].listen_host,
                     options.remote_forwards[i].listen_port,                      options.remote_forwards[i].listen_port,
                     options.remote_forwards[i].connect_host,                      options.remote_forwards[i].connect_host,
Line 895 
Line 811 
         int have_tty = 0;          int have_tty = 0;
         struct winsize ws;          struct winsize ws;
         char *cp;          char *cp;
           const char *display;
   
         /* Enable compression if requested. */          /* Enable compression if requested. */
         if (options.compression) {          if (options.compression) {
Line 956 
Line 873 
                         packet_disconnect("Protocol error waiting for pty request response.");                          packet_disconnect("Protocol error waiting for pty request response.");
         }          }
         /* Request X11 forwarding if enabled and DISPLAY is set. */          /* Request X11 forwarding if enabled and DISPLAY is set. */
         if (options.forward_x11 && getenv("DISPLAY") != NULL) {          display = getenv("DISPLAY");
           if (options.forward_x11 && display != NULL) {
                 char *proto, *data;                  char *proto, *data;
                 /* Get reasonable local authentication information. */                  /* Get reasonable local authentication information. */
                 x11_get_proto(&proto, &data);                  client_x11_get_proto(display, options.xauth_location,
                       options.forward_x11_trusted, &proto, &data);
                 /* Request forwarding with authentication spoofing. */                  /* Request forwarding with authentication spoofing. */
                 debug("Requesting X11 forwarding with authentication spoofing.");                  debug("Requesting X11 forwarding with authentication spoofing.");
                 x11_request_forwarding_with_spoofing(0, proto, data);                  x11_request_forwarding_with_spoofing(0, display, proto, data);
   
                 /* Read response from the server. */                  /* Read response from the server. */
                 type = packet_read();                  type = packet_read();
Line 1063 
Line 982 
         struct sockaddr_un addr;          struct sockaddr_un addr;
         mode_t old_umask;          mode_t old_umask;
   
         if (options.control_path == NULL || options.control_master <= 0)          if (options.control_path == NULL ||
               options.control_master == SSHCTL_MASTER_NO)
                 return;                  return;
   
           debug("setting up multiplex master socket");
   
         memset(&addr, '\0', sizeof(addr));          memset(&addr, '\0', sizeof(addr));
         addr.sun_family = AF_UNIX;          addr.sun_family = AF_UNIX;
         addr.sun_len = offsetof(struct sockaddr_un, sun_path) +          addr.sun_len = offsetof(struct sockaddr_un, sun_path) +
Line 1081 
Line 1003 
         old_umask = umask(0177);          old_umask = umask(0177);
         if (bind(control_fd, (struct sockaddr*)&addr, addr.sun_len) == -1) {          if (bind(control_fd, (struct sockaddr*)&addr, addr.sun_len) == -1) {
                 control_fd = -1;                  control_fd = -1;
                 if (errno == EINVAL)                  if (errno == EINVAL || errno == EADDRINUSE)
                         fatal("ControlSocket %s already exists",                          fatal("ControlSocket %s already exists",
                             options.control_path);                              options.control_path);
                 else                  else
Line 1100 
Line 1022 
 ssh_session2_setup(int id, void *arg)  ssh_session2_setup(int id, void *arg)
 {  {
         extern char **environ;          extern char **environ;
           const char *display;
         int interactive = tty_flag;          int interactive = tty_flag;
         if (options.forward_x11 && getenv("DISPLAY") != NULL) {  
           display = getenv("DISPLAY");
           if (options.forward_x11 && display != NULL) {
                 char *proto, *data;                  char *proto, *data;
                 /* Get reasonable local authentication information. */                  /* Get reasonable local authentication information. */
                 x11_get_proto(&proto, &data);                  client_x11_get_proto(display, options.xauth_location,
                       options.forward_x11_trusted, &proto, &data);
                 /* Request forwarding with authentication spoofing. */                  /* Request forwarding with authentication spoofing. */
                 debug("Requesting X11 forwarding with authentication spoofing.");                  debug("Requesting X11 forwarding with authentication spoofing.");
                 x11_request_forwarding_with_spoofing(id, proto, data);                  x11_request_forwarding_with_spoofing(id, display, proto, data);
                 interactive = 1;                  interactive = 1;
                 /* XXX wait for reply */                  /* XXX wait for reply */
         }          }
Line 1276 
Line 1201 
         extern char **environ;          extern char **environ;
         u_int  flags;          u_int  flags;
   
         if (stdin_null_flag) {          if (mux_command == 0)
                 if ((fd = open(_PATH_DEVNULL, O_RDONLY)) == -1)                  mux_command = SSHMUX_COMMAND_OPEN;
                         fatal("open(/dev/null): %s", strerror(errno));  
                 if (dup2(fd, STDIN_FILENO) == -1)          switch (options.control_master) {
                         fatal("dup2: %s", strerror(errno));          case SSHCTL_MASTER_AUTO:
                 if (fd > STDERR_FILENO)          case SSHCTL_MASTER_AUTO_ASK:
                         close(fd);                  debug("auto-mux: Trying existing master");
                   /* FALLTHROUGH */
           case SSHCTL_MASTER_NO:
                   break;
           default:
                   return;
         }          }
   
         memset(&addr, '\0', sizeof(addr));          memset(&addr, '\0', sizeof(addr));
Line 1297 
Line 1227 
         if ((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)          if ((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
                 fatal("%s socket(): %s", __func__, strerror(errno));                  fatal("%s socket(): %s", __func__, strerror(errno));
   
         if (connect(sock, (struct sockaddr*)&addr, addr.sun_len) == -1)          if (connect(sock, (struct sockaddr*)&addr, addr.sun_len) == -1) {
                 fatal("Couldn't connect to %s: %s", path, strerror(errno));                  if (mux_command != SSHMUX_COMMAND_OPEN) {
                           fatal("Control socket connect(%.100s): %s", path,
                               strerror(errno));
                   }
                   if (errno == ENOENT)
                           debug("Control socket \"%.100s\" does not exist", path);
                   else {
                           error("Control socket connect(%.100s): %s", path,
                               strerror(errno));
                   }
                   close(sock);
                   return;
           }
   
         if ((term = getenv("TERM")) == NULL)          if (stdin_null_flag) {
                 term = "";                  if ((fd = open(_PATH_DEVNULL, O_RDONLY)) == -1)
                           fatal("open(/dev/null): %s", strerror(errno));
                   if (dup2(fd, STDIN_FILENO) == -1)
                           fatal("dup2: %s", strerror(errno));
                   if (fd > STDERR_FILENO)
                           close(fd);
           }
   
           term = getenv("TERM");
   
         flags = 0;          flags = 0;
         if (tty_flag)          if (tty_flag)
                 flags |= SSHMUX_FLAG_TTY;                  flags |= SSHMUX_FLAG_TTY;
         if (subsystem_flag)          if (subsystem_flag)
                 flags |= SSHMUX_FLAG_SUBSYS;                  flags |= SSHMUX_FLAG_SUBSYS;
           if (options.forward_x11)
                   flags |= SSHMUX_FLAG_X11_FWD;
           if (options.forward_agent)
                   flags |= SSHMUX_FLAG_AGENT_FWD;
   
         buffer_init(&m);          buffer_init(&m);
   
         /* Send our command to server */          /* Send our command to server */
         buffer_put_int(&m, mux_command);          buffer_put_int(&m, mux_command);
         buffer_put_int(&m, flags);          buffer_put_int(&m, flags);
         if (ssh_msg_send(sock, /* version */1, &m) == -1)          if (ssh_msg_send(sock, SSHMUX_VER, &m) == -1)
                 fatal("%s: msg_send", __func__);                  fatal("%s: msg_send", __func__);
         buffer_clear(&m);          buffer_clear(&m);
   
         /* Get authorisation status and PID of controlee */          /* Get authorisation status and PID of controlee */
         if (ssh_msg_recv(sock, &m) == -1)          if (ssh_msg_recv(sock, &m) == -1)
                 fatal("%s: msg_recv", __func__);                  fatal("%s: msg_recv", __func__);
         if (buffer_get_char(&m) != 1)          if (buffer_get_char(&m) != SSHMUX_VER)
                 fatal("%s: wrong version", __func__);                  fatal("%s: wrong version", __func__);
         if (buffer_get_int(&m) != 1)          if (buffer_get_int(&m) != 1)
                 fatal("Connection to master denied");                  fatal("Connection to master denied");
Line 1345 
Line 1299 
         }          }
   
         /* SSHMUX_COMMAND_OPEN */          /* SSHMUX_COMMAND_OPEN */
         buffer_put_cstring(&m, term);          buffer_put_cstring(&m, term ? term : "");
         buffer_append(&command, "\0", 1);          buffer_append(&command, "\0", 1);
         buffer_put_cstring(&m, buffer_ptr(&command));          buffer_put_cstring(&m, buffer_ptr(&command));
   
Line 1367 
Line 1321 
                         }                          }
         }          }
   
         if (ssh_msg_send(sock, /* version */1, &m) == -1)          if (ssh_msg_send(sock, SSHMUX_VER, &m) == -1)
                 fatal("%s: msg_send", __func__);                  fatal("%s: msg_send", __func__);
   
         mm_send_fd(sock, STDIN_FILENO);          mm_send_fd(sock, STDIN_FILENO);
Line 1378 
Line 1332 
         buffer_clear(&m);          buffer_clear(&m);
         if (ssh_msg_recv(sock, &m) == -1)          if (ssh_msg_recv(sock, &m) == -1)
                 fatal("%s: msg_recv", __func__);                  fatal("%s: msg_recv", __func__);
         if (buffer_get_char(&m) != 1)          if (buffer_get_char(&m) != SSHMUX_VER)
                 fatal("%s: wrong version", __func__);                  fatal("%s: wrong version", __func__);
         buffer_free(&m);          buffer_free(&m);
   
Legend:
Removed from v.1.226.2.2  
changed lines
  Added in v.1.226.2.3