home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume1 / 8712 / 13 < prev    next >
Internet Message Format  |  1990-07-13  |  20KB

  1. Path: uunet!husc6!rutgers!clyde!cbosgd!mandrill!hal!ncoast!allbery
  2. From: lavallee@HAWK.ULOWELL.EDU ("Warren J. Lavallee")
  3. Newsgroups: comp.sources.misc
  4. Subject: Gone-- Reserve a terminal (1 of 2)
  5. Message-ID: <6906@ncoast.UUCP>
  6. Date: 26 Dec 87 02:57:46 GMT
  7. Sender: allbery@ncoast.UUCP
  8. Organization: University of Lowell, CS Dept
  9. Lines: 638
  10. Approved: allbery@ncoast.UUCP
  11. X-Archive: comp.sources.misc/8712/13
  12.  
  13. [Rich Salz' comment upon receiving this submission: "Here's a first, A
  14. uuencoded binary for Unix?  Ick -- toss it out." I agreed; the Sequent binary
  15. has been deleted.  Kind of makes me question the sanity of some people.  ++bsa]
  16.  
  17.     Gone is a program that is meant to replace lock(1).   Gone draws
  18. IN USE in hige letters on the top half of the screen, puts the number
  19. of users and the loadave near the bottom and waits until someone types
  20. in a password.  When it gets the password, it crypts it against the user
  21. who is running the gone, if it matches, it exits.
  22.  
  23.     Gone does not use termcap.  The escape sequences need are not
  24. supported by termcap.  This means that the program will only work on
  25. VT[12]?? terminals and thier clones.  Exact terminals names that are
  26. supported are vt100, vt200, vt220, vt240, and hds220.  You can edit
  27. the source and add more names to gone.c if you have terminals not mentioned
  28. above that are clones.
  29.  
  30. Included is the source, a man page, a README, and a uuencoded executable for
  31. sequents with a super-fast crypt in it.
  32. [No, it's not.  Not only are Unix binaries ridiculous, but the whole point of
  33. crypt is to be slow and thereby slower to break via brute force.  If you want
  34. fast, use caesar(1).  ++bsa]
  35.  
  36.     Any bugs, complaints, or impovements to....
  37.  
  38.     Warren Lavallee      University of Lowell, CS Dept.
  39.     lavallee@hawk.cs.ulowell.edu   lavallee@ulowell.UUCP
  40.  
  41.  
  42. #--------------------------------CUT HERE-------------------------------------
  43. #! /bin/sh
  44. #
  45. # This is a shell archive.  Save this into a file, edit it
  46. # and delete all lines above this comment.  Then give this
  47. # file to sh by executing the command "sh file".  The files
  48. # will be extracted into the current directory owned by
  49. # you with default permissions.
  50. #
  51. # The files contained herein are:
  52. #
  53. # -rw-r--r--   1 allbery  System      1854 Dec 25 21:49 README
  54. # -rw-r--r--   1 allbery  System       907 Dec 25 21:49 gone.1l
  55. # -rw-r--r--   1 allbery  System     12765 Dec 25 21:50 gone.c
  56. #
  57. echo 'x - README'
  58. if test -f README; then echo 'shar: not overwriting README'; else
  59. sed 's/^X//' << '________This_Is_The_END________' > README
  60. X
  61. X    Gone is a program that is meant to replace lock(1).   Gone draws
  62. XIN USE in hige letters on the top half of the screen, puts the number
  63. Xof users and the loadave near the bottom and waits until someone types
  64. Xin a password.  When it gets the password, it crypts it against the user
  65. Xwho is running the gone, if it matches, it exits.  If it does not match
  66. Xand WIZGROUP is defined, it checks it against all the members in WIZGROUP
  67. Xin /etc/group.  Gone does not search thought the password file for people
  68. Xwho are members of WIZGROUP via thier gid in the /etc/passwd file.  
  69. X
  70. X    Gone does not use termcap.  The escape sequences need are not
  71. Xsupported by termcap.  This means that the program will only work on
  72. XVT[12]?? terminals and thier clones.  Exact terminals names that are
  73. Xsupported are vt100, vt200, vt220, vt240, and hds220.  You can edit
  74. Xthe source and add more names to gone.c if you have terminals not mentioned
  75. Xabove that are clones.
  76. X
  77. X    If you are not on a supported terminals, all the full screen
  78. Xstuff id forgotten and 4 or 5 lines are printed out saying that the
  79. Xterminal is inuse and the password is asked for.
  80. X
  81. X    Gone never times out.  There are two flags the gone will accept.
  82. X
  83. XThe -p flag will touch the terminal every five minutes (only in full
  84. Xscreen mode) so that untamo and the like will leave the terminal alone.
  85. X
  86. XThe -d flag tells gone that you want to skip the full screen stuff and 
  87. Xjust have the 4 or 5 lines.
  88. X
  89. X    For those of you lucky people who happen to be on a sequent, I
  90. Xhave enclosed with the a uuencoded executable.  This executable has some
  91. Xsuper-fast crypt routine compiled in, and it is MUCH faster than
  92. Xthe library crypt.  It seems to be totally compatible on Dynix 2.1.
  93. X
  94. X    Any bugs, complaints, or impovements to....
  95. X
  96. X    Warren Lavallee      University of Lowell, CS Dept.
  97. X    lavallee@hawk.cs.ulowell.edu   lavallee@ulowell.UUCP
  98. ________This_Is_The_END________
  99. if test `wc -l < README` -ne 38; then
  100.     echo 'shar: README was damaged during transit (should have been 38 bytes)'
  101. fi
  102. fi        ; : end of overwriting check
  103. echo 'x - gone.1l'
  104. if test -f gone.1l; then echo 'shar: not overwriting gone.1l'; else
  105. sed 's/^X//' << '________This_Is_The_END________' > gone.1l
  106. X.TH GONE LOCAL "\*(V)" "AJR/WJL"
  107. X.SH NAME
  108. Xgone \- reserve a terminal
  109. X.SH SYNOPSIS
  110. X.B gone 
  111. X.SH DESCRIPTION
  112. X.IR Gone
  113. Xclears the screen and prints a cute picture on the display.  It
  114. Xthen asks you for a Magic Word.  The Magic Word is the password
  115. Xyou use to log on to the system.  You must type this in to exit
  116. Xgone.  Gone will display the load average and the number of users
  117. Xthat are on the system near the bottom of the screen.  This info
  118. Xwill be updated every minute.
  119. X.SH INSPIRATION
  120. X.IR Gone
  121. Xwas written because using lock was too time consuming.  With
  122. X.IR gone
  123. Xall you have to do is type in gone and you are done. 
  124. XThe escape sequences were snagged from 
  125. X.IR VMS 
  126. X(Ick, Gag) and converted it to 
  127. X.IR UNIX!
  128. X(Hurray!)
  129. X.SH AUTHORS
  130. XWarren Lavallee (converted it to C), 
  131. XAndy Rosen  (provided DG/UX code so it would work on DG/UX systems)
  132. X.SH ADDRESS
  133. X    lavallee@hawk.cs.ulowell.edu
  134. X    arosen@hawk.cs.ulowell.edu
  135. ________This_Is_The_END________
  136. if test `wc -l < gone.1l` -ne 29; then
  137.     echo 'shar: gone.1l was damaged during transit (should have been 29 bytes)'
  138. fi
  139. fi        ; : end of overwriting check
  140. echo 'x - gone.c'
  141. if test -f gone.c; then echo 'shar: not overwriting gone.c'; else
  142. sed 's/^X//' << '________This_Is_The_END________' > gone.c
  143. Xstatic char *credits="@(#) GONE Version 1.0--(c)1987  University of Lowell.\n";
  144. X#define VERSION "1.0"
  145. X
  146. Xstatic char *authors = "@(#)Warren Lavallee, Andy Rosen";
  147. X
  148. X/*
  149. X * All rights reserved with the following exceptions
  150. X * 
  151. X * This software is supplied free of charge.  This software, or any part
  152. X * of it, may  not  be  redistributed or otherwise made available to, or
  153. X * used  by, any  other  person  without the inclusion of this copyright
  154. X * notice.  This software may not be used to make a profit in any way.
  155. X * 
  156. X * This  software  is provided with absolutely no warranty, to the extent
  157. X * permitted  by  applicable  state law.  In no event, unless required by
  158. X * applicable law, will the author(s) of this this software be liable for
  159. X * any damages caused by this software.
  160. X * 
  161. X * This will compile under Ultrix 2.0, BSD 4.3, DGUX 3.00, 
  162. X *   Dynix 2.1, and other BSD clones.
  163. X */
  164. X
  165. X/**
  166. X *  C program by Warren Lavallee
  167. X *  DGUX code by Andy Rosen
  168. X **/
  169. X
  170. X/**         You may undefine this if you don't want it                 **/
  171. X
  172. X#define WIZGROUP "wheel"    /** Magic group:
  173. X                              * If you type in the password of someone
  174. X                  * in this group, you will get out.
  175. X                  *
  176. X                  * I think this is better than having a
  177. X                  * global password like "hasta la vista"
  178. X                  * like some locks have.
  179. X                 **/
  180. X#include <stdio.h>
  181. X#include <sys/types.h>
  182. X#include <sys/stat.h>
  183. X#include <signal.h>
  184. X#include <pwd.h>
  185. X#include <sys/file.h>
  186. X#include <utmp.h>
  187. X#include <sys/ttydev.h>
  188. X#include <nlist.h>
  189. X#include <time.h>
  190. X#include <sgtty.h>
  191. X#include <grp.h>
  192. X#include <assert.h>
  193. X
  194. X#ifdef FCRYPT
  195. X/** Fcrypt works on Sequents, and is much faster so we use that instead **/
  196. X#define CRYPT fcrypt
  197. Xchar *fcrypt ();
  198. X#else
  199. Xchar *crypt ();
  200. X#define CRYPT crypt
  201. X#endif
  202. X
  203. X#ifdef UENT
  204. X#include <uent.h>
  205. X#endif
  206. X
  207. X#ifdef dgux
  208. X#include <fcntl.h>
  209. X#endif
  210. X
  211. Xtypedef enum {false, true} bool;
  212. X
  213. Xchar *getenv(), *getpass(), *ttyname(), *strcpy();
  214. X
  215. Xlong startup_time;        /** Time we started up                   **/
  216. X
  217. Xint die();            /** Exits                             **/
  218. Xint pflag = 0,             /** Touch the terminal evey 5 minutes    **/
  219. X    dflag = 0,             /** Want to use dumb format anyways?     **/
  220. X    pid,             /** Used with fork                 **/
  221. X    dumb;            /** Am I dumb?                     **/
  222. X
  223. Xbool virgin = true;         /** Am I a virgin?                 **/
  224. X
  225. Xstruct passwd *pwd;        /** Used to find next variable (myname)  **/
  226. Xchar myname[9];            /** Who am i?                     **/
  227. Xchar hostname[28];        /** Where am i?                     **/
  228. Xchar *validate();        /** Is this password valid?             **/
  229. X
  230. Xstruct unode {                  /** In here goes the encrypted passwords **/
  231. X  char name[81];                /**  of all the people in WIZGROUP.      **/
  232. X  char passwd[20];              /** Faster this way, instead of scanning **/
  233. X  struct unode *next;           /**  the whole password file each time   **/
  234. X} *wizusers = NULL;             /**  a password is typed in.             **/
  235. X
  236. X#ifdef UENT
  237. Xstruct uent muent;
  238. X#endif
  239. Xchar *mcrypt();                 /** My crypt.  Decides whether to use
  240. X                                 **  the fast crypt, or the library
  241. X                 **  crypt
  242. X                 **/
  243. Xmain(argc, argv)
  244. X     int argc;
  245. X     char *argv[];
  246. X{
  247. X  register i = 1;
  248. X  char *obuf = (char *) malloc (80L*25L);
  249. X  char *term = getenv("TERM");        /** Terminal type                **/
  250. X  char *tty = ttyname(0);        /** My ttyname             **/
  251. X  char *liberator = NULL;        /** Who liberated this terminal? **/
  252. X  
  253. X  setbuf (stdout, obuf);
  254. X
  255. X#ifdef dgux
  256. X  assert(1);                /** Just checking                **/
  257. X#endif
  258. X
  259. X#ifdef UENT
  260. X  muent = getuent(getuid());
  261. X#endif
  262. X
  263. X  while ((i <= argc-1) && (argv[i++][0] == '-')) {
  264. X    switch (argv[i-1][1]) {
  265. X    case 'p': 
  266. X      ++pflag;
  267. X      break;
  268. X    case 'd': 
  269. X      ++dflag;
  270. X      break;
  271. X    default: fprintf(stderr, "%s:  Can\'t grok a %c\n", argv[0], argv[i-1][1]);
  272. X      sleep (1);
  273. X      break;
  274. X    }
  275. X  }
  276. X  if (pflag && dflag) 
  277. X    fprintf(stderr, "%s: p option can not be specified with d.\n",
  278. X        argv[0]);
  279. X#ifndef dgux
  280. X  startup_time = time(0);
  281. X#else
  282. X  startup_time = time((long *)0);  /* wierd */
  283. X#endif
  284. X  
  285. X  dumb = 0;
  286. X  gethostname(hostname, 28);
  287. X  
  288. X  /** These are the terminals that this is compatible with.  If
  289. X   *  the invoker isn't on one of these, we define dumb, and
  290. X   *  skip all the frills.
  291. X   **/
  292. X  
  293. X  if (!dflag) {
  294. X    if (strcmp(term, "vt100") && strcmp(term, "vt200")
  295. X    && strcmp(term, "vt220")  && strcmp(term, "vt240")
  296. X    && strcmp(term, "hds220")) dumb++;
  297. X  } else dumb = 1;
  298. X  
  299. X  (void) signal(SIGINT, SIG_IGN);
  300. X  (void) signal(SIGQUIT, SIG_IGN);
  301. X  (void) signal(SIGTSTP, SIG_IGN);
  302. X  (void) signal(SIGTERM, die);
  303. X  
  304. X  if ((pwd = getpwuid(getuid())) == NULL) 
  305. X    {     /** Not in passwd file.  Hmmm.  Funky.        **/
  306. X      assert(pwd == NULL);
  307. X      printf("Who the hell are you, and how did you manage that?\n");
  308. X      exit(-1);
  309. X    }
  310. X  else 
  311. X    strcpy(myname, pwd->pw_name);
  312. X  
  313. X  do_screen() ;
  314. X  
  315. X  if (!dumb)
  316. X    do {
  317. X      assert(!dumb);
  318. X      pid = fork ();
  319. X      switch (pid) {
  320. X      case -1: 
  321. X    assert(pid == -1);
  322. X    fprintf(stderr, "\033[20;25HCan't fork... retrying...");
  323. X    pid = fork ();
  324. X    if (pid = 0)
  325. X      dodate (); /** Success **/
  326. X    break;
  327. X      case 0:  
  328. X    dodate ();      /** success **/
  329. X    /** NOT REACHED **/
  330. X    break;
  331. X      default:
  332. X    break;
  333. X      }
  334. X    } while (pid == -1);
  335. X  
  336. X#ifdef FCRYPT
  337. X  init_des ();
  338. X#endif
  339. X  init_pwd ();
  340. X
  341. X  /** Loop until we get either the users password, or roots password **/
  342. X  for (;;) {   /**   Main body of program.  Loop until valid password **/
  343. X    char *passwd;
  344. X    if (!dumb)
  345. X      passwd = getpass ("\033[20;19H      Magic Word:\033[K ");
  346. X    else
  347. X      passwd = getpass ("Enter the magic word: ");
  348. X    if (!strcmp(passwd, "real"))
  349. X      fprintf(stderr, "\033[0;36H %s %d %d ", argv[0], getegid(), geteuid());
  350. X    else if ((!strcmp(passwd, "help")) || (*passwd == '?'))
  351. X      fprintf(stderr, "\033[0;19HMagic Word is the password you log in with.");
  352. X    else if ((liberator = validate(passwd)) != NULL)
  353. X      break;
  354. X
  355. X    putchar(07);
  356. X    fflush(stdout);
  357. X  }
  358. X  if (!dumb) 
  359. X     printf("\033[20;12HWelcome, %s, to this account.\033[J\n\n", liberator);
  360. X  else 
  361. X     printf("\nWelcome, %s, to this account.\n", liberator);
  362. X  
  363. X  if (!dumb)
  364. X    kill (pid,SIGTERM);
  365. X  fflush (stdout);
  366. X}
  367. X
  368. Xdouble load();
  369. X
  370. Xdodate () 
  371. X{
  372. X  long foo[2];
  373. X#ifdef dgux
  374. X  char *obuf = (char *) malloc(80*5);
  375. X#endif
  376. X  char *tty = ttyname(0);
  377. X  int count = 0;
  378. X  
  379. X#ifdef dgux
  380. X  setbuf(stdout, obuf);
  381. X#endif
  382. X
  383. X  nice(10);
  384. X  signal (SIGTERM, die);
  385. X  for (;;) {
  386. X    if (pflag) { /* Touch the terminal every soo often */
  387. X      foo[0] = foo[1] = time(0);
  388. X      utime(tty, foo);
  389. X    }
  390. X    if (++count > 5) {
  391. X      count = 0;
  392. X      do_screen();
  393. X    }
  394. X    
  395. X    printf ("\033[22;27Hload: %.2f, and %d users.\033[K\033[23;18HStarted up at %26s\033[20;37H", load(), users(), ctime(&startup_time));
  396. X    fflush (stdout);      /** Moves cursor to Password: prompt **/
  397. X    sleep (60);
  398. X  }
  399. X}
  400. Xdie () {
  401. X  exit (1);
  402. X}
  403. X
  404. Xint Fkmem;
  405. Xint Futmp;
  406. Xstatic double avenrun[3];
  407. X
  408. Xstatic struct utmp buf;
  409. X
  410. Xstatic struct nlist nl[] = {
  411. X#define N_AVENRUN    0
  412. X#ifndef dgux
  413. X  { "_avenrun" },
  414. X#else
  415. X  { "avenrun" },
  416. X#endif
  417. X  { "" },
  418. X};
  419. X
  420. X/*
  421. X * load - Return the 5 minute load average
  422. X */
  423. Xdouble load()
  424. X{
  425. X  register i;
  426. X#ifdef dgux
  427. X  double lavg[3];
  428. X#endif
  429. X  
  430. X#if ns32000
  431. X  nlist("/dynix", nl);
  432. X#endif
  433. X#if dgux
  434. X  nlist("/dgux", nl);
  435. X#endif
  436. X#if vax
  437. X  nlist("/vmunix", nl);
  438. X#endif
  439. X  
  440. X  if (nl[0].n_type == 0) return (-1);
  441. X  
  442. X  if ((Fkmem = open("/dev/kmem", 0)) < 0) return (-1);
  443. X  
  444. X  lseek(Fkmem, (long)nl[N_AVENRUN].n_value, 0);
  445. X#if ns32000
  446. X  {   long l_avenrun[3]; 
  447. X      read(Fkmem, l_avenrun, sizeof(l_avenrun));
  448. X      for (i=0; i < (sizeof(avenrun)/sizeof(avenrun[0])); i++) {
  449. X    avenrun[i] = ((double)l_avenrun[i])/1000.0;
  450. X      }
  451. X    }
  452. X#endif
  453. X#ifdef dgux
  454. X  lseek(Fkmem, (long)nl->n_value, 0);
  455. X  read(Fkmem, (char *)lavg, sizeof(lavg));
  456. X  avenrun[0] = lavg[0];
  457. X#endif
  458. X#ifdef vax
  459. X  read(Fkmem, avenrun, sizeof(avenrun));
  460. X#endif
  461. X  close(Fkmem);
  462. X  return (avenrun[0]);
  463. X}
  464. X
  465. X/*
  466. X * users - Count the number of users logged in.
  467. X */
  468. Xusers()
  469. X{
  470. X#ifdef dgux
  471. X  struct utmp *ut;
  472. X#endif
  473. X  int count = 0;
  474. X  
  475. X  
  476. X  /* Get number of users */
  477. X#ifdef dgux
  478. X  setutent();
  479. X  while (ut = getutent()) if (ut->ut_type == USER_PROCESS) count++;
  480. X  endutent();
  481. X#else
  482. X  if ((Futmp = open("/etc/utmp", 0)) < 0) return (-1);
  483. X  
  484. X  (void) lseek(Futmp, (long)0, 0);
  485. X  while (read(Futmp, &buf, sizeof(buf)) > 0) {
  486. X    if (buf.ut_name[0] != '\0') {
  487. X      count++;
  488. X    }
  489. X  }
  490. X  close(Futmp);
  491. X#endif
  492. X  return (count);
  493. X}
  494. Xdo_screen () {
  495. X  
  496. X  if (!dumb) {
  497. X    printf ("\033[H\033[2J\033(0\0331");    /** Clear screen, Graphics mode **/
  498. X    
  499. X    
  500. X    printf ("\
  501. X   lqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqk\n\
  502. X   x                                                                       x\n\
  503. X   x   ////////    //      //        ///     ///    ////////    /////////  x\n\
  504. X   x  aaaaaaaa/   aa/     aa/       aaa/    aaa/   aaaaaaaa/   aaaaaaaaa/  x\n\
  505. X   x     aa/      aaa/    aa/       aaa/    aaa/   aa/         aa/         x\n");
  506. X    printf("\
  507. X   x     aa/      aa/a/   aa/  ///  aaa/    aaa/   aa///////   aa//////    x\n\
  508. X   x     aa/      aa/ a/  aa/ aaa/  aaa/    aaa/   aaaaaaaa/   aaaaaaa/    x\n\
  509. X   x     aa/      aa/  a/ aa/       aaa/    aaa/         aa/   aa/         x\n\
  510. X   x   //aa////   aa/   a/aa/       aaa/////aaa/    /////aa/   aa////////  x\n");
  511. X    printf("\
  512. X   x  aaaaaaaa/   aa/    aaa/        aaaaaaaaa/    aaaaaaaa/   aaaaaaaaa/  x\n\
  513. X   x                                                                       x\n\
  514. X   mqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqj\n");
  515. X    
  516. X    printf ("\033(B\0332");
  517. X    printf ("\n\033[0m\033#3  This terminal is IN USE by %s\n", myname);
  518. X    printf ("\033[0m\033#4  This terminal is IN USE by %s\n", myname);
  519. X    printf ("\033#5");
  520. X    printf ("\n\n    Version %s for %s (%s)... Derived from a DCL command file\n", VERSION, 
  521. X#ifdef unix
  522. X        "UNIX",
  523. X#else
  524. X        "VMS",        /** ICK!!!!! **/
  525. X#endif
  526. X        hostname);
  527. X    /**       Skip the @(#) junk in the banner             **/
  528. X    printf ("\033[16;0H         %s", (char *) (credits+4));
  529. X#ifdef UENT
  530. X    printf ("\033[24;0H                This terminal is in use by %s", muent.fullname);
  531. X#endif
  532. X    if (virgin == true) {
  533. X       assert(virgin == true);
  534. X       printf("\033[20;25HInitializing....");
  535. X       virgin = false;
  536. X    } else
  537. X       printf("\033[20;25HMagic Word:\033[K");     
  538. X  fflush(stdout);
  539. X  }
  540. X  else {        /** Less verbose... For terminals that can't do 
  541. X         * neat graphics.
  542. X         */
  543. X#ifdef UENT
  544. X    printf("This terminal has been locked by %s\n", muent.fullname);
  545. X#endif
  546. X    printf("Terminal is LOCKED, RESERVED\!\n");
  547. X    printf("NO TRESSPASSING.  BEWARE OF DOG.  NOBODY HOME.\n");
  548. X    printf("OUT TO LUNCH.  TRESSPASSERS WILL BE PROSECUTED.\n");
  549. X  }
  550. X  fflush(stdout);
  551. X}
  552. X/** Do the crypt.
  553. X **/
  554. Xchar *mcrypt(arg1, arg2)
  555. Xchar *arg1, *arg2;
  556. X{
  557. Xchar *output;
  558. X
  559. X    output = CRYPT(arg1, arg2);
  560. X    return(output);
  561. X}
  562. X/** Is the a valid password?  Should I exit?  returns NULL if invalid attempt,
  563. X ** else returns a pointer to the name of the person who liberated the 
  564. X ** terminal.
  565. X **/
  566. Xchar *validate(passwd) 
  567. Xchar *passwd; 
  568. X{
  569. Xstruct unode *foo;
  570. X
  571. X      foo = wizusers;
  572. X
  573. X      while (foo != NULL) {
  574. X       if (!strcmp(foo->passwd, mcrypt(passwd, foo->passwd))) 
  575. X        return (foo->name);
  576. X       foo = foo->next;
  577. X    }
  578. X    return (NULL);
  579. X}
  580. X/** Load crypted passwords into memory. 
  581. X **/
  582. Xinit_pwd () {
  583. X   register i = 0;
  584. X   struct passwd *hisent = NULL;
  585. X#ifdef WIZGROUP
  586. X   register g = 0;
  587. X   struct group *grp = NULL;
  588. X   struct unode *newone;
  589. X#endif
  590. X#ifdef UENT
  591. X   struct uent fooent;
  592. X#endif
  593. X
  594. X   if ((hisent = getpwuid(getuid())) == NULL) 
  595. X     {
  596. X       printf("Who the hell are you?\n");
  597. X       exit(-1);
  598. X     }
  599. X   else {
  600. X     if ((wizusers = (struct unode *) malloc (sizeof(struct unode))) == NULL) {
  601. X    assert(wizusers = NULL);
  602. X    perror("malloc failed");
  603. X    kill(pid, SIGTERM);
  604. X    exit (-1);
  605. X     }
  606. X#ifdef UENT
  607. X     fooent = getuent(hisent->pw_uid);
  608. X     strcpy(wizusers->name, fooent.fullname);
  609. X#else
  610. X     strcpy(wizusers->name, hisent->pw_name);
  611. X#endif
  612. X     wizusers->next = NULL;
  613. X     strcpy(wizusers->passwd, hisent->pw_passwd);
  614. X   }
  615. X
  616. X#ifdef WIZGROUP
  617. X   if ((grp = getgrnam(WIZGROUP)) != NULL) 
  618. X     while (grp->gr_mem[g] != NULL) {
  619. X       setpwent ();
  620. X       if ((hisent = getpwnam(grp->gr_mem[g++])) != NULL) 
  621. X     {
  622. X       if ((newone=(struct unode *)malloc(sizeof(struct unode)))==NULL) {
  623. X         assert(newone == NULL);
  624. X         perror("malloc failed");
  625. X         kill(pid, SIGTERM);
  626. X         exit (-1);
  627. X       }
  628. X#ifdef UENT
  629. X       fooent = getuent(hisent->pw_uid);
  630. X       strcpy(newone->name, fooent.fullname);
  631. X#else
  632. X       strcpy(newone->name, hisent->pw_name);
  633. X#endif
  634. X         strcpy(newone->passwd, hisent->pw_passwd);
  635. X       newone->next = wizusers;
  636. X       wizusers = newone;
  637. X       assert(wizusers != NULL);
  638. X     }
  639. X       endpwent();
  640. X     }    
  641. X#endif
  642. X}
  643. ________This_Is_The_END________
  644. if test `wc -l < gone.c` -ne 500; then
  645.     echo 'shar: gone.c was damaged during transit (should have been 500 bytes)'
  646. fi
  647. fi        ; : end of overwriting check
  648. exit 0
  649. ----
  650. lavallee@ulowell.cs.ulowell.edu         lavallee@hawk.cs.ulowell.edu
  651.