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