contrib/opie/opielogin.c

   1 /* opielogin.c: The infamous /bin/login
   2
   3 %%% portions-copyright-cmetz-96
   4 Portions of this software are Copyright 1996-1999 by Craig Metz, All Rights
   5 Reserved. The Inner Net License Version 2 applies to these portions of
   6 the software.
   7 You should have received a copy of the license with this software. If
   8 you didn't get a copy, you may request one from <license@inner.net>.
   9
  10 Portions of this software are Copyright 1995 by Randall Atkinson and Dan
  11 McDonald, All Rights Reserved. All Rights under this copyright are assigned
  12 to the U.S. Naval Research Laboratory (NRL). The NRL Copyright Notice and
  13 License Agreement applies to this software.
  14
  15         History:
  16
  17         Modified by cmetz for OPIE 2.4. Omit "/dev/" in lastlog entry.
  18                 Don't chdir for invalid users. Fixed bug where getloginname()
  19                 didn't actually change spaces to underscores. Use struct
  20                 opie_key for key blocks. Do the home directory chdir() after
  21                 doing the setuid() in case we're on superuser-mapped NFS.
  22                 Initialize some variables explicitly. Call opieverify() if
  23                 login times out. Use opiestrncpy().
  24         Modified by cmetz for OPIE 2.32. Partially handle environment
  25                 variables on the command line (a better implementation is
  26                 coming soon). Handle failure to issue a challenge more
  27                 gracefully.
  28         Modified by cmetz for OPIE 2.31. Use _PATH_NOLOGIN. Move Solaris
  29                 drain bamage kluge after rflag check; it breaks rlogin.
  30                 Use TCSAFLUSH instead of TCSANOW (except where it flushes
  31                 data we need). Sleep before kluging for Solaris.
  32         Modified by cmetz for OPIE 2.3. Process login environment files.
  33                 Made logindevperm/fbtab handling more generic. Kluge around
  34                 Solaris drain bamage differently (maybe better?). Maybe
  35                 allow cleartext logins even when opiechallenge() fails.
  36                 Changed the conditions on when time.h and sys/time.h are
  37                 included. Send debug info to syslog. Use opielogin() instead
  38                 of dealing with utmp/setlogin() here.
  39         Modified by cmetz for OPIE 2.22. Call setlogin(). Decreased default
  40                 timeout to two minutes. Use opiereadpass() flags to get
  41                 around Solaris drain bamage.
  42         Modified by cmetz for OPIE 2.21. Took the sizeof() the wrong thing.
  43         Modified by cmetz for OPIE 2.2. Changed prompts to ask for OTP
  44                 response where appropriate. Simple though small speed-up.
  45                 Don't allow cleartext if echo on. Don't try to clear
  46                 non-blocking I/O. Use opiereadpass(). Don't mess with
  47                 termios (as much, at least) -- that's opiereadpass()'s
  48                 job. Change opiereadpass() calls to add echo arg. Fixed
  49                 CONTROL macro. Don't modify argv (at least, unless
  50                 we have a reason to). Allow user in if ruserok() says
  51                 so. Removed useless strings (I don't think that
  52                 removing the ucb copyright one is a problem -- please
  53                 let me know if I'm wrong). Use FUNCTION declaration et
  54                 al. Moved definition of TRUE here. Ifdef around more
  55                 headers. Make everything static. Removed support for
  56                 omitting domain name if same domain -- it generally
  57                 didn't work and it would be a big portability problem.
  58                 Use opiereadpass() in getloginname() and then post-
  59                 process. Added code to grab hpux time zone from
  60                 /etc/src.sh. Renamed MAIL_DIR to PATH_MAIL. Removed
  61                 dupe catchexit and extraneous closelog. openlog() as
  62                 soon as possible because SunOS syslog is broken.
  63                 Don't print an extra blank line before a new Response
  64                 prompt.
  65         Modified at NRL for OPIE 2.2. Changed strip_crlf to stripcrlf.
  66                 Do opiebackspace() on entries.
  67         Modified at NRL for OPIE 2.1. Since we don't seem to use the
  68                 result of opiechallenge() anymore, discard it. Changed
  69                 BSD4_3 to HAVE_GETTTYNAM. Other symbol changes for
  70                 autoconf. Removed obselete usage comment. Removed
  71                 des_crypt.h. File renamed to opielogin.c. Added bletch
  72                 for setpriority. Added slash between MAIL_DIR and name.
  73         Modified at NRL for OPIE 2.02. Flush stdio after printing login
  74                 prompt. Fixed Solaris shadow password problem introduced
  75                 in OPIE 2.01 (the shadow password structure is spwd, not
  76                 spasswd).
  77         Modified at NRL for OPIE 2.01. Changed password lookup handling
  78                 to use a static structure to avoid problems with drain-
  79                 bamaged shadow password packages. Make sure to close
  80                 syslog by function to avoid problems with drain bamaged
  81                 syslog implementations. Log a few interesting errors.
  82         Modified at NRL for OPIE 2.0.
  83         Modified at Bellcore for the Bellcore S/Key Version 1 software
  84                 distribution.
  85         Originally from BSD.
  86 */
  87 /*
  88  * Portions of this software are
  89  * Copyright (c) 1980,1987 Regents of the University of California.
  90  * All rights reserved.  The Berkeley software License Agreement
  91  * specifies the terms and conditions for redistribution.
  92  */
  93
  94 #include "opie_cfg.h"   /* OPIE: defines symbols for filenames & pathnames */
  95 #if HAVE_SYS_PARAM_H
  96 #include <sys/param.h>
  97 #endif /* HAVE_SYS_PARAM_H */
  98 #include <sys/stat.h>
  99 #include <sys/types.h>
 100
 101 #if HAVE_SETPRIORITY && HAVE_SYS_RESOURCE_H
 102 #include <sys/resource.h>
 103 #endif /* HAVE_SETPRIORITY && HAVE_SYS_RESOURCE_H */
 104
 105 #if TIME_WITH_SYS_TIME
 106 # include <sys/time.h>
 107 # include <time.h>
 108 #else /* TIME_WITH_SYS_TIME */
 109 #if HAVE_SYS_TIME_H
 110 #include <sys/time.h>
 111 #else /* HAVE_SYS_TIME_H */
 112 #include <time.h>
 113 #endif /* HAVE_SYS_TIME_H */
 114 #endif /* TIME_WITH_SYS_TIME */
 115
 116 #if HAVE_SYS_FILE_H
 117 #include <sys/file.h>
 118 #endif /* HAVE_SYS_FILE_H */
 119 #include <signal.h>
 120 #if HAVE_PWD_H
 121 #include <pwd.h>        /* POSIX Password routines */
 122 #endif /* HAVE_PWD_H */
 123 #include <stdio.h>
 124 #include <errno.h>
 125 #if HAVE_UNISTD_H
 126 #include <unistd.h>     /* Basic POSIX macros and functions */
 127 #endif /* HAVE_UNISTD_H */
 128 #include <termios.h>    /* POSIX terminal I/O */
 129 #if HAVE_STRING_H
 130 #include <string.h>     /* ANSI C string functions */
 131 #endif /* HAVE_STRING_H */
 132 #include <fcntl.h>      /* File I/O functions */
 133 #include <syslog.h>
 134 #include <grp.h>
 135 #include <netdb.h>
 136 #include <netinet/in.h> /* contains types needed for next include file */
 137 #include <arpa/inet.h>  /* Inet addr<-->ascii functions */
 138 #if HAVE_STDLIB_H
 139 #include <stdlib.h>
 140 #endif /* HAVE_STDLIB_H */
 141 #if HAVE_SYS_SELECT_H
 142 #include <sys/select.h>
 143 #endif /* HAVE_SYS_SELECT_H */
 144
 145 #ifdef  QUOTA
 146 #include <sys/quota.h>
 147 #endif
 148
 149 #if HAVE_GETTTYNAM
 150 #include <sys/ioctl.h>  /* non-portable routines used only a few places */
 151 #include <ttyent.h>
 152 #endif /* HAVE_GETTTYNAM */
 153
 154 #include "opie.h"
 155
 156 #define TTYGID(gid)     tty_gid(gid)    /* gid that owns all ttys */
 157
 158 #define NMAX    32
 159 #define HMAX    256
 160
 161 #if HAVE_LASTLOG_H
 162 #include <lastlog.h>
 163 #endif /* HAVE_LASTLOG_H */
 164
 165 static int rflag = 0;
 166 static int usererr = -1;
 167 static int stopmotd = 0;
 168 static char rusername[NMAX + 1];
 169 static char name[NMAX + 1] = "";
 170 static char minusnam[16] = "-";
 171 static char *envinit[1];        /* now set by setenv calls */
 172 static char term[64] = "";      /* important to initialise to a NULL string */
 173 static char host[HMAX + 1] = "";
 174 static struct passwd nouser;
 175 static struct passwd thisuser;
 176
 177 #if HAVE_SHADOW_H
 178 #include <shadow.h>
 179 #endif /* HAVE_SHADOW_H */
 180
 181 static char *ttyprompt;
 182
 183 #ifdef PERMSFILE
 184 extern char *home;
 185 #endif  /* PERMSFILE */
 186
 187 static struct termios attr;
 188
 189 extern int errno;
 190
 191 static int ouroptind;
 192 static char *ouroptarg;
 193
 194 #if HAVE_LASTLOG_H
 195 #ifndef _PATH_LASTLOG
 196 #define _PATH_LASTLOG "/var/adm/lastlog"
 197 #endif /* _PATH_LASTLOG */
 198
 199 static char lastlog[] = _PATH_LASTLOG;
 200 #endif /* HAVE_LASTLOG_H */
 201
 202 /*
 203  * The "timeout" variable bounds the time given to login.
 204  * We initialize it here for safety and so that it can be
 205  * patched on machines where the default value is not appropriate.
 206  */
 207 static int timeout = 120;
 208
 209 static void getstr __P((char *, int, char *));
 210
 211 #if HAVE_CRYPT_H
 212 #include <crypt.h>
 213 #endif /* HAVE_CRYPT_H */
 214
 215 #undef TRUE
 216 #define TRUE -1
 217
 218 static int need_opieverify = 0;
 219 static struct opie opie;
 220
 221 #ifdef TIOCSWINSZ
 222 /* Windowing variable relating to JWINSIZE/TIOCSWINSZ/TIOCGWINSZ. This is
 223 available on BSDish systems and at least Solaris 2.x, but portability to
 224 other systems is questionable. Use within this source code module is
 225 protected by suitable defines.
 226
 227 I'd be interested in hearing about a more portable approach. rja */
 228
 229 static struct winsize win = {0, 0, 0, 0};
 230 #endif
 231
 232
 233 /*------------------ BEGIN REAL CODE --------------------------------*/
 234
 235 /* We allow the malloc()s to potentially leak data out because we can
 236 only call this routine about four times in the lifetime of this process
 237 and the kernel will free all heap memory when we exit or exec. */
 238 static int lookupuser FUNCTION_NOARGS
 239 {
 240   struct passwd *pwd;
 241 #if HAVE_SHADOW
 242   struct spwd *spwd;
 243 #endif /* HAVE_SHADOW */
 244
 245   memcpy(&thisuser, &nouser, sizeof(thisuser));
 246
 247   if (!(pwd = getpwnam(name)))
 248     return -1;
 249
 250   thisuser.pw_uid = pwd->pw_uid;
 251   thisuser.pw_gid = pwd->pw_gid;
 252
 253   if (!(thisuser.pw_name = malloc(strlen(pwd->pw_name) + 1)))
 254     goto lookupuserbad;
 255   strcpy(thisuser.pw_name, pwd->pw_name);
 256
 257   if (!(thisuser.pw_dir = malloc(strlen(pwd->pw_dir) + 1)))
 258     goto lookupuserbad;
 259   strcpy(thisuser.pw_dir, pwd->pw_dir);
 260
 261   if (!(thisuser.pw_shell = malloc(strlen(pwd->pw_shell) + 1)))
 262     goto lookupuserbad;
 263   strcpy(thisuser.pw_shell, pwd->pw_shell);
 264
 265 #if HAVE_SHADOW
 266   if (!(spwd = getspnam(name)))
 267         goto lookupuserbad;
 268
 269   pwd->pw_passwd = spwd->sp_pwdp;
 270
 271   endspent();
 272 #endif /* HAVE_SHADOW */
 273
 274   if (!(thisuser.pw_passwd = malloc(strlen(pwd->pw_passwd) + 1)))
 275     goto lookupuserbad;
 276   strcpy(thisuser.pw_passwd, pwd->pw_passwd);
 277
 278   endpwent();
 279
 280   return ((thisuser.pw_passwd[0] == '*') || (thisuser.pw_passwd[0] == '#'));
 281
 282 lookupuserbad:
 283   memcpy(&thisuser, &nouser, sizeof(thisuser));
 284   return -1;
 285 }
 286
 287 static VOIDRET getloginname FUNCTION_NOARGS
 288 {
 289   char *namep, d;
 290   int flags;
 291   static int first = 1;
 292
 293   memset(name, 0, sizeof(name));
 294
 295   d = 0;
 296   while (name[0] == '\0') {
 297     flags = 1;
 298     if (ttyprompt) {
 299       if (first) {
 300         flags = 4;
 301         first--;
 302       } else
 303         printf(ttyprompt);
 304     } else
 305       printf("login: ");
 306     fflush(stdout);
 307     if (++d == 3)
 308       exit(0);
 309     if (!opiereadpass(name, sizeof(name)-1, flags)) {
 310       syslog(LOG_CRIT, "End-of-file (or other error?) on stdin!");
 311       exit(0);
 312     }
 313     for (namep = name; *namep; namep++) {
 314       if (*namep == ' ')
 315         *namep = '_';
 316     }
 317   }
 318 }
 319
 320 static VOIDRET timedout FUNCTION((i), int i)
 321 {
 322   /* input variable declared just to keep the compiler quiet */
 323   printf("Login timed out after %d seconds\n", timeout);
 324   syslog(LOG_CRIT, "Login timed out after %d seconds!", timeout);
 325
 326   if (need_opieverify)
 327     opieverify(&opie, NULL);
 328
 329   exit(0);
 330 }
 331
 332 #if !HAVE_MOTD_IN_PROFILE
 333 static VOIDRET catch FUNCTION((i), int i)
 334 {
 335   /* the input variable is declared to keep the compiler quiet */
 336   signal(SIGINT, SIG_IGN);
 337   stopmotd++;
 338 }
 339 #endif /* !HAVE_MOTD_IN_PROFILE */
 340
 341 static VOIDRET catchexit FUNCTION_NOARGS
 342 {
 343   int i;
 344   tcsetattr(STDIN_FILENO, TCSAFLUSH, &attr);
 345   putchar('\n');
 346   closelog();
 347   for (i = sysconf(_SC_OPEN_MAX); i > 2; i--)
 348     close(i);
 349 }
 350
 351 static int rootterm FUNCTION((ttyn), char *ttyn)
 352 {
 353 #if HAVE_GETTTYNAM
 354 /* The getttynam() call and the ttyent structure first appeared in 4.3 BSD and
 355 are not portable to System V systems such as Solaris 2.x. or modern versions
 356 of IRIX rja */
 357   register struct ttyent *t;
 358   char *tty;
 359
 360   tty = strrchr(ttyn, '/');
 361
 362   if (tty == NULL)
 363     tty = ttyn;
 364   else
 365     tty++;
 366
 367   if ((t = getttynam(tty)) != NULL)
 368     return (t->ty_status & TTY_SECURE);
 369
 370   return (1);   /* when in doubt, allow root logins */
 371
 372 #elif HAVE_ETC_DEFAULT_LOGIN
 373
 374   FILE *filno;
 375   char line[128];
 376   char *next, *next2;
 377
 378 /* SVR4 only permits two security modes for root logins: 1) only from CONSOLE,
 379 if the string "CONSOLE=/dev/console" exists and is not commented out with "#"
 380 characters, or 2) from anywhere.
 381
 382 So we open /etc/default/login file grab the file contents one line at a time
 383 verify that the line being tested isn't commented out check for the substring
 384 "CONSOLE" and decide whether to permit this attempted root login/su. */
 385
 386   if ((filno = fopen("/etc/default/login", "r")) != NULL) {
 387     while (fgets(line, 128, filno) != NULL) {
 388       next = line;
 389
 390       if ((line[0] != '#') && (next = strstr(line, "CONSOLE"))) {
 391         next += 7;      /* get past the string "CONSOLE" */
 392
 393         while (*next && (*next == ' ') || (*next == '\t'))
 394           next++;
 395
 396         if (*(next++) != '=')
 397           break;        /* some weird character, get next line */
 398
 399         next2 = next;
 400         while (*next2 && (*next2 != '\t') && (*next2 != ' ') &&
 401                (*next2 != '\n'))
 402           next2++;
 403         *next2 = 0;
 404
 405         return !strcmp(ttyn, next);     /* Allow the login if and only if the
 406                                            user's terminal line matches the
 407                                            setting for CONSOLE */
 408       }
 409     }   /* end while another line could be obtained */
 410   }     /* end if could open file */
 411   return (1);   /* when no CONSOLE line exists, root can login from anywhere */
 412 #elif HAVE_SECURETTY
 413   {
 414     FILE *f;
 415     char buffer[1024], *c;
 416     int rc = 0;
 417
 418     if (!(f = fopen("/etc/securetty", "r")))
 419       return 1;
 420
 421     if (c = strstr(ttyn, "/dev/"))
 422       ttyn += 5;
 423
 424     if (c = strrchr(ttyn, '/'))
 425       ttyn = ++c;
 426
 427     while (fgets(buffer, sizeof(buffer), f)) {
 428       if (c = strrchr(buffer, '\n'))
 429         *c = 0;
 430
 431       if (!(c = strrchr(buffer, '/')))
 432         c = buffer;
 433       else
 434         c++;
 435
 436       if (!strcmp(c, ttyn))
 437         rc = 1;
 438     };
 439
 440     fclose(f);
 441     return rc;
 442   }
 443 #else
 444   return (1);   /* when in doubt, allow root logins */
 445 #endif
 446 }
 447
 448 static int doremotelogin FUNCTION((host), char *host)
 449 {
 450   int rc;
 451
 452   getstr(rusername, sizeof(rusername), "remuser");
 453   getstr(name, sizeof(name), "locuser");
 454   getstr(term, sizeof(term), "Terminal type");
 455   if (getuid()) {
 456     memcpy(&thisuser, &nouser, sizeof(thisuser));
 457     syslog(LOG_ERR, "getuid() failed");
 458     return (-1);
 459   }
 460   if (lookupuser()) {
 461     syslog(LOG_ERR, "lookup failed for user %s", name);
 462     return (-1);
 463   }
 464   rc = ruserok(host, !thisuser.pw_uid, rusername, name);
 465   if (rc == -1) {
 466     syslog(LOG_ERR,
 467     "ruserok failed, host=%s, uid=%d, remote username=%s, local username=%s",
 468            host, thisuser.pw_uid, rusername, name);
 469   }
 470   return rc;
 471 }
 472
 473
 474 static VOIDRET getstr FUNCTION((buf, cnt, err), char *buf AND int cnt AND char *err)
 475 {
 476   char c;
 477
 478   do {
 479     if (read(0, &c, 1) != 1)
 480       exit(1);
 481     if (--cnt < 0) {
 482       printf("%s too long\r\n", err);
 483       syslog(LOG_CRIT, "%s too long", err);
 484       exit(1);
 485     }
 486     *buf++ = c;
 487   }
 488   while ((c != 0) && (c != '~'));
 489 }
 490
 491 struct speed_xlat {
 492   char *c;
 493   int i;
 494 }          speeds[] = {
 495
 496 #ifdef B0
 497   {
 498     "0", B0
 499   },
 500 #endif  /* B0 */
 501 #ifdef B50
 502   {
 503     "50", B50
 504   },
 505 #endif  /* B50 */
 506 #ifdef B75
 507   {
 508     "75", B75
 509   },
 510 #endif  /* B75 */
 511 #ifdef B110
 512   {
 513     "110", B110
 514   },
 515 #endif  /* B110 */
 516 #ifdef B134
 517   {
 518     "134", B134
 519   },
 520 #endif  /* B134 */
 521 #ifdef B150
 522   {
 523     "150", B150
 524   },
 525 #endif  /* B150 */
 526 #ifdef B200
 527   {
 528     "200", B200
 529   },
 530 #endif  /* B200 */
 531 #ifdef B300
 532   {
 533     "300", B300
 534   },
 535 #endif  /* B300 */
 536 #ifdef B600
 537   {
 538     "600", B600
 539   },
 540 #endif  /* B600 */
 541 #ifdef B1200
 542   {
 543     "1200", B1200
 544   },
 545 #endif  /* B1200 */
 546 #ifdef B1800
 547   {
 548     "1800", B1800
 549   },
 550 #endif  /* B1800 */
 551 #ifdef B2400
 552   {
 553     "2400", B2400
 554   },
 555 #endif  /* B2400 */
 556 #ifdef B4800
 557   {
 558     "4800", B4800
 559   },
 560 #endif  /* B4800 */
 561 #ifdef B7200
 562   {
 563     "7200", B7200
 564   },
 565 #endif  /* B7200 */
 566 #ifdef B9600
 567   {
 568     "9600", B9600
 569   },
 570 #endif  /* B9600 */
 571 #ifdef B14400
 572   {
 573     "14400", B14400
 574   },
 575 #endif  /* B14400 */
 576 #ifdef B19200
 577   {
 578     "19200", B19200
 579   },
 580 #endif  /* B19200 */
 581 #ifdef B28800
 582   {
 583     "28800", B28800
 584   },
 585 #endif  /* B28800 */
 586 #ifdef B38400
 587   {
 588     "38400", B38400
 589   },
 590 #endif  /* B38400 */
 591 #ifdef B57600
 592   {
 593     "57600", B57600
 594   },
 595 #endif  /* B57600 */
 596 #ifdef B115200
 597   {
 598     "115200", B115200
 599   },
 600 #endif  /* B115200 */
 601 #ifdef B230400
 602   {
 603     "230400", B230400
 604   },
 605 #endif  /* 230400 */
 606   {
 607     NULL, 0
 608   }
 609 };
 610
 611 static VOIDRET doremoteterm FUNCTION((term), char *term)
 612 {
 613   register char *cp = strchr(term, '/');
 614   char *speed;
 615   struct speed_xlat *x;
 616
 617   if (cp) {
 618     *cp++ = '\0';
 619     speed = cp;
 620     cp = strchr(speed, '/');
 621     if (cp)
 622       *cp++ = '\0';
 623     for (x = speeds; x->c != NULL; x++)
 624       if (strcmp(x->c, speed) == 0) {
 625         cfsetispeed(&attr, x->i);
 626         cfsetospeed(&attr, x->i);
 627         break;
 628       }
 629   }
 630 }
 631
 632 static int tty_gid FUNCTION((default_gid), int default_gid)
 633 {
 634   struct group *gr;
 635   int gid = default_gid;
 636
 637   gr = getgrnam(TTYGRPNAME);
 638   if (gr != (struct group *) 0)
 639     gid = gr->gr_gid;
 640   endgrent();
 641   return (gid);
 642 }
 643
 644 int main FUNCTION((argc, argv), int argc AND char *argv[])
 645 {
 646   extern char **environ;
 647   register char *namep;
 648
 649   int invalid, quietlog;
 650   FILE *nlfd;
 651   char *tty, host[256];
 652   int pflag = 0, hflag = 0, fflag = 0;
 653   int t, c;
 654   int i;
 655   char *p;
 656   char opieprompt[OPIE_CHALLENGE_MAX + 1];
 657   int af_pwok;
 658   int authsok = 0;
 659   char *pp;
 660   char buf[256];
 661   int uid;
 662   int opiepassed;
 663
 664 #ifndef DEBUG
 665   if (geteuid()) {
 666     fprintf(stderr, "This program requires super-user privileges.\n");
 667     exit(1);
 668   }
 669 #endif /* DEBUG */
 670
 671   for (t = sysconf(_SC_OPEN_MAX); t > 2; t--)
 672     close(t);
 673
 674   openlog("login", LOG_ODELAY, LOG_AUTH);
 675
 676   /* initialisation */
 677   host[0] = '\0';
 678   opieprompt[0] = '\0';
 679
 680   if (p = getenv("TERM")) {
 681 #ifdef DEBUG
 682     syslog(LOG_DEBUG, "environment TERM=%s", p);
 683 #endif /* DEBUG */
 684     opiestrncpy(term, p, sizeof(term));
 685   };
 686
 687   memset(&nouser, 0, sizeof(nouser));
 688   nouser.pw_uid = -1;
 689   nouser.pw_gid = -1;
 690   nouser.pw_passwd = "#nope";
 691   nouser.pw_name = nouser.pw_gecos = nouser.pw_dir = nouser.pw_shell = "";
 692
 693 #if HAVE_SETPRIORITY && HAVE_SYS_RESOURCE_H
 694   setpriority(PRIO_PROCESS, 0, 0);
 695 #endif /* HAVE_SETPRIORITY && HAVE_SYS_RESOURCE_H */
 696
 697   signal(SIGALRM, timedout);
 698   alarm(timeout);
 699   signal(SIGQUIT, SIG_IGN);
 700   signal(SIGINT, SIG_IGN);
 701
 702 #if DOTTYPROMPT
 703   ttyprompt = (char *) getenv("TTYPROMPT");
 704 #endif /* TTYPROMPT */
 705
 706 #ifdef  QUOTA
 707   quota(Q_SETUID, 0, 0, 0);
 708 #endif
 709
 710 #ifdef DEBUG
 711   syslog(LOG_DEBUG, "my args are: (argc=%d)", i = argc);
 712   while (--i)
 713     syslog(LOG_DEBUG, "%d: %s", i, argv[i]);
 714 #endif /* DEBUG */
 715
 716 /* Implement our own getopt()-like functionality, but do so in a much more
 717    strict manner to prevent security problems. */
 718   for (ouroptind = 1; ouroptind < argc; ouroptind++) {
 719     if (!argv[ouroptind])
 720       continue;
 721
 722     if (argv[ouroptind][0] == '-') {
 723       char *c = argv[ouroptind] + 1;
 724
 725       while(*c) {
 726         switch(*(c++)) {
 727           case 'd':
 728             if (*c || (++ouroptind == argc))
 729               exit(1);
 730
 731 /*    The '-d' option is apparently a performance hack to get around
 732    ttyname() being slow. The potential does exist for it to be used
 733    for malice, and it does not seem to be strictly necessary, so we
 734    will just eat it. */
 735             break;
 736
 737           case 'r':
 738             if (rflag || hflag || fflag) {
 739               fprintf(stderr, "Other options not allowed with -r\n");
 740               exit(1);
 741             }
 742
 743             if (*c || (++ouroptind == argc))
 744               exit(1);
 745
 746             if (!(ouroptarg = argv[ouroptind]))
 747               exit(1);
 748
 749             rflag = -1;
 750             if (!doremotelogin(ouroptarg))
 751               rflag = 1;
 752
 753             opiestrncpy(host, ouroptarg, sizeof(host));
 754             break;
 755
 756           case 'h':
 757             if (!getuid()) {
 758               if (rflag || hflag || fflag) {
 759                 fprintf(stderr, "Other options not allowed with -h\n");
 760                 exit(1);
 761               }
 762               hflag = 1;
 763
 764               if (*c || (++ouroptind == argc))
 765                 exit(1);
 766
 767               if (!(ouroptarg = argv[ouroptind]))
 768                 exit(1);
 769
 770               opiestrncpy(host, ouroptarg, sizeof(host));
 771             }
 772             break;
 773
 774           case 'f':
 775             if (rflag) {
 776               fprintf(stderr, "Only one of -r and -f allowed\n");
 777               exit(1);
 778             }
 779             fflag = 1;
 780
 781             if (*c || (++ouroptind == argc))
 782               exit(1);
 783
 784             if (!(ouroptarg = argv[ouroptind]))
 785               exit(1);
 786
 787             opiestrncpy(name, ouroptarg, sizeof(name));
 788             break;
 789           case 'p':
 790             pflag = 1;
 791             break;
 792         };
 793       };
 794       continue;
 795     };
 796
 797     if (strchr(argv[ouroptind], '=')) {
 798       if (!strncmp(argv[ouroptind], "TERM=", 5)) {
 799         opiestrncpy(term, &(argv[ouroptind][5]), sizeof(term));
 800
 801 #ifdef DEBUG
 802         syslog(LOG_DEBUG, "passed TERM=%s, ouroptind = %d", term, ouroptind);
 803 #endif /* DEBUG */
 804       } else {
 805 #ifdef DEBUG
 806         syslog(LOG_DEBUG, "eating %s, ouroptind = %d", argv[ouroptind], ouroptind);
 807 #endif /* DEBUG */
 808       };
 809       continue;
 810     };
 811
 812     opiestrncpy(name, argv[ouroptind], sizeof(name));
 813   };
 814
 815 #ifdef TIOCNXCL
 816   /* BSDism:  not sure how to rewrite for POSIX.  rja */
 817   ioctl(0, TIOCNXCL, 0);        /* set non-exclusive use of tty */
 818 #endif
 819
 820   /* get original termio attributes */
 821   if (tcgetattr(STDIN_FILENO, &attr) != 0)
 822     return (-1);
 823
 824 /* If talking to an rlogin process, propagate the terminal type and baud rate
 825    across the network. */
 826   if (rflag)
 827     doremoteterm(term);
 828   else {
 829     struct termios termios;
 830     fd_set fds;
 831     struct timeval timeval;
 832
 833     memset(&timeval, 0, sizeof(struct timeval));
 834
 835     FD_ZERO(&fds);
 836     FD_SET(0, &fds);
 837
 838 #if HAVE_USLEEP
 839     usleep(1);
 840 #endif /* HAVE_USLEEP */
 841
 842     if (select(1, &fds, NULL, NULL, &timeval)) {
 843 #ifdef DEBUG
 844       syslog(LOG_DEBUG, "reading user name from tty buffer");
 845 #endif /* DEBUG */
 846
 847       if (tcgetattr(0, &termios)) {
 848 #ifdef DEBUG
 849         syslog(LOG_DEBUG, "tcgetattr(0, &termios) failed");
 850 #endif /* DEBUG */
 851         exit(1);
 852       }
 853
 854       termios.c_lflag &= ~ECHO;
 855
 856       if (tcsetattr(0, TCSANOW, &termios)) {
 857 #ifdef DEBUG
 858         syslog(LOG_DEBUG, "tcsetattr(0, &termios) failed");
 859 #endif /* DEBUG */
 860         exit(1);
 861       }
 862
 863       if ((i = read(0, name, sizeof(name)-1)) > 0)
 864         name[i] = 0;
 865       if ((p = strchr(name, '\r')))
 866         *p = 0;
 867       if ((p = strchr(name, '\n')))
 868         *p = 0;
 869     }
 870   }
 871
 872 /* Force termios portable control characters to the system default values as
 873 specified in termios.h. This should help the one-time password login feel the
 874 same as the vendor-supplied login. Common extensions are also set for
 875 completeness, but these are set within appropriate defines for portability. */
 876
 877 #define CONTROL(x) (x - 64)
 878
 879 #ifdef VEOF
 880 #ifdef CEOF
 881   attr.c_cc[VEOF] = CEOF;
 882 #else   /* CEOF */
 883   attr.c_cc[VEOF] = CONTROL('D');
 884 #endif  /* CEOF */
 885 #endif  /* VEOF */
 886 #ifdef VEOL
 887 #ifdef CEOL
 888   attr.c_cc[VEOL] = CEOL;
 889 #else   /* CEOL */
 890   attr.c_cc[VEOL] = CONTROL('J');
 891 #endif  /* CEOL */
 892 #endif  /* VEOL */
 893 #ifdef VERASE
 894 #ifdef CERASE
 895   attr.c_cc[VERASE] = CERASE;
 896 #else   /* CERASE */
 897   attr.c_cc[VERASE] = CONTROL('H');
 898 #endif  /* CERASE */
 899 #endif  /* VERASE */
 900 #ifdef VINTR
 901 #ifdef CINTR
 902   attr.c_cc[VINTR] = CINTR;
 903 #else   /* CINTR */
 904   attr.c_cc[VINTR] = CONTROL('C');
 905 #endif  /* CINTR */
 906 #endif  /* VINTR */
 907 #ifdef VKILL
 908 #ifdef CKILL
 909   attr.c_cc[VKILL] = CKILL;
 910 #else   /* CKILL */
 911   attr.c_cc[VKILL] = CONTROL('U');
 912 #endif  /* CKILL */
 913 #endif  /* VKILL */
 914 #ifdef VQUIT
 915 #ifdef CQUIT
 916   attr.c_cc[VQUIT] = CQUIT;
 917 #else   /* CQUIT */
 918   attr.c_cc[VQUIT] = CONTROL('\\');
 919 #endif  /* CQUIT */
 920 #endif  /* VQUIT */
 921 #ifdef VSUSP
 922 #ifdef CSUSP
 923   attr.c_cc[VSUSP] = CSUSP;
 924 #else   /* CSUSP */
 925   attr.c_cc[VSUSP] = CONTROL('Z');
 926 #endif  /* CSUSP */
 927 #endif  /* VSUSP */
 928 #ifdef VSTOP
 929 #ifdef CSTOP
 930   attr.c_cc[VSTOP] = CSTOP;
 931 #else   /* CSTOP */
 932   attr.c_cc[VSTOP] = CONTROL('S');
 933 #endif  /* CSTOP */
 934 #endif  /* VSTOP */
 935 #ifdef VSTART
 936 #ifdef CSTART
 937   attr.c_cc[VSTART] = CSTART;
 938 #else   /* CSTART */
 939   attr.c_cc[VSTART] = CONTROL('Q');
 940 #endif  /* CSTART */
 941 #endif  /* VSTART */
 942 #ifdef VDSUSP
 943 #ifdef CDSUSP
 944   attr.c_cc[VDSUSP] = CDSUSP;
 945 #else   /* CDSUSP */
 946   attr.c_cc[VDSUSP] = 0;
 947 #endif  /* CDSUSP */
 948 #endif  /* VDSUSP */
 949 #ifdef VEOL2
 950 #ifdef CEOL2
 951   attr.c_cc[VEOL2] = CEOL2;
 952 #else   /* CEOL2 */
 953   attr.c_cc[VEOL2] = 0;
 954 #endif  /* CEOL2 */
 955 #endif  /* VEOL2 */
 956 #ifdef VREPRINT
 957 #ifdef CRPRNT
 958   attr.c_cc[VREPRINT] = CRPRNT;
 959 #else   /* CRPRNT */
 960   attr.c_cc[VREPRINT] = 0;
 961 #endif  /* CRPRNT */
 962 #endif  /* VREPRINT */
 963 #ifdef VWERASE
 964 #ifdef CWERASE
 965   attr.c_cc[VWERASE] = CWERASE;
 966 #else   /* CWERASE */
 967   attr.c_cc[VWERASE] = 0;
 968 #endif  /* CWERASE */
 969 #endif  /* VWERASE */
 970 #ifdef VLNEXT
 971 #ifdef CLNEXT
 972   attr.c_cc[VLNEXT] = CLNEXT;
 973 #else   /* CLNEXT */
 974   attr.c_cc[VLNEXT] = 0;
 975 #endif  /* CLNEXT */
 976 #endif  /* VLNEXT */
 977
 978   attr.c_lflag |= ICANON;       /* enable canonical input processing */
 979   attr.c_lflag &= ~ISIG;        /* disable INTR, QUIT,& SUSP signals */
 980   attr.c_lflag |= (ECHO | ECHOE);       /* enable echo and erase */
 981 #ifdef ONLCR
 982   /* POSIX does not specify any output processing flags, but the usage below
 983      is SVID compliant and is generally portable to modern versions of UNIX. */
 984   attr.c_oflag |= ONLCR;        /* map CR to CRNL on output */
 985 #endif
 986 #ifdef ICRNL
 987   attr.c_iflag |= ICRNL;
 988 #endif  /* ICRNL */
 989
 990   attr.c_oflag |= OPOST;
 991   attr.c_lflag |= ICANON;       /* enable canonical input */
 992   attr.c_lflag |= ECHO;
 993   attr.c_lflag |= ECHOE;        /* enable ERASE character */
 994   attr.c_lflag |= ECHOK;        /* enable KILL to delete line */
 995   attr.c_cflag |= HUPCL;        /* hangup on close */
 996
 997   /* Set revised termio attributes */
 998   if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &attr))
 999     return (-1);
