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

Diff for /src/usr.bin/ssh/session.c between version 1.74 and 1.74.2.2

version 1.74, 2001/04/17 19:34:25 version 1.74.2.2, 2001/09/27 19:03:55
Line 9 
Line 9 
  * called by a name other than "ssh" or "Secure Shell".   * called by a name other than "ssh" or "Secure Shell".
  *   *
  * SSH2 support by Markus Friedl.   * SSH2 support by Markus Friedl.
  * Copyright (c) 2000 Markus Friedl.  All rights reserved.   * Copyright (c) 2000, 2001 Markus Friedl.  All rights reserved.
  *   *
  * Redistribution and use in source and binary forms, with or without   * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions   * modification, are permitted provided that the following conditions
Line 46 
Line 46 
 #include "uidswap.h"  #include "uidswap.h"
 #include "compat.h"  #include "compat.h"
 #include "channels.h"  #include "channels.h"
 #include "nchan.h"  
 #include "bufaux.h"  #include "bufaux.h"
 #include "auth.h"  #include "auth.h"
 #include "auth-options.h"  #include "auth-options.h"
Line 65 
Line 64 
 struct Session {  struct Session {
         int     used;          int     used;
         int     self;          int     self;
         struct  passwd *pw;          struct passwd *pw;
           Authctxt *authctxt;
         pid_t   pid;          pid_t   pid;
         /* tty */          /* tty */
         char    *term;          char    *term;
Line 86 
Line 86 
 /* func */  /* func */
   
 Session *session_new(void);  Session *session_new(void);
 void    session_set_fds(Session *s, int fdin, int fdout, int fderr);  void    session_set_fds(Session *, int, int, int);
 void    session_pty_cleanup(Session *s);  static void     session_pty_cleanup(void *);
 void    session_proctitle(Session *s);  void    session_proctitle(Session *);
 void    do_exec_pty(Session *s, const char *command);  int     session_setup_x11fwd(Session *);
 void    do_exec_no_pty(Session *s, const char *command);  void    do_exec_pty(Session *, const char *);
 void    do_login(Session *s, const char *command);  void    do_exec_no_pty(Session *, const char *);
 void    do_child(Session *s, const char *command);  void    do_exec(Session *, const char *);
   void    do_login(Session *, const char *);
   void    do_child(Session *, const char *);
 void    do_motd(void);  void    do_motd(void);
 int     check_quietlogin(Session *s, const char *command);  int     check_quietlogin(Session *, const char *);
   
 void    do_authenticated1(Authctxt *authctxt);  static void do_authenticated1(Authctxt *);
 void    do_authenticated2(Authctxt *authctxt);  static void do_authenticated2(Authctxt *);
   
   static void session_close(Session *);
   static int session_pty_req(Session *);
   
 /* import */  /* import */
 extern ServerOptions options;  extern ServerOptions options;
 extern char *__progname;  extern char *__progname;
Line 108 
Line 113 
 extern int startup_pipe;  extern int startup_pipe;
 extern void destroy_sensitive_data(void);  extern void destroy_sensitive_data(void);
   
 /* Local Xauthority file. */  
 static char *xauthfile;  
   
 /* original command from peer. */  /* original command from peer. */
 char *original_command = NULL;  const char *original_command = NULL;
   
 /* data */  /* data */
 #define MAX_SESSIONS 10  #define MAX_SESSIONS 10
Line 154 
Line 156 
                 do_authenticated2(authctxt);                  do_authenticated2(authctxt);
         else          else
                 do_authenticated1(authctxt);                  do_authenticated1(authctxt);
 }  
   
 /*          /* remove agent socket */
  * Remove local Xauthority file.          if (auth_get_socket_name())
  */                  auth_sock_cleanup_proc(authctxt->pw);
 void  #ifdef KRB4
 xauthfile_cleanup_proc(void *ignore)          if (options.kerberos_ticket_cleanup)
 {                  krb4_cleanup_proc(authctxt);
         debug("xauthfile_cleanup_proc called");  #endif
   #ifdef KRB5
         if (xauthfile != NULL) {          if (options.kerberos_ticket_cleanup)
                 char *p;                  krb5_cleanup_proc(authctxt);
                 unlink(xauthfile);  #endif
                 p = strrchr(xauthfile, '/');  
                 if (p != NULL) {  
                         *p = '\0';  
                         rmdir(xauthfile);  
                 }  
                 xfree(xauthfile);  
                 xauthfile = NULL;  
         }  
 }  }
   
 /*  /*
  * Function to perform cleanup if we get aborted abnormally (e.g., due to a  
  * dropped connection).  
  */  
 void  
 pty_cleanup_proc(void *session)  
 {  
         Session *s=session;  
         if (s == NULL)  
                 fatal("pty_cleanup_proc: no session");  
         debug("pty_cleanup_proc: %s", s->tty);  
   
         if (s->pid != 0) {  
                 /* Record that the user has logged out. */  
                 record_logout(s->pid, s->tty);  
         }  
   
         /* Release the pseudo-tty. */  
         pty_release(s->tty);  
 }  
   
 /*  
  * Prepares for an interactive session.  This is called after the user has   * Prepares for an interactive session.  This is called after the user has
  * been successfully authenticated.  During this message exchange, pseudo   * been successfully authenticated.  During this message exchange, pseudo
  * terminals are allocated, X11, TCP/IP, and authentication agent forwardings   * terminals are allocated, X11, TCP/IP, and authentication agent forwardings
  * are requested, etc.   * are requested, etc.
  */   */
 void  static void
 do_authenticated1(Authctxt *authctxt)  do_authenticated1(Authctxt *authctxt)
 {  {
         Session *s;          Session *s;
         char *command;          char *command;
         int success, type, fd, n_bytes, plen, screen_flag, have_pty = 0;          int success, type, plen, screen_flag;
         int compression_level = 0, enable_compression_after_reply = 0;          int compression_level = 0, enable_compression_after_reply = 0;
         u_int proto_len, data_len, dlen;          u_int proto_len, data_len, dlen;
   
         s = session_new();          s = session_new();
           s->authctxt = authctxt;
         s->pw = authctxt->pw;          s->pw = authctxt->pw;
   
         /*          /*
Line 242 
Line 215 
                         break;                          break;
   
                 case SSH_CMSG_REQUEST_PTY:                  case SSH_CMSG_REQUEST_PTY:
                         if (no_pty_flag) {                          success = session_pty_req(s);
                                 debug("Allocating a pty not permitted for this authentication.");  
                                 break;  
                         }  
                         if (have_pty)  
                                 packet_disconnect("Protocol error: you already have a pty.");  
   
                         debug("Allocating pty.");  
   
                         /* Allocate a pty and open it. */  
                         if (!pty_allocate(&s->ptyfd, &s->ttyfd, s->tty,  
                             sizeof(s->tty))) {  
                                 error("Failed to allocate pty.");  
                                 break;  
                         }  
                         fatal_add_cleanup(pty_cleanup_proc, (void *)s);  
                         pty_setowner(s->pw, s->tty);  
   
                         /* Get TERM from the packet.  Note that the value may be of arbitrary length. */  
                         s->term = packet_get_string(&dlen);  
                         packet_integrity_check(dlen, strlen(s->term), type);  
                         /* packet_integrity_check(plen, 4 + dlen + 4*4 + n_bytes, type); */  
                         /* Remaining bytes */  
                         n_bytes = plen - (4 + dlen + 4 * 4);  
   
                         if (strcmp(s->term, "") == 0) {  
                                 xfree(s->term);  
                                 s->term = NULL;  
                         }  
                         /* Get window size from the packet. */  
                         s->row = packet_get_int();  
                         s->col = packet_get_int();  
                         s->xpixel = packet_get_int();  
                         s->ypixel = packet_get_int();  
                         pty_change_window_size(s->ptyfd, s->row, s->col, s->xpixel, s->ypixel);  
   
                         /* Get tty modes from the packet. */  
                         tty_parse_modes(s->ttyfd, &n_bytes);  
                         packet_integrity_check(plen, 4 + dlen + 4 * 4 + n_bytes, type);  
   
                         session_proctitle(s);  
   
                         /* Indicate that we now have a pty. */  
                         success = 1;  
                         have_pty = 1;  
                         break;                          break;
   
                 case SSH_CMSG_X11_REQUEST_FORWARDING:                  case SSH_CMSG_X11_REQUEST_FORWARDING:
                         if (!options.x11_forwarding) {  
                                 packet_send_debug("X11 forwarding disabled in server configuration file.");  
                                 break;  
                         }  
                         if (!options.xauth_location) {  
                                 packet_send_debug("No xauth program; cannot forward with spoofing.");  
                                 break;  
                         }  
                         if (no_x11_forwarding_flag) {  
                                 packet_send_debug("X11 forwarding not permitted for this authentication.");  
                                 break;  
                         }  
                         debug("Received request for X11 forwarding with auth spoofing.");  
                         if (s->display != NULL)  
                                 packet_disconnect("Protocol error: X11 display already set.");  
   
                         s->auth_proto = packet_get_string(&proto_len);                          s->auth_proto = packet_get_string(&proto_len);
                         s->auth_data = packet_get_string(&data_len);                          s->auth_data = packet_get_string(&data_len);
   
Line 317 
Line 230 
                                 if (!screen_flag)                                  if (!screen_flag)
                                         debug2("Buggy client: "                                          debug2("Buggy client: "
                                             "X11 screen flag missing");                                              "X11 screen flag missing");
                                 packet_integrity_check(plen,  
                                     4 + proto_len + 4 + data_len + 4, type);  
                                 s->screen = packet_get_int();                                  s->screen = packet_get_int();
                         } else {                          } else {
                                 packet_integrity_check(plen,  
                                     4 + proto_len + 4 + data_len, type);  
                                 s->screen = 0;                                  s->screen = 0;
                         }                          }
                         s->display = x11_create_display_inet(s->screen, options.x11_display_offset);                          packet_done();
                           success = session_setup_x11fwd(s);
                         if (s->display == NULL)                          if (!success) {
                                 break;                                  xfree(s->auth_proto);
                                   xfree(s->auth_data);
                         /* Setup to always have a local .Xauthority. */                                  s->auth_proto = NULL;
                         xauthfile = xmalloc(MAXPATHLEN);                                  s->auth_data = NULL;
                         strlcpy(xauthfile, "/tmp/ssh-XXXXXXXX", MAXPATHLEN);  
                         temporarily_use_uid(s->pw);  
                         if (mkdtemp(xauthfile) == NULL) {  
                                 restore_uid();  
                                 error("private X11 dir: mkdtemp %s failed: %s",  
                                     xauthfile, strerror(errno));  
                                 xfree(xauthfile);  
                                 xauthfile = NULL;  
                                 /* XXXX remove listening channels */  
                                 break;  
                         }                          }
                         strlcat(xauthfile, "/cookies", MAXPATHLEN);  
                         fd = open(xauthfile, O_RDWR|O_CREAT|O_EXCL, 0600);  
                         if (fd >= 0)  
                                 close(fd);  
                         restore_uid();  
                         fatal_add_cleanup(xauthfile_cleanup_proc, NULL);  
                         success = 1;  
                         break;                          break;
   
                 case SSH_CMSG_AGENT_REQUEST_FORWARDING:                  case SSH_CMSG_AGENT_REQUEST_FORWARDING:
Line 379 
Line 271 
                         if (packet_set_maxsize(packet_get_int()) > 0)                          if (packet_set_maxsize(packet_get_int()) > 0)
                                 success = 1;                                  success = 1;
                         break;                          break;
   
   #if defined(AFS) || defined(KRB5)
                   case SSH_CMSG_HAVE_KERBEROS_TGT:
                           if (!options.kerberos_tgt_passing) {
                                   verbose("Kerberos TGT passing disabled.");
                           } else {
                                   char *kdata = packet_get_string(&dlen);
                                   packet_integrity_check(plen, 4 + dlen, type);
   
                                   /* XXX - 0x41, see creds_to_radix version */
                                   if (kdata[0] != 0x41) {
   #ifdef KRB5
                                           krb5_data tgt;
                                           tgt.data = kdata;
                                           tgt.length = dlen;
   
                                           if (auth_krb5_tgt(s->authctxt, &tgt))
                                                   success = 1;
                                           else
                                                   verbose("Kerberos v5 TGT refused for %.100s", s->authctxt->user);
   #endif /* KRB5 */
                                   } else {
   #ifdef AFS
                                           if (auth_krb4_tgt(s->authctxt, kdata))
                                                   success = 1;
                                           else
                                                   verbose("Kerberos v4 TGT refused for %.100s", s->authctxt->user);
   #endif /* AFS */
                                   }
                                   xfree(kdata);
                           }
                           break;
   #endif /* AFS || KRB5 */
   
   #ifdef AFS
                   case SSH_CMSG_HAVE_AFS_TOKEN:
                           if (!options.afs_token_passing || !k_hasafs()) {
                                   verbose("AFS token passing disabled.");
                           } else {
                                   /* Accept AFS token. */
                                   char *token = packet_get_string(&dlen);
                                   packet_integrity_check(plen, 4 + dlen, type);
   
                                   if (auth_afs_token(s->authctxt, token))
                                           success = 1;
                                   else
                                           verbose("AFS token refused for %.100s",
                                               s->authctxt->user);
                                   xfree(token);
                           }
                           break;
   #endif /* AFS */
   
                 case SSH_CMSG_EXEC_SHELL:                  case SSH_CMSG_EXEC_SHELL:
                 case SSH_CMSG_EXEC_CMD:                  case SSH_CMSG_EXEC_CMD:
                         if (type == SSH_CMSG_EXEC_CMD) {                          if (type == SSH_CMSG_EXEC_CMD) {
                                 command = packet_get_string(&dlen);                                  command = packet_get_string(&dlen);
                                 debug("Exec command '%.500s'", command);                                  debug("Exec command '%.500s'", command);
                                 packet_integrity_check(plen, 4 + dlen, type);                                  do_exec(s, command);
                                   xfree(command);
                         } else {                          } else {
                                 command = NULL;                                  do_exec(s, NULL);
                                 packet_integrity_check(plen, 0, type);  
                         }                          }
                         if (forced_command != NULL) {                          packet_done();
                                 original_command = command;                          session_close(s);
                                 command = forced_command;  
                                 debug("Forced command '%.500s'", forced_command);  
                         }  
                         if (have_pty)  
                                 do_exec_pty(s, command);  
                         else  
                                 do_exec_no_pty(s, command);  
   
                         if (command != NULL)  
                                 xfree(command);  
                         /* Cleanup user's local Xauthority file. */  
                         if (xauthfile)  
                                 xauthfile_cleanup_proc(NULL);  
                         return;                          return;
   
                 default:                  default:
