crypto/openssh/session.c

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