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