1 files changed, 108 insertions, 115 deletions

diff --git a/session.c b/session.c
index cd03fd423..4bccb62d1 100644
--- a/session.c
+++ b/session.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: session.c,v 1.291 2017/08/18 05:36:45 djm Exp $ */
+/* $OpenBSD: session.c,v 1.292 2017/09/12 06:32:07 djm Exp $ */
 /*
  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
  *                    All rights reserved
@@ -113,24 +113,24 @@
 /* func */
 
 Session *session_new(void);
-void    session_set_fds(Session *, int, int, int, int, int);
+void    session_set_fds(struct ssh *, Session *, int, int, int, int, int);
 void    session_pty_cleanup(Session *);
 void    session_proctitle(Session *);
-int     session_setup_x11fwd(Session *);
-int     do_exec_pty(Session *, const char *);
-int     do_exec_no_pty(Session *, const char *);
-int     do_exec(Session *, const char *);
-void    do_login(Session *, const char *);
+int     session_setup_x11fwd(struct ssh *, Session *);
+int     do_exec_pty(struct ssh *, Session *, const char *);
+int     do_exec_no_pty(struct ssh *, Session *, const char *);
+int     do_exec(struct ssh *, Session *, const char *);
+void    do_login(struct ssh *, Session *, const char *);
+void    do_child(struct ssh *, Session *, const char *);
 #ifdef LOGIN_NEEDS_UTMPX
 static void     do_pre_login(Session *s);
 #endif
-void    do_child(Session *, const char *);
 void    do_motd(void);
 int     check_quietlogin(Session *, const char *);
 
-static void do_authenticated2(Authctxt *);
+static void do_authenticated2(struct ssh *, Authctxt *);
 
-static int session_pty_req(Session *);
+static int session_pty_req(struct ssh *, Session *);
 
 /* import */
 extern ServerOptions options;
@@ -183,7 +183,7 @@ auth_sock_cleanup_proc(struct passwd *pw)
 }
 
 static int
