![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mmuu.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 / zotnet / mf|
Return to mmuu.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / mh / zotnet / mf |
1.1 root 1: /* mmuu.c - routines to filter MMDF to UUCP 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:
35: static char buffer[BUFSIZ],
36: tmpbuf[BUFSIZ];
37:
38: long time ();
39: char *ctime ();
40:
41: /* */
42:
43: /*
44: * mmdf2uucp() - given a file descriptor to a mmdf 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 mmdf2uucp (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 = mmuu (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: static int mmuu (in, out, nodelim)
87: FILE *in,
88: *out;
89: int nodelim;
90: {
91: int i,
92: tmp_fd;
93: FILE *tmp;
94:
95: for (tmp_fd = NOTOK;;) {
96: if ((i = mmdf_file (&tmp_fd, in, &tmp, nodelim)) == DONE)
97: break;
98: else
99: if (i != OK)
100: return i;
101: if ((i = mmdf_headers (tmp, out, nodelim)) != OK)
102: return mmdf_die (i, tmp, in, out, nodelim);
103: if ((i = mmdf_text (tmp, out, nodelim)) != OK)
104: return mmdf_die (i, tmp, in, out, nodelim);
105: }
106:
107: fflush (out);
108:
109: return (ferror (in) || ferror (out) ? MFERR : MFOK);
110: }
111:
112: /* */
113:
114: static int mmdf_file (tmp_fd, in, tmp, nodelim)
115: int *tmp_fd,
116: nodelim;
117: FILE * in, **tmp;
118: {
119: int done,
120: fd;
121: char tmpfil[LINESIZ];
122: FILE * out;
123:
124: if (nodelim)
125: if (*tmp_fd != NOTOK)
126: return DONE;
127: else
128: if ((*tmp_fd = dup (fileno (in))) == NOTOK)
129: return MFERR;
130: else
131: if ((*tmp = fdopen (*tmp_fd, "r")) == NULL) {
132: close (*tmp_fd);
133: return MFERR;
134: }
135: else
136: return OK;
137:
138: if (fgets (tmpbuf, sizeof tmpbuf, in) == NULL)
139: return DONE;
140: if (!isdlm1 (tmpbuf))
141: return MFDLM;
142:
143: strcpy (tmpfil, "/tmp/mmuuXXXXXX");
144: unlink (mktemp (tmpfil));
145: if ((fd = creat (tmpfil, TMPMODE)) == NOTOK)
146: return MFERR;
147: close (fd);
148:
149: if ((fd = open (tmpfil, 2)) == NOTOK)
150: return MFERR;
151: if ((out = fdopen (fd, "w")) == NULL) {
152: close (fd);
153: return MFERR;
154: }
155: unlink (tmpfil);
156:
157: if ((*tmp_fd = dup (fd)) == NOTOK) {
158: close (fd);
159: return MFERR;
160: }
161: if ((*tmp = fdopen (*tmp_fd, "r")) == NULL) {
162: close (fd);
163: close (*tmp_fd);
164: return MFERR;
165: }
166:
167: /* */
168:
169: for (done = FALSE;;) {
170: if (fgets (tmpbuf, sizeof tmpbuf, in) == NULL)
171: return MFDLM;
172: if (done && isdlm2 (tmpbuf))
173: break;
174: done = tmpbuf[strlen (tmpbuf) - 1] == '\n';
175: fputs (tmpbuf, out);
176: }
177:
178: fclose (out);
179: fseek (*tmp, 0L, 0);
180: return OK;
181: }
182:
183: /* */
184:
185: static int mmdf_headers (in, out, nodelim)
186: FILE * in, *out;
187: int nodelim;
188: {
189: int fd,
190: i,
191: tmp_fd;
192: char *cp,
193: line[BUFSIZ],
194: from[LINESIZ],
195: date[LINESIZ],
196: tmpfil[LINESIZ];
197: FILE * tmp;
198:
199: *from = *date = NULL;
200:
201: strcpy (tmpfil, "/tmp/mmuuXXXXXX");
202: unlink (mktemp (tmpfil));
203: if ((fd = creat (tmpfil, TMPMODE)) == NOTOK)
204: return MFERR;
205: close (fd);
206: if ((tmp_fd = open (tmpfil, 2)) == NOTOK)
207: return MFERR;
208: unlink (tmpfil);
209:
210: if ((fd = dup (tmp_fd)) == NOTOK) {
211: close (tmp_fd);
212: return MFERR;
213: }
214: if ((tmp = fdopen (fd, "w")) == NULL) {
215: close (tmp_fd);
216: close (fd);
217: return MFERR;
218: }
219:
220: for (;;) {
221: switch (do_header (from, date, in, tmp)) {
222: case NOTOK:
223: close (tmp_fd);
224: fclose (tmp);
225: return MFHDR;
226:
227: case OK:
228: continue;
229:
230: case DONE:
231: fclose (tmp);
232: break;
233: }
234: break;
235: }
236:
237: /* */
238:
239: if (*date == NULL || *from == NULL) {
240: if (*date)
241: strcpy (buffer, "No (valid) From: field found in message\n");
242: else
243: if (*from)
244: strcpy (buffer, "No (valid) Date: field found in message\n");
245: else
246: strcpy (buffer,
247: "No (valid) From: or Date: fields found in message\n");
248: if (nodelim) {
249: if (*date == NULL) {
250: long clock;
251:
252: time (&clock);
253: sprintf (date, "%.24s", ctime (&clock));
254: }
255: if (*from == NULL)
256: sprintf (from, "%s!%s", SystemName (), getusr ());
257: }
258: else
259: return MFHDR;
260: }
261: else
262: buffer[0] = NULL;
263:
264: if (nodelim && (cp = index (from, '!')) != NULL) {
265: *cp++ = NULL;
266: fprintf (out, "From %s %s remote from %s\n", cp, date, from);
267: }
268: else
269: fprintf (out, "From %s %s\n", from, date);
270:
271: fprintf (out, "Munged: from %s to %s; %s\n",
272: LocalName (), SystemName (), dtimenow ());
273: if (buffer[0])
274: fprintf (out, "Illegal-Field: %s", buffer);
275:
276: if ((tmp = fdopen (tmp_fd, "r")) == NULL) {
277: close (tmp_fd);
278: return MFERR;
279: }
280: fseek (tmp, 0L, 0);
281:
282: while ((i = fread (line, sizeof *line, sizeof line, tmp)) > 0)
283: fwrite (line, sizeof *line, i, out);
284: putc ('\n', out); /* separate headers from body */
285: fclose (tmp);
286:
287: return OK;
288: }
289:
290: /* */
291:
292: static int mmdf_text (in, out, nodelim)
293: int nodelim;
294: FILE * in, *out;
295: {
296: int i;
297:
298: if (feof (in)) /* probably no body */
299: putc ('\n', out);
300: else
301: while ((i = fread (buffer, sizeof *buffer, sizeof buffer, in)) > 0)
302: fwrite (buffer, sizeof *buffer, i, out);
303:
304: if (!nodelim)
305: putc ('\n', out);
306: fclose (in);
307:
308: return OK;
309: }
310:
311: /* */
312:
313: static int do_header (from, date, in, out)
314: char *from,
315: *date;
316: FILE * in, *out;
317: {
318: int i,
319: margin,
320: some,
321: spat,
322: pos;
323: char *bp,
324: *cp,
325: *pp,
326: line[BUFSIZ];
327: struct adrx *adrxp;
328: struct header *hl;
329:
330: if ((i = mfgets (in, &bp)) != OK)
331: return i;
332:
333: if ((cp = index (bp, ':')) == NULL) {
334: fprintf (out, "Illegal-Field: %s\n", bp);
335: return OK;
336: }
337:
338: *cp = NULL;
339: for (hl = &headers[0]; hl -> h_name; hl++)
340: if (lequal (hl -> h_name, bp))
341: break;
342:
343: /* */
344:
345: switch (hl -> h_type) {
346: case HOTHR:
347: *cp = ':';
348: fprintf (out, "%s\n", bp);
349: break;
350:
351: case HDATE:
352: pp = ++cp;
353: if (*date != NULL || !lequal (hl -> h_name, "Date"))
354: return OK;
355: date_convert (pp, date);
356: if (*date == NULL)
357: fprintf (out,
358: "Illegal-Object: %s: %s -- illegal date construct\n",
359: hl -> h_name, pp);
360: break;
361:
362: case HFROM:
363: pp = ++cp;
364: if (*from != NULL)
365: return OK;
366: if ((adrxp = getadrx (pp)) == NULL) {
367: fprintf (out, "Illegal-Object: %s: %s -- %s\n",
368: hl -> h_name, pp, "no address");
369: return OK; /* catch errors later (possibly) */
370: }
371: addr_convert (adrxp, from, TRUE);
372: if (*from == NULL)
373: fprintf (out, "Illegal-Object: %s: %s -- %s\n",
374: hl -> h_name, adrxp -> text, adrxp -> err);
375: while (getadrx (NULL))
376: continue;
377: break;
378:
379: case HADDR:
380: case HSNDR:
381: spat = 0;
382: some = FALSE;
383: pp = ++cp;
384: margin = pos = strlen (hl -> h_name) + 2;
385: while (adrxp = getadrx (pp)) {
386: addr_convert (adrxp, line, FALSE);
387: if (line[0] != NULL) {
388: if (!spat++)
389: fprintf (out, "%s: ", hl -> h_name);
390: if (some++)
391: fputs (", ", out), pos += 2;
392: if (pos + strlen (line) >= OWIDTH) {
393: fprintf (out, "\n%*s", margin, " ");
394: pos = margin;
395: }
396: fputs (line, out);
397: pos += strlen (line);
398: }
399: else {
400: if (spat)
401: putc ('\n', out);
402: fprintf (out, "Illegal-Object: %s: %s -- %s\n",
403: hl -> h_name, adrxp -> text, adrxp -> err);
404: spat = 0;
405: some = FALSE;
406: pos = margin;
407: }
408: }
409: if (spat)
410: putc ('\n', out);
411: break;
412:
413: default:
414: return NOTOK;
415: }
416:
417: return OK;
418: }
419:
420: /* */
421:
422: static addr_convert (adrxp, to, notice)
423: struct adrx *adrxp;
424: char *to;
425: int notice;
426: {
427: int mboxlen,
428: uucplen;
429: char *cp,
430: tmp[LINESIZ],
431: uucp[LINESIZ];
432: static char path[LINESIZ] = "";
433:
434: if (path[0] == NULL)
435: strcpy (path, LocalName ());
436:
437: if (adrxp -> err || !adrxp -> mbox) {
438: *to = NULL;
439: return;
440: }
441: if (notice)
442: strcpy (path, adrxp -> host ? adrxp -> host : LocalName ());
443:
444: if (adrxp -> host == NULL)
445: if (index (adrxp -> mbox, '!') != NULL)
446: strcpy (tmp, adrxp -> mbox);
447: else
448: if (lequal (path, LocalName ()))
449: sprintf (tmp, "%s!%s", SystemName (), adrxp -> mbox);
450: else
451: sprintf (tmp, "%s!%s@%s", SystemName (), adrxp -> mbox, path);
452: else
453: if (index (adrxp -> mbox, '!') == NULL)
454: sprintf (tmp, "%s!%s@%s",
455: SystemName (), adrxp -> mbox, adrxp -> host);
456: else {
457: sprintf (uucp, "%%%s", UucpChan ());
458: uucplen = strlen (uucp);
459: cp = (lequal (LocalName (), adrxp -> host)
460: && (mboxlen = strlen (adrxp -> mbox) - uucplen) > 0)
461: ? (adrxp -> mbox) + mboxlen : NULL;
462: if (lequal (uucp, cp))
463: sprintf (tmp, "%.*s", mboxlen, adrxp -> mbox);
464: else
465: if ((cp = index (adrxp -> host, '.'))
466: && lequal (UucpChan (), cp + 1))
467: sprintf (tmp, "%.*s!%s",
468: cp - adrxp -> host, adrxp -> host, adrxp -> mbox);
469: else
470: if (lequal (adrxp -> host, UucpChan ()))
471: strcpy (tmp, adrxp -> mbox);
472: else {
473: sprintf (uucp, "%s!", SystemName ());
474: uucplen = strlen (uucp);
475: if (strncmp (uucp, adrxp -> mbox, uucplen))
476: sprintf (tmp, "%s!%s@%s",
477: SystemName (), adrxp -> mbox, adrxp -> host);
478: else
479: sprintf (tmp, "%s@%s", adrxp -> mbox, adrxp -> host);
480: }
481: }
482:
483: strcpy (to, tmp);
484: }
485:
486: /* */
487:
488: static date_convert (from, to)
489: char *from,
490: *to;
491: {
492: char *cp;
493:
494: if ((cp = dctime (dparsetime (from))) != NULL)
495: sprintf (to, "%.24s", cp);
496: else
497: *to = NULL;
498: }
499:
500: /* */
501:
502: static int mmdf_die (error, in1, in2, out, nodelim)
503: int error,
504: nodelim;
505: FILE * in1, *in2, *out;
506: {
507: int i;
508: long clock;
509: char date[LINESIZ];
510:
511: if (nodelim) {
512: fclose (in1);
513: return error;
514: }
515:
516: switch (error) {
517: case MFTXT:
518: putc ('\n', out);
519: break;
520: }
521:
522: time (&clock);
523: sprintf (date, "%.24s", ctime (&clock));
524: fprintf (out, "From %s %s\nSubject: %s %s\n\n",
525: getusr (), date, "Bad MMDF mailbox - error in",
526: error == MFHDR ? "Header" : error == MFTXT ? "Body" : "Mailbox");
527:
528: fprintf (out, "%s: %s\n%s\n--------\n",
529: "Error detected at line", buffer, "Message being processed");
530: fseek (in1, 0L, 0);
531: while ((i = fread (buffer, sizeof *buffer, sizeof buffer, in1)) > 0)
532: fwrite (buffer, sizeof *buffer, i, out);
533: fclose (in1);
534:
535: if (!feof (in2)) {
536: fprintf (out, "--------\n%s\n--------\n%s",
537: "Remainder of unfiltered mailbox follows", tmpbuf);
538: while ((i = fread (buffer, sizeof *buffer, sizeof buffer, in2)) > 0)
539: fwrite (buffer, sizeof *buffer, i, out);
540: }
541:
542: fprintf (out, "--------\n\n");
543: fflush (out);
544:
545: return error;
546: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.