crypto/openssh-4/session.c

   1 /*
   2  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   3  *                    All rights reserved
   4  *
   5  * As far as I am concerned, the code I have written for this software
   6  * can be used freely for any purpose.  Any derived versions of this
   7  * software must be clearly marked as such, and if the derived work is
   8  * incompatible with the protocol description in the RFC file, it must be
   9  * called by a name other than "ssh" or "Secure Shell".
  10  *
  11  * SSH2 support by Markus Friedl.
  12  * Copyright (c) 2000, 2001 Markus Friedl.  All rights reserved.
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions
  16  * are met:
  17  * 1. Redistributions of source code must retain the above copyright
  18  *    notice, this list of conditions and the following disclaimer.
  19  * 2. Redistributions in binary form must reproduce the above copyright
  20  *    notice, this list of conditions and the following disclaimer in the
  21  *    documentation and/or other materials provided with the distribution.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  25  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  26  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  28  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 #include "includes.h"
  36 RCSID("$OpenBSD: session.c,v 1.191 2005/12/24 02:27:41 djm Exp $");
  37
  38 #include "ssh.h"
  39 #include "ssh1.h"
  40 #include "ssh2.h"
  41 #include "xmalloc.h"
  42 #include "sshpty.h"
  43 #include "packet.h"
  44 #include "buffer.h"
  45 #include "match.h"
  46 #include "uidswap.h"
  47 #include "compat.h"
  48 #include "channels.h"
  49 #include "bufaux.h"
  50 #include "auth.h"
  51 #include "auth-options.h"
  52 #include "pathnames.h"
  53 #include "log.h"
  54 #include "servconf.h"
  55 #include "sshlogin.h"
  56 #include "serverloop.h"
  57 #include "canohost.h"
  58 #include "session.h"
  59 #include "kex.h"
  60 #include "monitor_wrap.h"
  61
  62 #if defined(KRB5) && defined(USE_AFS)
  63 #include <kafs.h>
  64 #endif
  65
  66 #ifdef GSSAPI
  67 #include "ssh-gss.h"
  68 #endif
  69
  70 /* func */
  71
  72 Session *session_new(void);
  73 void    session_set_fds(Session *, int, int, int);
  74 void    session_pty_cleanup(Session *);
  75 void    session_proctitle(Session *);
  76 int     session_setup_x11fwd(Session *);
  77 void    do_exec_pty(Session *, const char *);
  78 void    do_exec_no_pty(Session *, const char *);
  79 void    do_exec(Session *, const char *);
  80 void    do_login(Session *, const char *);
  81 #ifdef LOGIN_NEEDS_UTMPX
  82 static void     do_pre_login(Session *s);
  83 #endif
  84 void    do_child(Session *, const char *);
  85 void    do_motd(void);
  86 int     check_quietlogin(Session *, const char *);
  87
  88 static void do_authenticated1(Authctxt *);
  89 static void do_authenticated2(Authctxt *);
  90
  91 static int session_pty_req(Session *);
  92
  93 /* import */
  94 extern ServerOptions options;
  95 extern char *__progname;
  96 extern int log_stderr;
  97 extern int debug_flag;
  98 extern u_int utmp_len;
  99 extern int startup_pipe;
 100 extern void destroy_sensitive_data(void);
 101 extern Buffer loginmsg;
 102
 103 /* original command from peer. */
 104 const char *original_command = NULL;
 105
 106 /* data */
 107 #define MAX_SESSIONS 10
 108 Session sessions[MAX_SESSIONS];
 109
 110 #ifdef HAVE_LOGIN_CAP
 111 login_cap_t *lc;
 112 #endif
 113
 114 static int is_child = 0;
 115
 116 /* Name and directory of socket for authentication agent forwarding. */
 117 static char *auth_sock_name = NULL;
 118 static char *auth_sock_dir = NULL;
 119
 120 /* removes the agent forwarding socket */
 121
 122 static void
 123 auth_sock_cleanup_proc(struct passwd *pw)
 124 {
 125         if (auth_sock_name != NULL) {
 126                 temporarily_use_uid(pw);
 127                 unlink(auth_sock_name);
 128                 rmdir(auth_sock_dir);
 129                 auth_sock_name = NULL;
 130                 restore_uid();
 131         }
 132 }
 133
 134 static int
 135 auth_input_request_forwarding(struct passwd * pw)
 136 {
 137         Channel *nc;
 138         int sock;
 139         struct sockaddr_un sunaddr;
 140
 141         if (auth_sock_name != NULL) {
 142                 error("authentication forwarding requested twice.");
 143                 return 0;
 144         }
 145
 146         /* Temporarily drop privileged uid for mkdir/bind. */
 147         temporarily_use_uid(pw);
 148
 149         /* Allocate a buffer for the socket name, and format the name. */
 150         auth_sock_name = xmalloc(MAXPATHLEN);
 151         auth_sock_dir = xmalloc(MAXPATHLEN);
 152         strlcpy(auth_sock_dir, "/tmp/ssh-XXXXXXXXXX", MAXPATHLEN);
 153
 154         /* Create private directory for socket */
 155         if (mkdtemp(auth_sock_dir) == NULL) {
 156                 packet_send_debug("Agent forwarding disabled: "
 157                     "mkdtemp() failed: %.100s", strerror(errno));
 158                 restore_uid();
 159                 xfree(auth_sock_name);
 160                 xfree(auth_sock_dir);
 161                 auth_sock_name = NULL;
 162                 auth_sock_dir = NULL;
 163                 return 0;
 164         }
 165         snprintf(auth_sock_name, MAXPATHLEN, "%s/agent.%ld",
 166                  auth_sock_dir, (long) getpid());
 167
 168         /* Create the socket. */
 169         sock = socket(AF_UNIX, SOCK_STREAM, 0);
 170         if (sock < 0)
 171                 packet_disconnect("socket: %.100s", strerror(errno));
 172
 173         /* Bind it to the name. */
 174         memset(&sunaddr, 0, sizeof(sunaddr));
 175         sunaddr.sun_family = AF_UNIX;
 176         strlcpy(sunaddr.sun_path, auth_sock_name, sizeof(sunaddr.sun_path));
 177
 178         if (bind(sock, (struct sockaddr *) & sunaddr, sizeof(sunaddr)) < 0)
 179                 packet_disconnect("bind: %.100s", strerror(errno));
 180
 181         /* Restore the privileged uid. */
 182         restore_uid();
 183
 184         /* Start listening on the socket. */
 185         if (listen(sock, SSH_LISTEN_BACKLOG) < 0)
 186                 packet_disconnect("listen: %.100s", strerror(errno));
 187
 188         /* Allocate a channel for the authentication agent socket. */
 189         nc = channel_new("auth socket",
 190             SSH_CHANNEL_AUTH_SOCKET, sock, sock, -1,
 191             CHAN_X11_WINDOW_DEFAULT, CHAN_X11_PACKET_DEFAULT,
 192             0, "auth socket", 1);
 193         strlcpy(nc->path, auth_sock_name, sizeof(nc->path));
 194         return 1;
 195 }
 196
 197 static void
 198 display_loginmsg(void)
 199 {
 200         if (buffer_len(&loginmsg) > 0) {
 201                 buffer_append(&loginmsg, "\0", 1);
 202                 printf("%s", (char *)buffer_ptr(&loginmsg));
 203                 buffer_clear(&loginmsg);
 204         }
 205 }
 206
 207 void
 208 do_authenticated(Authctxt *authctxt)
 209 {
 210         setproctitle("%s", authctxt->pw->pw_name);
 211
 212         /* setup the channel layer */
 213         if (!no_port_forwarding_flag && options.allow_tcp_forwarding)
 214                 channel_permit_all_opens();
 215
 216         if (compat20)
 217                 do_authenticated2(authctxt);
 218         else
 219                 do_authenticated1(authctxt);
 220
 221         do_cleanup(authctxt);
 222 }
 223
 224 /*
 225  * Prepares for an interactive session.  This is called after the user has
 226  * been successfully authenticated.  During this message exchange, pseudo
 227  * terminals are allocated, X11, TCP/IP, and authentication agent forwardings
 228  * are requested, etc.
 229  */
 230 static void
 231 do_authenticated1(Authctxt *authctxt)
 232 {
 233         Session *s;
 234         char *command;
 235         int success, type, screen_flag;
 236         int enable_compression_after_reply = 0;
 237         u_int proto_len, data_len, dlen, compression_level = 0;
 238
 239         s = session_new();
 240         if (s == NULL) {
 241                 error("no more sessions");
 242                 return;
 243         }
 244         s->authctxt = authctxt;
 245         s->pw = authctxt->pw;
 246
 247         /*
 248          * We stay in this loop until the client requests to execute a shell
 249          * or a command.
 250          */
 251         for (;;) {
 252                 success = 0;
 253
 254                 /* Get a packet from the client. */
 255                 type = packet_read();
 256
 257                 /* Process the packet. */
 258                 switch (type) {
 259                 case SSH_CMSG_REQUEST_COMPRESSION:
 260                         compression_level = packet_get_int();
 261                         packet_check_eom();
 262                         if (compression_level < 1 || compression_level > 9) {
 263                                 packet_send_debug("Received invalid compression level %d.",
 264                                     compression_level);
 265                                 break;
 266                         }
 267                         if (options.compression == COMP_NONE) {
 268                                 debug2("compression disabled");
 269                                 break;
 270                         }
 271                         /* Enable compression after we have responded with SUCCESS. */
 272                         enable_compression_after_reply = 1;
 273                         success = 1;
 274                         break;
 275
 276                 case SSH_CMSG_REQUEST_PTY:
 277                         success = session_pty_req(s);
 278                         break;
 279
 280                 case SSH_CMSG_X11_REQUEST_FORWARDING:
 281                         s->auth_proto = packet_get_string(&proto_len);
 282                         s->auth_data = packet_get_string(&data_len);
 283
 284                         screen_flag = packet_get_protocol_flags() &
 285                             SSH_PROTOFLAG_SCREEN_NUMBER;
 286                         debug2("SSH_PROTOFLAG_SCREEN_NUMBER: %d", screen_flag);
 287
 288                         if (packet_remaining() == 4) {
 289                                 if (!screen_flag)
 290                                         debug2("Buggy client: "
 291                                             "X11 screen flag missing");
 292                                 s->screen = packet_get_int();
 293                         } else {
 294                                 s->screen = 0;
 295                         }
 296                         packet_check_eom();
 297                         success = session_setup_x11fwd(s);
 298                         if (!success) {
 299                                 xfree(s->auth_proto);
 300                                 xfree(s->auth_data);
 301                                 s->auth_proto = NULL;
 302                                 s->auth_data = NULL;
 303                         }
 304                         break;
 305
 306                 case SSH_CMSG_AGENT_REQUEST_FORWARDING:
 307                         if (no_agent_forwarding_flag || compat13) {
 308                                 debug("Authentication agent forwarding not permitted for this authentication.");
 309                                 break;
 310                         }
 311                         debug("Received authentication agent forwarding request.");
 312                         success = auth_input_request_forwarding(s->pw);
 313                         break;
 314
 315                 case SSH_CMSG_PORT_FORWARD_REQUEST:
 316                         if (no_port_forwarding_flag) {
 317                                 debug("Port forwarding not permitted for this authentication.");
 318                                 break;
 319                         }
 320                         if (!options.allow_tcp_forwarding) {
 321                                 debug("Port forwarding not permitted.");
 322                                 break;
 323                         }
 324                         debug("Received TCP/IP port forwarding request.");
 325                         channel_input_port_forward_request(s->pw->pw_uid == 0, options.gateway_ports);
 326                         success = 1;
 327                         break;
 328
 329                 case SSH_CMSG_MAX_PACKET_SIZE:
 330                         if (packet_set_maxsize(packet_get_int()) > 0)
 331                                 success = 1;
 332                         break;
 333
 334                 case SSH_CMSG_EXEC_SHELL:
 335                 case SSH_CMSG_EXEC_CMD:
 336                         if (type == SSH_CMSG_EXEC_CMD) {
 337                                 command = packet_get_string(&dlen);
 338                                 debug("Exec command '%.500s'", command);
 339                                 do_exec(s, command);
 340                                 xfree(command);
 341                         } else {
 342                                 do_exec(s, NULL);
 343                         }
 344                         packet_check_eom();
 345                         session_close(s);
 346                         return;
 347
 348                 default:
 349                         /*
 350                          * Any unknown messages in this phase are ignored,
 351                          * and a failure message is returned.
 352                          */
 353                         logit("Unknown packet type received after authentication: %d", type);
 354                 }
 355                 packet_start(success ? SSH_SMSG_SUCCESS : SSH_SMSG_FAILURE);
 356                 packet_send();
 357                 packet_write_wait();
 358
 359                 /* Enable compression now that we have replied if appropriate. */
 360                 if (enable_compression_after_reply) {
 361                         enable_compression_after_reply = 0;
 362                         packet_start_compression(compression_level);
 363                 }
 364         }
 365 }
 366
 367 /*
 368  * This is called to fork and execute a command when we have no tty.  This
 369  * will call do_child from the child, and server_loop from the parent after
 370  * setting up file descriptors and such.
 371  */
 372 void
 373 do_exec_no_pty(Session *s, const char *command)
 374 {
 375         pid_t pid;
 376
 377 #ifdef USE_PIPES
 378         int pin[2], pout[2], perr[2];
 379         /* Allocate pipes for communicating with the program. */
 380         if (pipe(pin) < 0 || pipe(pout) < 0 || pipe(perr) < 0)
 381                 packet_disconnect("Could not create pipes: %.100s",
 382                                   strerror(errno));
 383 #else /* USE_PIPES */
 384         int inout[2], err[2];
 385         /* Uses socket pairs to communicate with the program. */
 386         if (socketpair(AF_UNIX, SOCK_STREAM, 0, inout) < 0 ||
 387             socketpair(AF_UNIX, SOCK_STREAM, 0, err) < 0)
 388                 packet_disconnect("Could not create socket pairs: %.100s",
 389                                   strerror(errno));
 390 #endif /* USE_PIPES */
 391         if (s == NULL)
 392                 fatal("do_exec_no_pty: no session");
 393
 394         session_proctitle(s);
 395
 396 #if defined(USE_PAM)
 397         if (options.use_pam && !use_privsep)
 398                 do_pam_setcred(1);
 399 #endif /* USE_PAM */
 400
 401         /* Fork the child. */
 402         if ((pid = fork()) == 0) {
 403                 is_child = 1;
 404
 405                 /* Child.  Reinitialize the log since the pid has changed. */
 406                 log_init(__progname, options.log_level, options.log_facility, log_stderr);
 407
 408                 /*
 409                  * Create a new session and process group since the 4.4BSD
 410                  * setlogin() affects the entire process group.
 411                  */
 412                 if (setsid() < 0)
 413                         error("setsid failed: %.100s", strerror(errno));
 414
 415 #ifdef USE_PIPES
 416                 /*
 417                  * Redirect stdin.  We close the parent side of the socket
 418                  * pair, and make the child side the standard input.
 419                  */
 420                 close(pin[1]);
 421                 if (dup2(pin[0], 0) < 0)
 422                         perror("dup2 stdin");
 423                 close(pin[0]);
 424
 425                 /* Redirect stdout. */
 426                 close(pout[0]);
 427                 if (dup2(pout[1], 1) < 0)
 428                         perror("dup2 stdout");
 429                 close(pout[1]);
 430
 431                 /* Redirect stderr. */
 432                 close(perr[0]);
 433                 if (dup2(perr[1], 2) < 0)
 434                         perror("dup2 stderr");
 435                 close(perr[1]);
 436 #else /* USE_PIPES */
 437                 /*
 438                  * Redirect stdin, stdout, and stderr.  Stdin and stdout will
 439                  * use the same socket, as some programs (particularly rdist)
 440                  * seem to depend on it.
 441                  */
 442                 close(inout[1]);
 443                 close(err[1]);
 444                 if (dup2(inout[0], 0) < 0)      /* stdin */
 445                         perror("dup2 stdin");
 446                 if (dup2(inout[0], 1) < 0)      /* stdout.  Note: same socket as stdin. */
 447                         perror("dup2 stdout");
 448                 if (dup2(err[0], 2) < 0)        /* stderr */
 449                         perror("dup2 stderr");
 450 #endif /* USE_PIPES */
 451
 452 #ifdef _UNICOS
 453                 cray_init_job(s->pw); /* set up cray jid and tmpdir */
 454 #endif
 455
 456                 /* Do processing for the child (exec command etc). */
 457                 do_child(s, command);
 458                 /* NOTREACHED */
 459         }
 460 #ifdef _UNICOS
 461         signal(WJSIGNAL, cray_job_termination_handler);
 462 #endif /* _UNICOS */
 463 #ifdef HAVE_CYGWIN
 464         if (is_winnt)
 465                 cygwin_set_impersonation_token(INVALID_HANDLE_VALUE);
 466 #endif
 467         if (pid < 0)
 468                 packet_disconnect("fork failed: %.100s", strerror(errno));
 469         s->pid = pid;
 470         /* Set interactive/non-interactive mode. */
 471         packet_set_interactive(s->display != NULL);
 472 #ifdef USE_PIPES
 473         /* We are the parent.  Close the child sides of the pipes. */
 474         close(pin[0]);
 475         close(pout[1]);
 476         close(perr[1]);
 477
 478         if (compat20) {
 479                 if (s->is_subsystem) {
 480                         close(perr[0]);
 481                         perr[0] = -1;
 482                 }
 483                 session_set_fds(s, pin[1], pout[0], perr[0]);
 484         } else {
 485                 /* Enter the interactive session. */
 486                 server_loop(pid, pin[1], pout[0], perr[0]);
 487                 /* server_loop has closed pin[1], pout[0], and perr[0]. */
 488         }
 489 #else /* USE_PIPES */
 490         /* We are the parent.  Close the child sides of the socket pairs. */
 491         close(inout[0]);
 492         close(err[0]);
 493
 494         /*
 495          * Clear loginmsg, since it's the child's responsibility to display
 496          * it to the user, otherwise multiple sessions may accumulate
 497          * multiple copies of the login messages.
 498          */
 499         buffer_clear(&loginmsg);
 500
 501         /*
 502          * Enter the interactive session.  Note: server_loop must be able to
 503          * handle the case that fdin and fdout are the same.
 504          */
 505         if (compat20) {
 506                 session_set_fds(s, inout[1], inout[1], s->is_subsystem ? -1 : err[1]);
 507         } else {
 508                 server_loop(pid, inout[1], inout[1], err[1]);
 509                 /* server_loop has closed inout[1] and err[1]. */
 510         }
 511 #endif /* USE_PIPES */
 512 }
 513
 514 /*
 515  * This is called to fork and execute a command when we have a tty.  This
 516  * will call do_child from the child, and server_loop from the parent after
 517  * setting up file descriptors, controlling tty, updating wtmp, utmp,
 518  * lastlog, and other such operations.
 519  */
 520 void
 521 do_exec_pty(Session *s, const char *command)
 522 {
 523         int fdout, ptyfd, ttyfd, ptymaster;
 524         pid_t pid;
 525
 526         if (s == NULL)
 527                 fatal("do_exec_pty: no session");
 528         ptyfd = s->ptyfd;
 529         ttyfd = s->ttyfd;
 530
 531 #if defined(USE_PAM)
 532         if (options.use_pam) {
 533                 do_pam_set_tty(s->tty);
 534                 if (!use_privsep)
 535                         do_pam_setcred(1);
 536         }
 537 #endif
 538
 539         /* Fork the child. */
 540         if ((pid = fork()) == 0) {
 541                 is_child = 1;
 542
 543                 /* Child.  Reinitialize the log because the pid has changed. */
 544                 log_init(__progname, options.log_level, options.log_facility, log_stderr);
 545                 /* Close the master side of the pseudo tty. */
 546                 close(ptyfd);
 547
 548                 /* Make the pseudo tty our controlling tty. */
 549                 pty_make_controlling_tty(&ttyfd, s->tty);
 550
 551                 /* Redirect stdin/stdout/stderr from the pseudo tty. */
 552                 if (dup2(ttyfd, 0) < 0)
 553                         error("dup2 stdin: %s", strerror(errno));
 554                 if (dup2(ttyfd, 1) < 0)
 555                         error("dup2 stdout: %s", strerror(errno));
 556                 if (dup2(ttyfd, 2) < 0)
 557                         error("dup2 stderr: %s", strerror(errno));
 558
 559                 /* Close the extra descriptor for the pseudo tty. */
 560                 close(ttyfd);
 561
 562                 /* record login, etc. similar to login(1) */
 563 #ifndef HAVE_OSF_SIA
 564                 if (!(options.use_login && command == NULL)) {
 565 #ifdef _UNICOS
 566                         cray_init_job(s->pw); /* set up cray jid and tmpdir */
 567 #endif /* _UNICOS */
 568                         do_login(s, command);
 569                 }
 570 # ifdef LOGIN_NEEDS_UTMPX
 571                 else
 572                         do_pre_login(s);
 573 # endif
 574 #endif
 575
 576                 /* Do common processing for the child, such as execing the command. */
 577                 do_child(s, command);
 578                 /* NOTREACHED */
 579         }
 580 #ifdef _UNICOS
 581         signal(WJSIGNAL, cray_job_termination_handler);
 582 #endif /* _UNICOS */
 583 #ifdef HAVE_CYGWIN
 584         if (is_winnt)
 585                 cygwin_set_impersonation_token(INVALID_HANDLE_VALUE);
 586 #endif
 587         if (pid < 0)
 588                 packet_disconnect("fork failed: %.100s", strerror(errno));
 589         s->pid = pid;
 590
 591         /* Parent.  Close the slave side of the pseudo tty. */
 592         close(ttyfd);
 593
 594         /*
 595          * Create another descriptor of the pty master side for use as the
 596          * standard input.  We could use the original descriptor, but this
 597          * simplifies code in server_loop.  The descriptor is bidirectional.
 598          */
 599         fdout = dup(ptyfd);
 600         if (fdout < 0)
 601                 packet_disconnect("dup #1 failed: %.100s", strerror(errno));
 602
 603         /* we keep a reference to the pty master */
 604         ptymaster = dup(ptyfd);
 605         if (ptymaster < 0)
 606                 packet_disconnect("dup #2 failed: %.100s", strerror(errno));
 607         s->ptymaster = ptymaster;
 608
 609         /* Enter interactive session. */
 610         packet_set_interactive(1);
 611         if (compat20) {
 612                 session_set_fds(s, ptyfd, fdout, -1);
 613         } else {
 614                 server_loop(pid, ptyfd, fdout, -1);
 615                 /* server_loop _has_ closed ptyfd and fdout. */
 616         }
 617 }
 618
 619 #ifdef LOGIN_NEEDS_UTMPX
 620 static void
 621 do_pre_login(Session *s)
 622 {
 623         socklen_t fromlen;
 624         struct sockaddr_storage from;
 625         pid_t pid = getpid();
 626
 627         /*
 628          * Get IP address of client. If the connection is not a socket, let
 629          * the address be 0.0.0.0.
 630          */
 631         memset(&from, 0, sizeof(from));
 632         fromlen = sizeof(from);
 633         if (packet_connection_is_on_socket()) {
 634                 if (getpeername(packet_get_connection_in(),
 635                     (struct sockaddr *) & from, &fromlen) < 0) {
 636                         debug("getpeername: %.100s", strerror(errno));
 637                         cleanup_exit(255);
 638                 }
 639         }
 640
 641         record_utmp_only(pid, s->tty, s->pw->pw_name,
 642             get_remote_name_or_ip(utmp_len, options.use_dns),
 643             (struct sockaddr *)&from, fromlen);
 644 }
 645 #endif
 646
 647 /*
 648  * This is called to fork and execute a command.  If another command is
 649  * to be forced, execute that instead.
 650  */
 651 void
 652 do_exec(Session *s, const char *command)
 653 {
 654         if (forced_command) {
 655                 original_command = command;
 656                 command = forced_command;
 657                 debug("Forced command '%.900s'", command);
 658         }
 659
 660 #ifdef SSH_AUDIT_EVENTS
 661         if (command != NULL)
 662                 PRIVSEP(audit_run_command(command));
 663         else if (s->ttyfd == -1) {
 664                 char *shell = s->pw->pw_shell;
 665
 666                 if (shell[0] == '\0')   /* empty shell means /bin/sh */
 667                         shell =_PATH_BSHELL;
 668                 PRIVSEP(audit_run_command(shell));
 669         }
 670 #endif
 671
 672         if (s->ttyfd != -1)
 673                 do_exec_pty(s, command);
 674         else
 675                 do_exec_no_pty(s, command);
 676
 677         original_command = NULL;
 678
 679         /*
 680          * Clear loginmsg: it's the child's responsibility to display
 681          * it to the user, otherwise multiple sessions may accumulate
 682          * multiple copies of the login messages.
 683          */
 684         buffer_clear(&loginmsg);
 685 }
 686
 687 /* administrative, login(1)-like work */
 688 void
 689 do_login(Session *s, const char *command)
 690 {
 691         socklen_t fromlen;
 692         struct sockaddr_storage from;
 693         struct passwd * pw = s->pw;
 694         pid_t pid = getpid();
 695
 696         /*
 697          * Get IP address of client. If the connection is not a socket, let
 698          * the address be 0.0.0.0.
 699          */
 700         memset(&from, 0, sizeof(from));
 701         fromlen = sizeof(from);
 702         if (packet_connection_is_on_socket()) {
 703                 if (getpeername(packet_get_connection_in(),
 704                     (struct sockaddr *) & from, &fromlen) < 0) {
 705                         debug("getpeername: %.100s", strerror(errno));
 706                         cleanup_exit(255);
 707                 }
 708         }
 709
 710         /* Record that there was a login on that tty from the remote host. */
 711         if (!use_privsep)
 712                 record_login(pid, s->tty, pw->pw_name, pw->pw_uid,
 713                     get_remote_name_or_ip(utmp_len,
 714                     options.use_dns),
 715                     (struct sockaddr *)&from, fromlen);
 716
 717 #ifdef USE_PAM
 718         /*
 719          * If password change is needed, do it now.
 720          * This needs to occur before the ~/.hushlogin check.
 721          */
 722         if (options.use_pam && !use_privsep && s->authctxt->force_pwchange) {
 723                 display_loginmsg();
 724                 do_pam_chauthtok();
 725                 s->authctxt->force_pwchange = 0;
 726                 /* XXX - signal [net] parent to enable forwardings */
 727         }
 728 #endif
 729
 730         if (check_quietlogin(s, command))
 731                 return;
 732
 733         display_loginmsg();
 734
 735         do_motd();
 736 }
 737
 738 /*
 739  * Display the message of the day.
 740  */
 741 void
 742 do_motd(void)
 743 {
 744         FILE *f;
 745         char buf[256];
 746
 747         if (options.print_motd) {
 748 #ifdef HAVE_LOGIN_CAP
 749                 f = fopen(login_getcapstr(lc, "welcome", "/etc/motd",
 750                     "/etc/motd"), "r");
 751 #else
 752                 f = fopen("/etc/motd", "r");
 753 #endif
 754                 if (f) {
 755                         while (fgets(buf, sizeof(buf), f))
 756                                 fputs(buf, stdout);
 757                         fclose(f);
 758                 }
 759         }
 760 }
 761
 762
 763 /*
 764  * Check for quiet login, either .hushlogin or command given.
 765  */
 766 int
 767 check_quietlogin(Session *s, const char *command)
 768 {
 769         char buf[256];
 770         struct passwd *pw = s->pw;
 771         struct stat st;
 772
 773         /* Return 1 if .hushlogin exists or a command given. */
 774         if (command != NULL)
 775                 return 1;
 776         snprintf(buf, sizeof(buf), "%.200s/.hushlogin", pw->pw_dir);
 777 #ifdef HAVE_LOGIN_CAP
 778         if (login_getcapbool(lc, "hushlogin", 0) || stat(buf, &st) >= 0)
 779                 return 1;
 780 #else
 781         if (stat(buf, &st) >= 0)
 782                 return 1;
 783 #endif
 784         return 0;
 785 }
 786
 787 /*
 788  * Sets the value of the given variable in the environment.  If the variable
 789  * already exists, its value is overriden.
 790  */
 791 void
 792 child_set_env(char ***envp, u_int *envsizep, const char *name,
 793         const char *value)
 794 {
 795         char **env;
 796         u_int envsize;
 797         u_int i, namelen;
 798
 799         /*
 800          * If we're passed an uninitialized list, allocate a single null
 801          * entry before continuing.
 802          */
 803         if (*envp == NULL && *envsizep == 0) {
 804                 *envp = xmalloc(sizeof(char *));
 805                 *envp[0] = NULL;
 806                 *envsizep = 1;
 807         }
 808
 809         /*
 810          * Find the slot where the value should be stored.  If the variable
 811          * already exists, we reuse the slot; otherwise we append a new slot
 812          * at the end of the array, expanding if necessary.
 813          */
 814         env = *envp;
 815         namelen = strlen(name);
 816         for (i = 0; env[i]; i++)
 817                 if (strncmp(env[i], name, namelen) == 0 && env[i][namelen] == '=')
 818                         break;
 819         if (env[i]) {
 820                 /* Reuse the slot. */
 821                 xfree(env[i]);
 822         } else {
 823                 /* New variable.  Expand if necessary. */
 824                 envsize = *envsizep;
 825                 if (i >= envsize - 1) {
 826                         if (envsize >= 1000)
 827                                 fatal("child_set_env: too many env vars");
 828                         envsize += 50;
 829                         env = (*envp) = xrealloc(env, envsize * sizeof(char *));
 830                         *envsizep = envsize;
 831                 }
 832                 /* Need to set the NULL pointer at end of array beyond the new slot. */
 833                 env[i + 1] = NULL;
 834         }
 835
 836         /* Allocate space and format the variable in the appropriate slot. */
 837         env[i] = xmalloc(strlen(name) + 1 + strlen(value) + 1);
 838         snprintf(env[i], strlen(name) + 1 + strlen(value) + 1, "%s=%s", name, value);
 839 }
 840
 841 /*
 842  * Reads environment variables from the given file and adds/overrides them
 843  * into the environment.  If the file does not exist, this does nothing.
 844  * Otherwise, it must consist of empty lines, comments (line starts with '#')
 845  * and assignments of the form name=value.  No other forms are allowed.
 846  */
 847 static void
 848 read_environment_file(char ***env, u_int *envsize,
 849         const char *filename)
 850 {
 851         FILE *f;
 852         char buf[4096];
 853         char *cp, *value;
 854         u_int lineno = 0;
 855
 856         f = fopen(filename, "r");
 857         if (!f)
 858                 return;
 859
 860         while (fgets(buf, sizeof(buf), f)) {
 861                 if (++lineno > 1000)
 862                         fatal("Too many lines in environment file %s", filename);
 863                 for (cp = buf; *cp == ' ' || *cp == '\t'; cp++)
 864                         ;
 865                 if (!*cp || *cp == '#' || *cp == '\n')
 866                         continue;
 867                 if (strchr(cp, '\n'))
 868                         *strchr(cp, '\n') = '\0';
 869                 value = strchr(cp, '=');
 870                 if (value == NULL) {
 871                         fprintf(stderr, "Bad line %u in %.100s\n", lineno,
 872                             filename);
 873                         continue;
 874                 }
 875                 /*
 876                  * Replace the equals sign by nul, and advance value to
 877                  * the value string.
 878                  */
 879                 *value = '\0';
 880                 value++;
 881                 child_set_env(env, envsize, cp, value);
 882         }
 883         fclose(f);
 884 }
 885
 886 #ifdef HAVE_ETC_DEFAULT_LOGIN
 887 /*
 888  * Return named variable from specified environment, or NULL if not present.
 889  */
 890 static char *
 891 child_get_env(char **env, const char *name)
 892 {
 893         int i;
 894         size_t len;
 895
 896         len = strlen(name);
 897         for (i=0; env[i] != NULL; i++)
 898                 if (strncmp(name, env[i], len) == 0 && env[i][len] == '=')
 899                         return(env[i] + len + 1);
 900         return NULL;
 901 }
 902
 903 /*
 904  * Read /etc/default/login.
 905  * We pick up the PATH (or SUPATH for root) and UMASK.
 906  */
 907 static void
 908 read_etc_default_login(char ***env, u_int *envsize, uid_t uid)
 909 {
 910         char **tmpenv = NULL, *var;
 911         u_int i, tmpenvsize = 0;
 912         u_long mask;
 913
 914         /*
 915          * We don't want to copy the whole file to the child's environment,
 916          * so we use a temporary environment and copy the variables we're
 917          * interested in.
 918          */
 919         read_environment_file(&tmpenv, &tmpenvsize, "/etc/default/login");
 920
 921         if (tmpenv == NULL)
 922                 return;
 923
 924         if (uid == 0)
 925                 var = child_get_env(tmpenv, "SUPATH");
 926         else
 927                 var = child_get_env(tmpenv, "PATH");
 928         if (var != NULL)
 929                 child_set_env(env, envsize, "PATH", var);
 930
 931         if ((var = child_get_env(tmpenv, "UMASK")) != NULL)
 932                 if (sscanf(var, "%5lo", &mask) == 1)
 933                         umask((mode_t)mask);
 934
 935         for (i = 0; tmpenv[i] != NULL; i++)
 936                 xfree(tmpenv[i]);
 937         xfree(tmpenv);
 938 }
 939 #endif /* HAVE_ETC_DEFAULT_LOGIN */
 940
 941 void
 942 copy_environment(char **source, char ***env, u_int *envsize)
 943 {
 944         char *var_name, *var_val;
 945         int i;
 946
 947         if (source == NULL)
 948                 return;
 949
 950         for(i = 0; source[i] != NULL; i++) {
 951                 var_name = xstrdup(source[i]);
 952                 if ((var_val = strstr(var_name, "=")) == NULL) {
 953                         xfree(var_name);
 954                         continue;
 955                 }
 956                 *var_val++ = '\0';
 957
 958                 debug3("Copy environment: %s=%s", var_name, var_val);
 959                 child_set_env(env, envsize, var_name, var_val);
 960
 961                 xfree(var_name);
 962         }
 963 }
 964
 965 static char **
 966 do_setup_env(Session *s, const char *shell)
 967 {
 968         char buf[256];
 969         u_int i, envsize;
 970         char **env, *laddr, *path = NULL;
 971         struct passwd *pw = s->pw;
 972
 973         /* Initialize the environment. */
 974         envsize = 100;
 975         env = xmalloc(envsize * sizeof(char *));
 976         env[0] = NULL;
 977
 978 #ifdef HAVE_CYGWIN
 979         /*
 980          * The Windows environment contains some setting which are
 981          * important for a running system. They must not be dropped.
 982          */
 983         {
 984                 char **p;
 985
 986                 p = fetch_windows_environment();
 987                 copy_environment(p, &env, &envsize);
 988                 free_windows_environment(p);
 989         }
 990 #endif
 991
 992 #ifdef GSSAPI
 993         /* Allow any GSSAPI methods that we've used to alter
 994          * the childs environment as they see fit
 995          */
 996         ssh_gssapi_do_child(&env, &envsize);
 997 #endif
 998
 999         if (!options.use_login) {
1000                 /* Set basic environment. */
1001                 for (i = 0; i < s->num_env; i++)
1002                         child_set_env(&env, &envsize, s->env[i].name,
1003                             s->env[i].val);
1004
1005                 child_set_env(&env, &envsize, "USER", pw->pw_name);
1006                 child_set_env(&env, &envsize, "LOGNAME", pw->pw_name);
1007 #ifdef _AIX
1008                 child_set_env(&env, &envsize, "LOGIN", pw->pw_name);
1009 #endif
1010                 child_set_env(&env, &envsize, "HOME", pw->pw_dir);
1011 #ifdef HAVE_LOGIN_CAP
1012                 if (setusercontext(lc, pw, pw->pw_uid, LOGIN_SETPATH) < 0)
1013                         child_set_env(&env, &envsize, "PATH", _PATH_STDPATH);
1014                 else
1015                         child_set_env(&env, &envsize, "PATH", getenv("PATH"));
1016 #else /* HAVE_LOGIN_CAP */
1017 # ifndef HAVE_CYGWIN
1018                 /*
1019                  * There's no standard path on Windows. The path contains
1020                  * important components pointing to the system directories,
1021                  * needed for loading shared libraries. So the path better
1022                  * remains intact here.
1023                  */
1024 #  ifdef HAVE_ETC_DEFAULT_LOGIN
1025                 read_etc_default_login(&env, &envsize, pw->pw_uid);
1026                 path = child_get_env(env, "PATH");
1027 #  endif /* HAVE_ETC_DEFAULT_LOGIN */
1028                 if (path == NULL || *path == '\0') {
1029                         child_set_env(&env, &envsize, "PATH",
1030                             s->pw->pw_uid == 0 ?
1031                                 SUPERUSER_PATH : _PATH_STDPATH);
1032                 }
1033 # endif /* HAVE_CYGWIN */
1034 #endif /* HAVE_LOGIN_CAP */
1035
1036                 snprintf(buf, sizeof buf, "%.200s/%.50s",
1037                          _PATH_MAILDIR, pw->pw_name);
1038                 child_set_env(&env, &envsize, "MAIL", buf);
1039
1040                 /* Normal systems set SHELL by default. */
1041                 child_set_env(&env, &envsize, "SHELL", shell);
1042         }
1043         if (getenv("TZ"))
1044                 child_set_env(&env, &envsize, "TZ", getenv("TZ"));
1045
1046         /* Set custom environment options from RSA authentication. */
1047         if (!options.use_login) {
1048                 while (custom_environment) {
1049                         struct envstring *ce = custom_environment;
1050                         char *str = ce->s;
1051
1052                         for (i = 0; str[i] != '=' && str[i]; i++)
1053                                 ;
1054                         if (str[i] == '=') {
1055                                 str[i] = 0;
1056                                 child_set_env(&env, &envsize, str, str + i + 1);
1057                         }
1058                         custom_environment = ce->next;
1059                         xfree(ce->s);
1060                         xfree(ce);
1061                 }
1062         }
1063
1064         /* SSH_CLIENT deprecated */
1065         snprintf(buf, sizeof buf, "%.50s %d %d",
1066             get_remote_ipaddr(), get_remote_port(), get_local_port());
1067         child_set_env(&env, &envsize, "SSH_CLIENT", buf);
1068
1069         laddr = get_local_ipaddr(packet_get_connection_in());
1070         snprintf(buf, sizeof buf, "%.50s %d %.50s %d",
1071             get_remote_ipaddr(), get_remote_port(), laddr, get_local_port());
1072         xfree(laddr);
1073         child_set_env(&env, &envsize, "SSH_CONNECTION", buf);
1074
1075         if (s->ttyfd != -1)
1076                 child_set_env(&env, &envsize, "SSH_TTY", s->tty);
1077         if (s->term)
1078                 child_set_env(&env, &envsize, "TERM", s->term);
1079         if (s->display)
1080                 child_set_env(&env, &envsize, "DISPLAY", s->display);
1081         if (original_command)
1082                 child_set_env(&env, &envsize, "SSH_ORIGINAL_COMMAND",
1083                     original_command);
1084
1085 #ifdef _UNICOS
1086         if (cray_tmpdir[0] != '\0')
1087                 child_set_env(&env, &envsize, "TMPDIR", cray_tmpdir);
1088 #endif /* _UNICOS */
1089
1090         /*
1091          * Since we clear KRB5CCNAME at startup, if it's set now then it
1092          * must have been set by a native authentication method (eg AIX or
1093          * SIA), so copy it to the child.
1094          */
1095         {
1096                 char *cp;
1097
1098                 if ((cp = getenv("KRB5CCNAME")) != NULL)
1099                         child_set_env(&env, &envsize, "KRB5CCNAME", cp);
1100         }
1101
1102 #ifdef _AIX
1103         {
1104                 char *cp;
1105
1106                 if ((cp = getenv("AUTHSTATE")) != NULL)
1107                         child_set_env(&env, &envsize, "AUTHSTATE", cp);
1108                 read_environment_file(&env, &envsize, "/etc/environment");
1109         }
1110 #endif
1111 #ifdef KRB5
1112         if (s->authctxt->krb5_ccname)
1113                 child_set_env(&env, &envsize, "KRB5CCNAME",
1114                     s->authctxt->krb5_ccname);
1115 #endif
1116 #ifdef USE_PAM
1117         /*
1118          * Pull in any environment variables that may have
1119          * been set by PAM.
1120          */
1121         if (options.use_pam) {
1122                 char **p;
1123
1124                 p = fetch_pam_child_environment();
1125                 copy_environment(p, &env, &envsize);
1126                 free_pam_environment(p);
1127
1128                 p = fetch_pam_environment();
1129                 copy_environment(p, &env, &envsize);
1130                 free_pam_environment(p);
1131         }
1132 #endif /* USE_PAM */
1133
1134         if (auth_sock_name != NULL)
1135                 child_set_env(&env, &envsize, SSH_AUTHSOCKET_ENV_NAME,
1136                     auth_sock_name);
1137
1138         /* read $HOME/.ssh/environment. */
1139         if (options.permit_user_env && !options.use_login) {
1140                 snprintf(buf, sizeof buf, "%.200s/.ssh/environment",
1141                     strcmp(pw->pw_dir, "/") ? pw->pw_dir : "");
1142                 read_environment_file(&env, &envsize, buf);
1143         }
1144         if (debug_flag) {
1145                 /* dump the environment */
1146                 fprintf(stderr, "Environment:\n");
1147                 for (i = 0; env[i]; i++)
1148                         fprintf(stderr, "  %.200s\n", env[i]);
1149         }
1150         return env;
1151 }
1152
1153 /*
1154  * Run $HOME/.ssh/rc, /etc/ssh/sshrc, or xauth (whichever is found
1155  * first in this order).
1156  */
1157 static void
1158 do_rc_files(Session *s, const char *shell)
1159 {
1160         FILE *f = NULL;
1161         char cmd[1024];
1162         int do_xauth;
1163         struct stat st;
1164
1165         do_xauth =
1166             s->display != NULL && s->auth_proto != NULL && s->auth_data != NULL;
1167
1168         /* ignore _PATH_SSH_USER_RC for subsystems */
1169         if (!s->is_subsystem && (stat(_PATH_SSH_USER_RC, &st) >= 0)) {
1170                 snprintf(cmd, sizeof cmd, "%s -c '%s %s'",
1171                     shell, _PATH_BSHELL, _PATH_SSH_USER_RC);
1172                 if (debug_flag)
1173                         fprintf(stderr, "Running %s\n", cmd);
1174                 f = popen(cmd, "w");
1175                 if (f) {
1176                         if (do_xauth)
1177                                 fprintf(f, "%s %s\n", s->auth_proto,
1178                                     s->auth_data);
1179                         pclose(f);
1180                 } else
1181                         fprintf(stderr, "Could not run %s\n",
1182                             _PATH_SSH_USER_RC);
1183         } else if (stat(_PATH_SSH_SYSTEM_RC, &st) >= 0) {
1184                 if (debug_flag)
1185                         fprintf(stderr, "Running %s %s\n", _PATH_BSHELL,
1186                             _PATH_SSH_SYSTEM_RC);
1187                 f = popen(_PATH_BSHELL " " _PATH_SSH_SYSTEM_RC, "w");
1188                 if (f) {
1189                         if (do_xauth)
1190                                 fprintf(f, "%s %s\n", s->auth_proto,
1191                                     s->auth_data);
1192                         pclose(f);
1193                 } else
1194                         fprintf(stderr, "Could not run %s\n",
1195                             _PATH_SSH_SYSTEM_RC);
1196         } else if (do_xauth && options.xauth_location != NULL) {
1197                 /* Add authority data to .Xauthority if appropriate. */
1198                 if (debug_flag) {
1199                         fprintf(stderr,
1200                             "Running %.500s remove %.100s\n",
1201                             options.xauth_location, s->auth_display);
1202                         fprintf(stderr,
1203                             "%.500s add %.100s %.100s %.100s\n",
1204                             options.xauth_location, s->auth_display,
1205                             s->auth_proto, s->auth_data);
1206                 }
1207                 snprintf(cmd, sizeof cmd, "%s -q -",
1208                     options.xauth_location);
1209                 f = popen(cmd, "w");
1210                 if (f) {
1211                         fprintf(f, "remove %s\n",
1212                             s->auth_display);
1213                         fprintf(f, "add %s %s %s\n",
1214                             s->auth_display, s->auth_proto,
1215                             s->auth_data);
1216                         pclose(f);
1217                 } else {
1218                         fprintf(stderr, "Could not run %s\n",
1219                             cmd);
1220                 }
1221         }
1222 }
1223
1224 static void
1225 do_nologin(struct passwd *pw)
1226 {
1227         FILE *f = NULL;
1228         char buf[1024];
1229
1230 #ifdef HAVE_LOGIN_CAP
1231         if (!login_getcapbool(lc, "ignorenologin", 0) && pw->pw_uid)
1232                 f = fopen(login_getcapstr(lc, "nologin", _PATH_NOLOGIN,
1233                     _PATH_NOLOGIN), "r");
1234 #else
1235         if (pw->pw_uid)
1236                 f = fopen(_PATH_NOLOGIN, "r");
1237 #endif
1238         if (f) {
1239                 /* /etc/nologin exists.  Print its contents and exit. */
1240                 logit("User %.100s not allowed because %s exists",
1241                     pw->pw_name, _PATH_NOLOGIN);
1242                 while (fgets(buf, sizeof(buf), f))
1243                         fputs(buf, stderr);
1244                 fclose(f);
1245                 fflush(NULL);
1246                 exit(254);
1247         }
1248 }
1249
1250 /* Set login name, uid, gid, and groups. */
1251 void
1252 do_setusercontext(struct passwd *pw)
1253 {
1254 #ifndef HAVE_CYGWIN
1255         if (getuid() == 0 || geteuid() == 0)
1256 #endif /* HAVE_CYGWIN */
1257         {
1258
1259 #ifdef HAVE_SETPCRED
1260                 if (setpcred(pw->pw_name, (char **)NULL) == -1)
1261                         fatal("Failed to set process credentials");
1262 #endif /* HAVE_SETPCRED */
1263 #ifdef HAVE_LOGIN_CAP
1264 # ifdef __bsdi__
1265                 setpgid(0, 0);
1266 # endif
1267 #ifdef GSSAPI
1268                 if (options.gss_authentication) {
1269                         temporarily_use_uid(pw);
1270                         ssh_gssapi_storecreds();
1271                         restore_uid();
1272                 }
1273 #endif
1274 # ifdef USE_PAM
1275                 if (options.use_pam) {
1276                         do_pam_session();
1277                         do_pam_setcred(0);
1278                 }
1279 # endif /* USE_PAM */
1280                 if (setusercontext(lc, pw, pw->pw_uid,
1281                     (LOGIN_SETALL & ~LOGIN_SETPATH)) < 0) {
1282                         perror("unable to set user context");
1283                         exit(1);
1284                 }
1285 #else
1286 # if defined(HAVE_GETLUID) && defined(HAVE_SETLUID)
1287                 /* Sets login uid for accounting */
1288                 if (getluid() == -1 && setluid(pw->pw_uid) == -1)
1289                         error("setluid: %s", strerror(errno));
1290 # endif /* defined(HAVE_GETLUID) && defined(HAVE_SETLUID) */
1291
1292                 if (setlogin(pw->pw_name) < 0)
1293                         error("setlogin failed: %s", strerror(errno));
1294                 if (setgid(pw->pw_gid) < 0) {
1295                         perror("setgid");
1296                         exit(1);
1297                 }
1298                 /* Initialize the group list. */
1299                 if (initgroups(pw->pw_name, pw->pw_gid) < 0) {
1300                         perror("initgroups");
1301                         exit(1);
1302                 }
1303                 endgrent();
1304 #ifdef GSSAPI
1305                 if (options.gss_authentication) {
1306                         temporarily_use_uid(pw);
1307                         ssh_gssapi_storecreds();
1308                         restore_uid();
1309                 }
1310 #endif
1311 # ifdef USE_PAM
1312                 /*
1313                  * PAM credentials may take the form of supplementary groups.
1314                  * These will have been wiped by the above initgroups() call.
1315                  * Reestablish them here.
1316                  */
1317                 if (options.use_pam) {
1318                         do_pam_session();
1319                         do_pam_setcred(0);
1320                 }
1321 # endif /* USE_PAM */
1322 # if defined(WITH_IRIX_PROJECT) || defined(WITH_IRIX_JOBS) || defined(WITH_IRIX_ARRAY)
1323                 irix_setusercontext(pw);
1324 #  endif /* defined(WITH_IRIX_PROJECT) || defined(WITH_IRIX_JOBS) || defined(WITH_IRIX_ARRAY) */
1325 # ifdef _AIX
1326                 aix_usrinfo(pw);
1327 # endif /* _AIX */
1328 #if defined(HAVE_LIBIAF)  &&  !defined(BROKEN_LIBIAF)
1329                 if (set_id(pw->pw_name) != 0) {
1330                         exit(1);
1331                 }
1332 #endif /* HAVE_LIBIAF  && !BROKEN_LIBIAF */
1333                 /* Permanently switch to the desired uid. */
1334                 permanently_set_uid(pw);
1335 #endif
1336         }
1337
1338 #ifdef HAVE_CYGWIN
1339         if (is_winnt)
1340 #endif
1341         if (getuid() != pw->pw_uid || geteuid() != pw->pw_uid)
1342                 fatal("Failed to set uids to %u.", (u_int) pw->pw_uid);
1343 }
1344
1345 static void
1346 do_pwchange(Session *s)
1347 {
1348         fflush(NULL);
1349         fprintf(stderr, "WARNING: Your password has expired.\n");
1350         if (s->ttyfd != -1) {
1351                 fprintf(stderr,
1352                     "You must change your password now and login again!\n");
1353 #ifdef PASSWD_NEEDS_USERNAME
1354                 execl(_PATH_PASSWD_PROG, "passwd", s->pw->pw_name,
1355                     (char *)NULL);
1356 #else
1357                 execl(_PATH_PASSWD_PROG, "passwd", (char *)NULL);
1358 #endif
1359                 perror("passwd");
1360         } else {
1361                 fprintf(stderr,
1362                     "Password change required but no TTY available.\n");
1363         }
1364         exit(1);
1365 }
1366
1367 static void
1368 launch_login(struct passwd *pw, const char *hostname)
1369 {
1370         /* Launch login(1). */
1371
1372         execl(LOGIN_PROGRAM, "login", "-h", hostname,
1373 #ifdef xxxLOGIN_NEEDS_TERM
1374                     (s->term ? s->term : "unknown"),
1375 #endif /* LOGIN_NEEDS_TERM */
1376 #ifdef LOGIN_NO_ENDOPT
1377             "-p", "-f", pw->pw_name, (char *)NULL);
1378 #else
1379             "-p", "-f", "--", pw->pw_name, (char *)NULL);
1380 #endif
1381
1382         /* Login couldn't be executed, die. */
1383
1384         perror("login");
1385         exit(1);
1386 }
1387
1388 static void
1389 child_close_fds(void)
1390 {
1391         int i;
1392
1393         if (packet_get_connection_in() == packet_get_connection_out())
1394                 close(packet_get_connection_in());
1395         else {
1396                 close(packet_get_connection_in());
1397                 close(packet_get_connection_out());
1398         }
1399         /*
1400          * Close all descriptors related to channels.  They will still remain
1401          * open in the parent.
1402          */
1403         /* XXX better use close-on-exec? -markus */
1404         channel_close_all();
1405
1406         /*
1407          * Close any extra file descriptors.  Note that there may still be
1408          * descriptors left by system functions.  They will be closed later.
1409          */
1410         endpwent();
1411
1412         /*
1413          * Close any extra open file descriptors so that we don't have them
1414          * hanging around in clients.  Note that we want to do this after
1415          * initgroups, because at least on Solaris 2.3 it leaves file
1416          * descriptors open.
1417          */
1418         for (i = 3; i < 64; i++)
1419                 close(i);
1420 }
1421
1422 /*
1423  * Performs common processing for the child, such as setting up the
1424  * environment, closing extra file descriptors, setting the user and group
1425  * ids, and executing the command or shell.
1426  */
1427 void
1428 do_child(Session *s, const char *command)
1429 {
1430         extern char **environ;
1431         char **env;
1432         char *argv[10];
1433         const char *shell, *shell0, *hostname = NULL;
1434         struct passwd *pw = s->pw;
1435
1436         /* remove hostkey from the child's memory */
1437         destroy_sensitive_data();
1438
1439         /* Force a password change */
1440         if (s->authctxt->force_pwchange) {
1441                 do_setusercontext(pw);
1442                 child_close_fds();
1443                 do_pwchange(s);
1444                 exit(1);
1445         }
1446
1447         /* login(1) is only called if we execute the login shell */
1448         if (options.use_login && command != NULL)
1449                 options.use_login = 0;
1450
1451 #ifdef _UNICOS
1452         cray_setup(pw->pw_uid, pw->pw_name, command);
1453 #endif /* _UNICOS */
1454
1455         /*
1456          * Login(1) does this as well, and it needs uid 0 for the "-h"
1457          * switch, so we let login(1) to this for us.
1458          */
1459         if (!options.use_login) {
1460 #ifdef HAVE_OSF_SIA
1461                 session_setup_sia(pw, s->ttyfd == -1 ? NULL : s->tty);
1462                 if (!check_quietlogin(s, command))
1463                         do_motd();
1464 #else /* HAVE_OSF_SIA */
1465                 /* When PAM is enabled we rely on it to do the nologin check */
1466                 if (!options.use_pam)
1467                         do_nologin(pw);
1468                 do_setusercontext(pw);
1469                 /*
1470                  * PAM session modules in do_setusercontext may have
1471                  * generated messages, so if this in an interactive
1472                  * login then display them too.
1473                  */
1474                 if (!check_quietlogin(s, command))
1475                         display_loginmsg();
1476 #endif /* HAVE_OSF_SIA */
1477         }
1478
1479 #ifdef USE_PAM
1480         if (options.use_pam && !options.use_login && !is_pam_session_open()) {
1481                 debug3("PAM session not opened, exiting");
1482                 display_loginmsg();
1483                 exit(254);
1484         }
1485 #endif
1486
1487         /*
1488          * Get the shell from the password data.  An empty shell field is
1489          * legal, and means /bin/sh.
1490          */
1491         shell = (pw->pw_shell[0] == '\0') ? _PATH_BSHELL : pw->pw_shell;
1492
1493         /*
1494          * Make sure $SHELL points to the shell from the password file,
1495          * even if shell is overridden from login.conf
1496          */
1497         env = do_setup_env(s, shell);
1498
1499 #ifdef HAVE_LOGIN_CAP
1500         shell = login_getcapstr(lc, "shell", (char *)shell, (char *)shell);
1501 #endif
1502
1503         /* we have to stash the hostname before we close our socket. */
1504         if (options.use_login)
1505                 hostname = get_remote_name_or_ip(utmp_len,
1506                     options.use_dns);
1507         /*
1508          * Close the connection descriptors; note that this is the child, and
1509          * the server will still have the socket open, and it is important
1510          * that we do not shutdown it.  Note that the descriptors cannot be
1511          * closed before building the environment, as we call
1512          * get_remote_ipaddr there.
1513          */
1514         child_close_fds();
1515
1516         /*
1517          * Must take new environment into use so that .ssh/rc,
1518          * /etc/ssh/sshrc and xauth are run in the proper environment.
1519          */
1520         environ = env;
1521
1522 #if defined(KRB5) && defined(USE_AFS)
1523         /*
1524          * At this point, we check to see if AFS is active and if we have
1525          * a valid Kerberos 5 TGT. If so, it seems like a good idea to see
1526          * if we can (and need to) extend the ticket into an AFS token. If
1527          * we don't do this, we run into potential problems if the user's
1528          * home directory is in AFS and it's not world-readable.
1529          */
1530
1531         if (options.kerberos_get_afs_token && k_hasafs() &&
1532             (s->authctxt->krb5_ctx != NULL)) {
1533                 char cell[64];
1534
1535                 debug("Getting AFS token");
1536
1537                 k_setpag();
1538
1539                 if (k_afs_cell_of_file(pw->pw_dir, cell, sizeof(cell)) == 0)
1540                         krb5_afslog(s->authctxt->krb5_ctx,
1541                             s->authctxt->krb5_fwd_ccache, cell, NULL);
1542
1543                 krb5_afslog_home(s->authctxt->krb5_ctx,
1544                     s->authctxt->krb5_fwd_ccache, NULL, NULL, pw->pw_dir);
1545         }
1546 #endif
1547
1548         /* Change current directory to the user's home directory. */
1549         if (chdir(pw->pw_dir) < 0) {
1550                 fprintf(stderr, "Could not chdir to home directory %s: %s\n",
1551                     pw->pw_dir, strerror(errno));
1552 #ifdef HAVE_LOGIN_CAP
1553                 if (login_getcapbool(lc, "requirehome", 0))
1554                         exit(1);
1555 #endif
1556         }
1557
1558         if (!options.use_login)
1559                 do_rc_files(s, shell);
1560
1561         /* restore SIGPIPE for child */
1562         signal(SIGPIPE,  SIG_DFL);
1563
1564         if (options.use_login) {
1565                 launch_login(pw, hostname);
1566                 /* NEVERREACHED */
1567         }
1568
1569         /* Get the last component of the shell name. */
1570         if ((shell0 = strrchr(shell, '/')) != NULL)
1571                 shell0++;
1572         else
1573                 shell0 = shell;
1574
1575         /*
1576          * If we have no command, execute the shell.  In this case, the shell
1577          * name to be passed in argv[0] is preceded by '-' to indicate that
1578          * this is a login shell.
1579          */
1580         if (!command) {
1581                 char argv0[256];
1582
1583                 /* Start the shell.  Set initial character to '-'. */
1584                 argv0[0] = '-';
1585
1586                 if (strlcpy(argv0 + 1, shell0, sizeof(argv0) - 1)
1587                     >= sizeof(argv0) - 1) {
1588                         errno = EINVAL;
1589                         perror(shell);
1590                         exit(1);
1591                 }
1592
1593                 /* Execute the shell. */
1594                 argv[0] = argv0;
1595                 argv[1] = NULL;
1596                 execve(shell, argv, env);
1597
1598                 /* Executing the shell failed. */
1599                 perror(shell);
1600                 exit(1);
1601         }
1602         /*
1603          * Execute the command using the user's shell.  This uses the -c
1604          * option to execute the command.
1605          */
1606         argv[0] = (char *) shell0;
1607         argv[1] = "-c";
1608         argv[2] = (char *) command;
1609         argv[3] = NULL;
1610         execve(shell, argv, env);
1611         perror(shell);
1612         exit(1);
1613 }
1614
1615 Session *
1616 session_new(void)
1617 {
1618         int i;
1619         static int did_init = 0;
1620         if (!did_init) {
1621                 debug("session_new: init");
1622                 for (i = 0; i < MAX_SESSIONS; i++) {
1623                         sessions[i].used = 0;
1624                 }
1625                 did_init = 1;
1626         }
1627         for (i = 0; i < MAX_SESSIONS; i++) {
1628                 Session *s = &sessions[i];
1629                 if (! s->used) {
1630                         memset(s, 0, sizeof(*s));
1631                         s->chanid = -1;
1632                         s->ptyfd = -1;
1633                         s->ttyfd = -1;
1634                         s->used = 1;
1635                         s->self = i;
1636                         s->x11_chanids = NULL;
1637                         debug("session_new: session %d", i);
1638                         return s;
1639                 }
1640         }
1641         return NULL;
1642 }
1643
1644 static void
1645 session_dump(void)
1646 {
1647         int i;
1648         for (i = 0; i < MAX_SESSIONS; i++) {
1649                 Session *s = &sessions[i];
1650                 debug("dump: used %d session %d %p channel %d pid %ld",
1651                     s->used,
1652                     s->self,
1653                     s,
1654                     s->chanid,
1655                     (long)s->pid);
1656         }
1657 }
1658
1659 int
1660 session_open(Authctxt *authctxt, int chanid)
1661 {
1662         Session *s = session_new();
1663         debug("session_open: channel %d", chanid);
1664         if (s == NULL) {
1665                 error("no more sessions");
1666                 return 0;
1667         }
1668         s->authctxt = authctxt;
1669         s->pw = authctxt->pw;
1670         if (s->pw == NULL || !authctxt->valid)
1671                 fatal("no user for session %d", s->self);
1672         debug("session_open: session %d: link with channel %d", s->self, chanid);
1673         s->chanid = chanid;
1674         return 1;
1675 }
1676
1677 Session *
1678 session_by_tty(char *tty)
1679 {
1680         int i;
1681         for (i = 0; i < MAX_SESSIONS; i++) {
1682                 Session *s = &sessions[i];
1683                 if (s->used && s->ttyfd != -1 && strcmp(s->tty, tty) == 0) {
1684                         debug("session_by_tty: session %d tty %s", i, tty);
1685                         return s;
1686                 }
1687         }
1688         debug("session_by_tty: unknown tty %.100s", tty);
1689         session_dump();
1690         return NULL;
1691 }
1692
1693 static Session *
1694 session_by_channel(int id)
1695 {
1696         int i;
1697         for (i = 0; i < MAX_SESSIONS; i++) {
1698                 Session *s = &sessions[i];
1699                 if (s->used && s->chanid == id) {
1700                         debug("session_by_channel: session %d channel %d", i, id);
1701                         return s;
1702                 }
1703         }
1704         debug("session_by_channel: unknown channel %d", id);
1705         session_dump();
1706         return NULL;
1707 }
1708
1709 static Session *
1710 session_by_x11_channel(int id)
1711 {
1712         int i, j;
1713
1714         for (i = 0; i < MAX_SESSIONS; i++) {
1715                 Session *s = &sessions[i];
1716
1717                 if (s->x11_chanids == NULL || !s->used)
1718                         continue;
1719                 for (j = 0; s->x11_chanids[j] != -1; j++) {
1720                         if (s->x11_chanids[j] == id) {
1721                                 debug("session_by_x11_channel: session %d "
1722                                     "channel %d", s->self, id);
1723                                 return s;
1724                         }
1725                 }
1726         }
1727         debug("session_by_x11_channel: unknown channel %d", id);
1728         session_dump();
1729         return NULL;
1730 }
1731
1732 static Session *
1733 session_by_pid(pid_t pid)
1734 {
1735         int i;
1736         debug("session_by_pid: pid %ld", (long)pid);
1737         for (i = 0; i < MAX_SESSIONS; i++) {
1738                 Session *s = &sessions[i];
1739                 if (s->used && s->pid == pid)
1740                         return s;
1741         }
1742         error("session_by_pid: unknown pid %ld", (long)pid);
1743         session_dump();
1744         return NULL;
1745 }
1746
1747 static int
1748 session_window_change_req(Session *s)
1749 {
1750         s->col = packet_get_int();
1751         s->row = packet_get_int();
1752         s->xpixel = packet_get_int();
1753         s->ypixel = packet_get_int();
1754         packet_check_eom();
1755         pty_change_window_size(s->ptyfd, s->row, s->col, s->xpixel, s->ypixel);
1756         return 1;
1757 }
1758
1759 static int
1760 session_pty_req(Session *s)
1761 {
1762         u_int len;
1763         int n_bytes;
1764
1765         if (no_pty_flag) {
1766                 debug("Allocating a pty not permitted for this authentication.");
1767                 return 0;
1768         }
1769         if (s->ttyfd != -1) {
1770                 packet_disconnect("Protocol error: you already have a pty.");
1771                 return 0;
1772         }
1773
1774         s->term = packet_get_string(&len);
1775
1776         if (compat20) {
1777                 s->col = packet_get_int();
1778                 s->row = packet_get_int();
1779         } else {
1780                 s->row = packet_get_int();
1781                 s->col = packet_get_int();
1782         }
1783         s->xpixel = packet_get_int();
1784         s->ypixel = packet_get_int();
1785
1786         if (strcmp(s->term, "") == 0) {
1787                 xfree(s->term);
1788                 s->term = NULL;
1789         }
1790
1791         /* Allocate a pty and open it. */
1792         debug("Allocating pty.");
1793         if (!PRIVSEP(pty_allocate(&s->ptyfd, &s->ttyfd, s->tty, sizeof(s->tty)))) {
1794                 if (s->term)
1795                         xfree(s->term);
1796                 s->term = NULL;
1797                 s->ptyfd = -1;
1798                 s->ttyfd = -1;
1799                 error("session_pty_req: session %d alloc failed", s->self);
1800                 return 0;
1801         }
1802         debug("session_pty_req: session %d alloc %s", s->self, s->tty);
1803
1804         /* for SSH1 the tty modes length is not given */
1805         if (!compat20)
1806                 n_bytes = packet_remaining();
1807         tty_parse_modes(s->ttyfd, &n_bytes);
1808
1809         if (!use_privsep)
1810                 pty_setowner(s->pw, s->tty);
1811
1812         /* Set window size from the packet. */
1813         pty_change_window_size(s->ptyfd, s->row, s->col, s->xpixel, s->ypixel);
1814
1815         packet_check_eom();
1816         session_proctitle(s);
1817         return 1;
1818 }
1819
1820 static int
1821 session_subsystem_req(Session *s)
1822 {
1823         struct stat st;
1824         u_int len;
1825         int success = 0;
1826         char *cmd, *subsys = packet_get_string(&len);
1827         u_int i;
1828
1829         packet_check_eom();
1830         logit("subsystem request for %.100s", subsys);
1831
1832         for (i = 0; i < options.num_subsystems; i++) {
1833                 if (strcmp(subsys, options.subsystem_name[i]) == 0) {
1834                         cmd = options.subsystem_command[i];
1835                         if (stat(cmd, &st) < 0) {
1836                                 error("subsystem: cannot stat %s: %s", cmd,
1837                                     strerror(errno));
1838                                 break;
1839                         }
1840                         debug("subsystem: exec() %s", cmd);
1841                         s->is_subsystem = 1;
1842                         do_exec(s, cmd);
1843                         success = 1;
1844                         break;
1845                 }
1846         }
1847
1848         if (!success)
1849                 logit("subsystem request for %.100s failed, subsystem not found",
1850                     subsys);
1851
1852         xfree(subsys);
1853         return success;
1854 }
1855
1856 static int
1857 session_x11_req(Session *s)
1858 {
1859         int success;
1860
1861         if (s->auth_proto != NULL || s->auth_data != NULL) {
1862                 error("session_x11_req: session %d: "
1863                     "x11 forwarding already active", s->self);
1864                 return 0;
1865         }
1866         s->single_connection = packet_get_char();
1867         s->auth_proto = packet_get_string(NULL);
1868         s->auth_data = packet_get_string(NULL);
1869         s->screen = packet_get_int();
1870         packet_check_eom();
1871
1872         success = session_setup_x11fwd(s);
1873         if (!success) {
1874                 xfree(s->auth_proto);
1875                 xfree(s->auth_data);
1876                 s->auth_proto = NULL;
1877                 s->auth_data = NULL;
1878         }
1879         return success;
1880 }
1881
1882 static int
1883 session_shell_req(Session *s)
1884 {
1885         packet_check_eom();
1886         do_exec(s, NULL);
1887         return 1;
1888 }
1889
1890 static int
1891 session_exec_req(Session *s)
1892 {
1893         u_int len;
1894         char *command = packet_get_string(&len);
1895         packet_check_eom();
1896         do_exec(s, command);
1897         xfree(command);
1898         return 1;
1899 }
1900
1901 static int
1902 session_break_req(Session *s)
1903 {
1904
1905         packet_get_int();       /* ignored */
1906         packet_check_eom();
1907
1908         if (s->ttyfd == -1 ||
1909             tcsendbreak(s->ttyfd, 0) < 0)
1910                 return 0;
1911         return 1;
1912 }
1913
1914 static int
1915 session_env_req(Session *s)
1916 {
1917         char *name, *val;
1918         u_int name_len, val_len, i;
1919
1920         name = packet_get_string(&name_len);
1921         val = packet_get_string(&val_len);
1922         packet_check_eom();
1923
1924         /* Don't set too many environment variables */
1925         if (s->num_env > 128) {
1926                 debug2("Ignoring env request %s: too many env vars", name);
1927                 goto fail;
1928         }
1929
1930         for (i = 0; i < options.num_accept_env; i++) {
1931                 if (match_pattern(name, options.accept_env[i])) {
1932                         debug2("Setting env %d: %s=%s", s->num_env, name, val);
1933                         s->env = xrealloc(s->env, sizeof(*s->env) *
1934                             (s->num_env + 1));
1935                         s->env[s->num_env].name = name;
1936                         s->env[s->num_env].val = val;
1937                         s->num_env++;
1938                         return (1);
1939                 }
1940         }
1941         debug2("Ignoring env request %s: disallowed name", name);
1942
1943  fail:
1944         xfree(name);
1945         xfree(val);
1946         return (0);
1947 }
1948
1949 static int
1950 session_auth_agent_req(Session *s)
1951 {
1952         static int called = 0;
1953         packet_check_eom();
1954         if (no_agent_forwarding_flag) {
1955                 debug("session_auth_agent_req: no_agent_forwarding_flag");
1956                 return 0;
1957         }
1958         if (called) {
1959                 return 0;
1960         } else {
1961                 called = 1;
1962                 return auth_input_request_forwarding(s->pw);
1963         }
1964 }
1965
1966 int
1967 session_input_channel_req(Channel *c, const char *rtype)
1968 {
1969         int success = 0;
1970         Session *s;
1971
1972         if ((s = session_by_channel(c->self)) == NULL) {
1973                 logit("session_input_channel_req: no session %d req %.100s",
1974                     c->self, rtype);
1975                 return 0;
1976         }
1977         debug("session_input_channel_req: session %d req %s", s->self, rtype);
1978
1979         /*
1980          * a session is in LARVAL state until a shell, a command
1981          * or a subsystem is executed
1982          */
1983         if (c->type == SSH_CHANNEL_LARVAL) {
1984                 if (strcmp(rtype, "shell") == 0) {
1985                         success = session_shell_req(s);
1986                 } else if (strcmp(rtype, "exec") == 0) {
1987                         success = session_exec_req(s);
1988                 } else if (strcmp(rtype, "pty-req") == 0) {
1989                         success =  session_pty_req(s);
1990                 } else if (strcmp(rtype, "x11-req") == 0) {
1991                         success = session_x11_req(s);
1992                 } else if (strcmp(rtype, "auth-agent-req@openssh.com") == 0) {
1993                         success = session_auth_agent_req(s);
1994                 } else if (strcmp(rtype, "subsystem") == 0) {
1995                         success = session_subsystem_req(s);
1996                 } else if (strcmp(rtype, "env") == 0) {
1997                         success = session_env_req(s);
1998                 }
1999         }
2000         if (strcmp(rtype, "window-change") == 0) {
2001                 success = session_window_change_req(s);
2002         } else if (strcmp(rtype, "break") == 0) {
2003                 success = session_break_req(s);
2004         }
2005
2006         return success;
2007 }
2008
2009 void
2010 session_set_fds(Session *s, int fdin, int fdout, int fderr)
2011 {
2012         if (!compat20)
2013                 fatal("session_set_fds: called for proto != 2.0");
2014         /*
2015          * now that have a child and a pipe to the child,
2016          * we can activate our channel and register the fd's
2017          */
2018         if (s->chanid == -1)
2019                 fatal("no channel for session %d", s->self);
2020         channel_set_fds(s->chanid,
2021             fdout, fdin, fderr,
2022             fderr == -1 ? CHAN_EXTENDED_IGNORE : CHAN_EXTENDED_READ,
2023             1,
2024             CHAN_SES_WINDOW_DEFAULT);
2025 }
2026
2027 /*
2028  * Function to perform pty cleanup. Also called if we get aborted abnormally
2029  * (e.g., due to a dropped connection).
2030  */
2031 void
2032 session_pty_cleanup2(Session *s)
2033 {
2034         if (s == NULL) {
2035                 error("session_pty_cleanup: no session");
2036                 return;
2037         }
2038         if (s->ttyfd == -1)
2039                 return;
2040
2041         debug("session_pty_cleanup: session %d release %s", s->self, s->tty);
2042
2043         /* Record that the user has logged out. */
2044         if (s->pid != 0)
2045                 record_logout(s->pid, s->tty, s->pw->pw_name);
2046
2047         /* Release the pseudo-tty. */
2048         if (getuid() == 0)
2049                 pty_release(s->tty);
2050
2051         /*
2052          * Close the server side of the socket pairs.  We must do this after
2053          * the pty cleanup, so that another process doesn't get this pty
2054          * while we're still cleaning up.
2055          */
2056         if (close(s->ptymaster) < 0)
2057                 error("close(s->ptymaster/%d): %s", s->ptymaster, strerror(errno));
2058
2059         /* unlink pty from session */
2060         s->ttyfd = -1;
2061 }
2062
2063 void
2064 session_pty_cleanup(Session *s)
2065 {
2066         PRIVSEP(session_pty_cleanup2(s));
2067 }
2068
2069 static char *
2070 sig2name(int sig)
2071 {
2072 #define SSH_SIG(x) if (sig == SIG ## x) return #x
2073         SSH_SIG(ABRT);
2074         SSH_SIG(ALRM);
2075         SSH_SIG(FPE);
2076         SSH_SIG(HUP);
2077         SSH_SIG(ILL);
2078         SSH_SIG(INT);
2079         SSH_SIG(KILL);
2080         SSH_SIG(PIPE);
2081         SSH_SIG(QUIT);
2082         SSH_SIG(SEGV);
2083         SSH_SIG(TERM);
2084         SSH_SIG(USR1);
2085         SSH_SIG(USR2);
2086 #undef  SSH_SIG
2087         return "SIG@openssh.com";
2088 }
2089
2090 static void
2091 session_close_x11(int id)
2092 {
2093         Channel *c;
2094
2095         if ((c = channel_by_id(id)) == NULL) {
2096                 debug("session_close_x11: x11 channel %d missing", id);
2097         } else {
2098                 /* Detach X11 listener */
2099                 debug("session_close_x11: detach x11 channel %d", id);
2100                 channel_cancel_cleanup(id);
2101                 if (c->ostate != CHAN_OUTPUT_CLOSED)
2102                         chan_mark_dead(c);
2103         }
2104 }
2105
2106 static void
2107 session_close_single_x11(int id, void *arg)
2108 {
2109         Session *s;
2110         u_int i;
2111
2112         debug3("session_close_single_x11: channel %d", id);
2113         channel_cancel_cleanup(id);
2114         if ((s  = session_by_x11_channel(id)) == NULL)
2115                 fatal("session_close_single_x11: no x11 channel %d", id);
2116         for (i = 0; s->x11_chanids[i] != -1; i++) {
2117                 debug("session_close_single_x11: session %d: "
2118                     "closing channel %d", s->self, s->x11_chanids[i]);
2119                 /*
2120                  * The channel "id" is already closing, but make sure we
2121                  * close all of its siblings.
2122                  */
2123                 if (s->x11_chanids[i] != id)
2124                         session_close_x11(s->x11_chanids[i]);
2125         }
2126         xfree(s->x11_chanids);
2127         s->x11_chanids = NULL;
2128         if (s->display) {
2129                 xfree(s->display);
2130                 s->display = NULL;
2131         }
2132         if (s->auth_proto) {
2133                 xfree(s->auth_proto);
2134                 s->auth_proto = NULL;
2135         }
2136         if (s->auth_data) {
2137                 xfree(s->auth_data);
2138                 s->auth_data = NULL;
2139         }
2140         if (s->auth_display) {
2141                 xfree(s->auth_display);
2142                 s->auth_display = NULL;
2143         }
2144 }
2145
2146 static void
2147 session_exit_message(Session *s, int status)
2148 {
2149         Channel *c;
2150
2151         if ((c = channel_lookup(s->chanid)) == NULL)
2152                 fatal("session_exit_message: session %d: no channel %d",
2153                     s->self, s->chanid);
2154         debug("session_exit_message: session %d channel %d pid %ld",
2155             s->self, s->chanid, (long)s->pid);
2156
2157         if (WIFEXITED(status)) {
2158                 channel_request_start(s->chanid, "exit-status", 0);
2159                 packet_put_int(WEXITSTATUS(status));
2160                 packet_send();
2161         } else if (WIFSIGNALED(status)) {
2162                 channel_request_start(s->chanid, "exit-signal", 0);
2163                 packet_put_cstring(sig2name(WTERMSIG(status)));
2164 #ifdef WCOREDUMP
2165                 packet_put_char(WCOREDUMP(status));
2166 #else /* WCOREDUMP */
2167                 packet_put_char(0);
2168 #endif /* WCOREDUMP */
2169                 packet_put_cstring("");
2170                 packet_put_cstring("");
2171                 packet_send();
2172         } else {
2173                 /* Some weird exit cause.  Just exit. */
2174                 packet_disconnect("wait returned status %04x.", status);
2175         }
2176
2177         /* disconnect channel */
2178         debug("session_exit_message: release channel %d", s->chanid);
2179
2180         /*
2181          * Adjust cleanup callback attachment to send close messages when
2182          * the channel gets EOF. The session will be then be closed
2183          * by session_close_by_channel when the childs close their fds.
2184          */
2185         channel_register_cleanup(c->self, session_close_by_channel, 1);
2186
2187         /*
2188          * emulate a write failure with 'chan_write_failed', nobody will be
2189          * interested in data we write.
2190          * Note that we must not call 'chan_read_failed', since there could
2191          * be some more data waiting in the pipe.
2192          */
2193         if (c->ostate != CHAN_OUTPUT_CLOSED)
2194                 chan_write_failed(c);
2195 }
2196
2197 void
2198 session_close(Session *s)
2199 {
2200         u_int i;
2201
2202         debug("session_close: session %d pid %ld", s->self, (long)s->pid);
2203         if (s->ttyfd != -1)
2204                 session_pty_cleanup(s);
2205         if (s->term)
2206                 xfree(s->term);
2207         if (s->display)
2208                 xfree(s->display);
2209         if (s->x11_chanids)
2210                 xfree(s->x11_chanids);
2211         if (s->auth_display)
2212                 xfree(s->auth_display);
2213         if (s->auth_data)
2214                 xfree(s->auth_data);
2215         if (s->auth_proto)
2216                 xfree(s->auth_proto);
2217         s->used = 0;
2218         for (i = 0; i < s->num_env; i++) {
2219                 xfree(s->env[i].name);
2220                 xfree(s->env[i].val);
2221         }
2222         if (s->env != NULL)
2223                 xfree(s->env);
2224         session_proctitle(s);
2225 }
2226
2227 void
2228 session_close_by_pid(pid_t pid, int status)
2229 {
2230         Session *s = session_by_pid(pid);
2231         if (s == NULL) {
2232                 debug("session_close_by_pid: no session for pid %ld",
2233                     (long)pid);
2234                 return;
2235         }
2236         if (s->chanid != -1)
2237                 session_exit_message(s, status);
2238         if (s->ttyfd != -1)
2239                 session_pty_cleanup(s);
2240         s->pid = 0;
2241 }
2242
2243 /*
2244  * this is called when a channel dies before
2245  * the session 'child' itself dies
2246  */
2247 void
2248 session_close_by_channel(int id, void *arg)
2249 {
2250         Session *s = session_by_channel(id);
2251         u_int i;
2252
2253         if (s == NULL) {
2254                 debug("session_close_by_channel: no session for id %d", id);
2255                 return;
2256         }
2257         debug("session_close_by_channel: channel %d child %ld",
2258             id, (long)s->pid);
2259         if (s->pid != 0) {
2260                 debug("session_close_by_channel: channel %d: has child", id);
2261                 /*
2262                  * delay detach of session, but release pty, since
2263                  * the fd's to the child are already closed
2264                  */
2265                 if (s->ttyfd != -1)
2266                         session_pty_cleanup(s);
2267                 return;
2268         }
2269         /* detach by removing callback */
2270         channel_cancel_cleanup(s->chanid);
2271
2272         /* Close any X11 listeners associated with this session */
2273         if (s->x11_chanids != NULL) {
2274                 for (i = 0; s->x11_chanids[i] != -1; i++) {
2275                         session_close_x11(s->x11_chanids[i]);
2276                         s->x11_chanids[i] = -1;
2277                 }
2278         }
2279
2280         s->chanid = -1;
2281         session_close(s);
2282 }
2283
2284 void
2285 session_destroy_all(void (*closefunc)(Session *))
2286 {
2287         int i;
2288         for (i = 0; i < MAX_SESSIONS; i++) {
2289                 Session *s = &sessions[i];
2290                 if (s->used) {
2291                         if (closefunc != NULL)
2292                                 closefunc(s);
2293                         else
2294                                 session_close(s);
2295                 }
2296         }
2297 }
2298
2299 static char *
2300 session_tty_list(void)
2301 {
2302         static char buf[1024];
2303         int i;
2304         char *cp;
2305
2306         buf[0] = '\0';
2307         for (i = 0; i < MAX_SESSIONS; i++) {
2308                 Session *s = &sessions[i];
2309                 if (s->used && s->ttyfd != -1) {
2310
2311                         if (strncmp(s->tty, "/dev/", 5) != 0) {
2312                                 cp = strrchr(s->tty, '/');
2313                                 cp = (cp == NULL) ? s->tty : cp + 1;
2314                         } else
2315                                 cp = s->tty + 5;
2316
2317                         if (buf[0] != '\0')
2318                                 strlcat(buf, ",", sizeof buf);
2319                         strlcat(buf, cp, sizeof buf);
2320                 }
2321         }
2322         if (buf[0] == '\0')
2323                 strlcpy(buf, "notty", sizeof buf);
2324         return buf;
2325 }
2326
2327 void
2328 session_proctitle(Session *s)
2329 {
2330         if (s->pw == NULL)
2331                 error("no user for session %d", s->self);
2332         else
2333                 setproctitle("%s@%s", s->pw->pw_name, session_tty_list());
2334 }
2335
2336 int
2337 session_setup_x11fwd(Session *s)
2338 {
2339         struct stat st;
2340         char display[512], auth_display[512];
2341         char hostname[MAXHOSTNAMELEN];
2342         u_int i;
2343
2344         if (no_x11_forwarding_flag) {
2345                 packet_send_debug("X11 forwarding disabled in user configuration file.");
2346                 return 0;
2347         }
2348         if (!options.x11_forwarding) {
2349                 debug("X11 forwarding disabled in server configuration file.");
2350                 return 0;
2351         }
2352         if (!options.xauth_location ||
2353             (stat(options.xauth_location, &st) == -1)) {
2354                 packet_send_debug("No xauth program; cannot forward with spoofing.");
2355                 return 0;
2356         }
2357         if (options.use_login) {
2358                 packet_send_debug("X11 forwarding disabled; "
2359                     "not compatible with UseLogin=yes.");
2360                 return 0;
2361         }
2362         if (s->display != NULL) {
2363                 debug("X11 display already set.");
2364                 return 0;
2365         }
2366         if (x11_create_display_inet(options.x11_display_offset,
2367             options.x11_use_localhost, s->single_connection,
2368             &s->display_number, &s->x11_chanids) == -1) {
2369                 debug("x11_create_display_inet failed.");
2370                 return 0;
2371         }
2372         for (i = 0; s->x11_chanids[i] != -1; i++) {
2373                 channel_register_cleanup(s->x11_chanids[i],
2374                     session_close_single_x11, 0);
2375         }
2376
2377         /* Set up a suitable value for the DISPLAY variable. */
2378         if (gethostname(hostname, sizeof(hostname)) < 0)
2379                 fatal("gethostname: %.100s", strerror(errno));
2380         /*
2381          * auth_display must be used as the displayname when the
2382          * authorization entry is added with xauth(1).  This will be
2383          * different than the DISPLAY string for localhost displays.
2384          */
2385         if (options.x11_use_localhost) {
2386                 snprintf(display, sizeof display, "localhost:%u.%u",
2387                     s->display_number, s->screen);
2388                 snprintf(auth_display, sizeof auth_display, "unix:%u.%u",
2389                     s->display_number, s->screen);
2390                 s->display = xstrdup(display);
2391                 s->auth_display = xstrdup(auth_display);
2392         } else {
2393 #ifdef IPADDR_IN_DISPLAY
2394                 struct hostent *he;
2395                 struct in_addr my_addr;
2396
2397                 he = gethostbyname(hostname);
2398                 if (he == NULL) {
2399                         error("Can't get IP address for X11 DISPLAY.");
2400                         packet_send_debug("Can't get IP address for X11 DISPLAY.");
2401                         return 0;
2402                 }
2403                 memcpy(&my_addr, he->h_addr_list[0], sizeof(struct in_addr));
2404                 snprintf(display, sizeof display, "%.50s:%u.%u", inet_ntoa(my_addr),
2405                     s->display_number, s->screen);
2406 #else
2407                 snprintf(display, sizeof display, "%.400s:%u.%u", hostname,
2408                     s->display_number, s->screen);
2409 #endif
2410                 s->display = xstrdup(display);
2411                 s->auth_display = xstrdup(display);
2412         }
2413
2414         return 1;
2415 }
2416
2417 static void
2418 do_authenticated2(Authctxt *authctxt)
2419 {
2420         server_loop2(authctxt);
2421 }
2422
2423 void
2424 do_cleanup(Authctxt *authctxt)
2425 {
2426         static int called = 0;
2427
2428         debug("do_cleanup");
2429
2430         /* no cleanup if we're in the child for login shell */
2431         if (is_child)
2432                 return;
2433
2434         /* avoid double cleanup */
2435         if (called)
2436                 return;
2437         called = 1;
2438
2439         if (authctxt == NULL)
2440                 return;
2441 #ifdef KRB5
2442         if (options.kerberos_ticket_cleanup &&
2443             authctxt->krb5_ctx)
2444                 krb5_cleanup_proc(authctxt);
2445 #endif
2446
2447 #ifdef GSSAPI
2448         if (compat20 && options.gss_cleanup_creds)
2449                 ssh_gssapi_cleanup_creds();
2450 #endif
2451
2452 #ifdef USE_PAM
2453         if (options.use_pam) {
2454                 sshpam_cleanup();
2455                 sshpam_thread_cleanup();
2456         }
2457 #endif
2458
2459         /* remove agent socket */
2460         auth_sock_cleanup_proc(authctxt->pw);
2461
2462         /*
2463          * Cleanup ptys/utmp only if privsep is disabled,
2464          * or if running in monitor.
2465          */
2466         if (!use_privsep || mm_is_monitor())
2467                 session_destroy_all(session_pty_cleanup2);
2468 }