![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to unixtomh.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / sendbug|
Return to unixtomh.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / sendbug |
1.1 root 1: #ifndef lint
2: static char SccsId[] = "@(#)unixtomh.c 1.1 5/16/85";
3: #endif
4:
5: /*
6: * This program copies the mail file in standard unix format
7: * given as $1 to the file $2 in Rand Message Handler format.
8: * The change made is to bracket each message with a line
9: * containing 4 control-A's and to split the From line into
10: * a From: field and a Date: field, with the date in Arpanet
11: * standard format.
12: *
13: * This program is designed to be called from the rand mh program
14: * ``inc''
15: *
16: * Set SENDMAIL if you are running sendmail -- this guarantees that
17: * From: and Date: lines will appear already, and will put the info
18: * in the UNIX-From line into a Received-From: field.
19: */
20:
21: #include <stdio.h>
22: #include <sys/types.h>
23: #include <sys/timeb.h>
24: #include <ctype.h>
25:
26: #define SENDMAIL
27:
28: struct headline {
29: char *l_from; /* The name of the sender */
30: char *l_tty; /* His tty string (if any) */
31: char *l_date; /* The entire date string */
32: };
33:
34: char *savestr(), *copyin(), *copy(), *nextword(), *calloc();
35: char *index();
36:
37: #define NOSTR ((char *) 0)
38: #define UUCP /* Undo strange uucp naming */
39:
40: main(argc, argv)
41: char **argv;
42: {
43: char linebuf[BUFSIZ];
44: register int maybe;
45: register FILE *inf, *outf;
46: int inhdr, infld;
47:
48: if (argc > 3) {
49: fprintf(stderr, "Usage: unixtomh name1 name2\n");
50: exit(1);
51: }
52: outf = inf = NULL;
53: if (argc < 3)
54: outf = stdout;
55: if (argc < 2)
56: inf = stdin;
57: if (inf == NULL && (inf = fopen(argv[1], "r")) == NULL) {
58: perror(argv[1]);
59: exit(1);
60: }
61: if (outf == NULL && (outf = fopen(argv[2], "w")) == NULL) {
62: perror(argv[2]);
63: exit(1);
64: }
65: maybe = 1;
66: inhdr = 0;
67: infld = 0;
68: while (nullgets(linebuf, BUFSIZ, inf) > 0) {
69: if (maybe && ishead(linebuf)) {
70: fputs("\1\1\1\1\n", outf);
71: inhdr++;
72: dohead(linebuf, inf, outf);
73: continue;
74: }
75: if (strlen(linebuf) == 0) {
76: maybe = 1;
77: inhdr = 0;
78: infld = 0;
79: putc('\n', outf);
80: continue;
81: }
82: else
83: maybe = 0;
84: #ifndef SENDMAIL
85: if (inhdr && strcmpn(linebuf, "Date: ", 6) == 0)
86: continue;
87: if (inhdr && strcmpn(linebuf, "From: ", 6) == 0)
88: continue;
89: #endif SENDMAIL
90: if (infld && isspace(linebuf[0])) {
91: fputs(linebuf, outf);
92: putc('\n', outf);
93: continue;
94: }
95: if (inhdr && !isspace(linebuf[0])) {
96: char *colp, *sp;
97:
98: colp = index(linebuf, ':');
99: sp = index(linebuf, ' ');
100: if (colp == NOSTR || sp == NOSTR || sp < colp) {
101: putc('\n', outf);
102: inhdr = 0;
103: }
104: else
105: infld = 1;
106: }
107: fputs(linebuf, outf);
108: putc('\n', outf);
109: }
110: fputs("\1\1\1\1\n", outf);
111: fflush(outf);
112: if (ferror(outf)) {
113: fprintf(stderr, "unixtomh: write: ");
114: perror(argv[2]);
115: exit(1);
116: }
117: exit(0);
118: }
119:
120: /*
121: * Get a line from the given file descriptor, don't return the
122: * terminating newline.
123: */
124:
125: nullgets(linebuf, sz, file)
126: char linebuf[];
127: register FILE *file;
128: {
129: register char *cp;
130: register int c, cnt;
131:
132: cp = linebuf;
133: cnt = sz;
134: do {
135: if (--cnt <= 0) {
136: *cp = 0;
137: return(1);
138: }
139: c = getc(file);
140: *cp++ = c;
141: } while (c != EOF && c != '\n');
142: if (c == EOF && cp == linebuf+1)
143: return(0);
144: *--cp = 0;
145: return(1);
146: }
147:
148: /*
149: * Output the fields extracted from the From line --
150: * From: and Date: Untangle UUCP stuff if appropriate.
151: */
152:
153: dohead(line, infile, outfile)
154: char line[];
155: register FILE *infile, *outfile;
156: {
157: register char *cp;
158: struct headline hl;
159: char parbuf[BUFSIZ];
160: #ifdef UUCP
161: char *word();
162: char namebuf[BUFSIZ];
163: char linebuf[BUFSIZ];
164: int first;
165: long curoff;
166: #endif UUCP
167:
168: parse(line, &hl, parbuf);
169: #ifndef SENDMAIL
170: putdate(hl.l_date, outfile);
171: #endif SENDMAIL
172: #ifdef UUCP
173: if (strcmp(hl.l_from, "uucp") == 0) {
174: strcpy(namebuf, "");
175: first = 1;
176: for (;;) {
177: curoff = ftell(infile);
178: if (fgets(linebuf, BUFSIZ, infile) == NULL)
179: break;
180: if (strcmp(word(1, linebuf), ">From") != 0)
181: break;
182: if (strcmp(word(-3, linebuf), "remote") != 0)
183: break;
184: if (strcmp(word(-2, linebuf), "from") != 0)
185: break;
186: if (first) {
187: strcpy(namebuf, word(-1, linebuf));
188: strcat(namebuf, "!");
189: strcat(namebuf, word(2, linebuf));
190: first = 0;
191: }
192: else {
193: strcpy(rindex(namebuf, '!')+1,
194: word(-1, linebuf));
195: strcat(namebuf, "!");
196: strcat(namebuf, word(2, linebuf));
197: }
198: }
199: fseek(infile, curoff, 0);
200: #ifdef SENDMAIL
201: if (!first)
202: fprintf(outfile, "Return-Path: <%s>\n", namebuf);
203: #else SENDMAIL
204: if (first)
205: fprintf(outfile, "From: uucp\n");
206: else
207: fprintf(outfile, "From: %s\n", namebuf);
208: #endif SENDMAIL
209: return;
210: }
211: #endif UUCP
212: #ifdef SENDMAIL
213: if (hl.l_from[0] == '<')
214: fprintf(outfile, "Return-Path: %s\n", hl.l_from);
215: else
216: fprintf(outfile, "Return-Path: <%s>\n", hl.l_from);
217: #else SENDMAIL
218: fprintf(outfile, "From: %s\n", hl.l_from);
219: #endif SENDMAIL
220: }
221:
222: #ifdef UUCP
223:
224: /*
225: * Return liberal word i from the given string.
226: * The words are numbered 1, 2, 3, . . . from the left
227: * and -1, -2, . . . from the right.
228: */
229:
230: char *
231: word(index, str)
232: char str[];
233: {
234: register char *cp;
235: char *secbuf;
236: register int c;
237: static char retbuf[100];
238: char *gword();
239:
240: cp = str;
241: if ((c = index) > 0) {
242: while (c-- > 0)
243: cp = gword(cp, retbuf);
244: return(retbuf);
245: }
246: if (c == 0)
247: return("");
248: secbuf = (char *) alloca(strlen(str) + 1);
249: strcpy(secbuf, str);
250: rev(secbuf);
251: cp = word(-index, secbuf);
252: rev(cp);
253: return(cp);
254: }
255:
256: /*
257: * Skip leading blanks in the string, return
258: * first liberal word collected.
259: */
260:
261: char *
262: gword(cp, buf)
263: register char *cp;
264: char buf[];
265: {
266: register char *cp2;
267:
268: cp2 = buf;
269: while (*cp && any(*cp, " \t\n"))
270: cp++;
271: while (*cp && !any(*cp, " \t\n"))
272: *cp2++ = *cp++;
273: *cp2 = 0;
274: return(cp);
275: }
276:
277: /*
278: * Reverse the characters in the string in place
279: */
280:
281: rev(str)
282: char str[];
283: {
284: register char *cpl, *cpr;
285: register int s;
286:
287: s = strlen(str);
288: cpl = str;
289: cpr = &str[s-1];
290: while (cpl < cpr) {
291: s = *cpl;
292: *cpl++ = *cpr;
293: *cpr-- = s;
294: }
295: }
296: #endif UUCP
297:
298: /*
299: * Save a string in dynamic space.
300: * This little goodie is needed for
301: * a headline detector in head.c
302: */
303:
304: char *
305: savestr(str)
306: char str[];
307: {
308: register char *top;
309:
310: top = calloc(strlen(str) + 1, 1);
311: if (top == NOSTR) {
312: fprintf(stderr, "unixtomh: Ran out of memory\n");
313: exit(1);
314: }
315: copy(str, top);
316: return(top);
317: }
318:
319: /*
320: * See if the passed line buffer is a mail header.
321: * Return true if yes. Note the extreme pains to
322: * accomodate all funny formats.
323: */
324:
325: ishead(linebuf)
326: char linebuf[];
327: {
328: register char *cp;
329: struct headline hl;
330: char parbuf[BUFSIZ];
331:
332: cp = linebuf;
333: if (!isname("From ", cp, 5))
334: return(0);
335: parse(cp, &hl, parbuf);
336: if (hl.l_from == NOSTR || hl.l_date == NOSTR) {
337: fail(linebuf, "No from or date field");
338: return(0);
339: }
340: if (!isdate(hl.l_date)) {
341: fail(linebuf, "Date field not legal date");
342: return(0);
343: }
344:
345: /*
346: * I guess we got it!
347: */
348:
349: return(1);
350: }
351:
352: fail(linebuf, reason)
353: char linebuf[], reason[];
354: {
355: return;
356: }
357:
358: /*
359: * Split a headline into its useful components.
360: * Copy the line into dynamic string space, then set
361: * pointers into the copied line in the passed headline
362: * structure. Actually, it scans.
363: */
364:
365: parse(line, hl, pbuf)
366: char line[], pbuf[];
367: struct headline *hl;
368: {
369: register char *cp, *dp;
370: char *sp;
371: char word[BUFSIZ];
372:
373: hl->l_from = NOSTR;
374: hl->l_tty = NOSTR;
375: hl->l_date = NOSTR;
376: cp = line;
377: sp = pbuf;
378:
379: /*
380: * Skip the first "word" of the line, which should be "From"
381: * anyway.
382: */
383:
384: cp = nextword(cp, word);
385: dp = nextword(cp, word);
386: if (word[0] != 0)
387: hl->l_from = copyin(word, &sp);
388: if (isname(dp, "tty", 3)) {
389: cp = nextword(dp, word);
390: hl->l_tty = copyin(word, &sp);
391: if (cp != NOSTR)
392: hl->l_date = copyin(cp, &sp);
393: }
394: else
395: if (dp != NOSTR)
396: hl->l_date = copyin(dp, &sp);
397: }
398:
399: /*
400: * Copy the string on the left into the string on the right
401: * and bump the right (reference) string pointer by the length.
402: * Thus, dynamically allocate space in the right string, copying
403: * the left string into it.
404: */
405:
406: char *
407: copyin(src, space)
408: char src[];
409: char **space;
410: {
411: register char *cp, *top;
412: register int s;
413:
414: s = strlen(src);
415: cp = *space;
416: top = cp;
417: strcpy(cp, src);
418: cp += s + 1;
419: *space = cp;
420: return(top);
421: }
422:
423: /*
424: * See if the two passed strings agree in the first n characters.
425: * Return true if they do, gnu.
426: */
427:
428: isname(as1, as2, acount)
429: char *as1, *as2;
430: {
431: register char *s1, *s2;
432: register count;
433:
434: s1 = as1;
435: s2 = as2;
436: count = acount;
437: if (count > 0)
438: do
439: if (*s1++ != *s2++)
440: return(0);
441: while (--count);
442: return(1);
443: }
444:
445: /*
446: * Test to see if the passed string is a ctime(3) generated
447: * date string as documented in the manual. The template
448: * below is used as the criterion of correctness.
449: * Also, we check for a possible trailing time zone using
450: * the auxtype template.
451: */
452:
453: #define L 1 /* A lower case char */
454: #define S 2 /* A space */
455: #define D 3 /* A digit */
456: #define O 4 /* An optional digit or space */
457: #define C 5 /* A colon */
458: #define N 6 /* A new line */
459: #define U 7 /* An upper case char */
460:
461: char ctypes[] = {U,L,L,S,U,L,L,S,O,D,S,D,D,C,D,D,C,D,D,S,D,D,D,D,0};
462: char tmztypes[] = {U,L,L,S,U,L,L,S,O,D,S,D,D,C,D,D,C,D,D,S,U,U,U,S,D,D,D,D,0};
463:
464: isdate(date)
465: char date[];
466: {
467: register char *cp;
468:
469: cp = date;
470: if (cmatch(cp, ctypes))
471: return(1);
472: return(cmatch(cp, tmztypes));
473: }
474:
475: /*
476: * Match the given string against the given template.
477: * Return 1 if they match, 0 if they don't
478: */
479:
480: cmatch(str, temp)
481: char str[], temp[];
482: {
483: register char *cp, *tp;
484: register int c;
485:
486: cp = str;
487: tp = temp;
488: while (*cp != '\0' && *tp != 0) {
489: c = *cp++;
490: switch (*tp++) {
491: case L:
492: if (!islower(c))
493: return(0);
494: break;
495:
496: case S:
497: if (c != ' ')
498: return(0);
499: break;
500:
501: case D:
502: if (!isdigit(c))
503: return(0);
504: break;
505:
506: case O:
507: if (c != ' ' && !isdigit(c))
508: return(0);
509: break;
510:
511: case C:
512: if (c != ':')
513: return(0);
514: break;
515:
516: case N:
517: if (c != '\n')
518: return(0);
519: break;
520:
521: case U:
522: if (!isupper(c))
523: return(0);
524: break;
525: }
526: }
527: if (*cp != '\0' || *tp != 0)
528: return(0);
529: return(1);
530: }
531:
532: /*
533: * Collect a liberal (space, tab delimited) word into the word buffer
534: * passed. Also, return a pointer to the next word following that,
535: * or NOSTR if none follow.
536: */
537:
538: char *
539: nextword(wp, wbuf)
540: char wp[], wbuf[];
541: {
542: register char *cp, *cp2;
543:
544: if ((cp = wp) == NOSTR) {
545: copy("", wbuf);
546: return(NOSTR);
547: }
548: cp2 = wbuf;
549: while (!any(*cp, " \t") && *cp != '\0')
550: if (*cp == '"') {
551: *cp2++ = *cp++;
552: while (*cp != '\0' && *cp != '"')
553: *cp2++ = *cp++;
554: if (*cp == '"')
555: *cp2++ = *cp++;
556: } else
557: *cp2++ = *cp++;
558: *cp2 = '\0';
559: while (any(*cp, " \t"))
560: cp++;
561: if (*cp == '\0')
562: return(NOSTR);
563: return(cp);
564: }
565:
566: /*
567: * Copy str1 to str2, return pointer to null in str2.
568: */
569:
570: char *
571: copy(str1, str2)
572: char *str1, *str2;
573: {
574: register char *s1, *s2;
575:
576: s1 = str1;
577: s2 = str2;
578: while (*s1)
579: *s2++ = *s1++;
580: *s2 = 0;
581: return(s2);
582: }
583:
584: /*
585: * Is ch any of the characters in str?
586: */
587:
588: any(ch, str)
589: char *str;
590: {
591: register char *f;
592: register c;
593:
594: f = str;
595: c = ch;
596: while (*f)
597: if (c == *f++)
598: return(1);
599: return(0);
600: }
601:
602: /*
603: * Convert lower case letters to upper case.
604: */
605:
606: raise(c)
607: register int c;
608: {
609: if (c >= 'a' && c <= 'z')
610: c += 'A' - 'a';
611: return(c);
612: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.