1000
1001   atexit(catchexit);
1002
1003   tty = ttyname(0);
1004
1005   if (tty == (char *) 0 || *tty == '\0')
1006     tty = "UNKNOWN";    /* was: "/dev/tty??" */
1007
1008 #if HAVE_SETVBUF && defined(_IONBF)
1009 #if SETVBUF_REVERSED
1010   setvbuf(stdout, _IONBF, NULL, 0);
1011   setvbuf(stderr, _IONBF, NULL, 0);
1012 #else /* SETVBUF_REVERSED */
1013   setvbuf(stdout, NULL, _IONBF, 0);
1014   setvbuf(stderr, NULL, _IONBF, 0);
1015 #endif /* SETVBUF_REVERSED */
1016 #endif /* HAVE_SETVBUF && defined(_IONBF) */
1017
1018 #ifdef DEBUG
1019   syslog(LOG_DEBUG, "tty = %s", tty);
1020 #endif /* DEBUG */
1021
1022 #ifdef HAVE_LOGIN_ENVFILE
1023   {
1024     FILE *f;
1025
1026     if (f = fopen(HAVE_LOGIN_ENVFILE, "r")) {
1027       char line[128], *c, *c2;
1028
1029       while(fgets(line, sizeof(line)-1, f)) {
1030         c = line;
1031         while(*c && (isalnum(*c) || (*c == '_'))) c++;
1032           if (*c == '=') {
1033             *(c++) = 0;
1034             if (c2 = strchr(c, ';'))
1035               *c2 = 0;
1036             if (c2 = strchr(c, '\n'))
1037               *c2 = 0;
1038             if (c2 = strchr(c, ' '))
1039               continue;
1040             if (c2 = strchr(c, '\t'))
1041               continue;
1042             if (!strcmp(line, "TZ"))
1043               continue;
1044             if (setenv(line, c, 1) < 0) {
1045               fprintf(stderr, "setenv() failed -- environment full?\n");
1046               break;
1047             }
1048           }
1049         }
1050       fclose(f);
1051     }
1052   }
1053 #endif /* HAVE_LOGIN_ENVFILE */
1054
1055   t = 0;
1056   invalid = TRUE;
1057   af_pwok = opieaccessfile(host);
1058
1059   if (name[0])
1060     if (name[0] == '-') {
1061       fprintf(stderr, "User names can't start with '-'.\n");
1062       syslog(LOG_AUTH, "Attempt to use invalid username: %s.", name);
1063       exit(1);
1064     } else
1065       invalid = lookupuser();
1066
1067   do {
1068     /* If remote login take given name, otherwise prompt user for something. */
1069     if (invalid && !name[0]) {
1070       getloginname();
1071       invalid = lookupuser();
1072       authsok = 0;
1073     }
1074 #ifdef DEBUG
1075     syslog(LOG_DEBUG, "login name is +%s+, of length %d, [0] = %d", name, strlen(name), name[0]);
1076 #endif /* DEBUG */
1077
1078     if (fflag) {
1079       uid = getuid();
1080
1081       if (uid != 0 && uid != thisuser.pw_uid)
1082         fflag = 0;
1083       /* Disallow automatic login for root. */
1084       if (thisuser.pw_uid == 0)
1085         fflag = 0;
1086     }
1087     if (feof(stdin))
1088       exit(0);
1089
1090     /* If no remote login authentication and a password exists for this user,
1091        prompt for and verify a password. */
1092     if (!fflag && (rflag < 1) && *thisuser.pw_passwd) {
1093 #ifdef DEBUG
1094       syslog(LOG_DEBUG, "login name is +%s+, of length %d, [0] = %d\n", name, strlen(name), name[0]);
1095 #endif /* DEBUG */
1096
1097       /* Attempt a one-time password challenge */
1098       i = opiechallenge(&opie, name, opieprompt);
1099       need_opieverify = TRUE;
1100
1101       if ((i < 0) || (i > 1)) {
1102         syslog(LOG_ERR, "error: opiechallenge() returned %d, errno=%d!\n", i, errno);
1103       } else {
1104         printf("%s\n", opieprompt);
1105         authsok |= 1;
1106       }
1107
1108       if (!memcmp(&thisuser, &nouser, sizeof(thisuser)))
1109         if (host[0])
1110           syslog(LOG_WARNING, "Invalid login attempt for %s on %s from %s.",
1111                  name, tty, host);
1112         else
1113           syslog(LOG_WARNING, "Invalid login attempt for %s on %s.",
1114                  name, tty);
1115
1116       if (af_pwok && opiealways(thisuser.pw_dir))
1117         authsok |= 2;
1118
1119 #if DEBUG
1120       syslog(LOG_DEBUG, "af_pwok = %d, authsok = %d", af_pwok, authsok);
1121 #endif /* DEBUG */
1122
1123       if (!authsok)
1124         syslog(LOG_ERR, "no authentication methods are available for %s!", name);
1125
1126 #if NEW_PROMPTS
1127       if ((authsok & 1) || !authsok)
1128         printf("Response");
1129       if (((authsok & 3) == 3) || !authsok)
1130         printf(" or ");
1131       if ((authsok & 2) || !authsok)
1132         printf("Password");
1133       printf(": ");
1134       fflush(stdout);
1135       if (!opiereadpass(buf, sizeof(buf), !(authsok & 2)))
1136         invalid = TRUE;
1137 #else /* NEW_PROMPTS */
1138       if ((authsok & 3) == 1)
1139         printf("(OTP response required)\n");
1140       printf("Password:");
1141       fflush(stdout);
1142       if (!opiereadpass(buf, sizeof(buf), 0))
1143         invalid = TRUE;
1144 #endif /* NEW_PROMPTS */
1145
1146       if (!buf[0] && (authsok & 1)) {
1147         authsok &= ~2;
1148         /* Null line entered, so display appropriate prompt & flush current
1149            data. */
1150 #if NEW_PROMPTS
1151         printf("Response: ");
1152 #else /* NEW_PROMPTS */
1153         printf(" (echo on)\nPassword:");
1154 #endif /* NEW_PROMPTS */
1155         if (!opiereadpass(buf, sizeof(buf), 1))
1156           invalid = TRUE;
1157       }
1158
1159       if (authsok & 1) {
1160         i = opiegetsequence(&opie);
1161         opiepassed = !opieverify(&opie, buf);
1162         need_opieverify = 0;
1163
1164 #ifdef DEBUG
1165       syslog(LOG_DEBUG, "opiepassed = %d", opiepassed);
1166 #endif /* DEBUG */
1167       }
1168
1169       if (!invalid) {
1170         if ((authsok & 1) && opiepassed) {
1171           if (i < 10) {
1172             printf("Warning: Re-initialize your OTP information");
1173             if (i < 5)
1174               printf(" NOW!");
1175             printf("\n");
1176           }
1177         } else {
1178           if (authsok & 2) {
1179             pp = crypt(buf, thisuser.pw_passwd);
1180             invalid = strcmp(pp, thisuser.pw_passwd);
1181           } else
1182             invalid = TRUE;
1183         }
1184       }
1185     }
1186
1187     /* If user not super-user, check for logins disabled. */
1188     if (thisuser.pw_uid) {
1189       if (nlfd = fopen(_PATH_NOLOGIN, "r")) {
1190         while ((c = getc(nlfd)) != EOF)
1191           putchar(c);
1192         fflush(stdout);
1193         sleep(5);
1194         exit(0);
1195       }
1196     }
1197     /* If valid so far and root is logging in, see if root logins on this
1198        terminal are permitted. */
1199     if (!invalid && !thisuser.pw_uid && !rootterm(tty)) {
1200       if (host[0])
1201         syslog(LOG_CRIT, "ROOT LOGIN REFUSED ON %s FROM %.*s",
1202                tty, HMAX, host);
1203       else
1204         syslog(LOG_CRIT, "ROOT LOGIN REFUSED ON %s", tty);
1205       invalid = TRUE;
1206     }
1207     /* If invalid, then log failure attempt data to appropriate system
1208        logfiles and close the connection. */
1209     if (invalid) {
1210       printf("Login incorrect\n");
1211       if (host[0])
1212           syslog(LOG_ERR, "LOGIN FAILURE ON %s FROM %.*s, %.*s",
1213                  tty, HMAX, host, sizeof(name), name);
1214         else
1215           syslog(LOG_ERR, "LOGIN FAILURE ON %s, %.*s",
1216                  tty, sizeof(name), name);
1217       if (++t >= 5)
1218         exit(1);
1219     }
1220     if (*thisuser.pw_shell == '\0')
1221       thisuser.pw_shell = "/bin/sh";
1222     /* Remote login invalid must have been because of a restriction of some
1223        sort, no extra chances. */
1224     if (invalid) {
1225       if (!usererr)
1226         exit(1);
1227       name[0] = 0;
1228     }
1229   }
1230   while (invalid);
1231   /* Committed to login -- turn off timeout */
1232   alarm(0);
1233
1234 #ifdef  QUOTA
1235   if (quota(Q_SETUID, thisuser.pw_uid, 0, 0) < 0 && errno != EINVAL) {
1236     if (errno == EUSERS)
1237       printf("%s.\n%s.\n", "Too many users logged on already",
1238              "Try again later");
1239     else
1240       if (errno == EPROCLIM)
1241         printf("You have too many processes running.\n");
1242       else
1243         perror("quota (Q_SETUID)");
1244     sleep(5);
1245     exit(0);
1246   }
1247 #endif
1248
1249   if (opielogin(tty, name, host))
1250     syslog(LOG_ERR, "can't record login: tty %s, name %s, host %s", tty, name, host);
1251
1252   quietlog = !access(QUIET_LOGIN_FILE, F_OK);
1253
1254 #if HAVE_LASTLOG_H
1255   {
1256   int f;
1257
1258   if ((f = open(lastlog, O_RDWR)) >= 0) {
1259     struct lastlog ll;
1260
1261     lseek(f, (long)thisuser.pw_uid * sizeof(struct lastlog), 0);
1262
1263     if ((sizeof(ll) == read(f, (char *) &ll, sizeof(ll))) &&
1264         (ll.ll_time != 0) && (!quietlog)) {
1265       printf("Last login: %.*s ",
1266              24 - 5, (char *) ctime(&ll.ll_time));
1267       if (*ll.ll_host != '\0')
1268         printf("from %.*s\n", sizeof(ll.ll_host), ll.ll_host);
1269       else
1270         printf("on %.*s\n", sizeof(ll.ll_line), ll.ll_line);
1271     }
1272     lseek(f, (long)thisuser.pw_uid * sizeof(struct lastlog), 0);
1273
1274     time(&ll.ll_time);
1275     if (!strncmp(tty, "/dev/", 5))
1276       opiestrncpy(ll.ll_line, tty + 5, sizeof(ll.ll_line));
1277     else
1278       opiestrncpy(ll.ll_line, tty, sizeof(ll.ll_line));
1279     opiestrncpy(ll.ll_host, host, sizeof(ll.ll_host));
1280     write(f, (char *) &ll, sizeof ll);
1281     close(f);
1282   }
1283   }
1284 #endif /* HAVE_LASTLOG_H */
1285
1286   chown(tty, thisuser.pw_uid, TTYGID(thisuser.pw_gid));
1287
1288 #ifdef TIOCSWINSZ
1289 /* POSIX does not specify any interface to set/get window sizes, so this is
1290 not portable.  It should work on most recent BSDish systems and the defines
1291 should protect it on older System Vish systems.  It does work under Solaris
1292 2.4, though it isn't clear how many other SVR4 systems support it. I'd be
1293 interested in hearing of a more portable approach. rja */
1294   if (!hflag && !rflag)
1295     ioctl(0, TIOCSWINSZ, &win); /* set window size to 0,0,0,0 */
1296 #endif
1297
1298   chmod(tty, 0622);
1299   setgid(thisuser.pw_gid);
1300   initgroups(name, thisuser.pw_gid);
1301
1302 #ifdef  QUOTA
1303   quota(Q_DOWARN, thisuser.pw_uid, (dev_t) - 1, 0);
1304 #endif
1305
1306 #ifdef PERMSFILE
1307   home = thisuser.pw_dir;
1308   permsfile(name, tty, thisuser.pw_uid, thisuser.pw_gid);
1309   fflush(stderr);
1310 #endif  /* PERMSFILE */
1311
1312   setuid(thisuser.pw_uid);
1313
1314   /* destroy environment unless user has asked to preserve it */
1315   if (!pflag)
1316     environ = envinit;
1317   setenv("HOME", thisuser.pw_dir, 1);
1318   setenv("SHELL", thisuser.pw_shell, 1);
1319
1320   if (chdir(thisuser.pw_dir) < 0) {
1321 #if DEBUG
1322     syslog(LOG_DEBUG, "chdir(%s): %s(%d)", thisuser.pw_dir, strerror(errno),
1323            errno);
1324 #endif /* DEBUG */
1325     if (chdir("/") < 0) {
1326       printf("No directory!\n");
1327       invalid = TRUE;
1328     } else {
1329       printf("No directory! %s\n", "Logging in with HOME=/");
1330       strcpy(thisuser.pw_dir, "/");
1331     }
1332   }
1333
1334   if (!term[0]) {
1335 #if HAVE_GETTTYNAM
1336 /*
1337  * The getttynam() call and the ttyent structure first appeared in 4.3 BSD.
1338  * They are not portable to System V systems such as Solaris 2.x.
1339  *         rja
1340  */
1341   register struct ttyent *t;
1342   register char *c;
1343
1344   if (c = strrchr(tty, '/'))
1345     c++;
1346   else
1347     c = tty;
1348
1349   if (t = getttynam(c))
1350     opiestrncpy(term, t->ty_type, sizeof(term));
1351   else
1352 #endif /* HAVE_GETTTYNAM */
1353     strcpy(term, "unknown");
1354   }
1355
1356   setenv("USER", name, 1);
1357   setenv("LOGNAME", name, 1);
1358   setenv("PATH", DEFAULT_PATH, 0);
1359   if (term[0]) {
1360 #ifdef DEBUG
1361     syslog(LOG_DEBUG, "setting TERM=%s", term);
1362 #endif  /* DEBUG */
1363     setenv("TERM", term, 1);
1364   }
1365
1366 #ifdef HAVE_LOGIN_ENVFILE
1367   {
1368     FILE *f;
1369
1370     if (f = fopen(HAVE_LOGIN_ENVFILE, "r")) {
1371       char line[128], *c, *c2;
1372
1373       while(fgets(line, sizeof(line)-1, f)) {
1374         c = line;
1375         while(*c && (isalnum(*c) || (*c == '_'))) c++;
1376           if (*c == '=') {
1377             *(c++) = 0;
1378             if (c2 = strchr(c, ';'))
1379               *c2 = 0;
1380             if (c2 = strchr(c, '\n'))
1381               *c2 = 0;
1382             if (c2 = strchr(c, ' '))
1383               continue;
1384             if (c2 = strchr(c, '\t'))
1385               continue;
1386             if (setenv(line, c, 0) < 0) {
1387               fprintf(stderr, "setenv() failed -- environment full?\n");
1388               break;
1389             }
1390           }
1391         }
1392       fclose(f);
1393     }
1394   }
1395 #endif /* HAVE_LOGIN_ENVFILE */
1396
1397   if ((namep = strrchr(thisuser.pw_shell, '/')) == NULL)
1398     namep = thisuser.pw_shell;
1399   else
1400     namep++;
1401   strcat(minusnam, namep);
1402   if (tty[sizeof("tty") - 1] == 'd')
1403     syslog(LOG_INFO, "DIALUP %s, %s", tty, name);
1404   if (!thisuser.pw_uid)
1405     if (host[0])
1406       syslog(LOG_NOTICE, "ROOT LOGIN %s FROM %.*s", tty, HMAX, host);
1407     else
1408       syslog(LOG_NOTICE, "ROOT LOGIN %s", tty);
1409 #if !HAVE_MOTD_IN_PROFILE
1410   if (!quietlog) {
1411     FILE *mf;
1412     register c;
1413
1414     signal(SIGINT, catch);
1415     if ((mf = fopen(MOTD_FILE, "r")) != NULL) {
1416       while ((c = getc(mf)) != EOF && !stopmotd)
1417         putchar(c);
1418       fclose(mf);
1419     }
1420     signal(SIGINT, SIG_IGN);
1421   }
1422 #endif /* !HAVE_MOTD_IN_PROFILE */
1423 #if !HAVE_MAILCHECK_IN_PROFILE
1424   if (!quietlog) {
1425     struct stat st;
1426     char buf[128];
1427     int len;
1428
1429     opiestrncpy(buf, PATH_MAIL, sizeof(buf) - 2);
1430
1431     len = strlen(buf);
1432     if (*(buf + len - 1) != '/') {
1433         *(buf + len) = '/';
1434         *(buf + len + 1) = 0;
1435     }
1436
1437     strcat(buf, name);
1438 #if DEBUG
1439     syslog(LOG_DEBUG, "statting %s", buf);
1440 #endif /* DEBUG */
1441     if (!stat(buf, &st) && st.st_size)
1442       printf("You have %smail.\n",
1443              (st.st_mtime > st.st_atime) ? "new " : "");
1444   }
1445 #endif /* !HAVE_MAILCHECK_IN_PROFILE */
1446   signal(SIGALRM, SIG_DFL);
1447   signal(SIGQUIT, SIG_DFL);
1448   signal(SIGINT, SIG_DFL);
1449   signal(SIGTSTP, SIG_IGN);
1450
1451   attr.c_lflag |= (ISIG | IEXTEN);
1452
1453   catchexit();
1454   execlp(thisuser.pw_shell, minusnam, 0);
1455   perror(thisuser.pw_shell);
1456   printf("No shell\n");
1457   exit(0);
1458 }