Line 563 
Line 494 
   
         /* Fork the child. */          /* Fork the child. */
         if ((pid = fork()) == 0) {          if ((pid = fork()) == 0) {
   
                 /* Child.  Reinitialize the log because the pid has changed. */                  /* Child.  Reinitialize the log because the pid has changed. */
                 log_init(__progname, options.log_level, options.log_facility, log_stderr);                  log_init(__progname, options.log_level, options.log_facility, log_stderr);
   
                 /* Close the master side of the pseudo tty. */                  /* Close the master side of the pseudo tty. */
                 close(ptyfd);                  close(ptyfd);
   
Line 624 
Line 555 
         } else {          } else {
                 server_loop(pid, ptyfd, fdout, -1);                  server_loop(pid, ptyfd, fdout, -1);
                 /* server_loop _has_ closed ptyfd and fdout. */                  /* server_loop _has_ closed ptyfd and fdout. */
                 session_pty_cleanup(s);  
         }          }
 }  }
   
   /*
    * This is called to fork and execute a command.  If another command is
    * to be forced, execute that instead.
    */
   void
   do_exec(Session *s, const char *command)
   {
           if (forced_command) {
                   original_command = command;
                   command = forced_command;
                   debug("Forced command '%.900s'", command);
           }
   
           if (s->ttyfd != -1)
                   do_exec_pty(s, command);
           else
                   do_exec_no_pty(s, command);
   
           original_command = NULL;
   }
   
   
 /* administrative, login(1)-like work */  /* administrative, login(1)-like work */
 void  void
 do_login(Session *s, const char *command)  do_login(Session *s, const char *command)
