![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fred.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / quipu / uips / fred|
Return to fred.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / quipu / uips / fred |
1.1 root 1: /* fred.c - FRont-End to Dish */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/others/quipu/uips/fred/RCS/fred.c,v 7.6 90/07/27 08:45:23 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/others/quipu/uips/fred/RCS/fred.c,v 7.6 90/07/27 08:45:23 mrose Exp $
9: *
10: *
11: * $Log: fred.c,v $
12: * Revision 7.6 90/07/27 08:45:23 mrose
13: * update
14: *
15: * Revision 7.5 90/06/11 10:55:14 mrose
16: * UFN
17: *
18: * Revision 7.4 90/01/16 20:43:24 mrose
19: * last check-out
20: *
21: * Revision 7.3 90/01/11 18:36:28 mrose
22: * real-sync
23: *
24: * Revision 7.2 89/12/14 18:48:59 mrose
25: * KIS project
26: *
27: * Revision 7.1 89/12/13 20:01:46 mrose
28: * errfp
29: *
30: * Revision 7.0 89/11/23 22:08:56 mrose
31: * Release 6.0
32: *
33: */
34:
35: /*
36: * NOTICE
37: *
38: * Acquisition, use, and distribution of this module and related
39: * materials are subject to the restrictions of a license agreement.
40: * Consult the Preface in the User's Manual for the full terms of
41: * this agreement.
42: *
43: */
44:
45:
46: #include <ctype.h>
47: #include <setjmp.h>
48: #include <signal.h>
49: #include <varargs.h>
50: #include "fred.h"
51: #include "internet.h"
52:
53: #ifdef BSD42
54: #include <sys/file.h>
55: #endif
56: #ifdef SYS5
57: #include <fcntl.h>
58: #endif
59: #ifndef R_OK
60: #define R_OK 4
61: #endif
62:
63: /* DATA */
64:
65: static char *myname = "fred";
66:
67: static char **op = NULLVP;
68:
69: static int alarming = 0;
70: static int logging = 0;
71: static int ontty;
72: static int armed;
73: static jmp_buf alrmenv;
74: static jmp_buf intrenv;
75: int interrupted;
76:
77: int oneshot;
78:
79: char ufn_file[BUFSIZ] = "";
80:
81: SFP astat;
82: SFP istat;
83: SFP qstat;
84:
85: SFD alrmser ();
86: SFD intrser ();
87:
88: LLog _fred_log = {
89: "fred.log", NULLCP, NULLCP, LLOG_FATAL | LLOG_EXCEPTIONS | LLOG_NOTICE,
90: LLOG_NONE, -1, LLOGCLS | LLOGCRT | LLOGZER, NOTOK
91: };
92: LLog *fred_log = &_fred_log;
93:
94:
95: static char *from = NULL;
96: static char *reply_to = NULL;
97: static char *sender = NULL;
98: static char *subject = NULL;
99:
100: static struct pair {
101: char *p_name;
102: char **p_value;
103: } pairs[] = {
104: "From:", &from,
105: "Reply-To:", &reply_to,
106: "Sender:", &sender,
107: "Subject:", &subject,
108: };
109:
110: /* MAIN */
111:
112: /* ARGSUSED */
113:
114: main (argc, argv, envp)
115: int argc;
116: char **argv,
117: **envp;
118: {
119: int eof,
120: status,
121: vecp;
122: register char *cp;
123: char address[BUFSIZ],
124: buffer[BUFSIZ],
125: *vec[NVEC + 1];
126: struct sockaddr_in in_socket,
127: *isock = &in_socket;
128:
129: arginit (argv);
130:
131: rcinit ();
132:
133: rcfile (isodefile ("fredrc", 0), 0, 1);
134: if (access (isodefile ("ufnrc", 0), R_OK) != NOTOK)
135: area_quantum = -1;
136:
137: status = 0;
138:
139: if (mail) {
140: register int c;
141: register char *ep;
142: register struct pair *p;
143: FILE *fp;
144:
145: for (;;) {
146: ep = (cp = buffer) + sizeof buffer - 1;
147:
148: while ((c = getc (stdin)) != EOF)
149: if (c == '\n') {
150: if ((c = getc (stdin)) == ' ' || c == '\t') {
151: *cp++ = ' ';
152: while ((c = getc (stdin)) == ' ' || c == '\t')
153: continue;
154: if (c != EOF)
155: (void) ungetc (c, stdin);
156: else {
157: c = NULL;
158: break;
159: }
160: }
161: else {
162: if (c == EOF)
163: c = NULL;
164: else
165: (void) ungetc (c, stdin);
166: break;
167: }
168: }
169: else
170: if (cp < ep)
171: *cp++ = c != '\t' ? c & 0xff : ' ';
172:
173: if (cp == buffer)
174: break;
175: *cp = NULL;
176:
177: for (p = pairs; p -> p_name; p++)
178: if (lexnequ (buffer, p -> p_name, c = strlen (p -> p_name))
179: == 0) {
180: if (*p -> p_value == NULL) {
181: for (cp = buffer + c; *cp == ' ' || *cp == '\t'; cp++)
182: continue;
183: if (*cp) {
184: ep = cp + strlen (cp) - 1;
185: while (*ep == ' ')
186: ep--;
187: *++ep = NULL;
188: *p -> p_value = strdup (cp);
189: }
190: }
191: break;
192: }
193:
194: }
195:
196: if (!from && !reply_to && !sender)
197: adios (NULLCP, "unable to determine return address");
198:
199: (void) sprintf (buffer, "/bin/mail \"%s\"",
200: ep = reply_to ? reply_to : from ? from : sender);
201: if (watch) {
202: fprintf (stderr, "%s\n", buffer);
203: (void) fflush (stderr);
204: }
205:
206: (void) signal (SIGPIPE, SIG_IGN);
207: if ((fp = popen (buffer, "w")) == NULL)
208: adios ("failed", "popen");
209:
210: stdfp = errfp = fp;
211:
212: fprintf (stdfp, "To: %s\nSubject: Re: %s\n\n",
213: ep, subject ? subject : "white pages query");
214: (void) fflush (stdfp);
215:
216: if (f_bind (NULLVP) == NOTOK)
217: adios (NULLCP, "unable to open the white pages");
218:
219: if (subject) {
220: (void) strcpy (buffer, subject);
221: (void) ll_log (fred_log, LLOG_NOTICE, NULLCP, "%s asks: %s",
222: ep, buffer);
223:
224: bzero ((char *) vec, sizeof vec);
225: if (str2vecY (buffer, vec) < 1)
226: (void) f_help (NULLVP);
227: else
228: if (fredloop (vec, NOTOK) != OK)
229: status = 1;
230: }
231: else {
232: int didone = 0;
233:
234: while ((c = getc (stdin)) != EOF)
235: if (c != ' ' || c != '\t' || c != '\n')
236: break;
237:
238: if (c != EOF)
239: while (fgets (buffer, sizeof buffer, stdin)) {
240: if (cp = index (buffer, '\n'))
241: *cp = NULL;
242: if (buffer[0] == NULL)
243: break;
244:
245: (void) ll_log (fred_log, LLOG_NOTICE, NULLCP,
246: "%s asks: %s", ep, buffer);
247:
248: fprintf (stdfp, "%s>>> %s\n", didone ? "\n\n" : "", buffer);
249:
250: bzero ((char *) vec, sizeof vec);
251: if (str2vecY (buffer, vec) < 1)
252: break;
253:
254: if (fredloop (vec, NOTOK) != OK) {
255: status = 1;
256: break;
257: }
258: didone = 1;
259: }
260:
261: if (!didone)
262: (void) f_help (NULLVP);
263: }
264:
265: (void) fclose (fp);
266:
267: stdfp = stdout;
268:
269: goto were_out_of_here;
270: }
271:
272: if (network) {
273: int len;
274:
275: if (getpeername (fileno (stdin), (struct sockaddr *) isock,
276: (len = sizeof *isock, &len)) != NOTOK) {
277: (void) sprintf (address, "%s/%d",
278: inet_ntoa (isock -> sin_addr),
279: ntohs (isock -> sin_port));
280:
281: rcmap (isock);
282: }
283: else {
284: (void) ll_log (fred_log, LLOG_EXCEPTIONS, "failed", "getpeername");
285: (void) strcpy (address, "peer");
286: }
287: }
288: else
289: {
290: register struct hostent *hp;
291:
292: (void) strcpy (address, getlocalhost ());
293:
294: if (hp = gethostbystring (address)) {
295: bzero ((char *) isock, sizeof *isock);
296: isock -> sin_family = hp -> h_addrtype;
297: inaddr_copy (hp, isock);
298: rcmap (isock);
299: }
300: else
301: advise (NULLCP, "%s: unknown host", address);
302:
303: }
304:
305: if (!fflag) {
306: (void) sprintf (buffer, "%s/.fredrc", myhome);
307: rcfile (buffer, op ? 1 : 0, 0);
308: }
309:
310: if (f_bind (NULLVP) == NOTOK)
311: adios (NULLCP, "unable to open the white pages");
312:
313: if (network) {
314: errfp = stdout;
315:
316: switch (fetchline (buffer, sizeof buffer, stdin)) {
317: case NOTOK:
318: adios (NULLCP, "error reading query from %s", address);
319: /* NOTREACHED */
320:
321: case DONE:
322: buffer[0] = NULL;
323: /* and fall... */
324:
325: case OK:
326: default:
327: break;
328: }
329: if (cp = index (buffer, '\r'))
330: *cp = NULL;
331: if (cp = index (buffer, '\n'))
332: *cp = NULL;
333:
334: (void) ll_log (fred_log, LLOG_NOTICE, NULLCP, "%s asks: %s",
335: address, buffer);
336:
337: bzero ((char *) vec, sizeof vec);
338: if (str2vecY (buffer, vec) < 1)
339: (void) f_help (NULLVP);
340: else
341: if (fredloop (vec, NOTOK) != OK)
342: status = 1;
343:
344: goto were_out_of_here;
345: }
346:
347: if (op) {
348: vecp = 0;
349: if (strcmp (myname, "whois") == 0)
350: vec[vecp++] = myname;
351: while (*op)
352: vec[vecp++] = *op++;
353: vec[vecp] = NULL;
354:
355: if (fredloop (vec, NOTOK) != NOTOK)
356: status = 1;
357:
358: goto were_out_of_here;
359: }
360:
361: istat = signal (SIGINT, intrser);
362:
363: eof = 0;
364: for (interrupted = 0;; interrupted = 0) {
365: if (alarming) {
366: astat = signal (SIGALRM, alrmser);
367:
368: switch (setjmp (alrmenv)) {
369: case OK:
370: (void) alarm ((unsigned) 300);
371: break;
372:
373: default:
374: adios (NULLCP, "timed out due to inactivity");
375: }
376: }
377:
378: if ((usetty ? getline ("%s> ", buffer) : readline (buffer)) == NOTOK) {
379: if (eof)
380: break;
381:
382: eof = 1;
383: continue;
384: }
385: eof = 0;
386:
387: if (alarming)
388: (void) alarm ((unsigned) 0);
389:
390: if (logging)
391: (void) ll_log (fred_log, LLOG_NOTICE, NULLCP, "command: %s",
392: buffer);
393:
394: bzero ((char *) vec, sizeof vec);
395: if ((vecp = str2vecY (buffer, vec)) < 1)
396: continue;
397:
398: switch (fredloop (vec, OK)) {
399: case NOTOK:
400: status = 1;
401: break;
402:
403: case OK:
404: default:
405: continue;
406:
407: case DONE:
408: status = 0;
409: break;
410: }
411: break;
412: }
413:
414: (void) signal (SIGINT, istat);
415:
416: were_out_of_here: ;
417: (void) f_quit (NULLVP);
418:
419: exit (mail ? 0 : status); /* NOTREACHED */
420: }
421:
422: /* ARGINIT */
423:
424: static arginit (vec)
425: char **vec;
426: {
427: register char *ap,
428: *pp;
429:
430: if (myname = rindex (*vec, '/'))
431: myname++;
432: if (myname == NULL || *myname == NULL)
433: myname = *vec;
434:
435: if (strcmp (myname, "in.whitepages") == 0)
436: network++, fflag++;
437:
438: isodetailor (myname, 1);
439: ll_hdinit (fred_log, myname);
440:
441: if (ontty = isatty (fileno (stdin)))
442: verbose++;
443: oneshot = 0;
444:
445: for (vec++; ap = *vec; vec++) {
446: if (*ap == '-') {
447: while (*++ap)
448: switch (*ap) {
449: case 'a':
450: alarming++;
451: break;
452:
453: case 'd':
454: debug++;
455: break;
456:
457: case 'm':
458: mail++;
459: /* and fall... */
460:
461: case 'n':
462: network++;
463: /* and fall... */
464:
465: case 'f':
466: fflag++;
467: break;
468:
469: case 'k':
470: kflag++;
471: break;
472:
473: case 'l':
474: logging++;
475: break;
476:
477: case 'r':
478: readonly++;
479: pager = "internal";
480: break;
481:
482: case 'v':
483: verbose++;
484: break;
485:
486: case 'w':
487: watch++;
488: break;
489:
490: case 'q':
491: if ((pp = *++vec) == NULL
492: || sscanf (pp, "%d %d", &ifd, &ofd) != 2)
493: adios (NULLCP, "usage: %s -q fd-pair", myname);
494: usetty = 0;
495: break;
496:
497: default:
498: adios (NULLCP, "unknown switch -%c", *ap);
499: }
500: continue;
501: }
502: if (op == NULL) {
503: op = vec;
504: oneshot = 1;
505: break;
506: }
507: }
508:
509: if (debug)
510: ll_dbinit (fred_log, myname);
511: if (logging)
512: log_utmp ();
513: }
514:
515: /* INTERACTIVE */
516:
517: int getline (prompt, buffer)
518: char *prompt,
519: *buffer;
520: {
521: register int i;
522: register char *cp,
523: *ep;
524: static int sticky = 0;
525:
526: if (interrupted) {
527: interrupted = 0;
528: return NOTOK;
529: }
530:
531: if (sticky) {
532: sticky = 0;
533: return NOTOK;
534: }
535:
536: switch (setjmp (intrenv)) {
537: case OK:
538: armed++;
539: break;
540:
541: case NOTOK:
542: if (ontty)
543: printf ("\n"); /* and fall */
544: default:
545: armed = 0;
546: return NOTOK;
547: }
548:
549: if (ontty) {
550: printf (prompt, myname);
551: (void) fflush (stdout);
552: }
553:
554: for (ep = (cp = buffer) + BUFSIZ - 1; (i = getchar ()) != '\n';) {
555: if (i == EOF) {
556: if (ontty)
557: printf ("\n");
558: clearerr (stdin);
559: if (cp == buffer)
560: longjmp (intrenv, DONE);
561:
562: sticky++;
563: break;
564: }
565:
566: if (cp < ep)
567: *cp++ = i;
568: }
569: *cp = NULL;
570:
571: armed = 0;
572:
573: return OK;
574: }
575:
576: /* */
577:
578: static readline (buffer)
579: char *buffer;
580: {
581: register int i;
582: register char *bp,
583: *cp,
584: *ep;
585:
586: (void) signal (SIGINT, istat);
587: (void) signal (SIGQUIT, qstat);
588:
589: ep = (bp = buffer) + BUFSIZ - 1;
590:
591: (void) strcpy (bp, "whois ");
592: bp += strlen (bp);
593: while ((i = read (ifd, bp, ep - bp)) > 0) {
594: for (cp = bp + i; bp < cp; bp++)
595: if (*bp == '\n')
596: break;
597: if (bp < cp)
598: break;
599: }
600: if (i == NOTOK)
601: adios ("failed", "read from pipe");
602: if (i == 0)
603: exit (0);
604: *bp = NULL;
605:
606: if (watch) {
607: fprintf (stderr, "<--- %s\n", buffer);
608: (void) fflush (stderr);
609: }
610:
611: usetty = 1;
612:
613: return OK;
614: }
615:
616: /* */
617:
618: #ifndef IAC
619: #define IAC 255
620: #endif
621:
622:
623: static int fetchline (s, n, iop)
624: register char *s;
625: register int n;
626: register FILE *iop;
627: {
628: register int c;
629: register char *p;
630:
631: p = s;
632: while (--n > 0 && (c = getc (iop)) != EOF) {
633: while (c == IAC) {
634: (void) getc (iop);
635: c = getc (iop);
636: }
637: if ((*p++ = c) == '\n')
638: break;
639: }
640: if (ferror (iop))
641: return NOTOK;
642: if (c == EOF && p == s)
643: return DONE;
644: *p++ = NULL;
645:
646: return OK;
647: }
648:
649: /* */
650:
651: /* ARGSUSED */
652:
653: static SFD alrmser (sig)
654: int sig;
655: {
656: #ifndef BSDSIGS
657: (void) signal (SIGALRM, alrmser);
658: #endif
659:
660: longjmp (alrmenv, NOTOK);
661: }
662:
663: /* */
664:
665: /* ARGSUSED */
666:
667: static SFD intrser (sig)
668: int sig;
669: {
670: #ifndef BSDSIGS
671: (void) signal (SIGINT, intrser);
672: #endif
673:
674: if (armed)
675: longjmp (intrenv, NOTOK);
676:
677: interrupted++;
678: }
679:
680: /* */
681:
682: #ifndef lint
683: int ask (va_alist)
684: va_dcl
685: {
686: int x,
687: y,
688: result;
689: char buffer[BUFSIZ];
690: va_list ap;
691:
692: if (interrupted) {
693: interrupted = 0;
694: return NOTOK;
695: }
696:
697: if (!ontty)
698: return OK;
699:
700: switch (setjmp (intrenv)) {
701: case OK:
702: armed++;
703: break;
704:
705: case NOTOK:
706: default:
707: printf ("\n");
708: armed = 0;
709: return DONE;
710: }
711:
712: va_start (ap);
713:
714: _asprintf (buffer, NULLCP, ap);
715:
716: va_end (ap);
717:
718: again: ;
719: printf ("%s? (y)es, (n)o: ", buffer);
720:
721: x = y = getchar ();
722: while (y != '\n' && y != EOF)
723: y = getchar ();
724:
725: switch (x) {
726: case 'y':
727: case '\n':
728: result = OK;
729: break;
730:
731: case 'n':
732: result = NOTOK;
733: break;
734:
735: case EOF:
736: result = DONE;
737: break;
738:
739: default:
740: goto again;
741: }
742:
743: armed = 0;
744:
745: return result;
746: }
747: #else
748: /* VARARGS */
749:
750: int ask (fmt)
751: char *fmt;
752: {
753: return ask (fmt);
754: }
755: #endif
756:
757: /* */
758:
759: int str2vecY (buffer, vec)
760: char *buffer,
761: **vec;
762: {
763: int i;
764: register char *cp,
765: *dp;
766:
767: if (nametype <= 1) {
768: normal: ;
769: return str2vec (buffer, vec);
770: }
771:
772: for (cp = buffer; isspace (*cp); cp++)
773: continue;
774: for (dp = cp++; !isspace (*cp); cp++)
775: if (!*cp)
776: goto normal;
777: *cp = NULL;
778: if ((i = strlen (dp)) > 5 || strncmp ("whois", dp, i)) {
779: *cp = ' ';
780: goto normal;
781: }
782:
783: vec[0] = dp;
784: vec[1] = ++cp;
785: vec[2] = NULL;
786:
787: return 2;
788: }
789:
790: /* MAPPING */
791:
792: /* reads fred's IP-address to DN mapping file.
793:
794: for environments like Rutgers where IP-addresses can be more or less
795: trusted, this allows an easy mechanism for mapping local Rutgers users into
796: some DN other than the NULL user
797:
798: Syntax:
799:
800: <addrmask> <netaddr> <dn> <password>
801:
802: Each token is seperated by LWSP, though double-quotes may be used to
803: prevent separation.
804:
805: */
806:
807: static rcmap (isock)
808: struct sockaddr_in *isock;
809: {
810: u_long hostaddr,
811: netmask,
812: netaddr;
813: register char *cp;
814: char buffer[BUFSIZ + 1],
815: *vec[NVEC + 1];
816: FILE *fp;
817:
818: if ((fp = fopen (isodefile ("fredmap", 0), "r")) == NULL)
819: goto done;
820:
821: hostaddr = isock -> sin_addr.s_addr;
822:
823: while (fgets (buffer, sizeof buffer, fp)) {
824: if (*buffer == '#')
825: continue;
826: if (cp = index (buffer, '\n'))
827: *cp = NULL;
828: bzero ((char *) vec, sizeof vec);
829: if (str2vec (buffer, vec) != 4)
830: continue;
831: if ((netmask = inet_network (vec[0])) == NOTOK)
832: continue;
833: if ((netaddr = inet_network (vec[1])) == NOTOK)
834: continue;
835: if ((hostaddr & netmask) != netaddr)
836: continue;
837:
838: vec[1] = "thisis";
839:
840: runcom = 1, rcmode = 0400;
841: if (f_thisis (vec + 1) == NOTOK)
842: adios (NULLCP, "unable to bind as %s for %s",
843: vec[2], inet_ntoa (isock -> sin_addr));
844:
845: runcom = 0;
846: break;
847: }
848:
849: (void) fclose (fp);
850:
851: done: ;
852: (void) setgid (getgid ());
853: (void) setuid (getuid ());
854: }
855:
856: /* ERRORS */
857:
858: #ifndef lint
859: void _advise ();
860:
861:
862: void adios (va_alist)
863: va_dcl
864: {
865: va_list ap;
866:
867: va_start (ap);
868:
869: if (network)
870: (void) _ll_log (fred_log, LLOG_FATAL, ap);
871:
872: _advise (ap);
873:
874: va_end (ap);
875:
876: (void) f_quit (NULLVP);
877:
878: _exit (1);
879: }
880: #else
881: /* VARARGS */
882:
883: void adios (what, fmt)
884: char *what,
885: *fmt;
886: {
887: adios (what, fmt);
888: }
889: #endif
890:
891:
892: #ifndef lint
893: void advise (va_alist)
894: va_dcl
895: {
896: va_list ap;
897:
898: va_start (ap);
899:
900: _advise (ap);
901:
902: va_end (ap);
903: }
904:
905:
906: static void _advise (ap)
907: va_list ap;
908: {
909: char buffer[BUFSIZ];
910: FILE *fp = network ? stdfp : stderr;
911:
912: asprintf (buffer, ap);
913:
914: (void) fflush (stdfp);
915:
916: fprintf (fp, "%s: ", myname);
917: (void) fputs (buffer, fp);
918: (void) fputs (EOLN, fp);
919:
920: (void) fflush (fp);
921: }
922: #else
923: /* VARARGS */
924:
925: void advise (what, fmt)
926: char *what,
927: *fmt;
928: {
929: advise (what, fmt);
930: }
931: #endif
932:
933: /* MISCELLANY */
934:
935: #ifndef lint
936: char *strdup (s)
937: char *s;
938: {
939: char *p;
940:
941: if ((p = malloc((unsigned) (strlen (s) + 1))) == NULL)
942: adios (NULLCP, "out of memory");
943:
944: (void) strcpy (p, s);
945:
946: return p;
947: }
948: #endif
949:
950: /* */
951:
952: #include <utmp.h>
953:
954: #ifdef sun
955: #define BSD42
956: #undef SYS5
957: #endif
958:
959: #ifdef bsd43_ut_host
960: #undef BSD42
961: #define SYS5
962: #endif
963:
964: #ifdef BSD42
965: #define HMAX (sizeof (ut -> ut_host))
966: #endif
967: #define LMAX (sizeof (ut -> ut_line))
968: #define NMAX (sizeof (ut -> ut_name))
969:
970: #define SCPYN(a, b) strncpy(a, b, sizeof (a))
971: #define SCMPN(a, b) strncmp(a, b, sizeof (a))
972:
973:
974: #ifdef SYS5
975: struct utmp *getutent ();
976: #endif
977:
978: char *ttyname ();
979:
980:
981: static log_utmp () {
982: #ifndef SYS5
983: int ud;
984: #endif
985: char *line;
986: struct utmp uts;
987: register struct utmp *ut = &uts;
988:
989: if ((line = ttyname (fileno (stdin))) == NULL)
990: return;
991: if (strncmp (line, "/dev/", sizeof "/dev/" - 1) == 0)
992: line += sizeof "/dev/" - 1;
993: #ifndef SYS5
994: if ((ud = open ("/etc/utmp", 0)) == NOTOK)
995: return;
996: while (read (ud, (char *) ut, sizeof *ut) == sizeof *ut) {
997: if (ut -> ut_name[0] == NULL || SCMPN (ut -> ut_line, line))
998: continue;
999: #ifndef BSD42
1000: (void) ll_log (fred_log, LLOG_NOTICE, NULLCP, "%.*s on %.*s",
1001: NMAX, ut -> ut_name, LMAX, ut -> ut_line);
1002: #else
1003: (void) ll_log (fred_log, LLOG_NOTICE, NULLCP,
1004: "%.*s on %.*s (%.*s)",
1005: NMAX, ut -> ut_name, LMAX, ut -> ut_line,
1006: HMAX, ut -> ut_host);
1007: #endif
1008: break;
1009: }
1010: (void) close (ud);
1011: #else
1012: setutent ();
1013: while (ut = getutent ()) {
1014: if (ut -> ut_type != USER_PROCESS || SCMPN (ut -> ut_line, line))
1015: continue;
1016:
1017: (void) ll_log (fred_log, LLOG_NOTICE, NULLCP, "%.*s on %.*s",
1018: NMAX, ut -> ut_name, LMAX, ut -> ut_line);
1019: break;
1020: }
1021: endutent ();
1022: #endif
1023: }
1024:
1025:
1026: #ifdef bsd43_ut_host
1027: #define BSD42
1028: #undef SYS5
1029: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.