![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to head.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ucb / Mail|
Return to head.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb / Mail |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)head.c 2.4 (Berkeley) 8/28/83";
3: #endif
4:
5: #include "rcv.h"
6:
7: /*
8: * Mail -- a mail program
9: *
10: * Routines for processing and detecting headlines.
11: */
12:
13: /*
14: * See if the passed line buffer is a mail header.
15: * Return true if yes. Note the extreme pains to
16: * accomodate all funny formats.
17: */
18:
19: ishead(linebuf)
20: char linebuf[];
21: {
22: register char *cp;
23: struct headline hl;
24: char parbuf[BUFSIZ];
25:
26: cp = linebuf;
27: if (strncmp("From ", cp, 5) != 0)
28: return(0);
29: parse(cp, &hl, parbuf);
30: if (hl.l_from == NOSTR || hl.l_date == NOSTR) {
31: fail(linebuf, "No from or date field");
32: return(0);
33: }
34: if (!isdate(hl.l_date)) {
35: fail(linebuf, "Date field not legal date");
36: return(0);
37: }
38:
39: /*
40: * I guess we got it!
41: */
42:
43: return(1);
44: }
45:
46: fail(linebuf, reason)
47: char linebuf[], reason[];
48: {
49:
50: if (1 /*value("debug") == NOSTR*/)
51: return;
52: fprintf(stderr, "\"%s\"\nnot a header because %s\n", linebuf, reason);
53: }
54:
55: /*
56: * Split a headline into its useful components.
57: * Copy the line into dynamic string space, then set
58: * pointers into the copied line in the passed headline
59: * structure. Actually, it scans.
60: */
61:
62: parse(line, hl, pbuf)
63: char line[], pbuf[];
64: struct headline *hl;
65: {
66: register char *cp, *dp;
67: char *sp;
68: char word[LINESIZE];
69:
70: hl->l_from = NOSTR;
71: hl->l_tty = NOSTR;
72: hl->l_date = NOSTR;
73: cp = line;
74: sp = pbuf;
75:
76: /*
77: * Skip the first "word" of the line, which should be "From"
78: * anyway.
79: */
80:
81: cp = nextword(cp, word);
82: dp = nextword(cp, word);
83: if (!equal(word, ""))
84: hl->l_from = copyin(word, &sp);
85: if (strncmp(dp, "tty", 3) == 0) {
86: cp = nextword(dp, word);
87: hl->l_tty = copyin(word, &sp);
88: if (cp != NOSTR)
89: hl->l_date = copyin(cp, &sp);
90: }
91: else
92: if (dp != NOSTR)
93: hl->l_date = copyin(dp, &sp);
94: }
95:
96: /*
97: * Copy the string on the left into the string on the right
98: * and bump the right (reference) string pointer by the length.
99: * Thus, dynamically allocate space in the right string, copying
100: * the left string into it.
101: */
102:
103: char *
104: copyin(src, space)
105: char src[];
106: char **space;
107: {
108: register char *cp, *top;
109: register int s;
110:
111: s = strlen(src);
112: cp = *space;
113: top = cp;
114: strcpy(cp, src);
115: cp += s + 1;
116: *space = cp;
117: return(top);
118: }
119:
120: /*
121: * Test to see if the passed string is a ctime(3) generated
122: * date string as documented in the manual. The template
123: * below is used as the criterion of correctness.
124: * Also, we check for a possible trailing time zone using
125: * the auxtype template.
126: */
127:
128: #define L 1 /* A lower case char */
129: #define S 2 /* A space */
130: #define D 3 /* A digit */
131: #define O 4 /* An optional digit or space */
132: #define C 5 /* A colon */
133: #define N 6 /* A new line */
134: #define U 7 /* An upper case char */
135:
136: 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};
137: 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};
138:
139: isdate(date)
140: char date[];
141: {
142: register char *cp;
143:
144: cp = date;
145: if (cmatch(cp, ctypes))
146: return(1);
147: return(cmatch(cp, tmztypes));
148: }
149:
150: /*
151: * Match the given string against the given template.
152: * Return 1 if they match, 0 if they don't
153: */
154:
155: cmatch(str, temp)
156: char str[], temp[];
157: {
158: register char *cp, *tp;
159: register int c;
160:
161: cp = str;
162: tp = temp;
163: while (*cp != '\0' && *tp != 0) {
164: c = *cp++;
165: switch (*tp++) {
166: case L:
167: if (c < 'a' || c > 'z')
168: return(0);
169: break;
170:
171: case U:
172: if (c < 'A' || c > 'Z')
173: return(0);
174: break;
175:
176: case S:
177: if (c != ' ')
178: return(0);
179: break;
180:
181: case D:
182: if (!isdigit(c))
183: return(0);
184: break;
185:
186: case O:
187: if (c != ' ' && !isdigit(c))
188: return(0);
189: break;
190:
191: case C:
192: if (c != ':')
193: return(0);
194: break;
195:
196: case N:
197: if (c != '\n')
198: return(0);
199: break;
200: }
201: }
202: if (*cp != '\0' || *tp != 0)
203: return(0);
204: return(1);
205: }
206:
207: /*
208: * Collect a liberal (space, tab delimited) word into the word buffer
209: * passed. Also, return a pointer to the next word following that,
210: * or NOSTR if none follow.
211: */
212:
213: char *
214: nextword(wp, wbuf)
215: char wp[], wbuf[];
216: {
217: register char *cp, *cp2;
218:
219: if ((cp = wp) == NOSTR) {
220: copy("", wbuf);
221: return(NOSTR);
222: }
223: cp2 = wbuf;
224: while (!any(*cp, " \t") && *cp != '\0')
225: if (*cp == '"') {
226: *cp2++ = *cp++;
227: while (*cp != '\0' && *cp != '"')
228: *cp2++ = *cp++;
229: if (*cp == '"')
230: *cp2++ = *cp++;
231: } else
232: *cp2++ = *cp++;
233: *cp2 = '\0';
234: while (any(*cp, " \t"))
235: cp++;
236: if (*cp == '\0')
237: return(NOSTR);
238: return(cp);
239: }
240:
241: /*
242: * Test to see if the character is an ascii alphabetic.
243: */
244:
245: isalpha(c)
246: {
247: register int ch;
248:
249: ch = raise(c);
250: return(ch >= 'A' && ch <= 'Z');
251: }
252:
253: /*
254: * Test to see if the character is an ascii digit.
255: */
256:
257: isdigit(c)
258: {
259: return(c >= '0' && c <= '9');
260: }
261:
262: /*
263: * Copy str1 to str2, return pointer to null in str2.
264: */
265:
266: char *
267: copy(str1, str2)
268: char *str1, *str2;
269: {
270: register char *s1, *s2;
271:
272: s1 = str1;
273: s2 = str2;
274: while (*s1)
275: *s2++ = *s1++;
276: *s2 = 0;
277: return(s2);
278: }
279:
280: /*
281: * Is ch any of the characters in str?
282: */
283:
284: any(ch, str)
285: char *str;
286: {
287: register char *f;
288: register c;
289:
290: f = str;
291: c = ch;
292: while (*f)
293: if (c == *f++)
294: return(1);
295: return(0);
296: }
297:
298: /*
299: * Convert lower case letters to upper case.
300: */
301:
302: raise(c)
303: register int c;
304: {
305: if (c >= 'a' && c <= 'z')
306: c += 'A' - 'a';
307: return(c);
308: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.