1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30 /*
31 * University Copyright- Copyright (c) 1982, 1986, 1988
32 * The Regents of the University of California
33 * All Rights Reserved
34 *
35 * University Acknowledgment- Portions of this document are derived from
36 * software developed by the University of California, Berkeley, and its
37 * contributors.
38 */
39
40 /* Copyright (c) 1987, 1988 Microsoft Corporation */
41 /* All Rights Reserved */
42
43 /*
44 * For a complete reference to login(1), see the manual page. However,
45 * login has accreted some intentionally undocumented options, which are
46 * explained here:
47 *
48 * -a: This legacy flag appears to be unused.
49 *
50 * -f <username>: This flag was introduced by PSARC 1995/039 in support
51 * of Kerberos. But it's not used by Sun's Kerberos implementation.
52 * It is however employed by zlogin(1), since it allows one to tell
53 * login: "This user is authenticated." In the case of zlogin that's
54 * true because the zone always trusts the global zone.
55 *
56 * -z <zonename>: This flag is passed to login when zlogin(1) executes a
57 * zone login. This tells login(1) to skip it's normal CONSOLE check
58 * (i.e. that the root login must be on /dev/console) and tells us the
59 * name of the zone from which the login is occurring.
60 */
61
62 #include <sys/types.h>
63 #include <sys/param.h>
64 #include <unistd.h> /* For logfile locking */
65 #include <signal.h>
66 #include <stdio.h>
67 #include <sys/stat.h>
68 #include <string.h>
69 #include <deflt.h>
70 #include <grp.h>
71 #include <fcntl.h>
72 #include <lastlog.h>
73 #include <termio.h>
74 #include <utmpx.h>
75 #include <stdlib.h>
76 #include <wait.h>
77 #include <errno.h>
78 #include <ctype.h>
79 #include <syslog.h>
80 #include <ulimit.h>
81 #include <libgen.h>
82 #include <pwd.h>
83 #include <security/pam_appl.h>
84 #include <strings.h>
85 #include <libdevinfo.h>
86 #include <zone.h>
87 #include "login_audit.h"
88
89 #include <krb5_repository.h>
90 /*
91 *
92 * *** Defines, Macros, and String Constants ***
93 *
94 *
95 */
96
97 #define ISSUEFILE "/etc/issue" /* file to print before prompt */
98 #define NOLOGIN "/etc/nologin" /* file to lock users out during shutdown */
99
100 /*
101 * These need to be defined for UTMPX management.
102 * If we add in the utility functions later, we
103 * can remove them.
104 */
105 #define __UPDATE_ENTRY 1
106 #define __LOGIN 2
107
108 /*
109 * Intervals to sleep after failed login
110 */
111 #ifndef SLEEPTIME
112 #define SLEEPTIME 4 /* sleeptime before login incorrect msg */
113 #endif
114 static int Sleeptime = SLEEPTIME;
115
116 /*
117 * seconds login disabled after allowable number of unsuccessful attempts
118 */
119 #ifndef DISABLETIME
120 #define DISABLETIME 20
121 #endif
122 static int Disabletime = DISABLETIME;
123
124 #define MAXTRYS 5
125
126 static int retry = MAXTRYS;
127
128 /*
129 * Login logging support
130 */
131 #define LOGINLOG "/var/adm/loginlog" /* login log file */
132 #define LNAME_SIZE 20 /* size of logged logname */
133 #define TTYN_SIZE 15 /* size of logged tty name */
134 #define TIME_SIZE 30 /* size of logged time string */
135 #define ENT_SIZE (LNAME_SIZE + TTYN_SIZE + TIME_SIZE + 3)
136 #define L_WAITTIME 5 /* waittime for log file to unlock */
137 #define LOGTRYS 10 /* depth of 'try' logging */
138
139 /*
140 * String manipulation macros: SCPYN, SCPYL, EQN and ENVSTRNCAT
141 * SCPYL is the safer version of SCPYN
142 */
143 #define SCPYL(a, b) (void) strlcpy(a, b, sizeof (a))
144 #define SCPYN(a, b) (void) strncpy(a, b, sizeof (a))
145 #define EQN(a, b) (strncmp(a, b, sizeof (a)-1) == 0)
146 #define ENVSTRNCAT(to, from) {int deflen; deflen = strlen(to); \
147 (void) strncpy((to)+ deflen, (from), sizeof (to) - (1 + deflen)); }
148
149 /*
150 * Other macros
151 */
152 #define NMAX sizeof (((struct utmpx *)0)->ut_name)
153 #define HMAX sizeof (((struct utmpx *)0)->ut_host)
154 #define min(a, b) (((a) < (b)) ? (a) : (b))
155
156 /*
157 * Various useful files and string constants
158 */
159 #define SHELL "/usr/bin/sh"
160 #define SHELL2 "/sbin/sh"
161 #define SUBLOGIN "<!sublogin>"
162 #define LASTLOG "/var/adm/lastlog"
163 #define PROG_NAME "login"
164 #define HUSHLOGIN ".hushlogin"
165
166 /*
167 * Array and Buffer sizes
168 */
169 #define PBUFSIZE 8 /* max significant characters in a password */
170 #define MAXARGS 63 /* change value below if changing this */
171 #define MAXARGSWIDTH 2 /* log10(MAXARGS) */
172 #define MAXENV 1024
173 #define MAXLINE 2048
174
175 /*
176 * Miscellaneous constants
177 */
178 #define ROOTUID 0
179 #define ERROR 1
180 #define OK 0
181 #define LOG_ERROR 1
182 #define DONT_LOG_ERROR 0
183 #define TRUE 1
184 #define FALSE 0
185
186 /*
187 * Counters for counting the number of failed login attempts
188 */
189 static int trys = 0;
190 static int count = 1;
191
192 /*
193 * error value for login_exit() audit output (0 == no audit record)
194 */
195 static int audit_error = 0;
196
197 /*
198 * Externs a plenty
199 */
200 extern int getsecretkey();
201
202 /*
203 * The current user name
204 */
205 static char user_name[NMAX];
206 static char minusnam[16] = "-";
207
208 /*
209 * login_pid, used to find utmpx entry to update.
210 */
211 static pid_t login_pid;
212
213 /*
214 * locale environments to be passed to shells.
215 */
216 static char *localeenv[] = {
217 "LANG",
218 "LC_CTYPE", "LC_NUMERIC", "LC_TIME", "LC_COLLATE",
219 "LC_MONETARY", "LC_MESSAGES", "LC_ALL", 0};
220 static int locale_envmatch(char *, char *);
221
222 /*
223 * Environment variable support
224 */
225 static char shell[256] = { "SHELL=" };
226 static char home[MAXPATHLEN] = { "HOME=" };
227 static char term[64] = { "TERM=" };
228 static char logname[30] = { "LOGNAME=" };
229 static char timez[100] = { "TZ=" };
230 static char hertz[10] = { "HZ=" };
231 static char path[MAXPATHLEN] = { "PATH=" };
232 static char *newenv[10+MAXARGS] =
233 {home, path, logname, hertz, term, 0, 0};
234 static char **envinit = newenv;
235 static int basicenv;
236 static char *zero = (char *)0;
237 static char **envp;
238 #ifndef NO_MAIL
239 static char mail[30] = { "MAIL=/var/mail/" };
240 #endif
241 extern char **environ;
242 static char inputline[MAXLINE];
243
244 #define MAX_ID_LEN 256
245 #define MAX_REPOSITORY_LEN 256
246 #define MAX_PAMSERVICE_LEN 256
247
248 static char identity[MAX_ID_LEN];
249 static char repository[MAX_REPOSITORY_LEN];
250 static char progname[MAX_PAMSERVICE_LEN];
251
252
253 /*
254 * Strings used to prompt the user.
255 */
256 static char loginmsg[] = "login: ";
257 static char passwdmsg[] = "Password:";
258 static char incorrectmsg[] = "Login incorrect\n";
259
260 /*
261 * Password file support
262 */
263 static struct passwd *pwd = NULL;
264 static char remote_host[HMAX];
265 static char zone_name[ZONENAME_MAX];
266
267 /*
268 * Illegal passwd entries.
269 */
270 static struct passwd nouser = { "", "no:password", (uid_t)-1 };
271
272 /*
273 * Log file support
274 */
275 static char *log_entry[LOGTRYS];
276 static int writelog = 0;
277 static int lastlogok = 0;
278 static struct lastlog ll;
279 static int dosyslog = 0;
280 static int flogin = MAXTRYS; /* flag for SYSLOG_FAILED_LOGINS */
281
282 /*
283 * Default file toggles
284 */
285 static char *Pndefault = "/etc/default/login";
286 static char *Altshell = NULL;
287 static char *Console = NULL;
288 static int Passreqflag = 0;
289
290 #define DEFUMASK 022
291 static mode_t Umask = DEFUMASK;
292 static char *Def_tz = NULL;
293 static char *tmp_tz = NULL;
294 static char *Def_hertz = NULL;
295 #define SET_FSIZ 2 /* ulimit() command arg */
296 static long Def_ulimit = 0;
297 #define MAX_TIMEOUT (15 * 60)
298 #define DEF_TIMEOUT (5 * 60)
299 static unsigned Def_timeout = DEF_TIMEOUT;
300 static char *Def_path = NULL;
301 static char *Def_supath = NULL;
302 #define DEF_PATH "/usr/bin:" /* same as PATH */
303 #define DEF_SUPATH "/usr/sbin:/usr/bin" /* same as ROOTPATH */
304
305 /*
306 * Defaults for updating expired passwords
307 */
308 #define DEF_ATTEMPTS 3
309
310 /*
311 * ttyprompt will point to the environment variable TTYPROMPT.
312 * TTYPROMPT is set by ttymon if ttymon already wrote out the prompt.
313 */
314 static char *ttyprompt = NULL;
315 static char *ttyn = NULL;
316
317 /*
318 * Pass inherited environment. Used by telnetd in support of the telnet
319 * ENVIRON option.
320 */
321 static boolean_t pflag = B_FALSE;
322 static boolean_t uflag = B_FALSE;
323 static boolean_t Rflag = B_FALSE;
324 static boolean_t sflag = B_FALSE;
325 static boolean_t Uflag = B_FALSE;
326 static boolean_t tflag = B_FALSE;
327 static boolean_t hflag = B_FALSE;
328 static boolean_t rflag = B_FALSE;
329 static boolean_t zflag = B_FALSE;
330
331 /*
332 * Remote login support
333 */
334 static char rusername[NMAX+1], lusername[NMAX+1];
335 static char terminal[MAXPATHLEN];
336
337 /*
338 * Pre-authentication flag support
339 */
340 static int fflag;
341
342 static char ** getargs(char *);
343
344 static int login_conv(int, struct pam_message **,
345 struct pam_response **, void *);
346
347 static struct pam_conv pam_conv = {login_conv, NULL};
348 static pam_handle_t *pamh; /* Authentication handle */
349
350 /*
351 * Function declarations
352 */
353 static void turn_on_logging(void);
354 static void defaults(void);
355 static void usage(void);
356 static void process_rlogin(void);
357 static void login_authenticate();
358 static void setup_credentials(void);
359 static void adjust_nice(void);
360 static void update_utmpx_entry(int);
361 static void establish_user_environment(char **);
362 static void print_banner(void);
363 static void display_last_login_time(void);
364 static void exec_the_shell(void);
365 static int process_chroot_logins(void);
366 static void chdir_to_dir_user(void);
367 static void check_log(void);
368 static void validate_account(void);
369 static void doremoteterm(char *);
370 static int get_options(int, char **);
371 static void getstr(char *, int, char *);
372 static int legalenvvar(char *);
373 static void check_for_console(void);
374 static void check_for_dueling_unix(char *);
375 static void get_user_name(void);
376 static uint_t get_audit_id(void);
377 static void login_exit(int)__NORETURN;
378 static int logins_disabled(char *);
379 static void log_bad_attempts(void);
380 static int is_number(char *);
381
382 /*
383 * *** main ***
384 *
385 * The primary flow of control is directed in this routine.
386 * Control moves in line from top to bottom calling subfunctions
387 * which perform the bulk of the work. Many of these calls exit
388 * when a fatal error is encountered and do not return to main.
389 *
390 *
391 */
392
393 int
394 main(int argc, char *argv[], char **renvp)
395 {
396 int sublogin;
397 int pam_rc;
398
399 login_pid = getpid();
400
401 /*
402 * Set up Defaults and flags
403 */
404 defaults();
405 SCPYL(progname, PROG_NAME);
406
407 /*
408 * Set up default umask
409 */
410 if (Umask > ((mode_t)0777))
411 Umask = DEFUMASK;
412 (void) umask(Umask);
413
414 /*
415 * Set up default timeouts and delays
416 */
417 if (Def_timeout > MAX_TIMEOUT)
418 Def_timeout = MAX_TIMEOUT;
419 if (Sleeptime < 0 || Sleeptime > 5)
420 Sleeptime = SLEEPTIME;
421
422 (void) alarm(Def_timeout);
423
424 /*
425 * Ignore SIGQUIT and SIGINT and set nice to 0
426 */
427 (void) signal(SIGQUIT, SIG_IGN);
428 (void) signal(SIGINT, SIG_IGN);
429 (void) nice(0);
430
431 /*
432 * Set flag to disable the pid check if you find that you are
433 * a subsystem login.
434 */
435 sublogin = 0;
436 if (*renvp && strcmp(*renvp, SUBLOGIN) == 0)
437 sublogin = 1;
438
439 /*
440 * Parse Arguments
441 */
442 if (get_options(argc, argv) == -1) {
443 usage();
444 audit_error = ADT_FAIL_VALUE_BAD_CMD;
445 login_exit(1);
446 }
447
448 /*
449 * if devicename is not passed as argument, call ttyname(0)
450 */
451 if (ttyn == NULL) {
452 ttyn = ttyname(0);
453 if (ttyn == NULL)
454 ttyn = "/dev/???";
455 }
456
457 /*
458 * Call pam_start to initiate a PAM authentication operation
459 */
460
461 if ((pam_rc = pam_start(progname, user_name, &pam_conv, &pamh))
462 != PAM_SUCCESS) {
463 audit_error = ADT_FAIL_PAM + pam_rc;
464 login_exit(1);
465 }
466 if ((pam_rc = pam_set_item(pamh, PAM_TTY, ttyn)) != PAM_SUCCESS) {
467 audit_error = ADT_FAIL_PAM + pam_rc;
468 login_exit(1);
469 }
470 if ((pam_rc = pam_set_item(pamh, PAM_RHOST, remote_host)) !=
471 PAM_SUCCESS) {
472 audit_error = ADT_FAIL_PAM + pam_rc;
473 login_exit(1);
474 }
475
476 /*
477 * We currently only support special handling of the KRB5 PAM repository
478 */
479 if ((Rflag && strlen(repository)) &&
480 strcmp(repository, KRB5_REPOSITORY_NAME) == 0 &&
481 (uflag && strlen(identity))) {
482 krb5_repository_data_t krb5_data;
483 pam_repository_t pam_rep_data;
484
485 krb5_data.principal = identity;
486 krb5_data.flags = SUNW_PAM_KRB5_ALREADY_AUTHENTICATED;
487
488 pam_rep_data.type = repository;
489 pam_rep_data.scope = (void *)&krb5_data;
490 pam_rep_data.scope_len = sizeof (krb5_data);
491
492 (void) pam_set_item(pamh, PAM_REPOSITORY,
493 (void *)&pam_rep_data);
494 }
495
496 /*
497 * Open the log file which contains a record of successful and failed
498 * login attempts
499 */
500 turn_on_logging();
501
502 /*
503 * say "hi" to syslogd ..
504 */
505 openlog("login", 0, LOG_AUTH);
506
507 /*
508 * Do special processing for -r (rlogin) flag
509 */
510 if (rflag)
511 process_rlogin();
512
513 /*
514 * validate user
515 */
516 /* we are already authenticated. fill in what we must, then continue */
517 if (fflag) {
518 if ((pwd = getpwnam(user_name)) == NULL) {
519 audit_error = ADT_FAIL_VALUE_USERNAME;
520
521 log_bad_attempts();
522 (void) printf("Login failed: unknown user '%s'.\n",
523 user_name);
524 login_exit(1);
525 }
526 } else {
527 /*
528 * Perform the primary login authentication activity.
529 */
530 login_authenticate();
531 }
532
533 /* change root login, then we exec another login and try again */
534 if (process_chroot_logins() != OK)
535 login_exit(1);
536
537 /*
538 * If root login and not on system console then call exit(2)
539 */
540 check_for_console();
541
542 /*
543 * Check to see if a shutdown is in progress, if it is and
544 * we are not root then throw the user off the system
545 */
546 if (logins_disabled(user_name) == TRUE) {
547 audit_error = ADT_FAIL_VALUE_LOGIN_DISABLED;
548 login_exit(1);
549 }
550
551 if (pwd->pw_uid == 0) {
552 if (Def_supath != NULL)
553 Def_path = Def_supath;
554 else
555 Def_path = DEF_SUPATH;
556 }
557
558 /*
559 * Check account expiration and passwd aging
560 */
561 validate_account();
562
563 /*
564 * We only get here if we've been authenticated.
565 */
566
567 /*
568 * Now we set up the environment for the new user, which includes
569 * the users ulimit, nice value, ownership of this tty, uid, gid,
570 * and environment variables.
571 */
572 if (Def_ulimit > 0L && ulimit(SET_FSIZ, Def_ulimit) < 0L)
573 (void) printf("Could not set ULIMIT to %ld\n", Def_ulimit);
574
575 /* di_devperm_login() sends detailed errors to syslog */
576 if (di_devperm_login((const char *)ttyn, pwd->pw_uid, pwd->pw_gid,
577 NULL) == -1) {
578 (void) fprintf(stderr, "error processing /etc/logindevperm,"
579 " see syslog for more details\n");
580 }
581
582 adjust_nice(); /* passwd file can specify nice value */
583
584 setup_credentials(); /* Set user credentials - exits on failure */
585
586 /*
587 * NOTE: telnetd and rlogind rely upon this updating of utmpx
588 * to indicate that the authentication completed successfully,
589 * pam_open_session was called and therefore they are required to
590 * call pam_close_session.
591 */
592 update_utmpx_entry(sublogin);
593
594 /* set the real (and effective) UID */
595 if (setuid(pwd->pw_uid) == -1) {
596 login_exit(1);
597 }
598
599 /*
600 * Set up the basic environment for the exec. This includes
601 * HOME, PATH, LOGNAME, SHELL, TERM, TZ, HZ, and MAIL.
602 */
603 chdir_to_dir_user();
604
605 establish_user_environment(renvp);
606
607 (void) pam_end(pamh, PAM_SUCCESS); /* Done using PAM */
608 pamh = NULL;
609
610 if (pwd->pw_uid == 0) {
611 if (dosyslog) {
612 if (remote_host[0]) {
613 syslog(LOG_NOTICE, "ROOT LOGIN %s FROM %.*s",
614 ttyn, HMAX, remote_host);
615 } else
616 syslog(LOG_NOTICE, "ROOT LOGIN %s", ttyn);
617 }
618 }
619 closelog();
620
621 (void) signal(SIGQUIT, SIG_DFL);
622 (void) signal(SIGINT, SIG_DFL);
623
624 /*
625 * Display some useful information to the new user like the banner
626 * and last login time if not a quiet login.
627 */
628
629 if (access(HUSHLOGIN, F_OK) != 0) {
630 print_banner();
631 display_last_login_time();
632 }
633
634 /*
635 * Set SIGXCPU and SIGXFSZ to default disposition.
636 * Shells inherit signal disposition from parent.
637 * And the shells should have default dispositions
638 * for the two below signals.
639 */
640 (void) signal(SIGXCPU, SIG_DFL);
641 (void) signal(SIGXFSZ, SIG_DFL);
642
643 /*
644 * Now fire off the shell of choice
645 */
646 exec_the_shell();
647
648 /*
649 * All done
650 */
651 login_exit(1);
652 return (0);
653 }
654
655
656 /*
657 * *** Utility functions ***
658 */
659
660
661
662 /*
663 * donothing & catch - Signal catching functions
664 */
665
666 /*ARGSUSED*/
667 static void
668 donothing(int sig)
669 {
670 if (pamh)
671 (void) pam_end(pamh, PAM_ABORT);
672 }
673
674 #ifdef notdef
675 static int intrupt;
676
677 /*ARGSUSED*/
678 static void
679 catch(int sig)
680 {
681 ++intrupt;
682 }
683 #endif
684
685 /*
686 * *** Bad login logging support ***
687 */
688
689 /*
690 * badlogin() - log to the log file 'trys'
691 * unsuccessful attempts
692 */
693
694 static void
695 badlogin(void)
696 {
697 int retval, count1, fildes;
698
699 /*
700 * Tries to open the log file. If succeed, lock it and write
701 * in the failed attempts
702 */
703 if ((fildes = open(LOGINLOG, O_APPEND|O_WRONLY)) != -1) {
704
705 (void) sigset(SIGALRM, donothing);
706 (void) alarm(L_WAITTIME);
707 retval = lockf(fildes, F_LOCK, 0L);
708 (void) alarm(0);
709 (void) sigset(SIGALRM, SIG_DFL);
710 if (retval == 0) {
711 for (count1 = 0; count1 < trys; count1++)
712 (void) write(fildes, log_entry[count1],
713 (unsigned)strlen(log_entry[count1]));
714 (void) lockf(fildes, F_ULOCK, 0L);
715 }
716 (void) close(fildes);
717 }
718 }
719
720
721 /*
722 * log_bad_attempts - log each bad login attempt - called from
723 * login_authenticate. Exits when the maximum attempt
724 * count is exceeded.
725 */
726
727 static void
728 log_bad_attempts(void)
729 {
730 time_t timenow;
731
732 if (trys >= LOGTRYS)
733 return;
734 if (writelog) {
735 (void) time(&timenow);
736 (void) strncat(log_entry[trys], user_name, LNAME_SIZE);
737 (void) strncat(log_entry[trys], ":", (size_t)1);
738 (void) strncat(log_entry[trys], ttyn, TTYN_SIZE);
739 (void) strncat(log_entry[trys], ":", (size_t)1);
740 (void) strncat(log_entry[trys], ctime(&timenow), TIME_SIZE);
741 trys++;
742 }
743 if (count > flogin) {
744 if ((pwd = getpwnam(user_name)) != NULL) {
745 if (remote_host[0]) {
746 syslog(LOG_NOTICE,
747 "Login failure on %s from %.*s, "
748 "%.*s", ttyn, HMAX, remote_host,
749 NMAX, user_name);
750 } else {
751 syslog(LOG_NOTICE,
752 "Login failure on %s, %.*s",
753 ttyn, NMAX, user_name);
754 }
755 } else {
756 if (remote_host[0]) {
757 syslog(LOG_NOTICE,
758 "Login failure on %s from %.*s",
759 ttyn, HMAX, remote_host);
760 } else {
761 syslog(LOG_NOTICE,
762 "Login failure on %s", ttyn);
763 }
764 }
765 }
766 }
767
768
769 /*
770 * turn_on_logging - if the logfile exist, turn on attempt logging and
771 * initialize the string storage area
772 */
773
774 static void
775 turn_on_logging(void)
776 {
777 struct stat dbuf;
778 int i;
779
780 if (stat(LOGINLOG, &dbuf) == 0) {
781 writelog = 1;
782 for (i = 0; i < LOGTRYS; i++) {
783 if (!(log_entry[i] = malloc((size_t)ENT_SIZE))) {
784 writelog = 0;
785 break;
786 }
787 *log_entry[i] = '\0';
788 }
789 }
790 }
791
792
793 /*
794 * login_conv():
795 * This is the conv (conversation) function called from
796 * a PAM authentication module to print error messages
797 * or garner information from the user.
798 */
799 /*ARGSUSED*/
800 static int
801 login_conv(int num_msg, struct pam_message **msg,
802 struct pam_response **response, void *appdata_ptr)
803 {
804 struct pam_message *m;
805 struct pam_response *r;
806 char *temp;
807 int k, i;
808
809 if (num_msg <= 0)
810 return (PAM_CONV_ERR);
811
812 *response = calloc(num_msg, sizeof (struct pam_response));
813 if (*response == NULL)
814 return (PAM_BUF_ERR);
815
816 k = num_msg;
817 m = *msg;
818 r = *response;
819 while (k--) {
820
821 switch (m->msg_style) {
822
823 case PAM_PROMPT_ECHO_OFF:
824 errno = 0;
825 temp = getpassphrase(m->msg);
826 if (temp != NULL) {
827 if (errno == EINTR)
828 return (PAM_CONV_ERR);
829
830 r->resp = strdup(temp);
831 if (r->resp == NULL) {
832 /* free responses */
833 r = *response;
834 for (i = 0; i < num_msg; i++, r++) {
835 if (r->resp)
836 free(r->resp);
837 }
838 free(*response);
839 *response = NULL;
840 return (PAM_BUF_ERR);
841 }
842 }
843
844 m++;
845 r++;
846 break;
847
848 case PAM_PROMPT_ECHO_ON:
849 if (m->msg != NULL)
850 (void) fputs(m->msg, stdout);
851 r->resp = calloc(1, PAM_MAX_RESP_SIZE);
852 if (r->resp == NULL) {
853 /* free responses */
854 r = *response;
855 for (i = 0; i < num_msg; i++, r++) {
856 if (r->resp)
857 free(r->resp);
858 }
859 free(*response);
860 *response = NULL;
861 return (PAM_BUF_ERR);
862 }
863 /*
864 * The response might include environment variables
865 * information. We should store that information in
866 * envp if there is any; otherwise, envp is set to
867 * NULL.
868 */
869 bzero((void *)inputline, MAXLINE);
870
871 envp = getargs(inputline);
872
873 /* If we read in any input, process it. */
874 if (inputline[0] != '\0') {
875 int len;
876
877 if (envp != (char **)NULL)
878 /*
879 * If getargs() did not return NULL,
880 * *envp is the first string in
881 * inputline. envp++ makes envp point
882 * to environment variables information
883 * or be NULL.
884 */
885 envp++;
886
887 (void) strncpy(r->resp, inputline,
888 PAM_MAX_RESP_SIZE-1);
889 r->resp[PAM_MAX_RESP_SIZE-1] = NULL;
890 len = strlen(r->resp);
891 if (r->resp[len-1] == '\n')
892 r->resp[len-1] = '\0';
893 } else {
894 login_exit(1);
895 }
896 m++;
897 r++;
898 break;
899
900 case PAM_ERROR_MSG:
901 if (m->msg != NULL) {
902 (void) fputs(m->msg, stderr);
903 (void) fputs("\n", stderr);
904 }
905 m++;
906 r++;
907 break;
908 case PAM_TEXT_INFO:
909 if (m->msg != NULL) {
910 (void) fputs(m->msg, stdout);
911 (void) fputs("\n", stdout);
912 }
913 m++;
914 r++;
915 break;
916
917 default:
918 break;
919 }
920 }
921 return (PAM_SUCCESS);
922 }
923
924 /*
925 * verify_passwd - Authenticates the user.
926 * Returns: PAM_SUCCESS if authentication successful,
927 * PAM error code if authentication fails.
928 */
929
930 static int
931 verify_passwd(void)
932 {
933 int error;
934 char *user;
935 int flag = (Passreqflag ? PAM_DISALLOW_NULL_AUTHTOK : 0);
936
937 /*
938 * PAM authenticates the user for us.
939 */
940 error = pam_authenticate(pamh, flag);
941
942 /* get the user_name from the pam handle */
943 (void) pam_get_item(pamh, PAM_USER, (void**)&user);
944
945 if (user == NULL || *user == '\0')
946 return (PAM_SYSTEM_ERR);
947
948 SCPYL(user_name, user);
949 check_for_dueling_unix(user_name);
950
951 if (((pwd = getpwnam(user_name)) == NULL) &&
952 (error != PAM_USER_UNKNOWN)) {
953 return (PAM_SYSTEM_ERR);
954 }
955
956 return (error);
957 }
958
959 /*
960 * quotec - Called by getargs
961 */
962
963 static int
964 quotec(void)
965 {
966 int c, i, num;
967
968 switch (c = getc(stdin)) {
969
970 case 'n':
971 c = '\n';
972 break;
973
974 case 'r':
975 c = '\r';
976 break;
977
978 case 'v':
979 c = '\013';
980 break;
981
982 case 'b':
983 c = '\b';
984 break;
985
986 case 't':
987 c = '\t';
988 break;
989
990 case 'f':
991 c = '\f';
992 break;
993
994 case '0':
995 case '1':
996 case '2':
997 case '3':
998 case '4':
999 case '5':
1000 case '6':
1001 case '7':
1002 for (num = 0, i = 0; i < 3; i++) {
1003 num = num * 8 + (c - '0');
1004 if ((c = getc(stdin)) < '0' || c > '7')
1005 break;
1006 }
1007 (void) ungetc(c, stdin);
1008 c = num & 0377;
1009 break;
1010
1011 default:
1012 break;
1013 }
1014 return (c);
1015 }
1016
1017 /*
1018 * getargs - returns an input line. Exits if EOF encountered.
1019 */
1020 #define WHITESPACE 0
1021 #define ARGUMENT 1
1022
1023 static char **
1024 getargs(char *input_line)
1025 {
1026 static char envbuf[MAXLINE];
1027 static char *args[MAXARGS];
1028 char *ptr, **answer;
1029 int c;
1030 int state;
1031 char *p = input_line;
1032
1033 ptr = envbuf;
1034 answer = &args[0];
1035 state = WHITESPACE;
1036
1037 while ((c = getc(stdin)) != EOF && answer < &args[MAXARGS-1]) {
1038
1039 *(input_line++) = c;
1040
1041 switch (c) {
1042
1043 case '\n':
1044 if (ptr == &envbuf[0])
1045 return ((char **)NULL);
1046 *input_line = *ptr = '\0';
1047 *answer = NULL;
1048 return (&args[0]);
1049
1050 case ' ':
1051 case '\t':
1052 if (state == ARGUMENT) {
1053 *ptr++ = '\0';
1054 state = WHITESPACE;
1055 }
1056 break;
1057
1058 case '\\':
1059 c = quotec();
1060
1061 default:
1062 if (state == WHITESPACE) {
1063 *answer++ = ptr;
1064 state = ARGUMENT;
1065 }
1066 *ptr++ = c;
1067 }
1068
1069 /* Attempt at overflow, exit */
1070 if (input_line - p >= MAXLINE - 1 ||
1071 ptr >= &envbuf[sizeof (envbuf) - 1]) {
1072 audit_error = ADT_FAIL_VALUE_INPUT_OVERFLOW;
1073 login_exit(1);
1074 }
1075 }
1076
1077 /*
1078 * If we left loop because an EOF was received or we've overflown
1079 * args[], exit immediately.
1080 */
1081 login_exit(0);
1082 /* NOTREACHED */
1083 }
1084
1085 /*
1086 * get_user_name - Gets the user name either passed in, or from the
1087 * login: prompt.
1088 */
1089
1090 static void
1091 get_user_name(void)
1092 {
1093 FILE *fp;
1094
1095 if ((fp = fopen(ISSUEFILE, "r")) != NULL) {
1096 char *ptr, buffer[BUFSIZ];
1097 while ((ptr = fgets(buffer, sizeof (buffer), fp)) != NULL) {
1098 (void) fputs(ptr, stdout);
1099 }
1100 (void) fclose(fp);
1101 }
1102
1103 /*
1104 * if TTYPROMPT is not set, use our own prompt
1105 * otherwise, use ttyprompt. We just set PAM_USER_PROMPT
1106 * and let the module do the prompting.
1107 */
1108
1109 if ((ttyprompt == NULL) || (*ttyprompt == '\0'))
1110 (void) pam_set_item(pamh, PAM_USER_PROMPT, (void *)loginmsg);
1111 else
1112 (void) pam_set_item(pamh, PAM_USER_PROMPT, (void *)ttyprompt);
1113
1114 envp = &zero; /* XXX: is this right? */
1115 }
1116
1117
1118 /*
1119 * Check_for_dueling_unix - Check to see if the another login is talking
1120 * to the line we've got open as a login port
1121 * Exits if we're talking to another unix system
1122 */
1123
1124 static void
1125 check_for_dueling_unix(char *inputline)
1126 {
1127 if (EQN(loginmsg, inputline) || EQN(passwdmsg, inputline) ||
1128 EQN(incorrectmsg, inputline)) {
1129 (void) printf("Looking at a login line.\n");
1130 login_exit(8);
1131 }
1132 }
1133
1134 /*
1135 * logins_disabled - if the file /etc/nologin exists and the user is not
1136 * root then do not permit them to login
1137 */
1138 static int
1139 logins_disabled(char *user_name)
1140 {
1141 FILE *nlfd;
1142 int c;
1143 if (!EQN("root", user_name) &&
1144 ((nlfd = fopen(NOLOGIN, "r")) != (FILE *)NULL)) {
1145 while ((c = getc(nlfd)) != EOF)
1146 (void) putchar(c);
1147 (void) fflush(stdout);
1148 (void) sleep(5);
1149 return (TRUE);
1150 }
1151 return (FALSE);
1152 }
1153
1154 #define DEFAULT_CONSOLE "/dev/console"
1155
1156 /*
1157 * check_for_console - Checks if we're getting a root login on the
1158 * console, or a login from the global zone. Exits if not.
1159 *
1160 * If CONSOLE is set to /dev/console in /etc/default/login, then root logins
1161 * on /dev/vt/# are permitted as well. /dev/vt/# does not exist in non-global
1162 * zones, but checking them does no harm.
1163 */
1164 static void
1165 check_for_console(void)
1166 {
1167 const char *consoles[] = { "/dev/console", "/dev/vt/", NULL };
1168 int i;
1169
1170 if (pwd == NULL || pwd->pw_uid != 0 || zflag != B_FALSE ||
1171 Console == NULL)
1172 return;
1173
1174 if (strcmp(Console, DEFAULT_CONSOLE) == 0) {
1175 for (i = 0; consoles[i] != NULL; i ++) {
1176 if (strncmp(ttyn, consoles[i],
1177 strlen(consoles[i])) == 0)
1178 return;
1179 }
1180 } else {
1181 if (strcmp(ttyn, Console) == 0)
1182 return;
1183 }
1184
1185 (void) printf("Not on system console\n");
1186
1187 audit_error = ADT_FAIL_VALUE_CONSOLE;
1188 login_exit(10);
1189
1190 }
1191
1192 /*
1193 * List of environment variables or environment variable prefixes that should
1194 * not be propagated across logins, such as when the login -p option is used.
1195 */
1196 static const char *const illegal[] = {
1197 "SHELL=",
1198 "HOME=",
1199 "LOGNAME=",
1200 #ifndef NO_MAIL
1201 "MAIL=",
1202 #endif
1203 "CDPATH=",
1204 "IFS=",
1205 "PATH=",
1206 "LD_",
1207 "SMF_",
1208 NULL
1209 };
1210
1211 /*
1212 * legalenvvar - Is it legal to insert this environmental variable?
1213 */
1214
1215 static int
1216 legalenvvar(char *s)
1217 {
1218 const char *const *p;
1219
1220 for (p = &illegal[0]; *p; p++) {
1221 if (strncmp(s, *p, strlen(*p)) == 0)
1222 return (0);
1223 }
1224
1225 return (1);
1226 }
1227
1228
1229 /*
1230 * getstr - Get a string from standard input
1231 * Calls exit if read(2) fails.
1232 */
1233
1234 static void
1235 getstr(char *buf, int cnt, char *err)
1236 {
1237 char c;
1238
1239 do {
1240 if (read(0, &c, 1) != 1)
1241 login_exit(1);
1242 *buf++ = c;
1243 } while (--cnt > 1 && c != 0);
1244
1245 *buf = 0;
1246 err = err; /* For lint */
1247 }
1248
1249
1250 /*
1251 * defaults - read defaults
1252 */
1253
1254 static void
1255 defaults(void)
1256 {
1257 int flags;
1258 char *ptr;
1259
1260 if (defopen(Pndefault) == 0) {
1261 /*
1262 * ignore case
1263 */
1264 flags = defcntl(DC_GETFLAGS, 0);
1265 TURNOFF(flags, DC_CASE);
1266 (void) defcntl(DC_SETFLAGS, flags);
1267
1268 if ((Console = defread("CONSOLE=")) != NULL)
1269 Console = strdup(Console);
1270
1271 if ((Altshell = defread("ALTSHELL=")) != NULL)
1272 Altshell = strdup(Altshell);
1273
1274 if ((ptr = defread("PASSREQ=")) != NULL &&
1275 strcasecmp("YES", ptr) == 0)
1276 Passreqflag = 1;
1277
1278 if ((Def_tz = defread("TIMEZONE=")) != NULL)
1279 Def_tz = strdup(Def_tz);
1280
1281 if ((Def_hertz = defread("HZ=")) != NULL)
1282 Def_hertz = strdup(Def_hertz);
1283
1284 if ((Def_path = defread("PATH=")) != NULL)
1285 Def_path = strdup(Def_path);
1286
1287 if ((Def_supath = defread("SUPATH=")) != NULL)
1288 Def_supath = strdup(Def_supath);
1289
1290 if ((ptr = defread("ULIMIT=")) != NULL)
1291 Def_ulimit = atol(ptr);
1292
1293 if ((ptr = defread("TIMEOUT=")) != NULL)
1294 Def_timeout = (unsigned)atoi(ptr);
1295
1296 if ((ptr = defread("UMASK=")) != NULL)
1297 if (sscanf(ptr, "%lo", &Umask) != 1)
1298 Umask = DEFUMASK;
1299
1300 if ((ptr = defread("SLEEPTIME=")) != NULL) {
1301 if (is_number(ptr))
1302 Sleeptime = atoi(ptr);
1303 }
1304
1305 if ((ptr = defread("DISABLETIME=")) != NULL) {
1306 if (is_number(ptr))
1307 Disabletime = atoi(ptr);
1308 }
1309
1310 if ((ptr = defread("SYSLOG=")) != NULL)
1311 dosyslog = strcmp(ptr, "YES") == 0;
1312
1313 if ((ptr = defread("RETRIES=")) != NULL) {
1314 if (is_number(ptr))
1315 retry = atoi(ptr);
1316 }
1317
1318 if ((ptr = defread("SYSLOG_FAILED_LOGINS=")) != NULL) {
1319 if (is_number(ptr))
1320 flogin = atoi(ptr);
1321 else
1322 flogin = retry;
1323 } else
1324 flogin = retry;
1325 (void) defopen((char *)NULL);
1326 }
1327 }
1328
1329
1330 /*
1331 * get_options(argc, argv)
1332 * - parse the cmd line.
1333 * - return 0 if successful, -1 if failed.
1334 * Calls login_exit() on misuse of -r, -h, and -z flags
1335 */
1336
1337 static int
1338 get_options(int argc, char *argv[])
1339 {
1340 int c;
1341 int errflg = 0;
1342 char sflagname[NMAX+1];
1343 const char *flags_message = "Only one of -r, -h and -z allowed\n";
1344
1345 while ((c = getopt(argc, argv, "u:s:R:f:h:r:pad:t:U:z:")) != -1) {
1346 switch (c) {
1347 case 'a':
1348 break;
1349
1350 case 'd':
1351 /*
1352 * Must be root to pass in device name
1353 * otherwise we exit() as punishment for trying.
1354 */
1355 if (getuid() != 0 || geteuid() != 0) {
1356 audit_error = ADT_FAIL_VALUE_DEVICE_PERM;
1357 login_exit(1); /* sigh */
1358 /*NOTREACHED*/
1359 }
1360 ttyn = optarg;
1361 break;
1362
1363 case 'h':
1364 if (hflag || rflag || zflag) {
1365 (void) fprintf(stderr, flags_message);
1366 login_exit(1);
1367 }
1368 hflag = B_TRUE;
1369 SCPYL(remote_host, optarg);
1370 if (argv[optind]) {
1371 if (argv[optind][0] != '-') {
1372 SCPYL(terminal, argv[optind]);
1373 optind++;
1374 } else {
1375 /*
1376 * Allow "login -h hostname -" to
1377 * skip setting up an username as "-".
1378 */
1379 if (argv[optind][1] == '\0')
1380 optind++;
1381 }
1382
1383 }
1384 SCPYL(progname, "telnet");
1385 break;
1386
1387 case 'r':
1388 if (hflag || rflag || zflag) {
1389 (void) fprintf(stderr, flags_message);
1390 login_exit(1);
1391 }
1392 rflag = B_TRUE;
1393 SCPYL(remote_host, optarg);
1394 SCPYL(progname, "rlogin");
1395 break;
1396
1397 case 'p':
1398 pflag = B_TRUE;
1399 break;
1400
1401 case 'f':
1402 /*
1403 * Must be root to bypass authentication
1404 * otherwise we exit() as punishment for trying.
1405 */
1406 if (getuid() != 0 || geteuid() != 0) {
1407 audit_error = ADT_FAIL_VALUE_AUTH_BYPASS;
1408
1409 login_exit(1); /* sigh */
1410 /*NOTREACHED*/
1411 }
1412 /* save fflag user name for future use */
1413 SCPYL(user_name, optarg);
1414 fflag = B_TRUE;
1415 break;
1416 case 'u':
1417 if (!strlen(optarg)) {
1418 (void) fprintf(stderr,
1419 "Empty string supplied with -u\n");
1420 login_exit(1);
1421 }
1422 SCPYL(identity, optarg);
1423 uflag = B_TRUE;
1424 break;
1425 case 's':
1426 if (!strlen(optarg)) {
1427 (void) fprintf(stderr,
1428 "Empty string supplied with -s\n");
1429 login_exit(1);
1430 }
1431 SCPYL(sflagname, optarg);
1432 sflag = B_TRUE;
1433 break;
1434 case 'R':
1435 if (!strlen(optarg)) {
1436 (void) fprintf(stderr,
1437 "Empty string supplied with -R\n");
1438 login_exit(1);
1439 }
1440 SCPYL(repository, optarg);
1441 Rflag = B_TRUE;
1442 break;
1443 case 't':
1444 if (!strlen(optarg)) {
1445 (void) fprintf(stderr,
1446 "Empty string supplied with -t\n");
1447 login_exit(1);
1448 }
1449 SCPYL(terminal, optarg);
1450 tflag = B_TRUE;
1451 break;
1452 case 'U':
1453 /*
1454 * Kerberized rlogind may fork us with
1455 * -U "" if the rlogin client used the "-a"
1456 * option to send a NULL username. This is done
1457 * to force login to prompt for a user/password.
1458 * However, if Kerberos auth was used, we dont need
1459 * to prompt, so we will accept the option and
1460 * handle the situation later.
1461 */
1462 SCPYL(rusername, optarg);
1463 Uflag = B_TRUE;
1464 break;
1465 case 'z':
1466 if (hflag || rflag || zflag) {
1467 (void) fprintf(stderr, flags_message);
1468 login_exit(1);
1469 }
1470 (void) snprintf(zone_name, sizeof (zone_name),
1471 "zone:%s", optarg);
1472 SCPYL(progname, "zlogin");
1473 zflag = B_TRUE;
1474 break;
1475 default:
1476 errflg++;
1477 break;
1478 } /* end switch */
1479 } /* end while */
1480
1481 /*
1482 * If the 's svcname' flag was used, override the progname
1483 * value that is to be used in the pam_start call.
1484 */
1485 if (sflag)
1486 SCPYL(progname, sflagname);
1487
1488 /*
1489 * get the prompt set by ttymon
1490 */
1491 ttyprompt = getenv("TTYPROMPT");
1492
1493 if ((ttyprompt != NULL) && (*ttyprompt != '\0')) {
1494 /*
1495 * if ttyprompt is set, there should be data on
1496 * the stream already.
1497 */
1498 if ((envp = getargs(inputline)) != (char **)NULL) {
1499 /*
1500 * don't get name if name passed as argument.
1501 */
1502 SCPYL(user_name, *envp++);
1503 }
1504 } else if (optind < argc) {
1505 SCPYL(user_name, argv[optind]);
1506 (void) SCPYL(inputline, user_name);
1507 (void) strlcat(inputline, " \n", sizeof (inputline));
1508 envp = &argv[optind+1];
1509
1510 if (!fflag)
1511 SCPYL(lusername, user_name);
1512 }
1513
1514 if (errflg)
1515 return (-1);
1516 return (0);
1517 }
1518
1519 /*
1520 * usage - Print usage message
1521 *
1522 */
1523 static void
1524 usage(void)
1525 {
1526 (void) fprintf(stderr,
1527 "usage:\n"
1528 " login [-p] [-d device] [-R repository] [-s service]\n"
1529 "\t[-t terminal] [-u identity] [-U ruser]\n"
1530 "\t[-h hostname [terminal] | -r hostname] [name [environ]...]\n");
1531
1532 }
1533
1534 /*
1535 * doremoteterm - Sets the appropriate ioctls for a remote terminal
1536 */
1537 static char *speeds[] = {
1538 "0", "50", "75", "110", "134", "150", "200", "300",
1539 "600", "1200", "1800", "2400", "4800", "9600", "19200", "38400",
1540 "57600", "76800", "115200", "153600", "230400", "307200", "460800",
1541 "921600"
1542 };
1543
1544 #define NSPEEDS (sizeof (speeds) / sizeof (speeds[0]))
1545
1546
1547 static void
1548 doremoteterm(char *term)
1549 {
1550 struct termios tp;
1551 char *cp = strchr(term, '/'), **cpp;
1552 char *speed;
1553
1554 (void) ioctl(0, TCGETS, &tp);
1555
1556 if (cp) {
1557 *cp++ = '\0';
1558 speed = cp;
1559 cp = strchr(speed, '/');
1560
1561 if (cp)
1562 *cp++ = '\0';
1563
1564 for (cpp = speeds; cpp < &speeds[NSPEEDS]; cpp++)
1565 if (strcmp(*cpp, speed) == 0) {
1566 (void) cfsetospeed(&tp, cpp-speeds);
1567 break;
1568 }
1569 }
1570
1571 tp.c_lflag |= ECHO|ICANON;
1572 tp.c_iflag |= IGNPAR|ICRNL;
1573
1574 (void) ioctl(0, TCSETS, &tp);
1575
1576 }
1577
1578 /*
1579 * Process_rlogin - Does the work that rlogin and telnet
1580 * need done
1581 */
1582 static void
1583 process_rlogin(void)
1584 {
1585 /*
1586 * If a Kerberized rlogin was initiated, then these fields
1587 * must be read by rlogin daemon itself and passed down via
1588 * cmd line args.
1589 */
1590 if (!Uflag && !strlen(rusername))
1591 getstr(rusername, sizeof (rusername), "remuser");
1592 if (!strlen(lusername))
1593 getstr(lusername, sizeof (lusername), "locuser");
1594 if (!tflag && !strlen(terminal))
1595 getstr(terminal, sizeof (terminal), "Terminal type");
1596
1597 if (strlen(terminal))
1598 doremoteterm(terminal);
1599
1600 /* fflag has precedence over stuff passed by rlogind */
1601 if (fflag || getuid()) {
1602 pwd = &nouser;
1603 return;
1604 } else {
1605 if (pam_set_item(pamh, PAM_USER, lusername) != PAM_SUCCESS)
1606 login_exit(1);
1607
1608 pwd = getpwnam(lusername);
1609 if (pwd == NULL) {
1610 pwd = &nouser;
1611 return;
1612 }
1613 }
1614
1615 /*
1616 * Update PAM on the user name
1617 */
1618 if (strlen(lusername) &&
1619 pam_set_item(pamh, PAM_USER, lusername) != PAM_SUCCESS)
1620 login_exit(1);
1621
1622 if (strlen(rusername) &&
1623 pam_set_item(pamh, PAM_RUSER, rusername) != PAM_SUCCESS)
1624 login_exit(1);
1625
1626 SCPYL(user_name, lusername);
1627 envp = &zero;
1628 lusername[0] = '\0';
1629 }
1630
1631 /*
1632 * *** Account validation routines ***
1633 *
1634 */
1635
1636 /*
1637 * validate_account - This is the PAM version of validate.
1638 */
1639
1640 static void
1641 validate_account(void)
1642 {
1643 int error;
1644 int flag;
1645 int tries; /* new password retries */
1646
1647 (void) alarm(0); /* give user time to come up with password */
1648
1649 check_log();
1650
1651 if (Passreqflag)
1652 flag = PAM_DISALLOW_NULL_AUTHTOK;
1653 else
1654 flag = 0;
1655
1656 if ((error = pam_acct_mgmt(pamh, flag)) != PAM_SUCCESS) {
1657 if (error == PAM_NEW_AUTHTOK_REQD) {
1658 tries = 1;
1659 error = PAM_AUTHTOK_ERR;
1660 while (error == PAM_AUTHTOK_ERR &&
1661 tries <= DEF_ATTEMPTS) {
1662 if (tries > 1)
1663 (void) printf("Try again\n\n");
1664
1665 (void) printf("Choose a new password.\n");
1666
1667 error = pam_chauthtok(pamh,
1668 PAM_CHANGE_EXPIRED_AUTHTOK);
1669 if (error == PAM_TRY_AGAIN) {
1670 (void) sleep(1);
1671 error = pam_chauthtok(pamh,
1672 PAM_CHANGE_EXPIRED_AUTHTOK);
1673 }
1674 tries++;
1675 }
1676
1677 if (error != PAM_SUCCESS) {
1678 if (dosyslog)
1679 syslog(LOG_CRIT,
1680 "change password failure: %s",
1681 pam_strerror(pamh, error));
1682 audit_error = ADT_FAIL_PAM + error;
1683 login_exit(1);
1684 } else {
1685 audit_success(ADT_passwd, pwd, zone_name);
1686 }
1687 } else {
1688 (void) printf(incorrectmsg);
1689
1690 if (dosyslog)
1691 syslog(LOG_CRIT,
1692 "login account failure: %s",
1693 pam_strerror(pamh, error));
1694 audit_error = ADT_FAIL_PAM + error;
1695 login_exit(1);
1696 }
1697 }
1698 }
1699
1700 /*
1701 * Check_log - This is really a hack because PAM checks the log, but login
1702 * wants to know if the log is okay and PAM doesn't have
1703 * a module independent way of handing this info back.
1704 */
1705
1706 static void
1707 check_log(void)
1708 {
1709 int fdl;
1710 long long offset;
1711
1712 offset = (long long) pwd->pw_uid * (long long) sizeof (struct lastlog);
1713
1714 if ((fdl = open(LASTLOG, O_RDWR|O_CREAT, 0444)) >= 0) {
1715 if (llseek(fdl, offset, SEEK_SET) == offset &&
1716 read(fdl, (char *)&ll, sizeof (ll)) == sizeof (ll) &&
1717 ll.ll_time != 0)
1718 lastlogok = 1;
1719 (void) close(fdl);
1720 }
1721 }
1722
1723 /*
1724 * chdir_to_dir_user - Now chdir after setuid/setgid have happened to
1725 * place us in the user's home directory just in
1726 * case it was protected and the first chdir failed.
1727 * No chdir errors should happen at this point because
1728 * all failures should have happened on the first
1729 * time around.
1730 */
1731
1732 static void
1733 chdir_to_dir_user(void)
1734 {
1735 if (chdir(pwd->pw_dir) < 0) {
1736 if (chdir("/") < 0) {
1737 (void) printf("No directory!\n");
1738 /*
1739 * This probably won't work since we can't get to /.
1740 */
1741 if (dosyslog) {
1742 if (remote_host[0]) {
1743 syslog(LOG_CRIT,
1744 "LOGIN FAILURES ON %s FROM %.*s ",
1745 " %.*s", ttyn, HMAX,
1746 remote_host, NMAX, pwd->pw_name);
1747 } else {
1748 syslog(LOG_CRIT,
1749 "LOGIN FAILURES ON %s, %.*s",
1750 ttyn, NMAX, pwd->pw_name);
1751 }
1752 }
1753 closelog();
1754 (void) sleep(Disabletime);
1755 exit(1);
1756 } else {
1757 (void) printf("No directory! Logging in with home=/\n");
1758 pwd->pw_dir = "/";
1759 }
1760 }
1761 }
1762
1763
1764 /*
1765 * login_authenticate - Performs the main authentication work
1766 * 1. Prints the login prompt
1767 * 2. Requests and verifys the password
1768 * 3. Checks the port password
1769 */
1770
1771 static void
1772 login_authenticate(void)
1773 {
1774 char *user;
1775 int err;
1776 int login_successful = 0;
1777
1778 do {
1779 /* if scheme broken, then nothing to do but quit */
1780 if (pam_get_item(pamh, PAM_USER, (void **)&user) != PAM_SUCCESS)
1781 exit(1);
1782
1783 /*
1784 * only get name from utility if it is not already
1785 * supplied by pam_start or a pam_set_item.
1786 */
1787 if (!user || !user[0]) {
1788 /* use call back to get user name */
1789 get_user_name();
1790 }
1791
1792 err = verify_passwd();
1793
1794 /*
1795 * If root login and not on system console then call exit(2)
1796 */
1797 check_for_console();
1798
1799 switch (err) {
1800 case PAM_SUCCESS:
1801 case PAM_NEW_AUTHTOK_REQD:
1802 /*
1803 * Officially, pam_authenticate() shouldn't return this
1804 * but it's probably the right thing to return if
1805 * PAM_DISALLOW_NULL_AUTHTOK is set so the user will
1806 * be forced to change password later in this code.
1807 */
1808 count = 0;
1809 login_successful = 1;
1810 break;
1811 case PAM_MAXTRIES:
1812 count = retry;
1813 /*FALLTHROUGH*/
1814 case PAM_AUTH_ERR:
1815 case PAM_AUTHINFO_UNAVAIL:
1816 case PAM_USER_UNKNOWN:
1817 audit_failure(get_audit_id(), ADT_FAIL_PAM + err, pwd,
1818 remote_host, ttyn, zone_name);
1819 log_bad_attempts();
1820 break;
1821 case PAM_ABORT:
1822 log_bad_attempts();
1823 (void) sleep(Disabletime);
1824 (void) printf(incorrectmsg);
1825
1826 audit_error = ADT_FAIL_PAM + err;
1827 login_exit(1);
1828 /*NOTREACHED*/
1829 default: /* Some other PAM error */
1830 audit_error = ADT_FAIL_PAM + err;
1831 login_exit(1);
1832 /*NOTREACHED*/
1833 }
1834
1835 if (login_successful)
1836 break;
1837
1838 /* sleep after bad passwd */
1839 if (count)
1840 (void) sleep(Sleeptime);
1841 (void) printf(incorrectmsg);
1842 /* force name to be null in this case */
1843 if (pam_set_item(pamh, PAM_USER, NULL) != PAM_SUCCESS)
1844 login_exit(1);
1845 if (pam_set_item(pamh, PAM_RUSER, NULL) != PAM_SUCCESS)
1846 login_exit(1);
1847 } while (count++ < retry);
1848
1849 if (count >= retry) {
1850 audit_failure(get_audit_id(), ADT_FAIL_VALUE_MAX_TRIES, pwd,
1851 remote_host, ttyn, zone_name);
1852 /*
1853 * If logging is turned on, output the
1854 * string storage area to the log file,
1855 * and sleep for Disabletime
1856 * seconds before exiting.
1857 */
1858 if (writelog)
1859 badlogin();
1860 if (dosyslog) {
1861 if ((pwd = getpwnam(user_name)) != NULL) {
1862 if (remote_host[0]) {
1863 syslog(LOG_CRIT,
1864 "REPEATED LOGIN FAILURES ON %s "
1865 "FROM %.*s, %.*s",
1866 ttyn, HMAX, remote_host, NMAX,
1867 user_name);
1868 } else {
1869 syslog(LOG_CRIT,
1870 "REPEATED LOGIN FAILURES ON "
1871 "%s, %.*s",
1872 ttyn, NMAX, user_name);
1873 }
1874 } else {
1875 if (remote_host[0]) {
1876 syslog(LOG_CRIT,
1877 "REPEATED LOGIN FAILURES ON %s "
1878 "FROM %.*s",
1879 ttyn, HMAX, remote_host);
1880 } else {
1881 syslog(LOG_CRIT,
1882 "REPEATED LOGIN FAILURES ON %s",
1883 ttyn);
1884 }
1885 }
1886 }
1887 (void) sleep(Disabletime);
1888 exit(1);
1889 }
1890
1891 }
1892
1893 /*
1894 * *** Credential Related routines ***
1895 *
1896 */
1897
1898 /*
1899 * setup_credentials - sets the group ID, initializes the groups
1900 * and sets up the secretkey.
1901 * Exits if a failure occurrs.
1902 */
1903
1904
1905 /*
1906 * setup_credentials - PAM does all the work for us on this one.
1907 */
1908
1909 static void
1910 setup_credentials(void)
1911 {
1912 int error = 0;
1913
1914 /* set the real (and effective) GID */
1915 if (setgid(pwd->pw_gid) == -1) {
1916 login_exit(1);
1917 }
1918
1919 /*
1920 * Initialize the supplementary group access list.
1921 */
1922 if ((user_name[0] == '\0') ||
1923 (initgroups(user_name, pwd->pw_gid) == -1)) {
1924 audit_error = ADT_FAIL_VALUE_PROGRAM;
1925 login_exit(1);
1926 }
1927
1928 if ((error = pam_setcred(pamh, zflag ? PAM_REINITIALIZE_CRED :
1929 PAM_ESTABLISH_CRED)) != PAM_SUCCESS) {
1930 audit_error = ADT_FAIL_PAM + error;
1931 login_exit(error);
1932 }
1933
1934 /*
1935 * Record successful login and fork process that records logout.
1936 * We have to do this after setting credentials because pam_setcred()
1937 * loads key audit info into the cred, but before setuid() so audit
1938 * system calls will work.
1939 */
1940 audit_success(get_audit_id(), pwd, zone_name);
1941 }
1942
1943 static uint_t
1944 get_audit_id(void)
1945 {
1946 if (rflag)
1947 return (ADT_rlogin);
1948 else if (hflag)
1949 return (ADT_telnet);
1950 else if (zflag)
1951 return (ADT_zlogin);
1952
1953 return (ADT_login);
1954 }
1955
1956 /*
1957 *
1958 * *** Routines to get a new user set up and running ***
1959 *
1960 * Things to do when starting up a new user:
1961 * adjust_nice
1962 * update_utmpx_entry
1963 * establish_user_environment
1964 * print_banner
1965 * display_last_login_time
1966 * exec_the_shell
1967 *
1968 */
1969
1970
1971 /*
1972 * adjust_nice - Set the nice (process priority) value if the
1973 * gecos value contains an appropriate value.
1974 */
1975
1976 static void
1977 adjust_nice(void)
1978 {
1979 int pri, mflg, i;
1980
1981 if (strncmp("pri=", pwd->pw_gecos, 4) == 0) {
1982 pri = 0;
1983 mflg = 0;
1984 i = 4;
1985
1986 if (pwd->pw_gecos[i] == '-') {
1987 mflg++;
1988 i++;
1989 }
1990
1991 while (pwd->pw_gecos[i] >= '0' && pwd->pw_gecos[i] <= '9')
1992 pri = (pri * 10) + pwd->pw_gecos[i++] - '0';
1993
1994 if (mflg)
1995 pri = -pri;
1996
1997 (void) nice(pri);
1998 }
1999 }
2000
2001 /*
2002 * update_utmpx_entry - Searchs for the correct utmpx entry, making an
2003 * entry there if it finds one, otherwise exits.
2004 */
2005
2006 static void
2007 update_utmpx_entry(int sublogin)
2008 {
2009 int err;
2010 char *user;
2011 static char *errmsg = "No utmpx entry. "
2012 "You must exec \"login\" from the lowest level \"shell\".";
2013 int tmplen;
2014 struct utmpx *u = (struct utmpx *)0;
2015 struct utmpx utmpx;
2016 char *ttyntail;
2017
2018 /*
2019 * If we're not a sublogin then
2020 * we'll get an error back if our PID doesn't match the PID of the
2021 * entry we are updating, otherwise if its a sublogin the flags
2022 * field is set to 0, which means we just write a matching entry
2023 * (without checking the pid), or a new entry if an entry doesn't
2024 * exist.
2025 */
2026
2027 if ((err = pam_open_session(pamh, 0)) != PAM_SUCCESS) {
2028 audit_error = ADT_FAIL_PAM + err;
2029 login_exit(1);
2030 }
2031
2032 if ((err = pam_get_item(pamh, PAM_USER, (void **) &user)) !=
2033 PAM_SUCCESS) {
2034 audit_error = ADT_FAIL_PAM + err;
2035 login_exit(1);
2036 }
2037
2038 (void) memset((void *)&utmpx, 0, sizeof (utmpx));
2039 (void) time(&utmpx.ut_tv.tv_sec);
2040 utmpx.ut_pid = getpid();
2041
2042 if (rflag || hflag) {
2043 SCPYN(utmpx.ut_host, remote_host);
2044 tmplen = strlen(remote_host) + 1;
2045 if (tmplen < sizeof (utmpx.ut_host))
2046 utmpx.ut_syslen = tmplen;
2047 else
2048 utmpx.ut_syslen = sizeof (utmpx.ut_host);
2049 } else if (zflag) {
2050 /*
2051 * If this is a login from another zone, put the
2052 * zone:<zonename> string in the utmpx entry.
2053 */
2054 SCPYN(utmpx.ut_host, zone_name);
2055 tmplen = strlen(zone_name) + 1;
2056 if (tmplen < sizeof (utmpx.ut_host))
2057 utmpx.ut_syslen = tmplen;
2058 else
2059 utmpx.ut_syslen = sizeof (utmpx.ut_host);
2060 } else {
2061 utmpx.ut_syslen = 0;
2062 }
2063
2064 SCPYN(utmpx.ut_user, user);
2065
2066 /* skip over "/dev/" */
2067 ttyntail = basename(ttyn);
2068
2069 while ((u = getutxent()) != NULL) {
2070 if ((u->ut_type == INIT_PROCESS ||
2071 u->ut_type == LOGIN_PROCESS ||
2072 u->ut_type == USER_PROCESS) &&
2073 ((sublogin && strncmp(u->ut_line, ttyntail,
2074 sizeof (u->ut_line)) == 0) ||
2075 u->ut_pid == login_pid)) {
2076 SCPYN(utmpx.ut_line, (ttyn+sizeof ("/dev/")-1));
2077 (void) memcpy(utmpx.ut_id, u->ut_id,
2078 sizeof (utmpx.ut_id));
2079 utmpx.ut_exit.e_exit = u->ut_exit.e_exit;
2080 utmpx.ut_type = USER_PROCESS;
2081 (void) pututxline(&utmpx);
2082 break;
2083 }
2084 }
2085 endutxent();
2086
2087 if (u == (struct utmpx *)NULL) {
2088 if (!sublogin) {
2089 /*
2090 * no utmpx entry already setup
2091 * (init or rlogind/telnetd)
2092 */
2093 (void) puts(errmsg);
2094
2095 audit_error = ADT_FAIL_VALUE_PROGRAM;
2096 login_exit(1);
2097 }
2098 } else {
2099 /* Now attempt to write out this entry to the wtmp file if */
2100 /* we were successful in getting it from the utmpx file and */
2101 /* the wtmp file exists. */
2102 updwtmpx(WTMPX_FILE, &utmpx);
2103 }
2104 }
2105
2106
2107
2108 /*
2109 * process_chroot_logins - Chroots to the specified subdirectory and
2110 * re executes login.
2111 */
2112
2113 static int
2114 process_chroot_logins(void)
2115 {
2116 /*
2117 * If the shell field starts with a '*', do a chroot to the home
2118 * directory and perform a new login.
2119 */
2120
2121 if (*pwd->pw_shell == '*') {
2122 (void) pam_end(pamh, PAM_SUCCESS); /* Done using PAM */
2123 pamh = NULL; /* really done */
2124 if (chroot(pwd->pw_dir) < 0) {
2125 (void) printf("No Root Directory\n");
2126
2127 audit_failure(get_audit_id(),
2128 ADT_FAIL_VALUE_CHDIR_FAILED,
2129 pwd, remote_host, ttyn, zone_name);
2130
2131 return (ERROR);
2132 }
2133 /*
2134 * Set the environment flag <!sublogin> so that the next login
2135 * knows that it is a sublogin.
2136 */
2137 envinit[0] = SUBLOGIN;
2138 envinit[1] = (char *)NULL;
2139 (void) printf("Subsystem root: %s\n", pwd->pw_dir);
2140 (void) execle("/usr/bin/login", "login", (char *)0,
2141 &envinit[0]);
2142 (void) execle("/etc/login", "login", (char *)0, &envinit[0]);
2143 (void) printf("No /usr/bin/login or /etc/login on root\n");
2144
2145 audit_error = ADT_FAIL_VALUE_PROGRAM;
2146
2147 login_exit(1);
2148 }
2149 return (OK);
2150 }
2151
2152 /*
2153 * establish_user_environment - Set up the new users enviornment
2154 */
2155
2156 static void
2157 establish_user_environment(char **renvp)
2158 {
2159 int i, j, k, l_index, length, idx = 0;
2160 char *endptr;
2161 char **lenvp;
2162 char **pam_env;
2163
2164 lenvp = environ;
2165 while (*lenvp++)
2166 ;
2167
2168 /* count the number of PAM environment variables set by modules */
2169 if ((pam_env = pam_getenvlist(pamh)) != 0) {
2170 for (idx = 0; pam_env[idx] != 0; idx++)
2171 ;
2172 }
2173
2174 envinit = (char **)calloc(lenvp - environ + 10 + MAXARGS + idx,
2175 sizeof (char *));
2176 if (envinit == NULL) {
2177 (void) printf("Calloc failed - out of swap space.\n");
2178 login_exit(8);
2179 }
2180
2181 /*
2182 * add PAM environment variables first so they
2183 * can be overwritten at login's discretion.
2184 * check for illegal environment variables.
2185 */
2186 idx = 0; basicenv = 0;
2187 if (pam_env != 0) {
2188 while (pam_env[idx] != 0) {
2189 if (legalenvvar(pam_env[idx])) {
2190 envinit[basicenv] = pam_env[idx];
2191 basicenv++;
2192 }
2193 idx++;
2194 }
2195 }
2196 (void) memcpy(&envinit[basicenv], newenv, sizeof (newenv));
2197
2198 /* Set up environment */
2199 if (rflag) {
2200 ENVSTRNCAT(term, terminal);
2201 } else if (hflag) {
2202 if (strlen(terminal)) {
2203 ENVSTRNCAT(term, terminal);
2204 }
2205 } else {
2206 char *tp = getenv("TERM");
2207
2208 if ((tp != NULL) && (*tp != '\0'))
2209 ENVSTRNCAT(term, tp);
2210 }
2211
2212 ENVSTRNCAT(logname, pwd->pw_name);
2213
2214 /*
2215 * There are three places to get timezone info. init.c sets
2216 * TZ if the file /etc/default/init contains a value for TZ.
2217 * login.c looks in the file /etc/default/login for a
2218 * variable called TIMEZONE being set. If TIMEZONE has a
2219 * value, TZ is set to that value; no environment variable
2220 * TIMEZONE is set, only TZ. If neither of these methods
2221 * work to set TZ, then the library routines will default
2222 * to using the file /usr/lib/locale/TZ/localtime.
2223 *
2224 * There is a priority set up here. If /etc/default/init has
2225 * a value for TZ, that value remains top priority. If the
2226 * file /etc/default/login has TIMEZONE set, that has second
2227 * highest priority not overriding the value of TZ in
2228 * /etc/default/init. The reason for this priority is that the
2229 * file /etc/default/init is supposed to be sourced by
2230 * /etc/profile. We are doing the "sourcing" prematurely in
2231 * init.c. Additionally, a login C shell doesn't source the
2232 * file /etc/profile thus not sourcing /etc/default/init thus not
2233 * allowing an adminstrator to globally set TZ for all users
2234 */
2235 if (Def_tz != NULL) /* Is there a TZ from defaults/login? */
2236 tmp_tz = Def_tz;
2237
2238 if ((Def_tz = getenv("TZ")) != NULL) {
2239 ENVSTRNCAT(timez, Def_tz);
2240 } else if (tmp_tz != NULL) {
2241 Def_tz = tmp_tz;
2242 ENVSTRNCAT(timez, Def_tz);
2243 }
2244
2245 if (Def_hertz == NULL)
2246 (void) sprintf(hertz + strlen(hertz), "%lu", HZ);
2247 else
2248 ENVSTRNCAT(hertz, Def_hertz);
2249
2250 if (Def_path == NULL)
2251 (void) strlcat(path, DEF_PATH, sizeof (path));
2252 else
2253 ENVSTRNCAT(path, Def_path);
2254
2255 ENVSTRNCAT(home, pwd->pw_dir);
2256
2257 /*
2258 * Find the end of the basic environment
2259 */
2260 for (basicenv = 0; envinit[basicenv] != NULL; basicenv++)
2261 ;
2262
2263 /*
2264 * If TZ has a value, add it.
2265 */
2266 if (strcmp(timez, "TZ=") != 0)
2267 envinit[basicenv++] = timez;
2268
2269 if (*pwd->pw_shell == '\0') {
2270 /*
2271 * If possible, use the primary default shell,
2272 * otherwise, use the secondary one.
2273 */
2274 if (access(SHELL, X_OK) == 0)
2275 pwd->pw_shell = SHELL;
2276 else
2277 pwd->pw_shell = SHELL2;
2278 } else if (Altshell != NULL && strcmp(Altshell, "YES") == 0) {
2279 envinit[basicenv++] = shell;
2280 ENVSTRNCAT(shell, pwd->pw_shell);
2281 }
2282
2283 #ifndef NO_MAIL
2284 envinit[basicenv++] = mail;
2285 (void) strlcat(mail, pwd->pw_name, sizeof (mail));
2286 #endif
2287
2288 /*
2289 * Pick up locale environment variables, if any.
2290 */
2291 lenvp = renvp;
2292 while (*lenvp != NULL) {
2293 j = 0;
2294 while (localeenv[j] != 0) {
2295 /*
2296 * locale_envmatch() returns 1 if
2297 * *lenvp is localenev[j] and valid.
2298 */
2299 if (locale_envmatch(localeenv[j], *lenvp) == 1) {
2300 envinit[basicenv++] = *lenvp;
2301 break;
2302 }
2303 j++;
2304 }
2305 lenvp++;
2306 }
2307
2308 /*
2309 * If '-p' flag, then try to pass on allowable environment
2310 * variables. Note that by processing this first, what is
2311 * passed on the final "login:" line may over-ride the invocation
2312 * values. XXX is this correct?
2313 */
2314 if (pflag) {
2315 for (lenvp = renvp; *lenvp; lenvp++) {
2316 if (!legalenvvar(*lenvp)) {
2317 continue;
2318 }
2319 /*
2320 * If this isn't 'xxx=yyy', skip it. XXX
2321 */
2322 if ((endptr = strchr(*lenvp, '=')) == NULL) {
2323 continue;
2324 }
2325 length = endptr + 1 - *lenvp;
2326 for (j = 0; j < basicenv; j++) {
2327 if (strncmp(envinit[j], *lenvp, length) == 0) {
2328 /*
2329 * Replace previously established value
2330 */
2331 envinit[j] = *lenvp;
2332 break;
2333 }
2334 }
2335 if (j == basicenv) {
2336 /*
2337 * It's a new definition, so add it at the end.
2338 */
2339 envinit[basicenv++] = *lenvp;
2340 }
2341 }
2342 }
2343
2344 /*
2345 * Add in all the environment variables picked up from the
2346 * argument list to "login" or from the user response to the
2347 * "login" request, if any.
2348 */
2349
2350 if (envp == NULL)
2351 goto switch_env; /* done */
2352
2353 for (j = 0, k = 0, l_index = 0;
2354 *envp != NULL && j < (MAXARGS-1);
2355 j++, envp++) {
2356
2357 /*
2358 * Scan each string provided. If it doesn't have the
2359 * format xxx=yyy, then add the string "Ln=" to the beginning.
2360 */
2361 if ((endptr = strchr(*envp, '=')) == NULL) {
2362 /*
2363 * This much to be malloc'd:
2364 * strlen(*envp) + 1 char for 'L' +
2365 * MAXARGSWIDTH + 1 char for '=' + 1 for null char;
2366 *
2367 * total = strlen(*envp) + MAXARGSWIDTH + 3
2368 */
2369 int total = strlen(*envp) + MAXARGSWIDTH + 3;
2370 envinit[basicenv+k] = malloc(total);
2371 if (envinit[basicenv+k] == NULL) {
2372 (void) printf("%s: malloc failed\n", PROG_NAME);
2373 login_exit(1);
2374 }
2375 (void) snprintf(envinit[basicenv+k], total, "L%d=%s",
2376 l_index, *envp);
2377
2378 k++;
2379 l_index++;
2380 } else {
2381 if (!legalenvvar(*envp)) { /* this env var permited? */
2382 continue;
2383 } else {
2384
2385 /*
2386 * Check to see whether this string replaces
2387 * any previously defined string
2388 */
2389 for (i = 0, length = endptr + 1 - *envp;
2390 i < basicenv + k; i++) {
2391 if (strncmp(*envp, envinit[i], length)
2392 == 0) {
2393 envinit[i] = *envp;
2394 break;
2395 }
2396 }
2397
2398 /*
2399 * If it doesn't, place it at the end of
2400 * environment array.
2401 */
2402 if (i == basicenv+k) {
2403 envinit[basicenv+k] = *envp;
2404 k++;
2405 }
2406 }
2407 }
2408 } /* for (j = 0 ... ) */
2409
2410 switch_env:
2411 /*
2412 * Switch to the new environment.
2413 */
2414 environ = envinit;
2415 }
2416
2417 /*
2418 * print_banner - Print the banner at start up
2419 * Do not turn on DOBANNER ifdef. This is not
2420 * relevant to SunOS.
2421 */
2422
2423 static void
2424 print_banner(void)
2425 {
2426 #ifdef DOBANNER
2427 uname(&un);
2428 #if i386
2429 (void) printf("UNIX System V/386 Release %s\n%s\n"
2430 "Copyright (C) 1984, 1986, 1987, 1988 AT&T\n"
2431 "Copyright (C) 1987, 1988 Microsoft Corp.\nAll Rights Reserved\n",
2432 un.release, un.nodename);
2433 #elif sun
2434 (void) printf("SunOS Release %s Sun Microsystems %s\n%s\n"
2435 "Copyright (c) 1984, 1986, 1987, 1988 AT&T\n"
2436 "Copyright (c) 1988, 1989, 1990, 1991 Sun Microsystems\n"
2437 "All Rights Reserved\n",
2438 un.release, un.machine, un.nodename);
2439 #else
2440 (void) printf("UNIX System V Release %s AT&T %s\n%s\n"
2441 "Copyright (c) 1984, 1986, 1987, 1988 AT&T\nAll Rights Reserved\n",
2442 un.release, un.machine, un.nodename);
2443 #endif /* i386 */
2444 #endif /* DOBANNER */
2445 }
2446
2447 /*
2448 * display_last_login_time - Advise the user the time and date
2449 * that this login-id was last used.
2450 */
2451
2452 static void
2453 display_last_login_time(void)
2454 {
2455 if (lastlogok) {
2456 (void) printf("Last login: %.*s ", 24-5, ctime(&ll.ll_time));
2457
2458 if (*ll.ll_host != '\0')
2459 (void) printf("from %.*s\n", sizeof (ll.ll_host),
2460 ll.ll_host);
2461 else
2462 (void) printf("on %.*s\n", sizeof (ll.ll_line),
2463 ll.ll_line);
2464 }
2465 }
2466
2467 /*
2468 * exec_the_shell - invoke the specified shell or start up program
2469 */
2470
2471 static void
2472 exec_the_shell(void)
2473 {
2474 char *endptr;
2475 int i;
2476
2477 (void) strlcat(minusnam, basename(pwd->pw_shell),
2478 sizeof (minusnam));
2479
2480 /*
2481 * Exec the shell
2482 */
2483 (void) execl(pwd->pw_shell, minusnam, (char *)0);
2484
2485 /*
2486 * pwd->pw_shell was not an executable object file, maybe it
2487 * is a shell proceedure or a command line with arguments.
2488 * If so, turn off the SHELL= environment variable.
2489 */
2490 for (i = 0; envinit[i] != NULL; ++i) {
2491 if ((envinit[i] == shell) &&
2492 ((endptr = strchr(shell, '=')) != NULL))
2493 (*++endptr) = '\0';
2494 }
2495
2496 if (access(pwd->pw_shell, R_OK|X_OK) == 0) {
2497 (void) execl(SHELL, "sh", pwd->pw_shell, (char *)0);
2498 (void) execl(SHELL2, "sh", pwd->pw_shell, (char *)0);
2499 }
2500
2501 (void) printf("No shell\n");
2502 }
2503
2504 /*
2505 * login_exit - Call exit() and terminate.
2506 * This function is here for PAM so cleanup can
2507 * be done before the process exits.
2508 */
2509 static void
2510 login_exit(int exit_code)
2511 {
2512 if (pamh)
2513 (void) pam_end(pamh, PAM_ABORT);
2514
2515 if (audit_error)
2516 audit_failure(get_audit_id(), audit_error,
2517 pwd, remote_host, ttyn, zone_name);
2518
2519 exit(exit_code);
2520 /*NOTREACHED*/
2521 }
2522
2523 /*
2524 * Check if lenv and penv matches or not.
2525 */
2526 static int
2527 locale_envmatch(char *lenv, char *penv)
2528 {
2529 while ((*lenv == *penv) && *lenv && *penv != '=') {
2530 lenv++;
2531 penv++;
2532 }
2533
2534 /*
2535 * '/' is eliminated for security reason.
2536 */
2537 if (*lenv == '\0' && *penv == '=' && *(penv + 1) != '/')
2538 return (1);
2539 return (0);
2540 }
2541
2542 static int
2543 is_number(char *ptr)
2544 {
2545 while (*ptr != '\0') {
2546 if (!isdigit(*ptr))
2547 return (0);
2548 ptr++;
2549 }
2550 return (1);
2551 }