-auth_input_request_forwarding(struct passwd * pw)
+auth_input_request_forwarding(struct ssh *ssh, struct passwd * pw)
 {
         Channel *nc;
         int sock = -1;
@@ -223,7 +223,7 @@ auth_input_request_forwarding(struct passwd * pw)
                 goto authsock_err;
 
         /* Allocate a channel for the authentication agent socket. */
-        nc = channel_new("auth socket",
+        nc = channel_new(ssh, "auth socket",
             SSH_CHANNEL_AUTH_SOCKET, sock, sock, -1,
             CHAN_X11_WINDOW_DEFAULT, CHAN_X11_PACKET_DEFAULT,
             0, "auth socket", 1);
@@ -288,7 +288,7 @@ prepare_auth_info_file(struct passwd *pw, struct sshbuf *info)
 }
 
 void
-do_authenticated(Authctxt *authctxt)
+do_authenticated(struct ssh *ssh, Authctxt *authctxt)
 {
         setproctitle("%s", authctxt->pw->pw_name);
 
@@ -296,17 +296,17 @@ do_authenticated(Authctxt *authctxt)
         /* XXX - streamlocal? */
         if (no_port_forwarding_flag || options.disable_forwarding ||
             (options.allow_tcp_forwarding & FORWARD_LOCAL) == 0)
-                channel_disable_adm_local_opens();
+                channel_disable_adm_local_opens(ssh);
         else
-                channel_permit_all_opens();
+                channel_permit_all_opens(ssh);
 
         auth_debug_send();
 
         prepare_auth_info_file(authctxt->pw, authctxt->session_info);
 
-        do_authenticated2(authctxt);
+        do_authenticated2(ssh, authctxt);
 
-        do_cleanup(authctxt);
+        do_cleanup(ssh, authctxt);
 }
 
 /* Check untrusted xauth strings for metacharacters */
@@ -331,7 +331,7 @@ xauth_valid_string(const char *s)
  * setting up file descriptors and such.
  */
 int
-do_exec_no_pty(Session *s, const char *command)
+do_exec_no_pty(struct ssh *ssh, Session *s, const char *command)
 {
         pid_t pid;
 
@@ -456,7 +456,7 @@ do_exec_no_pty(Session *s, const char *command)
 #endif
 
                 /* Do processing for the child (exec command etc). */
-                do_child(s, command);
+                do_child(ssh, s, command);
                 /* NOTREACHED */
         default:
                 break;
@@ -487,7 +487,7 @@ do_exec_no_pty(Session *s, const char *command)
         close(pout[1]);
         close(perr[1]);
 
-        session_set_fds(s, pin[1], pout[0], perr[0],
+        session_set_fds(ssh, s, pin[1], pout[0], perr[0],
             s->is_subsystem, 0);
 #else
         /* We are the parent.  Close the child sides of the socket pairs. */
@@ -511,7 +511,7 @@ do_exec_no_pty(Session *s, const char *command)
  * lastlog, and other such operations.
  */
 int
-do_exec_pty(Session *s, const char *command)
+do_exec_pty(struct ssh *ssh, Session *s, const char *command)
 {
         int fdout, ptyfd, ttyfd, ptymaster;
         pid_t pid;
@@ -580,13 +580,13 @@ do_exec_pty(Session *s, const char *command)
                 cray_init_job(s->pw); /* set up cray jid and tmpdir */
 #endif /* _UNICOS */
 #ifndef HAVE_OSF_SIA
-                do_login(s, command);
+                do_login(ssh, s, command);
 #endif
                 /*
                  * Do common processing for the child, such as execing
                  * the command.
                  */
-                do_child(s, command);
+                do_child(ssh, s, command);
                 /* NOTREACHED */
         default:
                 break;
@@ -608,7 +608,7 @@ do_exec_pty(Session *s, const char *command)
         s->ptymaster = ptymaster;
         packet_set_interactive(1, 
             options.ip_qos_interactive, options.ip_qos_bulk);
-        session_set_fds(s, ptyfd, fdout, -1, 1, 1);
+        session_set_fds(ssh, s, ptyfd, fdout, -1, 1, 1);
         return 0;
 }
 
@@ -646,9 +646,8 @@ do_pre_login(Session *s)
  * to be forced, execute that instead.
  */
 int
-do_exec(Session *s, const char *command)
+do_exec(struct ssh *ssh, Session *s, const char *command)
 {
-        struct ssh *ssh = active_state; /* XXX */
         int ret;
         const char *forced = NULL, *tty = NULL;
         char session_type[1024];
@@ -707,9 +706,9 @@ do_exec(Session *s, const char *command)
         }
 #endif
         if (s->ttyfd != -1)
-                ret = do_exec_pty(s, command);
+                ret = do_exec_pty(ssh, s, command);
         else
-                ret = do_exec_no_pty(s, command);
+                ret = do_exec_no_pty(ssh, s, command);
 
         original_command = NULL;
 
@@ -725,9 +724,8 @@ do_exec(Session *s, const char *command)
 
 /* administrative, login(1)-like work */
 void
-do_login(Session *s, const char *command)
+do_login(struct ssh *ssh, Session *s, const char *command)
 {
-        struct ssh *ssh = active_state; /* XXX */
         socklen_t fromlen;
         struct sockaddr_storage from;
         struct passwd * pw = s->pw;
@@ -960,9 +958,8 @@ copy_environment(char **source, char ***env, u_int *envsize)
 }
 
 static char **
-do_setup_env(Session *s, const char *shell)
+do_setup_env(struct ssh *ssh, Session *s, const char *shell)
 {
-        struct ssh *ssh = active_state; /* XXX */
         char buf[256];
         u_int i, envsize;
         char **env, *laddr;
@@ -1421,7 +1418,7 @@ do_pwchange(Session *s)
 }
 
 static void
-child_close_fds(void)
+child_close_fds(struct ssh *ssh)
 {
         extern int auth_sock;
 
@@ -1441,7 +1438,7 @@ child_close_fds(void)
          * open in the parent.
          */
         /* XXX better use close-on-exec? -markus */
-        channel_close_all();
+        channel_close_all(ssh);
 
         /*
          * Close any extra file descriptors.  Note that there may still be
@@ -1465,7 +1462,7 @@ child_close_fds(void)
  */
 #define ARGV_MAX 10
 void
-do_child(Session *s, const char *command)
+do_child(struct ssh *ssh, Session *s, const char *command)
 {
         extern char **environ;
         char **env;
@@ -1481,7 +1478,7 @@ do_child(Session *s, const char *command)
         /* Force a password change */
         if (s->authctxt->force_pwchange) {
                 do_setusercontext(pw);
-                child_close_fds();
+                child_close_fds(ssh);
                 do_pwchange(s);
                 exit(1);
         }
@@ -1530,7 +1527,7 @@ do_child(Session *s, const char *command)
          * Make sure $SHELL points to the shell from the password file,
          * even if shell is overridden from login.conf
          */
-        env = do_setup_env(s, shell);
+        env = do_setup_env(ssh, s, shell);
 
 #ifdef HAVE_LOGIN_CAP
         shell = login_getcapstr(lc, "shell", (char *)shell, (char *)shell);
@@ -1543,7 +1540,7 @@ do_child(Session *s, const char *command)
          * closed before building the environment, as we call
          * ssh_remote_ipaddr there.
          */
-        child_close_fds();
+        child_close_fds(ssh);
 
         /*
          * Must take new environment into use so that .ssh/rc,
@@ -1840,7 +1837,7 @@ session_by_pid(pid_t pid)
 }
 
 static int
-session_window_change_req(Session *s)
+session_window_change_req(struct ssh *ssh, Session *s)
 {
         s->col = packet_get_int();
         s->row = packet_get_int();
@@ -1852,7 +1849,7 @@ session_window_change_req(Session *s)
 }
 
 static int
-session_pty_req(Session *s)
+session_pty_req(struct ssh *ssh, Session *s)
 {
         u_int len;
         int n_bytes;
@@ -1905,7 +1902,7 @@ session_pty_req(Session *s)
 }
 
 static int
-session_subsystem_req(Session *s)
+session_subsystem_req(struct ssh *ssh, Session *s)
 {
         struct stat st;
         u_int len;
@@ -1932,7 +1929,7 @@ session_subsystem_req(Session *s)
                                 s->is_subsystem = SUBSYSTEM_EXT;
                                 debug("subsystem: exec() %s", cmd);
                         }
-                        success = do_exec(s, cmd) == 0;
+                        success = do_exec(ssh, s, cmd) == 0;
                         break;
                 }
         }
@@ -1945,7 +1942,7 @@ session_subsystem_req(Session *s)
 }
 
 static int
-session_x11_req(Session *s)
+session_x11_req(struct ssh *ssh, Session *s)
 {
         int success;
 
@@ -1962,7 +1959,7 @@ session_x11_req(Session *s)
 
         if (xauth_valid_string(s->auth_proto) &&
             xauth_valid_string(s->auth_data))
-                success = session_setup_x11fwd(s);
+                success = session_setup_x11fwd(ssh, s);
         else {
                 success = 0;
                 error("Invalid X11 forwarding data");
@@ -1977,26 +1974,26 @@ session_x11_req(Session *s)
 }
 
 static int
-session_shell_req(Session *s)
+session_shell_req(struct ssh *ssh, Session *s)
 {
         packet_check_eom();
-        return do_exec(s, NULL) == 0;
+        return do_exec(ssh, s, NULL) == 0;
 }
 
 static int
-session_exec_req(Session *s)
+session_exec_req(struct ssh *ssh, Session *s)
 {
         u_int len, success;
 
         char *command = packet_get_string(&len);
         packet_check_eom();
-        success = do_exec(s, command) == 0;
+        success = do_exec(ssh, s, command) == 0;
         free(command);
         return success;
 }
 
 static int
-session_break_req(Session *s)
+session_break_req(struct ssh *ssh, Session *s)
 {
 
         packet_get_int();       /* ignored */
@@ -2008,7 +2005,7 @@ session_break_req(Session *s)
 }
 
 static int
-session_env_req(Session *s)
+session_env_req(struct ssh *ssh, Session *s)
 {
         char *name, *val;
         u_int name_len, val_len, i;
@@ -2043,7 +2040,7 @@ session_env_req(Session *s)
 }
 
 static int
-session_auth_agent_req(Session *s)
+session_auth_agent_req(struct ssh *ssh, Session *s)
 {
         static int called = 0;
         packet_check_eom();
@@ -2055,22 +2052,21 @@ session_auth_agent_req(Session *s)
                 return 0;
         } else {
                 called = 1;
-                return auth_input_request_forwarding(s->pw);
+                return auth_input_request_forwarding(ssh, s->pw);
         }
 }
 
 int
-session_input_channel_req(Channel *c, const char *rtype)
+session_input_channel_req(struct ssh *ssh, Channel *c, const char *rtype)
 {
         int success = 0;
         Session *s;
 
         if ((s = session_by_channel(c->self)) == NULL) {
-                logit("session_input_channel_req: no session %d req %.100s",
-                    c->self, rtype);
+                logit("%s: no session %d req %.100s", __func__, c->self, rtype);
                 return 0;
         }
-        debug("session_input_channel_req: session %d req %s", s->self, rtype);
+        debug("%s: session %d req %s", __func__, s->self, rtype);
 
         /*
          * a session is in LARVAL state until a shell, a command
@@ -2078,33 +2074,33 @@ session_input_channel_req(Channel *c, const char *rtype)
          */
         if (c->type == SSH_CHANNEL_LARVAL) {
                 if (strcmp(rtype, "shell") == 0) {
-                        success = session_shell_req(s);
+                        success = session_shell_req(ssh, s);
                 } else if (strcmp(rtype, "exec") == 0) {
-                        success = session_exec_req(s);
+                        success = session_exec_req(ssh, s);
                 } else if (strcmp(rtype, "pty-req") == 0) {
-                        success = session_pty_req(s);
+                        success = session_pty_req(ssh, s);
                 } else if (strcmp(rtype, "x11-req") == 0) {
-                        success = session_x11_req(s);
+                        success = session_x11_req(ssh, s);
                 } else if (strcmp(rtype, "auth-agent-req@openssh.com") == 0) {
-                        success = session_auth_agent_req(s);
+                        success = session_auth_agent_req(ssh, s);
                 } else if (strcmp(rtype, "subsystem") == 0) {
-                        success = session_subsystem_req(s);
+                        success = session_subsystem_req(ssh, s);
                 } else if (strcmp(rtype, "env") == 0) {
-                        success = session_env_req(s);
+                        success = session_env_req(ssh, s);
                 }
         }
         if (strcmp(rtype, "window-change") == 0) {
-                success = session_window_change_req(s);
+                success = session_window_change_req(ssh, s);
         } else if (strcmp(rtype, "break") == 0) {
-                success = session_break_req(s);
+                success = session_break_req(ssh, s);
         }
 
         return success;
 }
 
 void
-session_set_fds(Session *s, int fdin, int fdout, int fderr, int ignore_fderr,
-    int is_tty)
+session_set_fds(struct ssh *ssh, Session *s,
+    int fdin, int fdout, int fderr, int ignore_fderr, int is_tty)
 {
         /*
          * now that have a child and a pipe to the child,
@@ -2112,7 +2108,7 @@ session_set_fds(Session *s, int fdin, int fdout, int fderr, int ignore_fderr,
          */
         if (s->chanid == -1)
                 fatal("no channel for session %d", s->self);
-        channel_set_fds(s->chanid,
+        channel_set_fds(ssh, s->chanid,
             fdout, fdin, fderr,
             ignore_fderr ? CHAN_EXTENDED_IGNORE : CHAN_EXTENDED_READ,
             1, is_tty, CHAN_SES_WINDOW_DEFAULT);
@@ -2183,40 +2179,40 @@ sig2name(int sig)
 }
 
 static void
-session_close_x11(int id)
+session_close_x11(struct ssh *ssh, int id)
 {
         Channel *c;
 
-        if ((c = channel_by_id(id)) == NULL) {
-                debug("session_close_x11: x11 channel %d missing", id);
+        if ((c = channel_by_id(ssh, id)) == NULL) {
+                debug("%s: x11 channel %d missing", __func__, id);
         } else {
                 /* Detach X11 listener */
-                debug("session_close_x11: detach x11 channel %d", id);
-                channel_cancel_cleanup(id);
+                debug("%s: detach x11 channel %d", __func__, id);
+                channel_cancel_cleanup(ssh, id);
                 if (c->ostate != CHAN_OUTPUT_CLOSED)
-                        chan_mark_dead(c);
+                        chan_mark_dead(ssh, c);
         }
 }
 
 static void
-session_close_single_x11(int id, void *arg)
+session_close_single_x11(struct ssh *ssh, int id, void *arg)
 {
         Session *s;
         u_int i;
 
-        debug3("session_close_single_x11: channel %d", id);
-        channel_cancel_cleanup(id);
+        debug3("%s: channel %d", __func__, id);
+        channel_cancel_cleanup(ssh, id);
         if ((s = session_by_x11_channel(id)) == NULL)
-                fatal("session_close_single_x11: no x11 channel %d", id);
+                fatal("%s: no x11 channel %d", __func__, id);
         for (i = 0; s->x11_chanids[i] != -1; i++) {
-                debug("session_close_single_x11: session %d: "
-                    "closing channel %d", s->self, s->x11_chanids[i]);
+                debug("%s: session %d: closing channel %d",
+                    __func__, s->self, s->x11_chanids[i]);
                 /*
                  * The channel "id" is already closing, but make sure we
                  * close all of its siblings.
                  */
                 if (s->x11_chanids[i] != id)
-                        session_close_x11(s->x11_chanids[i]);
+                        session_close_x11(ssh, s->x11_chanids[i]);
         }
         free(s->x11_chanids);
         s->x11_chanids = NULL;
@@ -2231,22 +2227,22 @@ session_close_single_x11(int id, void *arg)
 }
 
 static void
-session_exit_message(Session *s, int status)
+session_exit_message(struct ssh *ssh, Session *s, int status)
 {
         Channel *c;
 
-        if ((c = channel_lookup(s->chanid)) == NULL)
-                fatal("session_exit_message: session %d: no channel %d",
-                    s->self, s->chanid);
-        debug("session_exit_message: session %d channel %d pid %ld",
-            s->self, s->chanid, (long)s->pid);
+        if ((c = channel_lookup(ssh, s->chanid)) == NULL)
+                fatal("%s: session %d: no channel %d",
+                    __func__, s->self, s->chanid);
+        debug("%s: session %d channel %d pid %ld",
+            __func__, s->self, s->chanid, (long)s->pid);
 
         if (WIFEXITED(status)) {
-                channel_request_start(s->chanid, "exit-status", 0);
+                channel_request_start(ssh, s->chanid, "exit-status", 0);
                 packet_put_int(WEXITSTATUS(status));
                 packet_send();
         } else if (WIFSIGNALED(status)) {
-                channel_request_start(s->chanid, "exit-signal", 0);
+                channel_request_start(ssh, s->chanid, "exit-signal", 0);
                 packet_put_cstring(sig2name(WTERMSIG(status)));
 #ifdef WCOREDUMP
                 packet_put_char(WCOREDUMP(status)? 1 : 0);
@@ -2262,14 +2258,14 @@ session_exit_message(Session *s, int status)
         }
 
         /* disconnect channel */
-        debug("session_exit_message: release channel %d", s->chanid);
+        debug("%s: release channel %d", __func__, s->chanid);
 
         /*
          * Adjust cleanup callback attachment to send close messages when
          * the channel gets EOF. The session will be then be closed
          * by session_close_by_channel when the childs close their fds.
          */
-        channel_register_cleanup(c->self, session_close_by_channel, 1);
+        channel_register_cleanup(ssh, c->self, session_close_by_channel, 1);
 
         /*
          * emulate a write failure with 'chan_write_failed', nobody will be
@@ -2278,13 +2274,12 @@ session_exit_message(Session *s, int status)
          * be some more data waiting in the pipe.
          */
         if (c->ostate != CHAN_OUTPUT_CLOSED)
-                chan_write_failed(c);
+                chan_write_failed(ssh, c);
 }
 
 void
-session_close(Session *s)
+session_close(struct ssh *ssh, Session *s)
 {
-        struct ssh *ssh = active_state; /* XXX */
         u_int i;
 
         verbose("Close session: user %s from %.200s port %d id %d",
@@ -2314,16 +2309,15 @@ session_close(Session *s)
 }
 
 void
-session_close_by_pid(pid_t pid, int status)
+session_close_by_pid(struct ssh *ssh, pid_t pid, int status)
 {
         Session *s = session_by_pid(pid);
         if (s == NULL) {
-                debug("session_close_by_pid: no session for pid %ld",
-                    (long)pid);
+                debug("%s: no session for pid %ld", __func__, (long)pid);
                 return;
         }
         if (s->chanid != -1)
-                session_exit_message(s, status);
+                session_exit_message(ssh, s, status);
         if (s->ttyfd != -1)
                 session_pty_cleanup(s);
         s->pid = 0;
@@ -2334,19 +2328,18 @@ session_close_by_pid(pid_t pid, int status)
  * the session 'child' itself dies
  */
 void
-session_close_by_channel(int id, void *arg)
+session_close_by_channel(struct ssh *ssh, int id, void *arg)
 {
         Session *s = session_by_channel(id);
         u_int i;
 
         if (s == NULL) {
-                debug("session_close_by_channel: no session for id %d", id);
+                debug("%s: no session for id %d", __func__, id);
                 return;
         }
-        debug("session_close_by_channel: channel %d child %ld",
-            id, (long)s->pid);
+        debug("%s: channel %d child %ld", __func__, id, (long)s->pid);
         if (s->pid != 0) {
-                debug("session_close_by_channel: channel %d: has child", id);
+                debug("%s: channel %d: has child", __func__, id);
                 /*
                  * delay detach of session, but release pty, since
                  * the fd's to the child are already closed
@@ -2356,22 +2349,22 @@ session_close_by_channel(int id, void *arg)
                 return;
         }
         /* detach by removing callback */
-        channel_cancel_cleanup(s->chanid);
+        channel_cancel_cleanup(ssh, s->chanid);
 
         /* Close any X11 listeners associated with this session */
         if (s->x11_chanids != NULL) {
                 for (i = 0; s->x11_chanids[i] != -1; i++) {
-                        session_close_x11(s->x11_chanids[i]);
+                        session_close_x11(ssh, s->x11_chanids[i]);
                         s->x11_chanids[i] = -1;
                 }
         }
 
         s->chanid = -1;
-        session_close(s);
+        session_close(ssh, s);
 }
 
 void
-session_destroy_all(void (*closefunc)(Session *))
+session_destroy_all(struct ssh *ssh, void (*closefunc)(Session *))
 {
         int i;
         for (i = 0; i < sessions_nalloc; i++) {
@@ -2380,7 +2373,7 @@ session_destroy_all(void (*closefunc)(Session *))
                         if (closefunc != NULL)
                                 closefunc(s);
                         else
-                                session_close(s);
+                                session_close(ssh, s);
                 }
         }
 }
@@ -2423,7 +2416,7 @@ session_proctitle(Session *s)
 }
 
 int
-session_setup_x11fwd(Session *s)
+session_setup_x11fwd(struct ssh *ssh, Session *s)
 {
         struct stat st;
         char display[512], auth_display[512];
@@ -2447,14 +2440,14 @@ session_setup_x11fwd(Session *s)
                 debug("X11 display already set.");
                 return 0;
         }
-        if (x11_create_display_inet(options.x11_display_offset,
+        if (x11_create_display_inet(ssh, options.x11_display_offset,
             options.x11_use_localhost, s->single_connection,
             &s->display_number, &s->x11_chanids) == -1) {
                 debug("x11_create_display_inet failed.");
                 return 0;
         }
         for (i = 0; s->x11_chanids[i] != -1; i++) {
-                channel_register_cleanup(s->x11_chanids[i],
+                channel_register_cleanup(ssh, s->x11_chanids[i],
                     session_close_single_x11, 0);
         }
 
@@ -2499,13 +2492,13 @@ session_setup_x11fwd(Session *s)
 }
 
 static void
-do_authenticated2(Authctxt *authctxt)
+do_authenticated2(struct ssh *ssh, Authctxt *authctxt)
 {
-        server_loop2(authctxt);
+        server_loop2(ssh, authctxt);
 }
 
 void
-do_cleanup(Authctxt *authctxt)
+do_cleanup(struct ssh *ssh, Authctxt *authctxt)
 {
         static int called = 0;
 
@@ -2561,7 +2554,7 @@ do_cleanup(Authctxt *authctxt)
          * or if running in monitor.
          */
         if (!use_privsep || mm_is_monitor())
-                session_destroy_all(session_pty_cleanup2);
+                session_destroy_all(ssh, session_pty_cleanup2);
 }
 
 /* Return a name for the remote host that fits inside utmp_size */