Line 714 
Line 666 
 check_quietlogin(Session *s, const char *command)  check_quietlogin(Session *s, const char *command)
 {  {
         char buf[256];          char buf[256];
         struct passwd * pw = s->pw;          struct passwd *pw = s->pw;
         struct stat st;          struct stat st;
   
         /* Return 1 if .hushlogin exists or a command given. */          /* Return 1 if .hushlogin exists or a command given. */
Line 735 
Line 687 
  * Sets the value of the given variable in the environment.  If the variable   * Sets the value of the given variable in the environment.  If the variable
  * already exists, its value is overriden.   * already exists, its value is overriden.
  */   */
 void  static void
 child_set_env(char ***envp, u_int *envsizep, const char *name,  child_set_env(char ***envp, u_int *envsizep, const char *name,
               const char *value)                const char *value)
 {  {
Line 776 
Line 728 
  * Otherwise, it must consist of empty lines, comments (line starts with '#')   * Otherwise, it must consist of empty lines, comments (line starts with '#')
  * and assignments of the form name=value.  No other forms are allowed.   * and assignments of the form name=value.  No other forms are allowed.
  */   */
 void  static void
 read_environment_file(char ***env, u_int *envsize,  read_environment_file(char ***env, u_int *envsize,
                       const char *filename)                        const char *filename)
 {  {
Line 820 
Line 772 
 do_child(Session *s, const char *command)  do_child(Session *s, const char *command)
 {  {
         const char *shell, *hostname = NULL, *cp = NULL;          const char *shell, *hostname = NULL, *cp = NULL;
         struct passwd * pw = s->pw;          struct passwd *pw = s->pw;
         char buf[256];          char buf[256];
         char cmd[1024];          char cmd[1024];
         FILE *f = NULL;          FILE *f = NULL;
Line 829 
Line 781 
         extern char **environ;          extern char **environ;
         struct stat st;          struct stat st;
         char *argv[10];          char *argv[10];
         int do_xauth = s->auth_proto != NULL && s->auth_data != NULL;          int do_xauth;
   
           do_xauth =
               s->display != NULL && s->auth_proto != NULL && s->auth_data != NULL;
   
         /* remove hostkey from the child's memory */          /* remove hostkey from the child's memory */
         destroy_sensitive_data();          destroy_sensitive_data();
   
Line 896 
Line 851 
         shell = login_getcapstr(lc, "shell", (char *)shell, (char *)shell);          shell = login_getcapstr(lc, "shell", (char *)shell, (char *)shell);
 #endif  #endif
   
 #ifdef AFS  
         /* Try to get AFS tokens for the local cell. */  
         if (k_hasafs()) {  
                 char cell[64];  
   
                 if (k_afs_cell_of_file(pw->pw_dir, cell, sizeof(cell)) == 0)  
                         krb_afslog(cell, 0);  
   
                 krb_afslog(0, 0);  
         }  
 #endif /* AFS */  
   
         /* Initialize the environment. */          /* Initialize the environment. */
         envsize = 100;          envsize = 100;
         env = xmalloc(envsize * sizeof(char *));          env = xmalloc(envsize * sizeof(char *));
Line 963 
Line 906 
         if (original_command)          if (original_command)
                 child_set_env(&env, &envsize, "SSH_ORIGINAL_COMMAND",                  child_set_env(&env, &envsize, "SSH_ORIGINAL_COMMAND",
                     original_command);                      original_command);
   
 #ifdef KRB4  #ifdef KRB4
         {          if (s->authctxt->krb4_ticket_file)
                 extern char *ticket;                  child_set_env(&env, &envsize, "KRBTKFILE",
                                 s->authctxt->krb4_ticket_file);
                 if (ticket)  #endif
                         child_set_env(&env, &envsize, "KRBTKFILE", ticket);  #ifdef KRB5
         }          if (s->authctxt->krb5_ticket_file)
 #endif /* KRB4 */                  child_set_env(&env, &envsize, "KRB5CCNAME",
                                 s->authctxt->krb5_ticket_file);
         if (xauthfile)  #endif
                 child_set_env(&env, &envsize, "XAUTHORITY", xauthfile);  
         if (auth_get_socket_name() != NULL)          if (auth_get_socket_name() != NULL)
                 child_set_env(&env, &envsize, SSH_AUTHSOCKET_ENV_NAME,                  child_set_env(&env, &envsize, SSH_AUTHSOCKET_ENV_NAME,
                               auth_get_socket_name());                                auth_get_socket_name());
Line 1046 
Line 987 
          */           */
         environ = env;          environ = env;
   
   #ifdef AFS
           /* Try to get AFS tokens for the local cell. */
           if (k_hasafs()) {
                   char cell[64];
   
                   if (k_afs_cell_of_file(pw->pw_dir, cell, sizeof(cell)) == 0)
                           krb_afslog(cell, 0);
   
                   krb_afslog(0, 0);
           }
   #endif /* AFS */
   
         /*          /*
          * Run $HOME/.ssh/rc, /etc/sshrc, or xauth (whichever is found first           * Run $HOME/.ssh/rc, /etc/sshrc, or xauth (whichever is found first
          * in this order).           * in this order).
Line 1053 
Line 1006 
         if (!options.use_login) {          if (!options.use_login) {
                 /* ignore _PATH_SSH_USER_RC for subsystems */                  /* ignore _PATH_SSH_USER_RC for subsystems */
                 if (!s->is_subsystem && (stat(_PATH_SSH_USER_RC, &st) >= 0)) {                  if (!s->is_subsystem && (stat(_PATH_SSH_USER_RC, &st) >= 0)) {
                           snprintf(cmd, sizeof cmd, "%s -c '%s %s'",
                               shell, _PATH_BSHELL, _PATH_SSH_USER_RC);
                         if (debug_flag)                          if (debug_flag)
                                 fprintf(stderr, "Running %s %s\n", _PATH_BSHELL,                                  fprintf(stderr, "Running %s\n", cmd);
                                     _PATH_SSH_USER_RC);                          f = popen(cmd, "w");
                         f = popen(_PATH_BSHELL " " _PATH_SSH_USER_RC, "w");  
                         if (f) {                          if (f) {
                                 if (do_xauth)                                  if (do_xauth)
                                         fprintf(f, "%s %s\n", s->auth_proto,                                          fprintf(f, "%s %s\n", s->auth_proto,
Line 1133 
Line 1087 
                 if (!options.use_login) {                  if (!options.use_login) {
                         char buf[256];                          char buf[256];
   
                         /*  
                          * Check for mail if we have a tty and it was enabled  
                          * in server options.  
                          */  
                         if (s->ttyfd != -1 && options.check_mail) {  
                                 char *mailbox;  
                                 struct stat mailstat;  
   
                                 mailbox = getenv("MAIL");  
                                 if (mailbox != NULL) {  
                                         if (stat(mailbox, &mailstat) != 0 ||  
                                             mailstat.st_size == 0)  
                                                 printf("No mail.\n");  
                                         else if (mailstat.st_mtime < mailstat.st_atime)  
                                                 printf("You have mail.\n");  
                                         else  
                                                 printf("You have new mail.\n");  
                                 }  
                         }  
                         /* Start the shell.  Set initial character to '-'. */                          /* Start the shell.  Set initial character to '-'. */
                         buf[0] = '-';                          buf[0] = '-';
                         strncpy(buf + 1, cp, sizeof(buf) - 1);                          strncpy(buf + 1, cp, sizeof(buf) - 1);
Line 1170 
Line 1105 
                         /* Launch login(1). */                          /* Launch login(1). */
   
                         execl("/usr/bin/login", "login", "-h", hostname,                          execl("/usr/bin/login", "login", "-h", hostname,
                              "-p", "-f", "--", pw->pw_name, NULL);                               "-p", "-f", "--", pw->pw_name, (char *)NULL);
   
                         /* Login couldn't be executed, die. */                          /* Login couldn't be executed, die. */
   
Line 1200 
Line 1135 
                 debug("session_new: init");                  debug("session_new: init");
                 for(i = 0; i < MAX_SESSIONS; i++) {                  for(i = 0; i < MAX_SESSIONS; i++) {
                         sessions[i].used = 0;                          sessions[i].used = 0;
                         sessions[i].self = i;  
                 }                  }
                 did_init = 1;                  did_init = 1;
         }          }
Line 1212 
Line 1146 
                         s->ptyfd = -1;                          s->ptyfd = -1;
                         s->ttyfd = -1;                          s->ttyfd = -1;
                         s->used = 1;                          s->used = 1;
                           s->self = i;
                         debug("session_new: session %d", i);                          debug("session_new: session %d", i);
                         return s;                          return s;
                 }                  }
Line 1219 
Line 1154 
         return NULL;          return NULL;
 }  }
   
 void  static void
 session_dump(void)  session_dump(void)
 {  {
         int i;          int i;
Line 1235 
Line 1170 
 }  }
   
 int  int
 session_open(int chanid)  session_open(Authctxt *authctxt, int chanid)
 {  {
         Session *s = session_new();          Session *s = session_new();
         debug("session_open: channel %d", chanid);          debug("session_open: channel %d", chanid);
Line 1243 
Line 1178 
                 error("no more sessions");                  error("no more sessions");
                 return 0;                  return 0;
         }          }
         s->pw = auth_get_user();          s->authctxt = authctxt;
           s->pw = authctxt->pw;
         if (s->pw == NULL)          if (s->pw == NULL)
                 fatal("no user for session %d", s->self);                  fatal("no user for session %d", s->self);
         debug("session_open: session %d: link with channel %d", s->self, chanid);          debug("session_open: session %d: link with channel %d", s->self, chanid);
Line 1251 
Line 1187 
         return 1;          return 1;
 }  }
   
 Session *  static Session *
 session_by_channel(int id)  session_by_channel(int id)
 {  {
         int i;          int i;
Line 1267 
Line 1203 
         return NULL;          return NULL;
 }  }
   
 Session *  static Session *
 session_by_pid(pid_t pid)  session_by_pid(pid_t pid)
 {  {
         int i;          int i;
Line 1282 
Line 1218 
         return NULL;          return NULL;
 }  }
   
 int  static int
 session_window_change_req(Session *s)  session_window_change_req(Session *s)
 {  {
         s->col = packet_get_int();          s->col = packet_get_int();
Line 1294 
Line 1230 
         return 1;          return 1;
 }  }
   
 int  static int
 session_pty_req(Session *s)  session_pty_req(Session *s)
 {  {
         u_int len;          u_int len;
         int n_bytes;          int n_bytes;
   
         if (no_pty_flag)          if (no_pty_flag) {
                   debug("Allocating a pty not permitted for this authentication.");
                 return 0;                  return 0;
         if (s->ttyfd != -1)          }
           if (s->ttyfd != -1) {
                   packet_disconnect("Protocol error: you already have a pty.");
                 return 0;                  return 0;
           }
   
         s->term = packet_get_string(&len);          s->term = packet_get_string(&len);
         s->col = packet_get_int();  
         s->row = packet_get_int();          if (compat20) {
                   s->col = packet_get_int();
                   s->row = packet_get_int();
           } else {
                   s->row = packet_get_int();
                   s->col = packet_get_int();
           }
         s->xpixel = packet_get_int();          s->xpixel = packet_get_int();
         s->ypixel = packet_get_int();          s->ypixel = packet_get_int();
   
Line 1314 
Line 1261 
                 xfree(s->term);                  xfree(s->term);
                 s->term = NULL;                  s->term = NULL;
         }          }
   
         /* Allocate a pty and open it. */          /* Allocate a pty and open it. */
           debug("Allocating pty.");
         if (!pty_allocate(&s->ptyfd, &s->ttyfd, s->tty, sizeof(s->tty))) {          if (!pty_allocate(&s->ptyfd, &s->ttyfd, s->tty, sizeof(s->tty))) {
                 xfree(s->term);                  if (s->term)
                           xfree(s->term);
                 s->term = NULL;                  s->term = NULL;
                 s->ptyfd = -1;                  s->ptyfd = -1;
                 s->ttyfd = -1;                  s->ttyfd = -1;
Line 1324 
Line 1274 
                 return 0;                  return 0;
         }          }
         debug("session_pty_req: session %d alloc %s", s->self, s->tty);          debug("session_pty_req: session %d alloc %s", s->self, s->tty);
   
           /* for SSH1 the tty modes length is not given */
           if (!compat20)
                   n_bytes = packet_remaining();
           tty_parse_modes(s->ttyfd, &n_bytes);
   
         /*          /*
          * Add a cleanup function to clear the utmp entry and record logout           * Add a cleanup function to clear the utmp entry and record logout
          * time in case we call fatal() (e.g., the connection gets closed).           * time in case we call fatal() (e.g., the connection gets closed).
          */           */
         fatal_add_cleanup(pty_cleanup_proc, (void *)s);          fatal_add_cleanup(session_pty_cleanup, (void *)s);
         pty_setowner(s->pw, s->tty);          pty_setowner(s->pw, s->tty);
         /* Get window size from the packet. */  
           /* Set window size from the packet. */
         pty_change_window_size(s->ptyfd, s->row, s->col, s->xpixel, s->ypixel);          pty_change_window_size(s->ptyfd, s->row, s->col, s->xpixel, s->ypixel);
   
         /* Get tty modes from the packet. */  
         tty_parse_modes(s->ttyfd, &n_bytes);  
         packet_done();          packet_done();
   
         session_proctitle(s);          session_proctitle(s);
   
         return 1;          return 1;
 }  }
   
 int  static int
 session_subsystem_req(Session *s)  session_subsystem_req(Session *s)
 {  {
         u_int len;          u_int len;
Line 1357 
Line 1310 
                 if(strcmp(subsys, options.subsystem_name[i]) == 0) {                  if(strcmp(subsys, options.subsystem_name[i]) == 0) {
                         debug("subsystem: exec() %s", options.subsystem_command[i]);                          debug("subsystem: exec() %s", options.subsystem_command[i]);
                         s->is_subsystem = 1;                          s->is_subsystem = 1;
                         do_exec_no_pty(s, options.subsystem_command[i]);                          do_exec(s, options.subsystem_command[i]);
                         success = 1;                          success = 1;
                 }                  }
         }          }
Line 1369 
Line 1322 
         return success;          return success;
 }  }
   
 int  static int
 session_x11_req(Session *s)  session_x11_req(Session *s)
 {  {
         int fd;          int success;
         if (no_x11_forwarding_flag) {  
                 debug("X11 forwarding disabled in user configuration file.");  
                 return 0;  
         }  
         if (!options.x11_forwarding) {  
                 debug("X11 forwarding disabled in server configuration file.");  
                 return 0;  
         }  
         if (xauthfile != NULL) {  
                 debug("X11 fwd already started.");  
                 return 0;  
         }  
   
         debug("Received request for X11 forwarding with auth spoofing.");  
         if (s->display != NULL)  
                 packet_disconnect("Protocol error: X11 display already set.");  
   
         s->single_connection = packet_get_char();          s->single_connection = packet_get_char();
         s->auth_proto = packet_get_string(NULL);          s->auth_proto = packet_get_string(NULL);
         s->auth_data = packet_get_string(NULL);          s->auth_data = packet_get_string(NULL);
         s->screen = packet_get_int();          s->screen = packet_get_int();
         packet_done();          packet_done();
   
         s->display = x11_create_display_inet(s->screen, options.x11_display_offset);          success = session_setup_x11fwd(s);
         if (s->display == NULL) {          if (!success) {
                 xfree(s->auth_proto);                  xfree(s->auth_proto);
                 xfree(s->auth_data);                  xfree(s->auth_data);
                 return 0;                  s->auth_proto = NULL;
                   s->auth_data = NULL;
         }          }
         xauthfile = xmalloc(MAXPATHLEN);          return success;
         strlcpy(xauthfile, "/tmp/ssh-XXXXXXXX", MAXPATHLEN);  
         temporarily_use_uid(s->pw);  
         if (mkdtemp(xauthfile) == NULL) {  
                 restore_uid();  
                 error("private X11 dir: mkdtemp %s failed: %s",  
                     xauthfile, strerror(errno));  
                 xfree(xauthfile);  
                 xauthfile = NULL;  
                 xfree(s->auth_proto);  
                 xfree(s->auth_data);  
                 /* XXXX remove listening channels */  
                 return 0;  
         }  
         strlcat(xauthfile, "/cookies", MAXPATHLEN);  
         fd = open(xauthfile, O_RDWR|O_CREAT|O_EXCL, 0600);  
         if (fd >= 0)  
                 close(fd);  
         restore_uid();  
         fatal_add_cleanup(xauthfile_cleanup_proc, s);  
         return 1;  
 }  }
   
 int  static int
 session_shell_req(Session *s)  session_shell_req(Session *s)
 {  {
         /* if forced_command == NULL, the shell is execed */  
         char *shell = forced_command;  
         packet_done();          packet_done();
         if (s->ttyfd == -1)          do_exec(s, NULL);
                 do_exec_no_pty(s, shell);  
         else  
                 do_exec_pty(s, shell);  
         return 1;          return 1;
 }  }
   
 int  static int
 session_exec_req(Session *s)  session_exec_req(Session *s)
 {  {
         u_int len;          u_int len;
         char *command = packet_get_string(&len);          char *command = packet_get_string(&len);
         packet_done();          packet_done();
         if (forced_command) {          do_exec(s, command);
                 original_command = command;          xfree(command);
                 command = forced_command;  
                 debug("Forced command '%.500s'", forced_command);  
         }  
         if (s->ttyfd == -1)  
                 do_exec_no_pty(s, command);  
         else  
                 do_exec_pty(s, command);  
         if (forced_command == NULL)  
                 xfree(command);  
         return 1;          return 1;
 }  }
   
 int  static int
 session_auth_agent_req(Session *s)  session_auth_agent_req(Session *s)
 {  {
         static int called = 0;          static int called = 0;
Line 1547 
Line 1451 
             1);              1);
 }  }
   
 void  /*
 session_pty_cleanup(Session *s)   * Function to perform pty cleanup. Also called if we get aborted abnormally
    * (e.g., due to a dropped connection).
    */
   static void
   session_pty_cleanup(void *session)
 {  {
         if (s == NULL || s->ttyfd == -1)          Session *s = session;
   
           if (s == NULL) {
                   error("session_pty_cleanup: no session");
                 return;                  return;
           }
           if (s->ttyfd == -1)
                   return;
   
         debug("session_pty_cleanup: session %d release %s", s->self, s->tty);          debug("session_pty_cleanup: session %d release %s", s->self, s->tty);
   
         /* Cancel the cleanup function. */  
         fatal_remove_cleanup(pty_cleanup_proc, (void *)s);  
   
         /* Record that the user has logged out. */          /* Record that the user has logged out. */
         record_logout(s->pid, s->tty);          if (s->pid != 0)
                   record_logout(s->pid, s->tty);
   
         /* Release the pseudo-tty. */          /* Release the pseudo-tty. */
         pty_release(s->tty);          pty_release(s->tty);
Line 1573 
Line 1485 
                 error("close(s->ptymaster): %s", strerror(errno));                  error("close(s->ptymaster): %s", strerror(errno));
 }  }
   
 void  static void
 session_exit_message(Session *s, int status)  session_exit_message(Session *s, int status)
 {  {
         Channel *c;          Channel *c;
Line 1581 
Line 1493 
                 fatal("session_close: no session");                  fatal("session_close: no session");
         c = channel_lookup(s->chanid);          c = channel_lookup(s->chanid);
         if (c == NULL)          if (c == NULL)
                 fatal("session_close: session %d: no channel %d",                  fatal("session_exit_message: session %d: no channel %d",
                     s->self, s->chanid);                      s->self, s->chanid);
         debug("session_exit_message: session %d channel %d pid %d",          debug("session_exit_message: session %d channel %d pid %d",
             s->self, s->chanid, s->pid);              s->self, s->chanid, s->pid);
Line 1618 
Line 1530 
         s->chanid = -1;          s->chanid = -1;
 }  }
   
 void  static void
 session_free(Session *s)  session_close(Session *s)
 {  {
         debug("session_free: session %d pid %d", s->self, s->pid);          debug("session_close: session %d pid %d", s->self, s->pid);
           if (s->ttyfd != -1) {
                   fatal_remove_cleanup(session_pty_cleanup, (void *)s);
                   session_pty_cleanup(s);
           }
         if (s->term)          if (s->term)
                 xfree(s->term);                  xfree(s->term);
         if (s->display)          if (s->display)
Line 1631 
Line 1547 
         if (s->auth_proto)          if (s->auth_proto)
                 xfree(s->auth_proto);                  xfree(s->auth_proto);
         s->used = 0;          s->used = 0;
 }  
   
 void  
 session_close(Session *s)  
 {  
         session_pty_cleanup(s);  
         session_free(s);  
         session_proctitle(s);          session_proctitle(s);
 }  }
   
Line 1646 
Line 1555 
 {  {
         Session *s = session_by_pid(pid);          Session *s = session_by_pid(pid);
         if (s == NULL) {          if (s == NULL) {
                 debug("session_close_by_pid: no session for pid %d", s->pid);                  debug("session_close_by_pid: no session for pid %d", pid);
                 return;                  return;
         }          }
         if (s->chanid != -1)          if (s->chanid != -1)
Line 1654 
Line 1563 
         session_close(s);          session_close(s);
 }  }
   
   int
   session_have_children(void)
   {
           int i;
   
           for(i = 0; i < MAX_SESSIONS; i++) {
                   Session *s = &sessions[i];
                   if (s->used && s->pid != -1) {
                           debug("session_have_children: id %d pid %d", i, s->pid);
                           return 1;
                   }
           }
           debug("session_have_children: no more children");
           return 0;
   }
   
 /*  /*
  * this is called when a channel dies before   * this is called when a channel dies before
  * the session 'child' itself dies   * the session 'child' itself dies
Line 1682 
Line 1607 
         }          }
 }  }
   
 char *  static char *
 session_tty_list(void)  session_tty_list(void)
 {  {
         static char buf[1024];          static char buf[1024];
Line 1710 
Line 1635 
                 setproctitle("%s@%s", s->pw->pw_name, session_tty_list());                  setproctitle("%s@%s", s->pw->pw_name, session_tty_list());
 }  }
   
 void  int
 do_authenticated2(Authctxt *authctxt)  session_setup_x11fwd(Session *s)
 {  {
           struct stat st;
   
         server_loop2();          if (no_x11_forwarding_flag) {
         if (xauthfile)                  packet_send_debug("X11 forwarding disabled in user configuration file.");
                 xauthfile_cleanup_proc(NULL);                  return 0;
           }
           if (!options.x11_forwarding) {
                   debug("X11 forwarding disabled in server configuration file.");
                   return 0;
           }
           if (!options.xauth_location ||
               (stat(options.xauth_location, &st) == -1)) {
                   packet_send_debug("No xauth program; cannot forward with spoofing.");
                   return 0;
           }
           if (options.use_login) {
                   packet_send_debug("X11 forwarding disabled; "
                       "not compatible with UseLogin=yes.");
                   return 0;
           }
           if (s->display != NULL) {
                   debug("X11 display already set.");
                   return 0;
           }
           s->display = x11_create_display_inet(s->screen, options.x11_display_offset);
           if (s->display == NULL) {
                   debug("x11_create_display_inet failed.");
                   return 0;
           }
           return 1;
   }
   
   static void
   do_authenticated2(Authctxt *authctxt)
   {
           server_loop2(authctxt);
 }  }
Legend:
Removed from v.1.74  
changed lines
  Added in v.1.74.2.2