![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to umhook.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / mh / uip|
Return to umhook.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / mh / uip |
1.1 root 1: /* umhook.c - one attempt at a rcvmail hook for UUCP mail */
2:
3: /* I don't comment my code heavily, so read this...
4:
5: You run this program from your .login file. The invocation is simply
6: "umhook". The program "detaches" itself and runs unattended until you
7: logout. Whenever you get UUCP mail (or upto a minute afterwards),
8: umhook will filter your UUCP mail drop to a temporary file. The mail
9: drop is *NOT* touched beyond this (even the access time remains the
10: same). For each message that was new in the mail drop, umhook will
11: fork a process to interpret your .maildelivery file.
12:
13: The umhook program uses the -ljobs control facility to do two things:
14: - determine when the controlling tty has gone away
15: - kill a child that's run away (the child sets up a process group)
16: */
17:
18: #include "../h/mh.h"
19: #include "../zotnet/mf.h"
20: #include <stdio.h>
21: #include "../zotnet/mts.h"
22: #include <pwd.h>
23: #include <signal.h>
24: #include <sys/ioctl.h>
25: #include <sys/types.h>
26: #include <sys/stat.h>
27:
28: /* */
29:
30: static struct swit switches[] = {
31: #define SLEEPSW 0
32: "sleep seconds", 0,
33:
34: #define HELPSW 1
35: "help", 4,
36:
37: NULL, NULL
38: };
39:
40: /* */
41:
42: static int snooze = 60;
43:
44: static int uucp = NOTOK;
45:
46: extern char *environ;
47:
48: static char myhome[BUFSIZ] = "";
49: static char mymail[BUFSIZ] = "";
50: static char myaddr[BUFSIZ] = "";
51: static char mystat[BUFSIZ] = "";
52: static char myuser[BUFSIZ] = "";
53:
54: int sigser ();
55:
56: long lseek ();
57: #ifdef SYS5
58: struct passwd *getpwuid ();
59: #endif SYS5
60:
61: /* */
62:
63: /* ARGSUSED */
64:
65: main (argc, argv)
66: int argc;
67: char **argv;
68: {
69: char *cp,
70: **ap,
71: **argp,
72: buf[100],
73: *arguments[MAXARGS];
74: struct passwd *pw;
75:
76: invo_name = r1bindex (argv[0], '/');
77: mts_init (invo_name);
78: if ((cp = m_find (invo_name)) != NULL) {
79: ap = brkstring (cp = getcpy (cp), " ", "\n");
80: ap = copyip (ap, arguments);
81: }
82: else
83: ap = arguments;
84: (void) copyip (argv + 1, ap);
85: argp = arguments;
86:
87: /* */
88:
89: while (cp = *argp++) {
90: if (*cp == '-')
91: switch (smatch (++cp, switches)) {
92: case AMBIGSW:
93: ambigsw (cp, switches);
94: done (1);
95: case UNKWNSW:
96: adios (NULLCP, "-%s unknown", cp);
97: case HELPSW:
98: (void) sprintf (buf, "%s [switches]", invo_name);
99: help (buf, switches);
100: done (1);
101:
102: case SLEEPSW:
103: if (!(cp = *argp++) || *cp == '-')
104: adios (NULLCP, "missing argument to %s", argp[-2]);
105: if ((snooze = atoi (cp)) < 0)
106: adios (NULLCP, "bad argument %s %s", argp[-2], cp);
107: continue;
108: }
109: adios (NULLCP, "usage: %s [switches]", invo_name);
110: }
111:
112: /* */
113:
114: if ((pw = getpwuid (getuid ())) == NULL)
115: adios (NULLCP, "you lose big");
116:
117: *environ = NULL;
118: (void) putenv ("USER", pw -> pw_name);
119: (void) putenv ("HOME", pw -> pw_dir);
120: (void) putenv ("SHELL", pw -> pw_shell);
121: if (chdir (pw -> pw_dir) == NOTOK)
122: (void) chdir ("/");
123: (void) umask (0077);
124:
125: if (geteuid () == 0) {
126: #ifdef BSD41A
127: (void) inigrp (pw -> pw_name, pw -> pw_gid);
128: #endif BSD41A
129: (void) setgid (pw -> pw_gid);
130: #ifdef BSD42
131: (void) initgroups (pw -> pw_name, pw -> pw_gid);
132: #endif BSD42
133: (void) setuid (pw -> pw_uid);
134: }
135:
136: (void) sprintf (mymail, "%s/%s",
137: uucpldir[0] ? uucpldir : pw -> pw_dir,
138: uucplfil[0] ? uucplfil : pw -> pw_name);
139: (void) strcpy (myuser, pw -> pw_name);
140: (void) sprintf (myaddr, "%s@%s", pw -> pw_name, LocalName ());
141: (void) strcpy (myhome, pw -> pw_dir);
142: (void) sprintf (mystat, ".%s_%d", invo_name, pw -> pw_uid);
143:
144: if (access (slocalproc, 1) == NOTOK)
145: adios (slocalproc, "unable to execute");
146:
147: closefds (fileno (stderr) + 1);
148:
149: (void) signal (SIGINT, SIG_IGN);
150: (void) signal (SIGHUP, sigser);
151: (void) signal (SIGQUIT, SIG_IGN);
152: (void) signal (SIGTERM, sigser);
153:
154: switch (fork ()) {
155: case NOTOK:
156: case OK:
157: umhook ();
158: break;
159:
160: default:
161: break;
162: }
163:
164: exit (0);
165: }
166:
167: /* */
168:
169: #ifndef TIOCGPGRP
170: #define pgrp_ok(pg) 1
171: #else TIOCGPGRP
172: #define pgrp_ok(pg) (ioctl (2, TIOCGPGRP, (char *) &pg) != NOTOK)
173: #endif TIOCGPGRP
174:
175: static umhook () {
176: int pg;
177: struct stat st1,
178: st2;
179:
180: st_init (&st1);
181:
182: for (; pgrp_ok (pg);) {
183: if (stat (mymail, &st2) == NOTOK) {
184: st2.st_ino = (ino_t) 0;
185: st2.st_size = (off_t) 0;
186: st2.st_mtime = (time_t) 0;
187: }
188: else
189: if (st1.st_mtime != st2.st_mtime)
190: if (st1.st_ino != st2.st_ino)
191: process ((off_t) 0, &st2);
192: else
193: if (st1.st_size < st2.st_size)
194: process (st1.st_size, &st2);
195:
196: st1.st_ino = st2.st_ino;
197: st1.st_size = st2.st_size;
198: st1.st_mtime = st2.st_mtime;
199:
200: sleep ((unsigned) snooze);
201: }
202: }
203:
204: /* */
205:
206: static process (offset, st)
207: off_t offset;
208: struct stat *st;
209: {
210: int td1,
211: td2;
212: time_t timep[2];
213: char tmpfil[BUFSIZ];
214: register FILE *fp;
215:
216: if ((uucp = lkopen (mymail, 0)) == NOTOK)
217: adios (NULLCP, "unable to lock and open %s", mymail);
218: if (lseek (uucp, (long) offset, 0) == (long) NOTOK)
219: adios (mymail, "unable to position to %ld offset on", offset);
220:
221: (void) strcpy (tmpfil, m_tmpfil (invo_name));
222: if ((td1 = creat (tmpfil, TMPMODE)) == NOTOK)
223: adios (tmpfil, "unable to create");
224: (void) close (td1);
225:
226: if ((td1 = open (tmpfil, 2)) == NOTOK)
227: adios (tmpfil, "unable to open");
228: (void) unlink (tmpfil);
229: if ((td2 = dup (td1)) == NOTOK)
230: adios ("file descriptor", "unable to dup");
231:
232: switch (uucp2mmdf (uucp, td1, FALSE)) {
233: case MFPRM:
234: adios (NULLCP, "internal error while filtering UUCP mail");
235:
236: case MFSIO:
237: adios (NULLCP, "no free file pointers");
238:
239: case MFERR:
240: adios ("UUCP mail", "i/o error while filtering");
241:
242: case MFOK:
243: case MFROM:
244: case MFHDR:
245: case MFTXT:
246: timep[0] = st -> st_atime;
247: timep[1] = st -> st_mtime;
248: utime (mymail, timep);
249: st_update (st);
250: break;
251: }
252: (void) lkclose (uucp, mymail), uucp = NOTOK;
253:
254: /* */
255:
256: (void) close (td1);
257:
258: (void) lseek (td2, 0L, 0);
259: if ((fp = fdopen (td2, "r")) == NULL)
260: adios (NULLCP, "no free file pointers");
261:
262: while (hook (fp))
263: continue;
264: (void) fclose (fp);
265: }
266:
267: /* */
268:
269: static int hook (in)
270: register FILE *in;
271: {
272: int child_id,
273: done,
274: fd1,
275: fd2,
276: i;
277: char buffer[BUFSIZ],
278: mysndr[BUFSIZ],
279: myfile[BUFSIZ];
280: register FILE *out;
281:
282: if (fgets (buffer, sizeof buffer, in) == NULL)
283: return FALSE;
284:
285: /* should insist on isdlm1 (buffer) here... */
286:
287: (void) strcpy (myfile, m_tmpfil (invo_name));
288: if ((fd1 = creat (myfile, TMPMODE)) == NOTOK)
289: adios (myfile, "unable to create");
290: (void) close (fd1);
291:
292: if ((fd1 = open (myfile, 2)) == NOTOK)
293: adios (myfile, "unable to open");
294: (void) unlink (myfile);
295: if ((fd2 = dup (fd1)) == NOTOK)
296: adios ("file descriptor", "unable to dup");
297:
298: if ((out = fdopen (fd1, "w")) == NULL)
299: adios (NULLCP, "no free file pointers");
300:
301: for (done = TRUE;;) {
302: if (fgets (buffer, sizeof buffer, in) == NULL)
303: break; /* should be error */
304: if (done && isdlm2 (buffer))
305: break;
306: done = buffer[strlen (buffer) - 1] == '\n';
307: fputs (buffer, out);
308: }
309: (void) fclose (out);
310:
311: (void) lseek (fd2, 0L, 0);
312: seeksndr (fd2, mysndr);
313:
314: /* */
315:
316: switch (child_id = fork ()) {
317: case NOTOK:
318: adios ("fork", "unable to");/* NOTREACHED */
319:
320: case OK:
321: (void) lseek (fd2, 0L, 0);
322: if (fd2 != 0)
323: (void) dup2 (fd2, 0);
324: (void) freopen ("/dev/null", "w", stdout);
325: (void) freopen ("/dev/null", "w", stderr);
326: if (fd2 != 3)
327: (void) dup2 (fd2, 3);
328: closefds (4);
329: #ifdef TIOCNOTTY
330: if ((i = open ("/dev/tty", 2)) != NOTOK) {
331: (void) ioctl (i, TIOCNOTTY, NULLCP);
332: (void) close (i);
333: }
334: #endif TIOCNOTTY
335: #ifdef BSD42
336: (void) setpgrp (0, getpid ());
337: #endif BSD42
338:
339: execlp (slocalproc, r1bindex (slocalproc, '/'),
340: "-file", myfile, "-mailbox", mymail,
341: "-home", myhome, "-addr", myaddr,
342: "-user", myuser, "-sender", mysndr, NULLCP);
343: adios (slocalproc, "unable to exec");/* NOTREACHED */
344:
345: default:
346: (void) close (fd2);
347: (void) pidwait (child_id, OK);
348: return TRUE;
349: }
350: }
351:
352: /* */
353:
354: static seeksndr (fd1, mysndr)
355: int fd1;
356: char *mysndr;
357: {
358: int fd2;
359: char *bp,
360: *hp,
361: from[BUFSIZ],
362: sender[BUFSIZ];
363: register FILE *in;
364:
365: if ((fd2 = dup (fd1)) == NOTOK)
366: adios ("file descriptor", "unable to dup");
367: if ((in = fdopen (fd2, "r")) == NULL)
368: adios (NULLCP, "no free file pointers");
369:
370: for (from[0] = sender[0] = NULL; mfgets (in, &hp) != DONE;)
371: if ((bp = index (hp, ':')) != NULL) {
372: *bp++ = NULL;
373: if (lequal (hp, "From"))
374: seekaddr (from, bp);
375: else
376: if (lequal (hp, "Sender"))
377: seekaddr (sender, bp);
378: }
379: (void) fclose (in);
380:
381: (void) strcpy (mysndr, sender[0] ? sender : from[0] ? from : myaddr);
382: }
383:
384: /* */
385:
386: static seekaddr (addr, bp)
387: char *addr,
388: *bp;
389: {
390: struct adrx *adrxp;
391:
392: if ((adrxp = seekadrx (bp)) == NULL)
393: return;
394: if (adrxp -> err || !adrxp -> mbox)
395: return;
396:
397: if (adrxp -> host)
398: (void) sprintf (addr, "%s@%s", adrxp -> mbox, adrxp -> host);
399: else
400: (void) strcpy (addr, adrxp -> mbox);
401:
402: while (seekadrx (NULLCP))
403: continue;
404: }
405:
406: /* */
407:
408: static st_init(st)
409: struct stat *st;
410: {
411: int fd;
412:
413: if ((fd = open (mystat, 0)) == NOTOK
414: || read (fd, (char *) st, sizeof *st) != (sizeof *st)) {
415: st -> st_ino = (ino_t) 0;
416: st -> st_size = (off_t) 0;
417: st -> st_mtime = (time_t) 0;
418: }
419: if (fd != NOTOK)
420: (void) close (fd);
421: }
422:
423:
424: static st_update(st)
425: struct stat *st;
426: {
427: static int fd = NOTOK;
428:
429: if (fd == NOTOK
430: && (fd = creat (mystat, TMPMODE)) == NOTOK)
431: adios (mystat, "unable to write");
432:
433: (void) lseek (fd, 0L, 0);
434: if (write (fd, (char *) st, sizeof *st) != (sizeof *st))
435: adios (mystat, "error writing");
436: }
437:
438: /* */
439:
440: #ifdef BSD42
441: /* ARGSUSED */
442: #endif BSD42
443:
444: static int sigser (sig)
445: int sig;
446: {
447: #ifndef BSD42
448: (void) signal (sig, SIG_IGN);
449: #endif BSD42
450:
451: done (1);
452: }
453:
454: /* */
455:
456: void done (status)
457: int status;
458: {
459: (void) lkclose (uucp, mymail), uucp = NOTOK;
460: exit (status);
461: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.