![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uumm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / zotnet / mf|
Return to uumm.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / zotnet / mf |
1.1 root 1: /* uumm.c - routines to filter UUCP to MMDF mailboxes */
2:
3: #include "mf.h"
4: #include "../tws/tws.h"
5: #include <stdio.h>
6: #include "../mts/mts.h"
7: #include <ctype.h>
8: #include <sys/types.h>
9: #include <sys/stat.h>
10:
11: /* */
12:
13: static struct header {
14: char *h_name;
15: int h_type;
16: } headers[] = {
17: "From", HFROM,
18: "Sender", HSNDR,
19: "Reply-To", HADDR,
20: "To", HADDR,
21: "cc", HADDR,
22: "Bcc", HADDR,
23: "Resent-From", HADDR,
24: "Resent-Sender", HADDR,
25: "Resent-Reply-To", HADDR,
26: "Resent-To", HADDR,
27: "Resent-cc", HADDR,
28: "Resent-Bcc", HADDR,
29: "Date", HDATE,
30: "Resent-Date", HDATE,
31: NULL, HOTHR
32: };
33:
34: static char buffer[BUFSIZ],
35: tmpbuf[BUFSIZ];
36:
37: char *shrink ();
38:
39: long time ();
40:
41: /* */
42:
43: /*
44: * uucp2mmdf() - given a file descriptor to a uucp mailbox, filter
45: * its contents to the file descriptor for a mmdf mailbox. Returns
46: * non-zero on error (see mf.h for values)
47: *
48: * It is assumed that the caller will have made sure that the necessary
49: * locking has been performed on the output fd.
50: */
51:
52: int uucp2mmdf (infd, outfd, nodelim)
53: int infd,
54: outfd,
55: nodelim;
56: {
57: int fd,
58: result;
59: struct stat st;
60: FILE * in, *out;
61:
62: if (fstat (infd, &st) == NOTOK || fstat (outfd, &st) == NOTOK)
63: return MFPRM;
64: if ((in = fdopen (infd, "r")) == NULL
65: || (out = fdopen (outfd, "w")) == NULL)
66: return MFSIO;
67:
68: result = uumm (in, out, nodelim);
69:
70: /* for STDIO - free up some fp:s */
71: fd = dup (fileno (in));
72: fclose (in);
73: dup2 (fd, infd);
74: close (fd);
75:
76: fd = dup (fileno (out));
77: fclose (out);
78: dup2 (fd, outfd);
79: close (fd);
80:
81: return result;
82: }
83:
84: /* */
85:
86: int uumm (in, out, nodelim)
87: FILE *in,
88: *out;
89: int nodelim;
90: {
91: int i,
92: tmp_fd;
93: char from[LINESIZ],
94: date[LINESIZ];
95: FILE *tmp;
96:
97: for (tmp_fd = NOTOK;;) {
98: if ((i = uucp_file (&tmp_fd, in, &tmp, nodelim)) == DONE)
99: break;
100: else
101: if (i != OK)
102: return i;
103: if ((i = uucp_from (from, date, tmp)) != OK)
104: return uucp_die (i, tmp, in, out, nodelim);
105: if ((i = uucp_headers (from, date, tmp, out, nodelim)) != OK)
106: return uucp_die (i, tmp, in, out, nodelim);
107: if ((i = uucp_text (tmp, out, nodelim)) != OK)
108: return uucp_die (i, tmp, in, out, nodelim);
109: }
110:
111: fflush (out);
112:
113: return (ferror (in) || ferror (out) ? MFERR : MFOK);
114: }
115:
116: /* */
117:
118: static int uucp_file (tmp_fd, in, tmp, nodelim)
119: int *tmp_fd,
120: nodelim;
121: FILE * in, **tmp;
122: {
123: int done,
124: fd;
125: char tmpfil[LINESIZ];
126: FILE * out;
127:
128: if (nodelim)
129: if (*tmp_fd != NOTOK)
130: return DONE;
131: else
132: if ((*tmp_fd = dup (fileno (in))) == NOTOK)
133: return MFERR;
134: else
135: if ((*tmp = fdopen (*tmp_fd, "r")) == NULL) {
136: close (*tmp_fd);
137: return MFERR;
138: }
139: else
140: return OK;
141:
142: if (*tmp_fd == NOTOK && fgets (tmpbuf, sizeof tmpbuf, in) == NULL)
143: return DONE;
144: else
145: if (feof (in))
146: return DONE;
147:
148: strcpy (tmpfil, "/tmp/uummXXXXXX");
149: unlink (mktemp (tmpfil));
150: if ((fd = creat (tmpfil, TMPMODE)) == NOTOK)
151: return MFERR;
152: close (fd);
153:
154: if ((fd = open (tmpfil, 2)) == NOTOK)
155: return MFERR;
156: if ((out = fdopen (fd, "w")) == NULL) {
157: close (fd);
158: return MFERR;
159: }
160: unlink (tmpfil);
161:
162: if ((*tmp_fd = dup (fd)) == NOTOK) {
163: close (fd);
164: return MFERR;
165: }
166: if ((*tmp = fdopen (*tmp_fd, "r")) == NULL) {
167: close (fd);
168: close (*tmp_fd);
169: return MFERR;
170: }
171:
172: /* */
173:
174: for (done = FALSE;;) {
175: if (done)
176: if (isfrom (tmpbuf))
177: break;
178: else
179: putc ('\n', out);
180: done = tmpbuf[0] == '\n';
181: if (!done)
182: fputs (tmpbuf, out);
183: if (fgets (tmpbuf, sizeof tmpbuf, in) == NULL)
184: break;
185: }
186:
187: fclose (out);
188: fseek (*tmp, 0L, 0);
189: return OK;
190: }
191:
192: /* */
193:
194: /* We might want to attempt recovery here. Forget it. */
195:
196: static int uucp_from (from, date, in)
197: char *from,
198: *date;
199: FILE * in;
200: {
201: char *cp,
202: *pp,
203: fromwhom[LINESIZ];
204: struct adrx *adrxp;
205:
206: if (fgets (buffer, sizeof buffer, in) == NULL || !isfrom (buffer))
207: return MFROM;
208: if (buffer[strlen (buffer) - 1] == '\n')
209: buffer[strlen (buffer) - 1] = NULL;
210: if ((cp = index (buffer, ' ')) == NULL)
211: return MFROM;
212: pp = ++cp;
213: if ((cp = index (cp, ' ')) == NULL)
214: return MFROM;
215: *cp++ = NULL;
216: strcpy (fromwhom, pp);
217: while (isspace (*cp))
218: cp++;
219: sprintf (date, "%.24s", cp);
220:
221: for (;;) {
222: if ((cp = index (cp + 1, 'r')) == NULL) {
223: if (index (fromwhom, '!') || index (fromwhom, '@'))
224: strcpy (from, fromwhom);
225: else
226: sprintf (from, "%s!%s", SystemName (), fromwhom);
227: break;
228: }
229: if (strncmp (cp, "remote from ", 12) == 0) {
230: *cp = NULL;
231: sprintf (from, "%s!%s", cp + 12, fromwhom);
232: break;
233: }
234: }
235:
236: if ((adrxp = seekadrx (from)) == NULL)
237: return MFROM;
238: addr_convert (adrxp, from, TRUE);
239: while (seekadrx (NULL))
240: continue;
241: if (from[0] == NULL)
242: return MFROM;
243: date_convert (date, date);
244: return (date[0] != NULL ? OK : MFROM);
245: }
246:
247: /* */
248:
249: static int uucp_headers (from, date, in, out, nodelim)
250: int nodelim;
251: char *from,
252: *date;
253: FILE * in, *out;
254: {
255: int i,
256: seen_from,
257: seen_sender,
258: seen_date;
259:
260: seen_from = seen_sender = seen_date = 0;
261: if (!nodelim)
262: fputs (mmdlm1, out);
263:
264: fprintf (out, "Munged: from %s to %s; %s\n",
265: SystemName (), LocalName (), dtimenow ());
266:
267: for (;;) {
268: switch (do_header (&seen_from, &seen_sender, &seen_date, in, out)) {
269: case NOTOK:
270: return MFHDR;
271:
272: case OK:
273: continue;
274:
275: case DONE:
276: break;
277: }
278: break;
279: }
280: /* extra newline separates headers and body */
281: fprintf (out, "%sDate: %s\n%s: %s\n\n",
282: seen_date ? "UUCP-" : NULL, date,
283: seen_from ? (seen_sender ? "UUCP-Sender" : "Sender") : "From",
284: from);
285:
286: return OK;
287: }
288:
289: /* */
290:
291: static int uucp_text (in, out, nodelim)
292: int nodelim;
293: FILE * in, *out;
294: {
295: if (feof (in)) /* probably no body */
296: putc ('\n', out);
297: else
298: while (fgets (buffer, sizeof buffer, in) != NULL) {
299: if (!nodelim && isdlm2 (buffer))
300: buffer[0]++;
301: fputs (buffer, out);
302: }
303:
304: if (!nodelim)
305: fputs (mmdlm2, out);
306: fclose (in);
307:
308: return OK;
309: }
310:
311: /* */
312:
313: static int do_header (seen_from, seen_sender, seen_date, in, out)
314: int *seen_from,
315: *seen_sender,
316: *seen_date;
317: FILE * in, *out;
318: {
319: int i,
320: margin,
321: some,
322: spat,
323: pos;
324: char *bp,
325: *cp,
326: *pp,
327: line[BUFSIZ];
328: struct adrx *adrxp;
329: struct header *hl;
330:
331: if ((i = mfgets (in, &bp)) != OK)
332: return i;
333:
334: if ((cp = index (bp, ':')) == NULL) {
335: fprintf (out, "Illegal-Field: %s\n", bp);
336: return OK;
337: }
338:
339: *cp = NULL;
340: for (hl = &headers[0]; hl -> h_name; hl++)
341: if (lequal (hl -> h_name, bp))
342: break;
343:
344: /* */
345:
346: switch (hl -> h_type) {
347: case HDATE:
348: if (lequal (hl -> h_name, "Date"))
349: (*seen_date)++;
350: for (pp = cp + 1; isspace (*pp); pp++)
351: continue;
352: date_convert (pp, line);
353: if (line[0] == NULL)
354: fprintf (out, "Illegal-Object: %s: %s -- %s\n",
355: hl -> h_name, pp, "illegal date construct");
356: else
357: fprintf (out, "%s: %s\n", hl -> h_name, line);
358: break;
359:
360: case HOTHR:
361: *cp = ':';
362: fprintf (out, "%s\n", bp);
363: break;
364:
365: case HFROM:
366: case HSNDR:
367: if (hl -> h_type == HFROM)
368: (*seen_from)++;
369: else
370: (*seen_sender)++;
371: case HADDR:
372: spat = 0;
373: some = FALSE;
374: pp = ++cp;
375: margin = pos = strlen (hl -> h_name) + 2;
376: while (adrxp = seekadrx (pp)) {
377: addr_convert (adrxp, line, FALSE);
378: if (line[0] != NULL) {
379: if (!spat++)
380: fprintf (out, "%s: ", hl -> h_name);
381: if (some++)
382: fputs (", ", out), pos += 2;
383: if (pos + strlen (line) >= OWIDTH) {
384: fprintf (out, "\n%*s", margin, " ");
385: pos = margin;
386: }
387: fputs (line, out);
388: pos += strlen (line);
389: }
390: else {
391: if (spat)
392: putc ('\n', out);
393: fprintf (out, "Illegal-Object: %s: %s -- %s\n",
394: hl -> h_name, adrxp -> text, adrxp -> err);
395: spat = 0;
396: some = FALSE;
397: pos = margin;
398: }
399: }
400: if (spat)
401: putc ('\n', out);
402: break;
403:
404: default:
405: return NOTOK;
406: }
407:
408: return OK;
409: }
410:
411: /* */
412:
413: addr_convert (adrxp, to, notice)
414: struct adrx *adrxp;
415: char *to;
416: int notice;
417: {
418: int addrlen,
419: uucplen;
420: char *cp,
421: *wp,
422: addr[BUFSIZ],
423: tmp[LINESIZ],
424: uucp[LINESIZ];
425: static char path[LINESIZ] = "";
426:
427: if (adrxp -> err || !adrxp -> mbox) {
428: *to = NULL;
429: return;
430: }
431: if (notice)
432: if ((cp = rindex (adrxp -> mbox, '!')) != NULL)
433: sprintf (path, "%.*s!", cp - adrxp -> mbox, adrxp -> mbox);
434: else
435: path[0] = NULL;
436:
437: sprintf (addr, "%s%s", path, adrxp -> mbox);
438: sprintf (uucp, "%s!", SystemName ());
439: uucplen = strlen (uucp);
440: if ((addrlen = strlen (addr) - uucplen - 1) >= 0)
441: for (cp = addr + addrlen; cp >= addr; cp--)
442: if (strncmp (cp, uucp, uucplen) == NULL) {
443: if (cp != addr && *(cp - 1) != '!')
444: continue;
445: strcpy (addr, cp + uucplen);
446: break;
447: }
448:
449: /* */
450:
451: if (adrxp -> host == NULL) {
452: cp = shrink (addr);
453: #ifdef MMDFMTS
454: sprintf (uucp, "%s%%%s@%s", cp, UucpChan (), LocalName ());
455: #else MMDFMTS
456: if (wp = index (adrxp -> mbox, '!'))
457: sprintf (uucp, "%s@%.*s.%s",
458: wp + 1, wp - adrxp -> mbox, adrxp -> mbox, UucpChan ());
459: else
460: sprintf (uucp, "%s@%s.%s",
461: adrxp -> mbox, SystemName (), UucpChan ());
462: #endif MMDFMTS
463: if (strcmp (adrxp -> mbox, cp))
464: sprintf (tmp, "\"%s\" <%s>", adrxp -> mbox, uucp);
465: else
466: strcpy (tmp, uucp);
467: }
468: else
469: if ((wp = rindex (adrxp -> mbox, '!')) == NULL)
470: sprintf (tmp, "%s@%s", adrxp -> mbox, adrxp -> host);
471: else {
472: sprintf (uucp, "%%%s", UucpChan ());
473: uucplen = strlen (uucp);
474: cp = (lequal (LocalName (), adrxp -> host)
475: && (addrlen = strlen (addr) - uucplen) > 0)
476: ? addr + addrlen : NULL;
477: if (lequal (uucp, cp))
478: sprintf (tmp, "%s@%s", shrink (addr), adrxp -> host);
479: else {
480: if (lequal (adrxp -> mbox, ++wp))
481: sprintf (tmp, "%s@%s", wp, adrxp -> host);
482: else
483: sprintf (tmp, "\"%s\" <%s@%s>", adrxp -> mbox,
484: wp, adrxp -> host);
485: }
486: }
487:
488: strcpy (to, tmp);
489: }
490:
491: /* */
492:
493: static char *shrink (addr)
494: char *addr;
495: {
496: int i,
497: j;
498: char *cp,
499: *pp,
500: *wp,
501: *xp;
502: static char r1[BUFSIZ],
503: r2[BUFSIZ];
504:
505: sprintf (r2, "%s!", SystemName ());
506: i = strlen (r2);
507: if ((j = strlen (addr) - i - 1) >= 0)
508: for (cp = &addr[j]; cp >= addr; cp--)
509: if (strncmp (cp, r2, i) == NULL) {
510: if (cp != addr && *(cp - 1) != '!')
511: continue;
512: strcpy (addr, cp + i);
513: break;
514: }
515:
516: if ((cp = rindex (addr, '!')) == NULL) {
517: sprintf (r1, "%s%s", r2, addr);
518: return r1;
519: }
520: *cp++ = NULL;
521:
522: if ((pp = rindex (addr, '!')) == NULL) {
523: *--cp = '!';
524: strcpy (r1, addr);
525: return r1;
526: }
527: strcpy (r1, cp);
528:
529: while ((pp = rindex (addr, '!')) != NULL) {
530: for (pp++, xp = addr; (wp = index (xp, '!')) != NULL;) {
531: *wp = NULL;
532: if (strcmp (pp, xp)) {
533: *wp++ = '!';
534: xp = wp;
535: }
536: else {
537: pp = xp;
538: break;
539: }
540: }
541: sprintf (r2, "%s!%s", pp, r1);
542: strcpy (r1, r2);
543: if (--pp > addr)
544: *pp = NULL;
545: }
546:
547: /* */
548:
549: if ((wp = index (r1, '!')) != NULL) {
550: *wp = NULL;
551: strcpy (r2, r1);
552: *wp = '!';
553: if (strcmp (addr, r2)) {
554: sprintf (r2, "%s!%s", addr, r1);
555: strcpy (r1, r2);
556: }
557: }
558:
559: return r1;
560: }
561:
562: /* */
563:
564: date_convert (from, to)
565: char from[],
566: *to;
567: {
568: static int zone = -1,
569: flags = TW_NULL;
570: char date[LINESIZ];
571: struct tws *tw;
572:
573: if (dparsetime (from)) /* might be OK as is */
574: strcpy (date, from);
575: else
576: if (isdigit (from[20])) {
577: if (zone == -1) {
578: if (tw = dtwstime ()) {
579: zone = tw -> tw_zone;
580: flags = tw -> tw_flags;
581: }
582: else
583: zone = 0, flags = TW_NULL;
584: }
585: sprintf (date, "%.3s, %.2s %.3s %.2s %.2s:%.2s:%.2s %s",
586: from + 0, from + 8, from + 4, from + 22, from + 11,
587: from + 14, from + 17, dtimezone (zone, flags));
588: }
589: else
590: sprintf (date, "%.3s, %.2s %.3s %.2s %.2s:%.2s:%.2s %s",
591: from + 0, from + 8, from + 4, from + 26, from + 11,
592: from + 14, from + 17, from + 20);
593:
594: strcpy (to, date);
595: }
596:
597: /* */
598:
599: static int uucp_die (error, in1, in2, out, nodelim)
600: int error,
601: nodelim;
602: FILE * in1, *in2, *out;
603: {
604: long clock;
605: char date[LINESIZ];
606:
607: if (nodelim) {
608: fclose (in1);
609: return error;
610: }
611:
612: switch (error) {
613: case MFHDR:
614: putc ('\n', out);
615: case MFTXT:
616: fprintf (out, "\n%s", mmdlm2);
617: break;
618: }
619:
620: time (&clock);
621: sprintf (date, "%.*s", sizeof date - 1, dtime (&clock));
622: fprintf (out, "%sFrom: %s <%s@%s>\nDate: %s\nSubject: %s %s\n\n",
623: mmdlm1, "UUCP to MMDF filter", getusr (), LocalName (), date,
624: "Bad UUCP mailbox - error in",
625: error == MFHDR ? "Header" : error == MFTXT ? "Body" : "Mailbox");
626:
627: fprintf (out, "%s: %s\n%s\n--------\n",
628: "Error detected at line", buffer, "Message being processed");
629: fseek (in1, 0L, 0);
630: while (fgets (buffer, sizeof buffer, in1) != NULL) {
631: if (isdlm2 (buffer))
632: buffer[0]++;
633: fputs (buffer, out);
634: }
635: fclose (in1);
636:
637: if (!feof (in2)) {
638: fprintf (out, "--------\n%s\n--------\n%s",
639: "Remainder of unfiltered mailbox follows", tmpbuf);
640: while (fgets (buffer, sizeof buffer, in2) != NULL) {
641: if (isdlm2 (buffer))
642: buffer[0]++;
643: fputs (buffer, out);
644: }
645: }
646:
647: fprintf (out, "--------\n%s", mmdlm2);
648: fflush (out);
649:
650: return error;
651: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.