cbf9b8ab3a709a54c9a3a5dce315581388aae821
[openafs.git] / src / login / login.c
1 /*
2  * Notes:
3  *
4  * This is an AFS-aware login.
5  *
6  * Machine/os specific code is surrounded by #ifdef <system>
7  *
8  * The Q_SETUID and Q_DOWARN #ifdefs are for IBM's AOS which doesn't
9  * define them if NFS is configured. Like that matters anymore
10  */
11
12 /*
13  * Copyright (c) 1980, 1987, 1988 The Regents of the University of California.
14  * All rights reserved.
15  *
16  * Redistribution and use in source and binary forms are permitted
17  * provided that the above copyright notice and this paragraph are
18  * duplicated in all such forms and that any documentation,
19  * advertising materials, and other materials related to such
20  * distribution and use acknowledge that the software was developed
21  * by the University of California, Berkeley.  The name of the
22  * University may not be used to endorse or promote products derived
23  * from this software without specific prior written permission.
24  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
25  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
26  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
27  */
28
29 /*
30  * login [ name ]
31  * login -h hostname    (for telnetd, etc.)
32  * login -f name        (for pre-authenticated login: datakit, xterm, etc.)
33  */
34
35 #if !defined(UT_NAMESIZE)
36 #define UT_NAMESIZE 8
37 #endif
38
39 #include <afsconfig.h>
40 #include <afs/param.h>
41
42 RCSID
43     ("$Header$");
44
45 #include <unistd.h>
46 #include <stdlib.h>
47 #include <limits.h>
48 #include <afs/kautils.h>
49 #ifdef  AFS_SUN5_ENV
50 #include <sys/fs/ufs_quota.h>
51 #else
52 #if  !defined(AFS_HPUX_ENV) && !defined(AFS_AIX_ENV)
53 #if defined(AFS_SUN_ENV) || (defined(AFS_ATHENA_STDENV) && !defined(AFS_DEC_ENV)) || defined(AFS_OSF_ENV)
54 #include <ufs/quota.h>
55 #elif defined(AFS_FBSD_ENV)
56 #include <ufs/ufs/quota.h>
57 #else
58 #include <sys/quota.h>
59 #endif
60 #endif /* AIX */
61 #endif /* SUN5 */
62 #include <sys/stat.h>
63 #include <sys/time.h>
64 #include <sys/resource.h>
65 #include <sys/file.h>
66 #ifdef  AFS_SUN5_ENV
67 #include <sys/termios.h>
68 #include <sys/ttychars.h>
69 /* hack to get it to build */
70 #define CBRK    0377
71 #include <sys/ttydev.h>
72 #include <sys/ttold.h>
73 #include <sys/filio.h>
74 #endif
75 #ifdef AFS_FBSD_ENV
76 #define USE_OLD_TTY 1
77 #include <sys/ttydefaults.h>
78 #endif
79 #include <sys/ioctl.h>
80
81 #include <utmp.h>
82 #ifdef  AFS_SUN5_ENV
83 #include <utmpx.h>
84 #include <dirent.h>
85 #endif
86 #include <signal.h>
87 #if !defined(AIX) && !defined(AFS_HPUX_ENV) && !defined(AFS_AIX32_ENV) && !defined(AFS_FBSD_ENV)
88 #include <lastlog.h>
89 #endif
90 #include <errno.h>
91 #if defined(AIX)
92 #include <stand.h>
93 #undef B300
94 #undef B1200
95 #undef B9600
96 #include <sys/termio.h>
97 #include <sys/syslog.h>
98 #include <fcntl.h>
99 #else
100 #if !defined(AFS_HPUX_ENV) && !defined(AFS_SUN5_ENV)
101 #include <ttyent.h>
102 #endif
103 #if defined(AFS_HPUX_ENV)
104 #include <sgtty.h>
105 #include <sys/bsdtty.h>
106 #endif
107 #include <syslog.h>
108 #endif
109 #include <grp.h>
110 #include <pwd.h>
111 #include <setjmp.h>
112 #include <stdio.h>
113 #include <string.h>
114 #include <time.h>
115
116 #define TTYGRPNAME      "tty"   /* name of group to own ttys */
117
118 #define MOTDFILE        "/etc/motd"
119
120 #if defined(AFS_SUN5_ENV) || defined(AFS_HPUX100_ENV)
121 #ifndef NO_MAIL
122 #ifdef V4FS
123 #define MAILDIR         "/var/mail/"
124 #else
125 #define MAILDIR         "/usr/mail/"
126 #endif /* V4FS */
127 static char mail[30];
128 #endif /* NO_MAIL */
129 #else /* AFS_SUN5_ENV || AFS_HPUX100_ENV */
130 #define MAILDIR         "/usr/spool/mail"
131 #endif /* AFS_SUN5_ENV || AFS_HPUX100_ENV */
132
133 #define NOLOGIN         "/etc/nologin"
134 #define HUSHLOGIN       ".hushlogin"
135 #define LASTLOG         "/usr/adm/lastlog"
136 #define BSHELL          "/bin/sh"
137 #define SECURETTY_FILE  "/etc/securetty"
138
139 /*
140  * This bounds the time given to login.  Not a define so it can
141  * be patched on machines where it's too small.
142  */
143 int timeout = 300;
144
145 struct passwd *pwd, *getpwnam();
146 int failures;
147 char term[64], *hostname, *username, *tty;
148 #ifdef  AFS_OSF_ENV
149 char ousername[256];
150 #endif
151 struct sgttyb sgttyb;
152
153 #ifdef  AFS_SUN5_ENV
154 #include <deflt.h>
155 extern char *defread(), *strdup();
156 static void defaults();
157 static char *Pndefault = "/etc/default/login";
158 static char *Altshell = NULL;
159 static char *Console = NULL;
160 static int Idleweeks = -1;
161 static char *Passreq = NULL;
162 #define DEFUMASK        022
163 static mode_t Umask = DEFUMASK;
164 static char *Def_tz = NULL;
165 static char *tmp_tz = NULL;
166 static char *Def_hertz = NULL;
167 #define SET_FSIZ        2       /* ulimit() command arg */
168 static long Def_ulimit = 0;
169 #define MAX_TIMEOUT     (15 * 60)
170 #define DEF_TIMEOUT     5*60
171 static unsigned Def_timeout = DEF_TIMEOUT;
172 static char *Def_path = NULL;
173 static char *Def_supath = NULL;
174 #define DEF_PATH        "/usr/bin:"     /* same as PATH */
175 #define DEF_SUPATH      "/usr/sbin:/usr/bin"    /* same as ROOTPATH */
176 /*
177  * Intervals to sleep after failed login
178  */
179 #ifndef SLEEPTIME
180 #       define  SLEEPTIME 4     /* sleeptime before login incorrect msg */
181 #endif
182 static int Sleeptime = SLEEPTIME;
183
184 #include <shadow.h>
185 /* This is for Solaris's shadow pass struc */
186 static struct spwd *spwd;
187 char *ttypmt = NULL;
188 char *d_tz = NULL;
189 char *d_dev = NULL;
190 static int authenticated_remote_user = 0;
191 static char rhost[64], rusername[10], lusername[10];
192 #endif
193 #ifdef  AFS_SUN_ENV
194 int usererr = -1;
195 #endif
196
197 /* For setting of TZ environment on HPUX */
198 #ifdef AFS_HPUX_ENV
199 #define MAX_TZ_LEN 256
200 static char TZ[MAX_TZ_LEN];
201 #endif /* AFS_HPUX_ENV */
202
203 #ifdef AFS_KERBEROS_ENV
204 extern char *ktc_tkt_string();
205 #endif
206
207 #if !defined(AIX) && !defined(AFS_HPUX_ENV)
208 struct tchars tc = {
209 /*      CINTR, CQUIT, CSTART, CSTOP, 000, 000 */
210     CINTR, CQUIT, CSTART, CSTOP, CEOT, CBRK
211 };
212
213 struct ltchars ltc = {
214     CSUSP, CDSUSP, CRPRNT, CFLUSH, CWERASE, CLNEXT
215 };
216 #endif
217
218 #ifdef  AFS_OSF_ENV
219 #include <sia.h>
220 #include <paths.h>
221 SIAENTITY *entity = NULL;
222
223 #ifdef  AFS_OSF20_ENV
224 #include <sys/security.h>
225 #endif
226 #include <prot.h>
227 #endif
228
229 #ifndef NOPAG
230 #define NOPAG   0xffffffff
231 #endif
232
233 /* For avoiding making an osi_audit call when non-root */
234 osi_audit()
235 {
236     return 0;
237 }
238
239 static void
240 timedout(x)
241 {
242     fprintf(stderr, "Login timed out after %d seconds\n", timeout);
243     exit(0);
244 }
245
246 char *
247 cv2string(ttp, aval)
248      register char *ttp;
249      register unsigned long aval;
250 {
251     register char *tp = ttp;
252     register int i;
253     int any = 0;
254
255     *(--tp) = 0;
256     while (aval != 0) {
257         i = aval % 10;
258         *(--tp) = '0' + i;
259         aval /= 10;
260         any = 1;
261     }
262     if (!any)
263         *(--tp) = '0';
264     return tp;
265 }
266
267 #include "AFS_component_version_number.c"
268
269
270 #ifdef  AFS_SUN5_ENV
271 struct utmpx utmp;
272 #else
273 struct utmp utmp;
274 #endif
275
276 #if     defined(AFS_SUN5_ENV) || defined(AFS_HPUX_ENV)
277 /* the following utmp field is used for user counting: */
278 #define how_to_count ut_exit.e_exit
279 char *ttyntail;
280 #define SUBLOGIN        "<!sublogin>"
281 int sublogin;
282 main(argc, argv, renvp)
283      char **renvp;
284 #else
285 main(argc, argv)
286 #endif
287      int argc;
288      char **argv;
289 {
290     extern int errno, optind;
291     extern char *optarg, **environ;
292     struct group *gr, *getgrnam();
293     register int ch;
294     register char *p;
295     int ask, fflag, hflag, rflag, pflag, cnt, locl, zero = 0, dflag =
296         0, rlog = 0;
297     int quietlog, passwd_req, ioctlval;
298     char *domain, *salt, *envinit[2], *ttyn = 0, *pp;
299     char tbuf[MAXPATHLEN + 2];
300     char *ttyname(), *stypeof(), *crypt(), *getpass();
301     extern off_t lseek();
302     int local, code = 0;
303     char *lcell;                /* local cellname */
304     char realm[MAXKTCREALMLEN];
305     char buf1[256], **envp;
306     afs_int32 j, pagval = NOPAG, ngroups, groups[NGROUPS_MAX];
307     long password_expires = -1;
308     extern char *AFSVersion;    /* generated version */
309     int afsLoginFail = 0;
310     char *reason;
311
312 #if defined(AFS_SUN5_ENV) || defined(AFS_HPUX_ENV)
313     char retry_chdir = 0;
314 #endif /* AFS_SUN5_ENV || AFS_HPUX_ENV */
315
316 #ifdef  AFS_OSF_ENV
317     char tname[sizeof(_PATH_TTY) + 10], *loginname = NULL;
318     int oargc = argc;
319     char **oargv = argv;
320
321 #else
322 #ifdef  AFS_SUN5_ENV
323
324     defaults();                 /* Set up Defaults and flags */
325     if (Umask < 0 || ((mode_t) 0777) < Umask)   /* Set up default umask */
326         Umask = DEFUMASK;
327     (void)umask(Umask);
328
329     if (Def_timeout > MAX_TIMEOUT)      /* Set up default timeouts and delays */
330         Def_timeout = MAX_TIMEOUT;
331     if (Sleeptime < 0 || Sleeptime > 5)
332         Sleeptime = SLEEPTIME;
333     (void)alarm(Def_timeout);
334 #else
335     (void)alarm((u_int) timeout);
336 #endif
337     (void)signal(SIGALRM, timedout);
338 #endif
339     (void)signal(SIGQUIT, SIG_IGN);
340     (void)signal(SIGINT, SIG_IGN);
341 #if !defined(AIX) && !defined(AFS_HPUX_ENV)
342     (void)setpriority(PRIO_PROCESS, 0, 0);
343 #endif
344 #ifdef Q_SETUID
345     (void)quota(Q_SETUID, 0, 0, 0);
346 #endif /* Q_SETUID */
347
348     /*
349      * -p is used by getty to tell login not to destroy the environment
350      * -f is used to skip a second login authentication 
351      * -h is used by other servers to pass the name of the remote
352      *    host to login so that it may be placed in utmp and wtmp
353      */
354     (void)gethostname(tbuf, sizeof(tbuf));
355     domain = strchr(tbuf, '.');
356
357 #ifdef  AFS_HPUX_ENV
358     /*
359      * Set flag to disable the pid check if you find that you are
360      * a subsystem login.
361      */
362     sublogin = 0;
363     if (*renvp && strcmp(*renvp, SUBLOGIN) == 0)
364         sublogin = 1;
365 #endif
366     fflag = hflag = pflag = rflag = 0;
367     memset(&utmp, '\0', sizeof(utmp));
368     passwd_req = 1;
369 #ifdef  AFS_SUN_ENV
370 #ifdef  AFS_SUN5_ENV
371     while ((ch = getopt(argc, argv, "fh:prd")) != -1) {
372 #else
373     while ((ch = getopt(argc, argv, "fh:pr")) != -1) {
374 #endif
375 #else
376     while ((ch = getopt(argc, argv, "fh:p")) != EOF) {
377 #endif
378 /*printf("ch='%c'\n", ch);*/
379         switch (ch) {
380         case 'f':
381             fflag = 1;
382             break;
383         case 'h':
384 #ifdef  AFS_SUN_ENV
385             if (hflag || rflag) {
386                 fprintf(stderr, "Only one of -r and -h allowed\n");
387                 exit(1);
388             }
389 #endif
390             if (getuid()) {
391                 fprintf(stderr, "login: -h for super-user only.\n");
392
393                 exit(1);
394             }
395             rlog = 1;
396             hflag = 1;
397             if (domain && (p = strchr(optarg, '.'))
398                 && strcasecmp(p, domain) == 0)
399                 *p = 0;
400             hostname = optarg;
401             break;
402 #ifdef  AFS_SUN_ENV
403         case 'r':
404             if (hflag || rflag) {
405                 fprintf(stderr, "Only one of -r and -h allowed\n");
406                 exit(1);
407             }
408             if (argv[2] == 0)
409                 exit(1);
410 #ifndef AFS_SUN5_ENV
411 /*                      fflag = 1;*/
412 #endif
413             rflag = 1;
414 #ifndef AFS_SUN5_ENV
415             usererr = doremotelogin(argv[2]);
416             strncpy(utmp.ut_host, argv[2], sizeof(utmp.ut_host));
417             argc -= 2;
418             argv += 2;
419 #endif
420             continue;
421
422             break;
423 #ifdef  AFS_SUN5_ENV
424         case 'd':               /* Ignode the '-d device' option for now!!! */
425             dflag = 0;          /* XXX */
426             d_dev = *++argv;
427             argc--;
428             break;
429 #endif
430 #endif
431         case 'p':
432             pflag = 1;
433             break;
434         case '?':
435         default:
436             fprintf(stderr, "usage: login [-fp] [username]\n");
437             exit(1);
438         }
439     }
440     argc -= optind;
441     argv += optind;
442 #ifdef  AFS_SUN5_ENV
443     if (rflag)
444         strcpy(rhost, *argv++);
445     if (hflag) {
446         if (argv[0] && (*argv[0] != '-')) {
447             if ((!strncmp(*argv, "TERM=", strlen("TERM=")))) {
448                 strncpy(term, &((*argv)[strlen("TERM=")]), sizeof(term));
449             }
450         }
451         ask = 1;
452     } else
453 #endif
454 #if     defined(AFS_SUN_ENV) && !defined(AFS_SUN5_ENV)
455     if (!rflag && *argv) {
456 #else
457     if (*argv) {
458 #endif
459 #ifdef  AFS_OSF_ENV
460         memset(ousername, '\0', sizeof(ousername));
461         strcpy(ousername, *argv);
462         loginname = ousername;
463 #else
464         username = *argv;
465 #endif
466         ask = 0;
467     } else {
468 #ifdef  AFS_SUN5_ENV
469         ttypmt = getenv("TTYPROMPT");
470         if (ttypmt && (*ttypmt != '\0')) {
471             extern char **getargs();
472             /*
473              * if ttyprompt is set, there should be data on the stream already. 
474              */
475             if ((envp = getargs(buf1)) != (char **)NULL) {
476                 username = *envp;
477             }
478         }
479         ask = 0;
480 #else
481 #ifdef  AFS_SUN_ENV
482         if (rflag)
483             ask = 0;
484         else
485 #endif
486             ask = 1;
487 #endif
488     }
489     ioctlval = 0;
490 #if !defined(AIX) && !defined(AFS_HPUX_ENV) && !defined(AFS_OSF_ENV)
491     (void)ioctl(0, TIOCLSET, &ioctlval);
492
493     (void)ioctl(0, TIOCNXCL, 0);
494
495     (void)fcntl(0, F_SETFL, ioctlval);
496     (void)ioctl(0, TIOCGETP, &sgttyb);
497 #ifdef  AFS_SUN_ENV
498     (void)ioctl(0, FIONBIO, &zero);
499     (void)ioctl(0, FIOASYNC, &zero);
500     (void)ioctl(0, TIOCLGET, &locl);
501     /*
502      * If talking to an rlogin process,
503      * propagate the terminal type and
504      * baud rate across the network.
505      */
506 #ifdef  AFS_SUN5_ENV
507     if (rflag) {
508         doremotelogin();
509 #else
510     if (rflag || rlog) {
511         doremoteterm(term, &sgttyb);
512 #endif
513     }
514     locl &= LPASS8;
515     locl |= LCRTBS | LCTLECH | LDECCTQ;
516     if (sgttyb.sg_ospeed >= B1200)
517         locl |= LCRTERA | LCRTKIL;
518     (void)ioctl(0, TIOCLSET, &locl);
519 #endif
520     sgttyb.sg_erase = CERASE;
521     sgttyb.sg_kill = CKILL;
522     (void)ioctl(0, TIOCSLTC, &ltc);
523     (void)ioctl(0, TIOCSETC, &tc);
524 #ifdef  AFS_SUN5_ENV
525     if (!rflag)
526 #endif
527         (void)ioctl(0, TIOCSETP, &sgttyb);
528 #endif /* AIX  */
529     for (cnt = getdtablesize(); cnt > 2; cnt--)
530         close(cnt);
531 #ifdef  AFS_SUN52_ENV
532     if (dflag) {
533         ttyn = d_dev;
534     } else
535 #endif
536     if (ttyn == NULL) {
537         ttyn = ttyname(0);
538         if (ttyn == NULL || *ttyn == '\0') {
539 #ifdef  AFS_OSF_ENV
540             (void)sprintf(tname, "%s??", _PATH_TTY);
541             ttyn = tname;
542 #else
543             ttyn = "/dev/tty??";
544 #endif
545
546         }
547     }
548 #ifdef  AFS_HPUX_ENV
549     ttyntail = ttyn + sizeof("/dev/") - 1;
550 #endif
551     if (tty = strrchr(ttyn, '/'))
552         ++tty;
553     else
554         tty = ttyn;
555
556     openlog("login", LOG_ODELAY, LOG_AUTH);
557
558 #ifdef  AFS_OSF_ENV
559 #define _PATH_HUSHLOGIN ".hushlogin"
560 #define _PATH_MAILDIR   "/var/spool/mail"
561 #ifndef _PATH_DEFPATH
562 #define _PATH_DEFPATH   "/usr/bin:."
563 #endif
564     {
565         int cnt;
566         int authret = 0, doafs = 0;
567         char shell[PATH_MAX + 1] = _PATH_BSHELL, *pass, user[40], ouser[40];
568         int (*sia_collect) () = sia_collect_trm;
569         int getloginp(), uid;
570         struct passwd *pwd;
571
572 /*printf("loginname=%s,  ttyn=%s, fflag=%d\n", loginname, ttyn, fflag);*/
573         quietlog = 0;
574         if ((sia_ses_init
575              (&entity, oargc, oargv, hostname, loginname, ttyn, 1,
576               NULL)) == SIASUCCESS) {
577             static int useGetPass = 0;
578             int cnt1 = 0, first = 0;
579             char *prompt, *reason, pword[BUFSIZ];
580             /***** SIA SESSION AUTHENTICATION *****/
581             if (!fflag) {
582                 for (cnt = 5; cnt; cnt--) {
583                     doafs = 0;
584                     if (first++ || !entity->name) {
585                         clean_entity_pwd(entity);
586                         if (getloginp(entity) < 0) {
587                             printf("Illegal login name\n");
588                             doafs = -1;
589                             break;
590                         }
591                     }
592                     strcpy(user, entity->name);
593                     prompt = "Password:";
594                     if ((pwd = getpwnam(user))) {
595                         if (!strcmp(pwd->pw_passwd, "X")) {
596                             doafs = 1;
597                         }
598                     }
599                     if (useGetPass) {
600                         pass = getpass(prompt);
601                     } else {
602                         code =
603                             ka_UserReadPassword(prompt, pword, sizeof(pword),
604                                                 &reason);
605                         pass = pword;
606                         if (code) {
607                             if (code != KANULLPASSWORD) {
608                                 if (++cnt1 > 3)
609                                     useGetPass = 1;
610                             }
611                             fprintf(stderr,
612                                     "Unable to read password because %s\n",
613                                     reason);
614                             continue;
615                         }
616                     }
617
618                     if (!pwd) {
619                         printf("Login incorrect\n");
620                         fflush(stdout);
621                         continue;
622                     }
623
624                     if (doafs
625                         ||
626                         ((authret =
627                           sia_ses_authent(sia_collect, pass,
628                                           entity)) == SIASUCCESS)) {
629                         if (doafs) {
630                             uid = pwd->pw_uid;
631                             sia_make_entity_pwd(pwd, entity);
632                         } else {
633                             uid = entity->pwd->pw_uid;
634                             pwd = entity->pwd;
635                         }
636                       doafs:
637                         authret = do_afs_auth(pwd, pass, doafs);
638                         if (!authret) {
639                             strcpy(ouser, user);
640                             printf("Login incorrect\n");
641                             fflush(stdout);
642                             continue;
643                         }
644
645                         printf("AFS (R) %s Login\n", AFSVersion);
646
647                         if (uid) {
648                             groups[0] = groups[1] = 0;
649                             ngroups = getgroups(NGROUPS, groups);
650                             pagval =
651                                 get_pag_from_groups(groups[0], groups[1]);
652                         }
653                         break;
654                     } else if (authret & SIASTOP) {
655                         break;
656                     } else if (authret == SIAFAIL) {
657                         /* why did it fail ? */
658                         struct ttyent *ptr;
659                         setttyent();
660                         /* 
661                          ** if the "ptys" command does not exist in the
662                          ** /etc/securettys file, then root login's are
663                          ** allowed only from the console
664                          */
665                         if (!pwd->pw_uid)       /* for root */
666                             if (((ptr = getttynam("ptys")) == NULL)
667                                 || !(ptr->ty_status & TTY_SECURE)) {
668                                 printf
669                                     ("root login refused on this terminal\n");
670                                 continue;
671                             }
672                     }
673                     if (doafs || (authret != SIASUCCESS)) {
674                         uid = pwd->pw_uid;
675                         sia_make_entity_pwd(pwd, entity);
676                         goto doafs;
677                     }
678                     printf("login incorrect\n");
679                 }
680                 if (cnt <= 0 || (doafs == -1)) {
681                     sia_ses_release(&entity);
682                     exit(1);
683                 }
684             }
685             /***** SIA SESSION ESTABLISHMENT *****/
686             if (sia_ses_estab(sia_collect, entity) == SIASUCCESS) {
687                 /*
688                  * Display and update lastlog file entry.  -DAL003
689                  */
690                 quietlog = access(_PATH_HUSHLOGIN, F_OK) == 0;
691                 if (!quietlog)
692                     quietlog = !*entity->pwd->pw_passwd
693                         && !usershell(entity->pwd->pw_shell);
694                 if (!entity->tty)
695                     dolastlog(quietlog);
696                 /* END DAL003 */
697 #ifdef AFS_KERBEROS_ENV
698                 (void)chown(ktc_tkt_string(), pwd->pw_uid, pwd->pw_gid);
699 #endif /* AFS_KERBEROS_ENV */
700                 /***** SIA LAUNCHING SESSION *****/
701                 if (sia_ses_launch(sia_collect, entity) == SIASUCCESS) {
702                     ngroups = getgroups(NGROUPS, groups);
703                     if ((pagval != NOPAG)
704                         && (afs_get_pag_from_groups(groups[0], groups[1])) ==
705                         NOPAG) {
706                         /* we will have to shift grouplist to make room for pag */
707                         if (ngroups + 2 > NGROUPS) {
708                             perror("Too many groups");  /* XXX */
709                             exit(3);
710                         }
711                         for (j = ngroups - 1; j >= 0; j--) {
712                             groups[j + 2] = groups[j];
713                         }
714                         ngroups += 2;
715                         get_groups_from_pag(pagval, &groups[0], &groups[1]);
716                         seteuid(0);     /* Since the seteuid was set the user already */
717                         if (setgroups(ngroups, groups) == -1) {
718                             perror("setgroups");
719                             exit(3);
720                         }
721                         seteuid(entity->pwd->pw_uid);   /* Set euid back */
722                     }
723                     /****** Nothing left to fail *******/
724                     if (setreuid(geteuid(), geteuid()) < 0) {
725                         perror("setreuid()");
726                         exit(3);
727                     }
728                     /****** set up environment   *******/
729                     /* destroy environment unless user has requested preservation */
730                     envinit[0] = envinit[1] = 0;
731                     if (environ)
732                         for (cnt = 0; environ[cnt] != NULL; cnt++)
733                             if (!strncmp(environ[cnt], "TERM=", 5)) {
734                                 envinit[0] = environ[cnt];
735                                 break;
736                             }
737                     if (!pflag)
738                         environ = envinit;
739                     (void)setenv("HOME", entity->pwd->pw_dir, 1);
740                     if (entity->pwd->pw_shell && *entity->pwd->pw_shell)
741                         strncpy(shell, entity->pwd->pw_shell, sizeof shell);
742                     (void)setenv("SHELL", shell, 1);
743                     if (term[0] == '\0')
744                         (void)strncpy(term, stypeof(tty), sizeof(term));
745                     (void)setenv("TERM", term, 0);
746                     (void)setenv("USER", entity->pwd->pw_name, 1);
747                     (void)setenv("LOGNAME", entity->pwd->pw_name, 1);
748                     (void)setenv("PATH", _PATH_DEFPATH, 0);
749 #ifdef AFS_KERBEROS_ENV
750                     (void)setenv("KRBTKFILE", ktc_tkt_string(), 0);
751 #endif /* AFS_KERBEROS_ENV */
752                     if (!quietlog) {
753                         struct stat st;
754
755                         motd();
756                         (void)sprintf(tbuf, "%s/%s", _PATH_MAILDIR,
757                                       entity->pwd->pw_name);
758                         if (stat(tbuf, &st) == 0 && st.st_size != 0)
759                             (void)printf("You have %smail.\n",
760                                          (st.st_mtime >
761                                           st.st_atime) ? "new " : "");
762                     }
763                     /******* Setup default signals **********/
764                     (void)signal(SIGALRM, SIG_DFL);
765                     (void)signal(SIGQUIT, SIG_DFL);
766                     (void)signal(SIGINT, SIG_DFL);
767                     (void)signal(SIGTSTP, SIG_IGN);
768
769                     tbuf[0] = '-';
770                     (void)strcpy(tbuf + 1,
771                                  (p = strrchr(shell, '/')) ? p + 1 : shell);
772                     sia_ses_release(&entity);
773                     execlp(shell, tbuf, 0);
774                     (void)printf("login: no shell: %s.\n", strerror(errno));
775                     exit(0);
776                 }
777                 /***** SIA session launch failure *****/
778             }
779             /***** SIA session establishment failure *****/
780         }
781         if (entity != NULL) {
782             sia_ses_release(&entity);
783         }
784         syslog(LOG_ERR, " LOGIN FAILURE ");
785         exit(1);
786     }
787 #else /* AFS_OSF_ENV */
788 #ifdef AFS_HPUX_ENV
789     {                           /* This block sets TZ environment on HPUX */
790         /* First set TZ environment here, so that
791          * LOGIN FAILURE will get correct time stamp.
792          * For logins from console, -p flag is not set,
793          * the TZ environment set here will be cleared later.
794          * We're gonna set it once again later after it's cleared.
795          */
796         FILE *fp;
797         char buf[MAX_TZ_LEN];
798         char *env_p = NULL;
799         int tz_incorrect = 0;
800
801         /* set TZ only if tz_incorrect
802          * (*env_p==0 or env_p==0 ) and there is a correct /etc/TIMEZONE
803          * otherwise, just let it be default (US eastern on HP)
804          */
805         env_p = getenv("TZ");
806         if (!env_p)
807             tz_incorrect = 1;
808         else if (!(*env_p))
809             tz_incorrect = 1;
810
811         if (tz_incorrect) {
812             /* HP UX 10.0 or later has different file format */
813 #ifdef AFS_HPUX100_ENV
814             /* /etc/TIMEZONE file example (HP-UX 10 or later)
815              * TZ=EST5EDT
816              * export TZ
817              */
818             fp = fopen("/etc/TIMEZONE", "r");
819             if (fp) {
820                 if ((fgets(buf, sizeof(buf), fp)) != NULL) {
821                     buf[strlen(buf) - 1] = 0;
822                     if (!strncmp(buf, "TZ=", 3)) {
823                         strncpy(TZ, buf, MAX_TZ_LEN);
824                         putenv(TZ);
825                     }
826                 }
827                 fclose(fp);
828             }
829 #else /* AFS_HPUX100_ENV */
830             /* /etc/src.sh file example (HP-UX 9 or earlier)
831              * SYSTEM_NAME=myname; export SYSTEM_NAME
832              * TZ=EST5EDT; export TZ
833              */
834             fp = fopen("/etc/src.sh", "r");
835             if (fp) {
836                 while ((fgets(buf, sizeof(buf), fp)) != NULL) {
837                     buf[strlen(buf) - 1] = 0;
838                     if (!strncmp(buf, "TZ=", 3)) {
839                         char *p = strchr(buf, ';');
840                         if (p)
841                             *p = 0;
842                         strncpy(TZ, buf, MAX_TZ_LEN);
843                         putenv(TZ);
844                     }
845                 }
846                 fclose(fp);
847             }
848 #endif /* AFS_HPUX100_ENV */
849         } else {
850             *TZ = 0;
851         }
852     }
853 #endif /* AFS_HPUX_ENV */
854     for (cnt = 0;; ask = 1) {
855         ioctlval = 0;
856 #if !defined(AIX) && !defined(AFS_HPUX_ENV)
857         (void)ioctl(0, TIOCSETD, &ioctlval);
858 #endif /* !AIX and !hpux */
859
860         if (ask | !username) {
861             fflag = 0;
862             getloginname(1);
863         }
864         /*
865          * Note if trying multiple user names;
866          * log failures for previous user name,
867          * but don't bother logging one failure
868          * for nonexistent name (mistyped username).
869          */
870         if (failures && strcmp(tbuf, username)) {
871             if (failures > (pwd ? 0 : 1))
872                 badlogin(tbuf);
873             failures = 0;
874         }
875         (void)strcpy(tbuf, username);
876         salt = "xx";
877 #ifdef  AFS_SUN5_ENV
878         if ((pwd = getpwnam(username)) && (spwd = getspnam(username))) {
879             initgroups(username, pwd->pw_gid);  /* XXX */
880             salt = spwd->sp_pwdp;
881         }
882 #else /* if !SUN5 */
883         if (pwd = getpwnam(username))
884             salt = pwd->pw_passwd;
885 #endif /* else !SUN5 */
886
887         /* if user not super-user, check for disabled logins */
888         if (pwd == NULL || pwd->pw_uid) {
889             checknologin();
890         }
891
892         /*
893          * Disallow automatic login to root; if not invoked by
894          * root, disallow if the uid's differ.
895          */
896         if (fflag && pwd) {
897             uid_t uid = getuid();
898
899             /*
900              *  allow f flag only if user running login is
901              *  same as target user or superuser
902              */
903             fflag = (uid == 0) || (uid == pwd->pw_uid);
904             if (fflag)
905                 passwd_req = 0;
906 /*                      passwd_req = pwd->pw_uid == 0 || (uid && uid != pwd->pw_uid);*/
907         }
908
909         /*
910          * If no pre-authentication and a password exists
911          * for this user, prompt for one and verify it.
912          */
913         if (!passwd_req || (pwd && !*pwd->pw_passwd)) {
914             break;
915         }
916 #if     defined(AFS_SUN_ENV) && !defined(AFS_SUN5_ENV)
917         if (!usererr)
918             break;
919 #endif
920 #if !defined(AIX) && !defined(AFS_HPUX_ENV)
921         setpriority(PRIO_PROCESS, 0, -4);
922 #endif
923
924         /*
925          * The basic model for logging in now, is that *if* there
926          * is a kerberos record for this individual user we will
927          * trust kerberos (provided the user really has an account
928          * locally.)  If there is no kerberos record (or the password
929          * were typed incorrectly.) we would attempt to authenticate
930          * against the local password file entry.  Naturally, if
931          * both fail we use existing failure code.
932          */
933         if (pwd) {
934             char pword[BUFSIZ];
935             int cnt1 = 0;
936             static int useGetPass = 0;
937
938             if (useGetPass) {
939                 pp = getpass("Password:");
940                 memcpy(pword, pp, 8);
941             } else {
942                 code =
943                     ka_UserReadPassword("Password:", pword, sizeof(pword),
944                                         &reason);
945
946                 if (code) {
947                     if (code != KANULLPASSWORD) {
948                         if (++cnt1 > 5)
949                             useGetPass = 1;
950                     }
951                     fprintf(stderr, "Unable to read password because %s\n",
952                             reason);
953                     goto loginfailed;
954                 }
955             }
956             pp = pword;
957             if (ka_UserAuthenticateGeneral(KA_USERAUTH_VERSION + KA_USERAUTH_DOSETPAG, pwd->pw_name,    /* kerberos name */
958                                            NULL,        /* instance */
959                                            NULL,        /* realm */
960                                            pp,  /* password */
961                                            0,   /* default lifetime */
962                                            &password_expires, 0,        /* spare 2 */
963                                            &reason      /* error string */
964                 )) {
965
966                 afsLoginFail = 1;
967                 pword[8] = '\0';
968             } else {
969                 if (strcmp(pwd->pw_passwd, "*"))
970                     break;      /* out of for loop */
971 #if !defined(AIX) && !defined(AFS_HPUX_ENV)
972                 (void)ioctl(0, TIOCHPCL, (struct sgttyb *)NULL);
973 #endif /* AIX */
974                 goto loginfailed;
975             }
976         } else {
977             pp = getpass("Password:");
978         }
979
980         p = crypt(pp, salt);
981         (void)memset(pp, '\0', strlen(pp));
982 #ifdef  AFS_SUN5_ENV
983         if (spwd && !strcmp(p, spwd->sp_pwdp))
984 #else
985         if (pwd && !strcmp(p, pwd->pw_passwd))
986 #endif
987         {
988             /* Only print this if local authentication is successful */
989             if (afsLoginFail) {
990                 printf("Unable to authenticate to AFS because %s\n", reason);
991                 printf("proceeding with local authentication...\n");
992             }
993             afsLoginFail = 0;
994             break;
995         }
996         afsLoginFail = 0;
997
998       loginfailed:
999         printf("Login incorrect\n");
1000         failures++;
1001         /* we allow 10 tries, but after 3 we start backing off */
1002         if (++cnt > 3) {
1003             if (cnt >= 6) {
1004                 badlogin(username);
1005 #if !defined(AIX) && !defined(AFS_HPUX_ENV)
1006                 (void)ioctl(0, TIOCHPCL, (struct sgttyb *)NULL);
1007 #endif /* AIX */
1008                 (void)close(0);
1009                 (void)close(1);
1010                 (void)close(2);
1011                 sleep(10);
1012                 exit(1);
1013             }
1014             sleep((u_int) ((cnt - 3) * 5));
1015         }
1016     }
1017 #if !defined(AIX) && !defined(AFS_HPUX_ENV)
1018     setpriority(PRIO_PROCESS, 0, 0);
1019 #endif /* AIX */
1020 #ifdef  AFS_SUN5_ENV
1021     /*  Exits if root login not on system console. */
1022     if (pwd->pw_uid == 0) {
1023         if ((Console != NULL) && (strcmp(ttyn, Console) != 0)) {
1024             (void)printf("Not on system console\n");
1025             exit(10);
1026         }
1027         if (Def_supath != NULL)
1028             Def_path = Def_supath;
1029         else
1030             Def_path = DEF_SUPATH;
1031     }
1032 #endif /* AFS_SUN5_ENV */
1033
1034     printf("AFS (R) %s Login\n", AFSVersion);   /* generated version */
1035
1036     /* committed to login -- turn off timeout */
1037     (void)alarm((u_int) 0);
1038
1039     /*
1040      * If valid so far and root is logging in, see if root logins on
1041      * this terminal are permitted.
1042      */
1043 #if !defined(AIX) && !defined(AFS_SUN5_ENV)
1044 #ifdef  AFS_HPUX_ENV
1045     /* This is the /etc/securetty feature.  We wanted to 1st prompt for a
1046      * password even if we know that this is not a securetty because
1047      * we don't want to give any clue if the potential intruder guesses
1048      * the correct password.
1049      */
1050     if ((pwd->pw_uid == 0) && !rootterm(ttyn + sizeof("/dev/") - 1)) {
1051 #else
1052     if (pwd->pw_uid == 0 && !rootterm(tty)) {
1053 #endif
1054         if (hostname)
1055             syslog(LOG_NOTICE, "ROOT LOGIN REFUSED FROM %s", hostname);
1056         else
1057             syslog(LOG_NOTICE, "ROOT LOGIN REFUSED ON %s", tty);
1058         printf("Login incorrect\n");
1059
1060         /*
1061          * Reset tty line.
1062          */
1063
1064         (void)chmod(ttyn, 0666);
1065
1066         sleepexit(1);
1067     }
1068 #endif /* !AIX & !SUN5 */
1069 #ifdef Q_SETUID
1070     if (quota(Q_SETUID, pwd->pw_uid, 0, 0) < 0 && errno != EINVAL) {
1071         switch (errno) {
1072         case EUSERS:
1073             fprintf(stderr,
1074                     "Too many users logged on already.\nTry again later.\n");
1075             break;
1076         case EPROCLIM:
1077             fprintf(stderr, "You have too many processes running.\n");
1078             break;
1079         default:
1080             perror("quota (Q_SETUID)");
1081         }
1082
1083         /*
1084          * Reset tty line.
1085          */
1086
1087         (void)chmod(ttyn, 0666);
1088
1089         sleepexit(0);
1090     }
1091 #endif /* Q_SETUID */
1092
1093     /* For Solaris and HP, we might want to chdir later for remotely 
1094      * mounted home directory because home direcotry may be
1095      * protected now
1096      */
1097     if (chdir(pwd->pw_dir) < 0) {
1098 #if !defined(AFS_SUN5_ENV) && !defined(AFS_HPUX_ENV)
1099         printf("No directory %s!\n", pwd->pw_dir);
1100 #endif /* !defined(AFS_SUN5_ENV) && !defined(AFS_HPUX_ENV) */
1101         if (chdir("/")) {
1102
1103             /*
1104              * Reset tty line.
1105              */
1106
1107             (void)chmod(ttyn, 0666);
1108
1109             exit(0);
1110         }
1111 #if !defined(AFS_SUN5_ENV) && !defined(AFS_HPUX_ENV)
1112         pwd->pw_dir = "/";
1113         printf("Logging in with home = \"/\".\n");
1114 #else /* !defined(AFS_SUN5_ENV) && !defined(AFS_HPUX_ENV) */
1115         retry_chdir = 1;
1116 #endif /* !defined(AFS_SUN5_ENV) && !defined(AFS_HPUX_ENV) */
1117     }
1118
1119     /* nothing else left to fail -- really log in */
1120     {
1121 #ifdef  AFS_SUN5_ENV
1122         long tlen;
1123         struct utmpx *utx, *getutxent(), *pututxline();
1124 #endif
1125 #if defined(AFS_HPUX_ENV)
1126         register struct utmp *u = NULL;
1127         extern pid_t getpid();
1128 #endif
1129
1130 #ifdef  AFS_SUN5_ENV
1131         (void)time(&utmp.ut_tv.tv_sec);
1132 #else
1133         (void)time(&utmp.ut_time);
1134 #endif
1135         strncpy(utmp.ut_name, username, sizeof(utmp.ut_name));
1136 #if !defined(AIX)               /*&& !defined(AFS_SUN5_ENV) */
1137         if (hostname)
1138             strncpy(utmp.ut_host, hostname, sizeof(utmp.ut_host));
1139 #endif
1140         strncpy(utmp.ut_line, tty, sizeof(utmp.ut_line));
1141 #if defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV)
1142         utmp.ut_type = USER_PROCESS;
1143         if (!strncmp(ttyn, "/dev/", strlen("/dev/"))) {
1144             strncpy(utmp.ut_line, &(ttyn[strlen("/dev/")]),
1145                     sizeof(utmp.ut_line));
1146         }
1147
1148         utmp.ut_pid = getpid();
1149         if ((!strncmp(tty, "tty", strlen("tty")))
1150             || (!strncmp(tty, "pty", strlen("pty")))) {
1151             strncpy(utmp.ut_id, &(tty[strlen("tty")]), sizeof(utmp.ut_id));
1152         }
1153 #endif /* AFS_HPUX_ENV */
1154 #ifdef  AFS_HPUX_ENV
1155         /*
1156          * Find the entry for this pid (or line if we are a sublogin)
1157          * in the utmp file.
1158          */
1159         while ((u = getutent()) != NULL) {
1160             if ((u->ut_type == INIT_PROCESS || u->ut_type == LOGIN_PROCESS
1161                  || u->ut_type == USER_PROCESS)
1162                 &&
1163                 ((sublogin
1164                   && strncmp(u->ut_line, ttyntail, sizeof(u->ut_line)) == 0)
1165                  || u->ut_pid == utmp.ut_pid)) {
1166
1167                 /*
1168                  * Copy in the name of the tty minus the
1169                  * "/dev/", the id, and set the type of entry
1170                  * to USER_PROCESS.
1171                  */
1172                 (void)strncpy(utmp.ut_line, ttyntail, sizeof(utmp.ut_line));
1173                 utmp.ut_id[0] = u->ut_id[0];
1174                 utmp.ut_id[1] = u->ut_id[1];
1175                 utmp.ut_id[2] = u->ut_id[2];
1176                 utmp.ut_id[3] = u->ut_id[3];
1177                 utmp.ut_type = USER_PROCESS;
1178                 utmp.how_to_count = add_count();
1179
1180                 /*
1181                  * Copy remote host information
1182                  */
1183                 strncpy(utmp.ut_host, u->ut_host, sizeof(utmp.ut_host));
1184                 utmp.ut_addr = u->ut_addr;
1185
1186                 /* Return the new updated utmp file entry. */
1187                 pututline(&utmp);
1188                 break;
1189             }
1190         }
1191         endutent();             /* Close utmp file */
1192 #endif
1193 #ifdef  AFS_SUN5_ENV
1194         utmp.ut_syslen = (tlen =
1195                           strlen(utmp.ut_host)) ? min(tlen + 1,
1196                                                       sizeof(utmp.
1197                                                              ut_host)) : 0;
1198         strncpy(utmp.ut_user, username, sizeof(utmp.ut_user));
1199         while ((utx = getutxent()) != NULL) {
1200             if ((utx->ut_type == INIT_PROCESS || utx->ut_type == LOGIN_PROCESS
1201                  || utx->ut_type == USER_PROCESS)
1202                 && (utx->ut_pid == utmp.ut_pid)) {
1203                 strncpy(utmp.ut_line, (ttyn + sizeof("/dev/") - 1),
1204                         sizeof(utmp.ut_line));
1205                 utmp.ut_id[0] = utx->ut_id[0];
1206                 utmp.ut_id[1] = utx->ut_id[1];
1207                 utmp.ut_id[2] = utx->ut_id[2];
1208                 utmp.ut_id[3] = utx->ut_id[3];
1209                 utmp.ut_type = USER_PROCESS;
1210                 pututxline(&utmp);
1211                 break;
1212             }
1213         }
1214         endutxent();            /* Close utmp file */
1215         if (!utx) {
1216             printf
1217                 ("No utmpx entry.  You must exec 'login' from the lowest level 'sh'\n");
1218             exit(1);
1219         } else
1220             updwtmpx(WTMPX_FILE, &utmp);
1221 #else
1222         login(&utmp);
1223 #endif
1224     }
1225
1226     quietlog = access(HUSHLOGIN, F_OK) == 0;
1227     dolastlog(quietlog);
1228
1229 #if !defined(AIX) && !defined(AFS_HPUX_ENV)
1230 #ifdef  AFS_SUN_ENV
1231     if (!hflag && !rflag) {     /* XXX */
1232 #else
1233     if (!hflag) {               /* XXX */
1234 #endif
1235         static struct winsize win = { 0, 0, 0, 0 };
1236
1237         (void)ioctl(0, TIOCSWINSZ, &win);
1238     }
1239 #endif /* !AIX and !hpux */
1240
1241 #ifdef  AFS_SUN5_ENV
1242     /*
1243      * Set the user's ulimit
1244      */
1245     if (Def_ulimit > 0L && ulimit(SET_FSIZ, Def_ulimit) < 0L)
1246         (void)printf("Could not set ULIMIT to %ld\n", Def_ulimit);
1247
1248 #endif
1249 #if     defined(AFS_SUN_ENV)
1250     /*
1251      * Set owner/group/permissions of framebuffer devices
1252      */
1253     (void)set_fb_attrs(ttyn, pwd->pw_uid, pwd->pw_gid);
1254 #endif
1255
1256     (void)chown(ttyn, pwd->pw_uid,
1257                 (gr = getgrnam(TTYGRPNAME)) ? gr->gr_gid : pwd->pw_gid);
1258
1259
1260     (void)chmod(ttyn, 0620);
1261     (void)setgid(pwd->pw_gid);
1262
1263 #ifdef  AFS_HPUX_ENV
1264     if ((pwd->pw_gid < 0) || (pwd->pw_gid > MAXUID)) {
1265         printf("Bad group id.\n");
1266         exit(1);
1267     }
1268     if ((pwd->pw_uid < 0) || (pwd->pw_uid > MAXUID)) {
1269         printf("Bad user id.\n");
1270         exit(1);
1271     }
1272 #endif
1273
1274 #ifdef AFS_KERBEROS_ENV
1275     (void)chown(ktc_tkt_string(), pwd->pw_uid, pwd->pw_gid);
1276
1277 #endif
1278
1279     groups[0] = groups[1] = 0;
1280     ngroups = getgroups(NGROUPS_MAX, groups);
1281     pagval = get_pag_from_groups(groups[0], groups[1]);
1282     initgroups(username, pwd->pw_gid);
1283     ngroups = getgroups(NGROUPS_MAX, groups);
1284     if ((pagval != NOPAG)
1285         && (afs_get_pag_from_groups(groups[0], groups[1])) == NOPAG) {
1286         /* we will have to shift grouplist to make room for pag */
1287         if (ngroups + 2 > NGROUPS_MAX)
1288             return E2BIG;       /* XXX */
1289         for (j = ngroups - 1; j >= 0; j--) {
1290             groups[j + 2] = groups[j];
1291         }
1292         ngroups += 2;
1293         get_groups_from_pag(pagval, &groups[0], &groups[1]);
1294         if (setgroups(ngroups, groups) == -1) {
1295             perror("setgroups");
1296             return -1;
1297         }
1298     }
1299 #ifdef Q_DOWARN
1300     quota(Q_DOWARN, pwd->pw_uid, (dev_t) - 1, 0);
1301 #endif /* Q_DOWARN */
1302
1303     /* destroy environment unless user has requested preservation */
1304     if (!pflag) {
1305         envinit[0] = NULL;
1306         envinit[1] = NULL;
1307         environ = envinit;
1308     }
1309     (void)setuid(pwd->pw_uid);
1310
1311 #if defined(AFS_SUN5_ENV) || defined(AFS_HPUX_ENV)
1312     /* This is the time to retry chdir for Solaris and HP
1313      */
1314     if (retry_chdir && chdir(pwd->pw_dir) < 0) {
1315         printf("No directory %s!\n", pwd->pw_dir);
1316         if (chdir("/") < 0) {
1317             /* reset tty line and exit */
1318             (void)chmod(ttyn, 0666);
1319             exit(0);
1320         }
1321         pwd->pw_dir = "/";
1322         printf("Logging with home = \"/\".\n");
1323     }
1324 #endif /* AFS_SUN5_ENV || AFS_HPUX_ENV */
1325
1326     if (*pwd->pw_shell == '\0')
1327         pwd->pw_shell = BSHELL;
1328 #if !defined(AIX) && !defined(AFS_HPUX_ENV)
1329     /* turn on new line discipline for the csh */
1330     else if (!strcmp(pwd->pw_shell, "/bin/csh")) {
1331         ioctlval = NTTYDISC;
1332         (void)ioctl(0, TIOCSETD, &ioctlval);
1333     }
1334 #endif /* AIX */
1335 #ifdef  AFS_SUN5_ENV
1336     else {
1337         if (Altshell != NULL && strcmp(Altshell, "YES") == 0) {
1338             (void)setenv("SHELL", pwd->pw_shell, 1);
1339         }
1340     }
1341     if (Def_tz != NULL) {
1342         tmp_tz = Def_tz;
1343     }
1344     Def_tz = getenv("TZ");
1345     if (Def_tz) {
1346         setenv("TZ", Def_tz, 1);
1347     } else {
1348         if (tmp_tz) {
1349             Def_tz = tmp_tz;
1350             setenv("TZ", Def_tz, 1);
1351         }
1352     }
1353     if (Def_hertz == NULL)
1354         (void)setenv("HZ", HZ, 1);
1355     else
1356         (void)setenv("HZ", Def_hertz, 1);
1357
1358 #endif
1359
1360 #ifdef AFS_HPUX_ENV
1361     /* if pflag is not set
1362      * the TZ environment was cleared moments ago */
1363     if (*TZ && !pflag) {
1364         setenv("TZ", &TZ[3], 1);
1365     }
1366 #endif /* AFS_HPUX_ENV */
1367
1368     (void)setenv("HOME", pwd->pw_dir, 1);
1369     (void)setenv("SHELL", pwd->pw_shell, 1);
1370     if (term[0] == '\0')
1371         strncpy(term, stypeof(tty), sizeof(term));
1372     (void)setenv("TERM", term, 0);
1373     (void)setenv("USER", pwd->pw_name, 1);
1374     (void)setenv("LOGNAME", pwd->pw_name, 1);
1375 #ifdef  AFS_SUN5_ENV
1376     if (Def_path == NULL)
1377         (void)setenv("PATH", DEF_PATH, 0);
1378     else
1379         (void)setenv("PATH", Def_path, 0);
1380 #else
1381     (void)setenv("PATH", "/usr/ucb:/bin:/usr/bin:", 0);
1382 #endif
1383
1384 #if     defined(AFS_SUN5_ENV) || defined(AFS_HPUX100_ENV)
1385 #ifndef NO_MAIL
1386     /* Sol, HP: set MAIL only if NO_MAIL is not set */
1387     sprintf(mail, "%s%s", MAILDIR, pwd->pw_name);
1388     (void)setenv("MAIL", mail, 0);
1389 #endif /* NO_MAIL */
1390 #endif /* AFS_SUN5_ENV || AFS_HPUX100_ENV */
1391
1392 #ifdef AFS_KERBEROS_ENV
1393     (void)setenv("KRBTKFILE", ktc_tkt_string(), 0);
1394 #endif
1395
1396     if (password_expires >= 0) {
1397         char sbuffer[100];
1398         (void)setenv("PASSWORD_EXPIRES",
1399                      cv2string(&sbuffer[100], password_expires), 1);
1400     }
1401
1402     if (tty[sizeof("tty") - 1] == 'd')
1403         syslog(LOG_INFO, "DIALUP %s, %s", tty, pwd->pw_name);
1404     if (pwd->pw_uid == 0)
1405         if (hostname)
1406             syslog(LOG_NOTICE, "ROOT LOGIN ON %s FROM %s", tty, hostname);
1407         else
1408             syslog(LOG_NOTICE, "ROOT LOGIN ON %s", tty);
1409
1410     if (!quietlog) {
1411         struct stat st;
1412
1413 #if     ! defined(AFS_SUN5_ENV) && (! defined(AFS_HPUX_ENV))
1414         /* In Solaris the shell displays motd */
1415         /* On hp700s /etc/profile also does it so it's redundant here too */
1416         motd();
1417         /* Don't check email either, should be done in shell */
1418         (void)sprintf(tbuf, "%s/%s", MAILDIR, pwd->pw_name);
1419         if (stat(tbuf, &st) == 0 && st.st_size != 0)
1420             printf("You have %smail.\n",
1421                    (st.st_mtime > st.st_atime) ? "new " : "");
1422 #endif
1423     }
1424
1425     (void)signal(SIGALRM, SIG_DFL);
1426     (void)signal(SIGQUIT, SIG_DFL);
1427     (void)signal(SIGINT, SIG_DFL);
1428 #if !defined(AIX) && !defined(AFS_HPUX_ENV)
1429     (void)signal(SIGTSTP, SIG_IGN);
1430 #endif /* AIX */
1431
1432     tbuf[0] = '-';
1433     strcpy(tbuf + 1,
1434            (p = strrchr(pwd->pw_shell, '/')) ? p + 1 : pwd->pw_shell);
1435     execlp(pwd->pw_shell, tbuf, 0);
1436     fprintf(stderr, "login: no shell: ");
1437     perror(pwd->pw_shell);
1438     exit(0);
1439 #endif /* else AFS_OSF_ENV */
1440 }
1441
1442 getloginname(prompt)
1443      int prompt;
1444 {
1445     register int ch;
1446     register char *p;
1447     static char nbuf[UT_NAMESIZE + 1];
1448
1449     for (;;) {
1450         if (prompt) {
1451             printf("login: ");
1452             prompt = 0;
1453         }
1454         for (p = nbuf; (ch = getchar()) != '\n';) {
1455             if (ch == EOF) {
1456                 badlogin(username);
1457                 exit(0);
1458             }
1459             if (p < nbuf + UT_NAMESIZE)
1460                 *p++ = (char)ch;
1461         }
1462         if (p > nbuf) {
1463             if (nbuf[0] == '-')
1464                 fprintf(stderr, "login names may not start with '-'.\n");
1465             else {
1466                 *p = '\0';
1467                 username = nbuf;
1468                 break;
1469             }
1470         } else
1471             prompt = 1;
1472     }
1473 }
1474
1475
1476 #ifdef  AFS_HPUX_ENV
1477 rootterm(tty)
1478      char *tty;
1479 {
1480     register FILE *fd;
1481     char buf[100];
1482
1483     /*
1484      * check to see if /etc/securetty exists, if it does then scan
1485      * file to see if passwd tty is in the file.  Return 1 if it is, 0 if not.
1486      */
1487     if ((fd = fopen(SECURETTY_FILE, "r")) == NULL)
1488         return (1);
1489     while (fgets(buf, sizeof buf, fd) != NULL) {
1490         buf[strlen(buf) - 1] = '\0';
1491         if (strcmp(tty, buf) == 0) {
1492             fclose(fd);
1493             return (1);
1494         }
1495     }
1496     fclose(fd);
1497     return (0);
1498 }
1499 #endif
1500 #if !defined(AIX) && !defined(AFS_HPUX_ENV) && !defined(AFS_SUN5_ENV)
1501 rootterm(ttyn)
1502      char *ttyn;
1503 {
1504     struct ttyent *t;
1505
1506     return ((t = getttynam(ttyn)) && t->ty_status & TTY_SECURE);
1507 }
1508 #endif
1509
1510 jmp_buf motdinterrupt;
1511
1512 motd()
1513 {
1514     register int fd, nchars;
1515     void (*oldint) ();
1516     void sigint();
1517     char tbuf[8192];
1518
1519     if ((fd = open(MOTDFILE, O_RDONLY, 0)) < 0)
1520         return;
1521     oldint = signal(SIGINT, sigint);
1522     if (setjmp(motdinterrupt) == 0)
1523         while ((nchars = read(fd, tbuf, sizeof(tbuf))) > 0)
1524             (void)write(fileno(stdout), tbuf, nchars);
1525     (void)signal(SIGINT, oldint);
1526     (void)close(fd);
1527 }
1528
1529 void
1530 sigint()
1531 {
1532     longjmp(motdinterrupt, 1);
1533 }
1534
1535 checknologin()
1536 {
1537     register int fd, nchars;
1538     char tbuf[8192];
1539
1540     if ((fd = open(NOLOGIN, O_RDONLY, 0)) >= 0) {
1541         while ((nchars = read(fd, tbuf, sizeof(tbuf))) > 0)
1542             (void)write(fileno(stdout), tbuf, nchars);
1543         sleepexit(0);
1544     }
1545 }
1546
1547 #if defined(AIX) || defined(AFS_HPUX_ENV) || defined(AFS_AIX32_ENV)
1548 dolastlog(quiet)
1549      int quiet;
1550 {
1551     return 0;
1552 }
1553 #else
1554 #ifdef  AFS_OSF_ENV
1555 dolastlog(quiet)
1556      int quiet;
1557 {
1558 #define _PATH_LASTLOG   "/var/adm/lastlog"
1559     struct lastlog ll;
1560     int fd;
1561     struct passwd *pwd;
1562
1563     pwd = entity->pwd;
1564     if ((fd = open(_PATH_LASTLOG, (O_RDWR | O_CREAT), 0666)) < 0)
1565         fprintf(stderr, "Can't open %s", _PATH_LASTLOG);
1566     else {
1567         (void)lseek(fd, (off_t) pwd->pw_uid * sizeof(ll), L_SET);
1568         if (!quiet) {
1569             if (read(fd, (char *)&ll, sizeof(ll)) == sizeof(ll)
1570                 && ll.ll_time != 0) {
1571                 (void)printf("Last login: %.*s ", 24 - 5,
1572                              (char *)ctime(&ll.ll_time));
1573                 if (*ll.ll_host != '\0')
1574                     (void)printf("from %.*s\n", sizeof(ll.ll_host),
1575                                  ll.ll_host);
1576                 else
1577                     (void)printf("on %.*s\n", sizeof(ll.ll_line), ll.ll_line);
1578             }
1579         }
1580         (void)close(fd);
1581     }
1582 }
1583 #else
1584 dolastlog(quiet)
1585      int quiet;
1586 {
1587     struct lastlog ll;
1588     int fd;
1589
1590     if ((fd = open(LASTLOG, O_RDWR, 0)) >= 0) {
1591         (void)lseek(fd, (off_t) pwd->pw_uid * sizeof(ll), L_SET);
1592         if (!quiet) {
1593             if (read(fd, (char *)&ll, sizeof(ll)) == sizeof(ll)
1594                 && ll.ll_time != 0) {
1595                 printf("Last login: %.*s ", 24 - 5,
1596                        (char *)ctime(&ll.ll_time));
1597                 if (*ll.ll_host != '\0')
1598                     printf("from %.*s\n", sizeof(ll.ll_host), ll.ll_host);
1599                 else
1600                     printf("on %.*s\n", sizeof(ll.ll_line), ll.ll_line);
1601             }
1602             (void)lseek(fd, (off_t) pwd->pw_uid * sizeof(ll), L_SET);
1603         }
1604         memset(&ll, '\0', sizeof(ll));
1605         (void)time(&ll.ll_time);
1606         strncpy(ll.ll_line, tty, sizeof(ll.ll_line));
1607         if (hostname)
1608             strncpy(ll.ll_host, hostname, sizeof(ll.ll_host));
1609         (void)write(fd, (char *)&ll, sizeof(ll));
1610         (void)close(fd);
1611     }
1612 }
1613 #endif
1614 #endif /* AIX */
1615
1616 badlogin(name)
1617      char *name;
1618 {
1619     if (failures == 0)
1620         return;
1621     if (hostname)
1622         syslog(LOG_NOTICE, "%d LOGIN FAILURE%s FROM %s, %s", failures,
1623                failures > 1 ? "S" : "", hostname, name);
1624     else
1625         syslog(LOG_NOTICE, "%d LOGIN FAILURE%s ON %s, %s", failures,
1626                failures > 1 ? "S" : "", tty, name);
1627 }
1628
1629 #undef  UNKNOWN
1630 #ifdef  AFS_SUN5_ENV
1631 #define UNKNOWN "sun"
1632 #else
1633 #define UNKNOWN "su"
1634 #endif
1635
1636 #if defined(AIX) || defined(AFS_HPUX_ENV) || defined(AFS_SUN5_ENV)
1637 char *
1638 stypeof(ttyid)
1639      char *ttyid;
1640 {
1641     return (UNKNOWN);
1642 }
1643 #else
1644 char *
1645 stypeof(ttyid)
1646      char *ttyid;
1647 {
1648     struct ttyent *t;
1649
1650     return (ttyid && (t = getttynam(ttyid)) ? t->ty_type : UNKNOWN);
1651 }
1652 #endif
1653
1654 getstr(buf, cnt, err)
1655      char *buf, *err;
1656      int cnt;
1657 {
1658     char ch;
1659
1660     do {
1661         if (read(0, &ch, sizeof(ch)) != sizeof(ch))
1662             exit(1);
1663         if (--cnt < 0) {
1664             fprintf(stderr, "%s too long\r\n", err);
1665             sleepexit(1);
1666         }
1667         *buf++ = ch;
1668     } while (ch);
1669 }
1670
1671 sleepexit(eval)
1672      int eval;
1673 {
1674     sleep((u_int) 5);
1675     exit(eval);
1676 }
1677
1678
1679 int
1680 get_pag_from_groups(g0, g1)
1681      afs_uint32 g0, g1;
1682 {
1683     afs_uint32 h, l, result;
1684
1685     g0 -= 0x3f00;
1686     g1 -= 0x3f00;
1687     if (g0 < 0xc000 && g1 < 0xc000) {
1688         l = ((g0 & 0x3fff) << 14) | (g1 & 0x3fff);
1689         h = (g0 >> 14);
1690         h = (g1 >> 14) + h + h + h;
1691         result = ((h << 28) | l);
1692         /* Additional testing */
1693         if (((result >> 24) & 0xff) == 'A')
1694             return result;
1695         else
1696             return NOPAG;
1697     }
1698     return NOPAG;
1699 }
1700
1701
1702 get_groups_from_pag(pag, g0p, g1p)
1703      afs_uint32 pag;
1704      afs_uint32 *g0p, *g1p;
1705 {
1706     unsigned short g0, g1;
1707
1708     pag &= 0x7fffffff;
1709     g0 = 0x3fff & (pag >> 14);
1710     g1 = 0x3fff & pag;
1711     g0 |= ((pag >> 28) / 3) << 14;
1712     g1 |= ((pag >> 28) % 3) << 14;
1713     *g0p = g0 + 0x3f00;
1714     *g1p = g1 + 0x3f00;
1715 }
1716
1717
1718 #if     defined(AFS_SUN_ENV)
1719 /*
1720  * set_fb_attrs -- change owner/group/permissions of framebuffers
1721  *                 listed in /etc/fbtab.
1722  *
1723  * Note:
1724  * Exiting from set_fb_attrs upon error is not advisable
1725  * since it would disable logins on console devices.
1726  *
1727  * File format:
1728  * console mode device_name[:device_name ...]
1729  * # begins a comment and may appear anywhere on a line.
1730  *
1731  * Example:
1732  * /dev/console 0660 /dev/fb:/dev/cgtwo0:/dev/bwtwo0
1733  * /dev/console 0660 /dev/gpone0a:/dev/gpone0b
1734  *
1735  * Description:
1736  * The example above sets the owner/group/permissions of the listed
1737  * devices to uid/gid/0660 if ttyn is /dev/console
1738  */
1739
1740 #define FIELD_DELIMS    " \t\n"
1741 #define COLON           ":"
1742 #define COLON_C         ':'
1743 #define WILDCARD        "/*"
1744 #define WILDCARD_LEN    2
1745 #define MAX_LINELEN     256
1746 #ifdef AFS_SUN5_ENV
1747 #define FBTAB           "/etc/logindevperm"
1748 #else
1749 #define FBTAB           "/etc/fbtab"
1750 #endif
1751
1752
1753 set_fb_attrs(ttyn, uid, gid)
1754      char *ttyn;
1755      int uid;
1756      int gid;
1757 {
1758     char line[MAX_LINELEN];
1759     char *console;
1760     char *mode_str;
1761     char *dev_list;
1762     char *device;
1763     char *ptr;
1764     int mode;
1765     long strtol();
1766     FILE *fp;
1767
1768     if ((fp = fopen(FBTAB, "r")) == NULL)
1769         return;
1770     while (fgets(line, MAX_LINELEN, fp)) {
1771         if (ptr = strchr(line, '#'))
1772             *ptr = '\0';        /* handle comments */
1773         if ((console = strtok(line, FIELD_DELIMS)) == NULL)
1774             continue;           /* ignore blank lines */
1775         if (strcmp(console, ttyn) != 0)
1776             continue;           /* ignore non-consoles */
1777         mode_str = strtok((char *)NULL, FIELD_DELIMS);
1778         if (mode_str == NULL) {
1779             (void)fprintf(stderr, "%s: invalid entry -- %s\n", FBTAB, line);
1780             continue;
1781         }
1782         /* convert string to octal value */
1783         mode = (int)strtol(mode_str, (char **)NULL, 8);
1784         if (mode < 0 || mode > 0777) {
1785             (void)fprintf(stderr, "%s: invalid mode -- %s\n", FBTAB,
1786                           mode_str);
1787             continue;
1788         }
1789         dev_list = strtok((char *)NULL, FIELD_DELIMS);
1790         if (dev_list == NULL) {
1791             (void)fprintf(stderr, "%s: %s -- empty device list\n", FBTAB,
1792                           console);
1793             continue;
1794         }
1795 #ifdef  AFS_SUN5_ENV
1796         device = strtok(dev_list, COLON);
1797         while (device) {
1798             ptr = strstr(device, WILDCARD);
1799             if (ptr && (strlen(device) - (ptr - &device[0])) == WILDCARD_LEN) {
1800                 /* The device was a (legally-specified) directory. */
1801                 DIR *dev_dir;
1802                 struct dirent *dir_e;
1803                 char dev_file[MAXPATHLEN];
1804
1805                 *ptr = '\0';    /* Remove the wildcard from the dir name. */
1806                 if ((dev_dir = opendir(device)) == (DIR *) NULL) {
1807                     syslog(LOG_ERR, "bad device %s%s in %s, ignored", device,
1808                            WILDCARD, FBTAB);
1809                     continue;
1810                 }
1811
1812                 /* Directory is open; alter its files. */
1813                 /* Must link with /usr/lib/libc.a before 
1814                  * /usr/ucblib/libucb.a or the d_name structs
1815                  * miss the first two characters of the filename */
1816                 while (dir_e = readdir(dev_dir)) {
1817                     if (strcmp(dir_e->d_name, "..")
1818                         && strcmp(dir_e->d_name, ".")) {
1819                         strcpy(dev_file, device);
1820                         strcat(dev_file, "/");
1821                         strcat(dev_file, dir_e->d_name);
1822                         (void)chown(dev_file, uid, gid);
1823                         (void)chmod(dev_file, mode);
1824                     }
1825                 }
1826                 (void)closedir(dev_dir);
1827             } else {
1828                 /* 'device' was not a directory, so we can just do it. */
1829                 (void)chown(device, uid, gid);
1830                 (void)chmod(device, mode);
1831             }
1832             device = strtok((char *)NULL, COLON);       /* Move thru list. */
1833 #else
1834         device = strtok(dev_list, COLON);
1835         while (device) {
1836             (void)chown(device, uid, gid);
1837             (void)chmod(device, mode);
1838             device = strtok((char *)NULL, COLON);
1839 #endif
1840         }
1841     }
1842     (void)fclose(fp);
1843 }
1844 #endif
1845
1846
1847 #ifdef  AFS_SUN5_ENV
1848 static int
1849 quotec()
1850 {
1851     register int c, i, num;
1852
1853     switch (c = getc(stdin)) {
1854     case 'n':
1855         c = '\n';
1856         break;
1857     case 'r':
1858         c = '\r';
1859         break;
1860     case 'v':
1861         c = '\013';
1862         break;
1863     case 'b':
1864         c = '\b';
1865         break;
1866     case 't':
1867         c = '\t';
1868         break;
1869     case 'f':
1870         c = '\f';
1871         break;
1872     case '0':
1873     case '1':
1874     case '2':
1875     case '3':
1876     case '4':
1877     case '5':
1878     case '6':
1879     case '7':
1880         for (num = 0, i = 0; i < 3; i++) {
1881             num = num * 8 + (c - '0');
1882             if ((c = getc(stdin)) < '0' || c > '7')
1883                 break;
1884         }
1885         ungetc(c, stdin);
1886         c = num & 0377;
1887         break;
1888     default:
1889         break;
1890     }
1891     return (c);
1892 }
1893
1894 static char **
1895 getargs(inline)
1896      char *inline;
1897 {
1898     static char envbuf[256];
1899     static char *args[63];
1900     register char *ptr, **answer;
1901     register int c;
1902     int state;
1903     extern int quotec();
1904
1905     for (ptr = envbuf; ptr < &envbuf[sizeof(envbuf)];)
1906         *ptr++ = '\0';
1907     for (answer = args; answer < &args[63];)
1908         *answer++ = (char *)NULL;
1909     for (ptr = envbuf, answer = &args[0], state = 0;
1910          (c = getc(stdin)) != EOF;) {
1911         *(inline++) = c;
1912         switch (c) {
1913         case '\n':
1914             if (ptr == &envbuf[0])
1915                 return ((char **)NULL);
1916             else
1917                 return (&args[0]);
1918         case ' ':
1919         case '\t':
1920             if (state == 1) {
1921                 *ptr++ = '\0';
1922                 state = 0;
1923             }
1924             break;
1925         case '\\':
1926             c = quotec();
1927         default:
1928             if (state == 0) {
1929                 *answer++ = ptr;
1930                 state = 1;
1931             }
1932             *ptr++ = c;
1933         }
1934         if (ptr == &envbuf[sizeof(envbuf) - 1]) {
1935             ungetc('\n', stdin);
1936             putc('\n', stdout);
1937         }
1938     }
1939     exit(0);
1940 }
1941 #endif
1942
1943 #ifdef  AFS_SUN_ENV
1944 #ifdef  AFS_SUN5_ENV
1945 doremotelogin()
1946 {
1947     static struct passwd nouser = { "", "no:password", ~0 };
1948
1949     getstr(rusername, sizeof(rusername), "remuser");
1950     getstr(lusername, sizeof(lusername), "locuser");
1951     if (!username)
1952         username = lusername;
1953     getstr(term, sizeof(term), "Terminal type");
1954     if (getuid()) {
1955         pwd = &nouser;
1956         goto out;
1957
1958     }
1959     pwd = getpwnam(lusername);
1960     if (pwd == NULL) {
1961         pwd = &nouser;
1962         goto out;
1963     }
1964   out:
1965     doremoteterm(term);
1966     return;
1967 }
1968 #else
1969 doremotelogin(host)
1970      char *host;
1971 {
1972     int code;
1973     static char rusername[100], lusername[100];
1974     static struct passwd nouser = { "", "no:password", ~0 };
1975
1976     getstr(rusername, sizeof(rusername), "remuser");
1977     getstr(lusername, sizeof(lusername), "locuser");
1978     if (!username)
1979         username = lusername;
1980     getstr(term, sizeof(term), "Terminal type");
1981     if (getuid()) {
1982         pwd = &nouser;
1983         return -1;
1984     }
1985     pwd = getpwnam(lusername);
1986     if (pwd == NULL) {
1987         pwd = &nouser;
1988         return -1;
1989     }
1990     code = ruserok(host, (pwd->pw_uid == 0), rusername, lusername);
1991 /*printf("DOREM=%d, host=%s, uid=%d, ruser=%s, luser=%s\n", code, host, pwd->pw_uid, rusername, lusername);*/
1992     return code;
1993 }
1994 #endif
1995
1996 char *speeds[] = { "0", "50", "75", "110", "134", "150", "200", "300",
1997     "600", "1200", "1800", "2400", "4800", "9600", "19200", "38400"
1998 };
1999
2000 #define NSPEEDS (sizeof (speeds) / sizeof (speeds[0]))
2001
2002 #ifdef  AFS_SUN5_ENV
2003 doremoteterm(terminal)
2004 #else
2005 doremoteterm(terminal, tp)
2006      struct sgttyb *tp;
2007 #endif
2008      char *terminal;
2009 {
2010 #ifdef  AFS_SUN5_ENV
2011     struct termios tp;
2012 #endif
2013     register char *cp = strchr(terminal, '/'), **cpp;
2014     char *speed;
2015
2016 #ifdef  AFS_SUN5_ENV
2017     (void)ioctl(0, TCGETS, &tp);
2018 #endif
2019     if (cp) {
2020         *cp++ = '\0';
2021         speed = cp;
2022         cp = strchr(speed, '/');
2023         if (cp)
2024             *cp++ = '\0';
2025         for (cpp = speeds; cpp < &speeds[NSPEEDS]; cpp++)
2026             if (strcmp(*cpp, speed) == 0) {
2027 #ifdef  AFS_SUN5_ENV
2028                 tp.c_cflag =
2029                     ((tp.c_cflag & ~CBAUD) | ((cpp - speeds) & CBAUD));
2030 #else
2031                 tp->sg_ispeed = tp->sg_ospeed = cpp - speeds;
2032 #endif
2033                 break;
2034             }
2035     }
2036 #ifdef  AFS_SUN5_ENV
2037     tp.c_lflag = ECHO | ICANON | IGNPAR | ICRNL;
2038     (void)ioctl(0, TCSETS, &tp);
2039 #else
2040     tp->sg_flags = ECHO | CRMOD | ANYP | XTABS;
2041 #endif
2042 }
2043 #endif
2044
2045 #ifdef AFS_OSF_ENV
2046 /*
2047  *  Check if the specified program is really a shell (e.g. "sh" or "csh").
2048  */
2049 usershell(shell)
2050      char *shell;
2051 {
2052     register char *p;
2053     char *getusershell();
2054
2055     setusershell();
2056     while ((p = getusershell()) != NULL)
2057         if (strcmp(p, shell) == 0)
2058             break;
2059     endusershell();
2060     return (!!p);
2061 }
2062
2063 static char *
2064 getlinep(const char *string, int size, FILE * stream)
2065 {
2066     extern int errno;
2067     int c;
2068     char *cp;
2069
2070     errno = 0;
2071     if (!fgets(string, size, stream) || ferror(stream) || errno == EINTR)
2072         return NULL;
2073     else if (cp = strchr(string, '\n'))
2074         *cp = '\0';
2075     else
2076         while ((c = getc(stdin)) != '\n' && c != EOF && errno != EINTR);
2077     return string;
2078 }
2079
2080 clean_entity_pwd(SIAENTITY * entity)
2081 {
2082     if (entity->acctname != NULL) {
2083         free(entity->acctname);
2084         entity->acctname = NULL;
2085     }
2086     if (entity->pwd != NULL) {
2087         if (entity->pwd->pw_name) {
2088             memset(entity->pwd->pw_name, '\0', strlen(entity->pwd->pw_name));
2089             free(entity->pwd->pw_name);
2090             entity->pwd->pw_name = NULL;
2091         }
2092         if (entity->pwd->pw_passwd) {
2093             memset(entity->pwd->pw_passwd, '\0',
2094                    strlen(entity->pwd->pw_passwd));
2095             free(entity->pwd->pw_passwd);
2096             entity->pwd->pw_passwd = NULL;
2097         }
2098         if (entity->pwd->pw_comment) {
2099             memset(entity->pwd->pw_comment, '\0',
2100                    strlen(entity->pwd->pw_comment));
2101             free(entity->pwd->pw_comment);
2102             entity->pwd->pw_comment = NULL;
2103         }
2104         if (entity->pwd->pw_gecos) {
2105             memset(entity->pwd->pw_gecos, '\0',
2106                    strlen(entity->pwd->pw_gecos));
2107             free(entity->pwd->pw_gecos);
2108             entity->pwd->pw_gecos = NULL;
2109         }
2110         if (entity->pwd->pw_dir) {
2111             memset(entity->pwd->pw_dir, '\0', strlen(entity->pwd->pw_dir));
2112             free(entity->pwd->pw_dir);
2113             entity->pwd->pw_dir = NULL;
2114         }
2115         if (entity->pwd->pw_shell) {
2116             memset(entity->pwd->pw_shell, '\0',
2117                    strlen(entity->pwd->pw_shell));
2118             free(entity->pwd->pw_shell);
2119             entity->pwd->pw_shell = NULL;
2120         }
2121         free(entity->pwd);
2122         entity->pwd = NULL;
2123     }
2124 }
2125
2126 int
2127 getloginp(entity)
2128      SIAENTITY *entity;
2129 {
2130     char result[100];
2131
2132     fputs("login: ", stdout);
2133     if (getlinep(result, sizeof result, stdin) == (char *)NULL) {
2134         return (-1);
2135     }
2136     entity->name = (char *)malloc(SIANAMEMIN + 1);
2137     if (entity->name == NULL)
2138         return (-1);
2139     strcpy((unsigned char *)entity->name, result);
2140     return (1);
2141 }
2142
2143 #ifdef AFS_KERBEROS_ENV
2144 extern char *ktc_tkt_string();
2145 #endif
2146
2147 int
2148 do_afs_auth(pwd, pass, doafs)
2149      struct passwd *pwd;
2150      char *pass;
2151      int doafs;
2152 {
2153     char *namep;
2154     int code, afsLoginFail = 0;
2155     char *lcell, realm[MAXKTCREALMLEN], *pword, prompt[256];
2156     char *shell, *reason;
2157
2158   loop:
2159     if (pass) {
2160         pword = pass;
2161     } else {
2162         sprintf(prompt, "Enter AFS password: ");
2163         pword = getpass(prompt);
2164         if (strlen(pword) == 0) {
2165             printf
2166                 ("Unable to read password because zero length password is illegal\n");
2167             printf("Login incorrect\n");
2168             fflush(stdout);
2169             goto loop;
2170         }
2171     }
2172
2173     if (ka_UserAuthenticateGeneral(KA_USERAUTH_VERSION + KA_USERAUTH_DOSETPAG, pwd->pw_name,    /* kerberos name */
2174                                    NULL,        /* instance */
2175                                    NULL,        /* realm */
2176                                    pword,       /* password */
2177                                    0,   /* default lifetime */
2178                                    0,   /* spare 1 */
2179                                    0,   /* spare 2 */
2180                                    &reason /* error string */ )) {
2181         afsLoginFail = 1;
2182         if (doafs)
2183             return 0;
2184     } else {
2185         if (pwd->pw_passwd && strcmp(pwd->pw_passwd, "*"))
2186             return 1;           /* Success */
2187     }
2188
2189     if (!pwd->pw_passwd)
2190         return 0;
2191     namep = crypt(pword, pwd->pw_passwd);
2192     code = strcmp(namep, pwd->pw_passwd) == 0 ? 1 : 0;
2193     if ((code == 1) && afsLoginFail) {
2194         /* Only print this if local authentication is successful */
2195         printf("Unable to authenticate to AFS because %s\n", reason);
2196         printf("proceeding with local authentication...\n");
2197     }
2198     return code;
2199 }
2200
2201
2202 #endif
2203
2204 #ifdef  AFS_SUN5_ENV
2205 static void
2206 defaults()
2207 {
2208     extern int defopen(), defcntl();
2209     register int flags;
2210     register char *ptr;
2211
2212     if (defopen(Pndefault) == 0) {
2213         /*
2214          * ignore case
2215          */
2216         flags = defcntl(DC_GETFLAGS, 0);
2217         TURNOFF(flags, DC_CASE);
2218         defcntl(DC_SETFLAGS, flags);
2219
2220         if ((Console = defread("CONSOLE=")) != NULL)
2221             Console = strdup(Console);
2222         if ((Altshell = defread("ALTSHELL=")) != NULL)
2223             Altshell = strdup(Altshell);
2224         if ((Passreq = defread("PASSREQ=")) != NULL)
2225             Passreq = strdup(Passreq);
2226         if ((Def_tz = defread("TIMEZONE=")) != NULL)
2227             Def_tz = strdup(Def_tz);
2228         if ((Def_hertz = defread("HZ=")) != NULL)
2229             Def_hertz = strdup(Def_hertz);
2230         if ((Def_path = defread("PATH=")) != NULL)
2231             Def_path = strdup(Def_path);
2232         if ((Def_supath = defread("SUPATH=")) != NULL)
2233             Def_supath = strdup(Def_supath);
2234         if ((ptr = defread("ULIMIT=")) != NULL)
2235             Def_ulimit = atol(ptr);
2236         if ((ptr = defread("TIMEOUT=")) != NULL)
2237             Def_timeout = (unsigned)atoi(ptr);
2238         if ((ptr = defread("UMASK=")) != NULL)
2239             if (sscanf(ptr, "%lo", &Umask) != 1)
2240                 Umask = DEFUMASK;
2241         if ((ptr = defread("IDLEWEEKS=")) != NULL)
2242             Idleweeks = atoi(ptr);
2243         if ((ptr = defread("SLEEPTIME=")) != NULL)
2244             Sleeptime = atoi(ptr);
2245         (void)defopen(NULL);
2246     }
2247     return;
2248 }
2249 #endif
2250
2251 #ifdef  AFS_HPUX_ENV
2252 /*
2253  * returns 1 if user should be counted as 1 user;
2254  * returns 3 if user should be counted as a pty
2255  * may return other stuff in the future
2256  */
2257 int
2258 add_count()
2259 {
2260     if (isapty()) {
2261         if (is_nlio())
2262             return (1);
2263         else
2264             return (3);
2265     } else
2266         return (1);
2267 }
2268
2269 /*
2270  * returns 1 if user is a pty, 0 otherwise
2271  */
2272 #define SSTRPTYMAJOR 157        /* major number for Streams slave pty's */
2273 #define SPTYMAJOR 17            /* major number for slave  pty's */
2274 #define PTYSC     0x00          /* select code for pty's         */
2275 #define select_code(x) (((x) & 0xff0000) >> 16)
2276 isapty()
2277 {
2278     struct stat sbuf;
2279     static int firsttime = 1;
2280     static int retval;
2281
2282     if (firsttime) {
2283         firsttime = 0;
2284         if (fstat(0, &sbuf) != 0 ||     /* can't stat */
2285             (sbuf.st_mode & S_IFMT) != S_IFCHR ||       /* not char special */
2286             major(sbuf.st_rdev) != SPTYMAJOR || /* not pty major num */
2287             select_code(sbuf.st_rdev) != PTYSC) {       /* not pty minor num */
2288             /* Check to see if it is a Streams PTY */
2289             if (major(sbuf.st_rdev) == SSTRPTYMAJOR) {
2290                 retval = 1;
2291             } else
2292                 retval = 0;     /* neither a BSD nor a Streams PTY */
2293         } else {
2294             retval = 1;
2295 #ifdef TRUX
2296             if (ISB1 && !remote_login)
2297                 retval = 0;     /* local pty for td tty simulation */
2298 #endif /* TRUX */
2299         }
2300     }
2301     return (retval);
2302 }
2303
2304 #define NLIOUCOUNT      _IO('K',28)     /* _IO(K, 28) */
2305 #define NLIOSERV        0x4b33  /* (('K' << 8) + 51 */
2306
2307 /*
2308  * returns 1 if user is an NL server, else returns 0
2309  */
2310 is_nlio()
2311 {
2312     if (ioctl(0, NLIOUCOUNT) == NLIOSERV)
2313         return (1);
2314     else
2315         return (0);
2316 }
2317 #endif