![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to aux.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / Mail|
Return to aux.c CVS log | Up to [Research Unix] / researchv8dc / cmd / Mail |
1.1 root 1: #ifndef lint
2: static char *sccsid = "@(#)aux.c 2.11 (Berkeley) 8/11/83";
3: #endif
4:
5: #include "rcv.h"
6: #include <sys/stat.h>
7: #include <ctype.h>
8:
9: /*
10: * Mail -- a mail program
11: *
12: * Auxiliary functions.
13: */
14:
15: /*
16: * Return a pointer to a dynamic copy of the argument.
17: */
18:
19: char *
20: savestr(str)
21: char *str;
22: {
23: register char *cp, *cp2, *top;
24:
25: for (cp = str; *cp; cp++)
26: ;
27: top = salloc(cp-str + 1);
28: if (top == NOSTR)
29: return(NOSTR);
30: for (cp = str, cp2 = top; *cp; cp++)
31: *cp2++ = *cp;
32: *cp2 = 0;
33: return(top);
34: }
35:
36: /*
37: * Copy the name from the passed header line into the passed
38: * name buffer. Null pad the name buffer.
39: */
40:
41: copyname(linebuf, nbuf)
42: char *linebuf, *nbuf;
43: {
44: register char *cp, *cp2;
45:
46: for (cp = linebuf + 5, cp2 = nbuf; *cp != ' ' && cp2-nbuf < 8; cp++)
47: *cp2++ = *cp;
48: while (cp2-nbuf < 8)
49: *cp2++ = 0;
50: }
51:
52: /*
53: * Announce a fatal error and die.
54: */
55:
56: panic(str)
57: char *str;
58: {
59: prs("panic: ");
60: prs(str);
61: prs("\n");
62: exit(1);
63: }
64:
65: /*
66: * Catch stdio errors and report them more nicely.
67: */
68:
69: _error(str)
70: char *str;
71: {
72: prs("Stdio Error: ");
73: prs(str);
74: prs("\n");
75: abort();
76: }
77:
78: /*
79: * Print a string on diagnostic output.
80: */
81:
82: prs(str)
83: char *str;
84: {
85: register char *s;
86:
87: for (s = str; *s; s++)
88: ;
89: write(2, str, s-str);
90: }
91:
92: /*
93: * Touch the named message by setting its MTOUCH flag.
94: * Touched messages have the effect of not being sent
95: * back to the system mailbox on exit.
96: */
97:
98: touch(mesg)
99: {
100: register struct message *mp;
101:
102: if (mesg < 1 || mesg > msgCount)
103: return;
104: mp = &message[mesg-1];
105: mp->m_flag |= MTOUCH;
106: if ((mp->m_flag & MREAD) == 0)
107: mp->m_flag |= MREAD|MSTATUS;
108: }
109:
110: /*
111: * Test to see if the passed file name is a directory.
112: * Return true if it is.
113: */
114:
115: isdir(name)
116: char name[];
117: {
118: struct stat sbuf;
119:
120: if (stat(name, &sbuf) < 0)
121: return(0);
122: return((sbuf.st_mode & S_IFMT) == S_IFDIR);
123: }
124:
125: /*
126: * Count the number of arguments in the given string raw list.
127: */
128:
129: argcount(argv)
130: char **argv;
131: {
132: register char **ap;
133:
134: for (ap = argv; *ap != NOSTR; ap++)
135: ;
136: return(ap-argv);
137: }
138:
139: /*
140: * Given a file address, determine the
141: * block number it represents.
142: */
143:
144: blockof(off)
145: off_t off;
146: {
147: off_t a;
148:
149: a = off >> 9;
150: a &= 077777;
151: return((int) a);
152: }
153:
154: /*
155: * Take a file address, and determine
156: * its offset in the current block.
157: */
158:
159: offsetof(off)
160: off_t off;
161: {
162: off_t a;
163:
164: a = off & 0777;
165: return((int) a);
166: }
167:
168: /*
169: * Determine if the passed file is actually a tty, via a call to
170: * gtty. This is not totally reliable, but . . .
171: */
172:
173: isatty(f)
174: {
175: struct sgttyb buf;
176:
177: if (gtty(f, &buf) < 0)
178: return(0);
179: return(1);
180: }
181:
182: /*
183: * Return the desired header line from the passed message
184: * pointer (or NOSTR if the desired header field is not available).
185: */
186:
187: char *
188: hfield(field, mp)
189: char field[];
190: struct message *mp;
191: {
192: register FILE *ibuf;
193: char linebuf[LINESIZE];
194: register int lc;
195:
196: ibuf = setinput(mp);
197: if ((lc = mp->m_lines) <= 0)
198: return(NOSTR);
199: if (readline(ibuf, linebuf) < 0)
200: return(NOSTR);
201: lc--;
202: do {
203: lc = gethfield(ibuf, linebuf, lc);
204: if (lc == -1)
205: return(NOSTR);
206: #ifdef defined(USGFROM)
207: /*
208: * The check against 'FROM:' is an icky kludge to prevent
209: * Mail from accepting the USG 'FROM:' field, their answer
210: * to everyone else's 'Full-name:' field, as a valid From
211: * line. Otherwise, Mail would try to respond to some
212: * truly fascinating, but unfortunately invalid, addresses!
213: */
214: if (ishfield(linebuf, field) && strncmp(linebuf, "FROM:", 5))
215: #else !defined(USGFROM)
216: if (ishfield(linebuf, field))
217: #endif defined(USGFROM)
218: return(savestr(hcontents(linebuf)));
219: } while (lc > 0);
220: return(NOSTR);
221: }
222:
223: /*
224: * Return the next header field found in the given message.
225: * Return > 0 if something found, <= 0 elsewise.
226: * Must deal with \ continuations & other such fraud.
227: */
228:
229: gethfield(f, linebuf, rem)
230: register FILE *f;
231: char linebuf[];
232: register int rem;
233: {
234: char line2[LINESIZE];
235: long loc;
236: register char *cp, *cp2;
237: register int c;
238:
239:
240: for (;;) {
241: if (rem <= 0)
242: return(-1);
243: if (readline(f, linebuf) < 0)
244: return(-1);
245: rem--;
246: if (strlen(linebuf) == 0)
247: return(-1);
248: if (isspace(linebuf[0]))
249: continue;
250: if (linebuf[0] == '>')
251: continue;
252: cp = index(linebuf, ':');
253: if (cp == NOSTR)
254: continue;
255: for (cp2 = linebuf; cp2 < cp; cp2++)
256: if (isdigit(*cp2))
257: continue;
258:
259: /*
260: * I guess we got a headline.
261: * Handle wraparounding
262: */
263:
264: for (;;) {
265: if (rem <= 0)
266: break;
267: #ifdef CANTELL
268: loc = ftell(f);
269: if (readline(f, line2) < 0)
270: break;
271: rem--;
272: if (!isspace(line2[0])) {
273: fseek(f, loc, 0);
274: rem++;
275: break;
276: }
277: #else
278: c = getc(f);
279: ungetc(c, f);
280: if (!isspace(c) || c == '\n')
281: break;
282: if (readline(f, line2) < 0)
283: break;
284: rem--;
285: #endif
286: cp2 = line2;
287: for (cp2 = line2; *cp2 != 0 && isspace(*cp2); cp2++)
288: ;
289: if (strlen(linebuf) + strlen(cp2) >= LINESIZE-2)
290: break;
291: cp = &linebuf[strlen(linebuf)];
292: while (cp > linebuf &&
293: (isspace(cp[-1]) || cp[-1] == '\\'))
294: cp--;
295: *cp++ = ' ';
296: for (cp2 = line2; *cp2 != 0 && isspace(*cp2); cp2++)
297: ;
298: strcpy(cp, cp2);
299: }
300: if ((c = strlen(linebuf)) > 0) {
301: cp = &linebuf[c-1];
302: while (cp > linebuf && isspace(*cp))
303: cp--;
304: *++cp = 0;
305: }
306: return(rem);
307: }
308: /* NOTREACHED */
309: }
310:
311: /*
312: * Check whether the passed line is a header line of
313: * the desired breed.
314: */
315:
316: ishfield(linebuf, field)
317: char linebuf[], field[];
318: {
319: register char *cp;
320: register int c;
321:
322: if ((cp = index(linebuf, ':')) == NOSTR)
323: return(0);
324: if (cp == linebuf)
325: return(0);
326: cp--;
327: while (cp > linebuf && isspace(*cp))
328: cp--;
329: c = *++cp;
330: *cp = 0;
331: if (icequal(linebuf ,field)) {
332: *cp = c;
333: return(1);
334: }
335: *cp = c;
336: return(0);
337: }
338:
339: /*
340: * Extract the non label information from the given header field
341: * and return it.
342: */
343:
344: char *
345: hcontents(hfield)
346: char hfield[];
347: {
348: register char *cp;
349:
350: if ((cp = index(hfield, ':')) == NOSTR)
351: return(NOSTR);
352: cp++;
353: while (*cp && isspace(*cp))
354: cp++;
355: return(cp);
356: }
357:
358: /*
359: * Compare two strings, ignoring case.
360: */
361:
362: icequal(s1, s2)
363: register char *s1, *s2;
364: {
365:
366: while (raise(*s1++) == raise(*s2))
367: if (*s2++ == 0)
368: return(1);
369: return(0);
370: }
371:
372: /*
373: * Copy a string, lowercasing it as we go.
374: */
375: istrcpy(dest, src)
376: char *dest, *src;
377: {
378: register char *cp, *cp2;
379:
380: cp2 = dest;
381: cp = src;
382: do {
383: *cp2++ = little(*cp);
384: } while (*cp++ != 0);
385: }
386:
387: /*
388: * The following code deals with input stacking to do source
389: * commands. All but the current file pointer are saved on
390: * the stack.
391: */
392:
393: static int ssp = -1; /* Top of file stack */
394: struct sstack {
395: FILE *s_file; /* File we were in. */
396: int s_cond; /* Saved state of conditionals */
397: int s_loading; /* Loading .mailrc, etc. */
398: } sstack[_NFILE];
399:
400: /*
401: * Pushdown current input file and switch to a new one.
402: * Set the global flag "sourcing" so that others will realize
403: * that they are no longer reading from a tty (in all probability).
404: */
405:
406: source(name)
407: char name[];
408: {
409: register FILE *fi;
410: register char *cp;
411:
412: if ((cp = expand(name)) == NOSTR)
413: return(1);
414: if ((fi = fopen(cp, "r")) == NULL) {
415: perror(cp);
416: return(1);
417: }
418: if (ssp >= _NFILE-2) {
419: printf("Too much \"sourcing\" going on.\n");
420: fclose(fi);
421: return(1);
422: }
423: sstack[++ssp].s_file = input;
424: sstack[ssp].s_cond = cond;
425: sstack[ssp].s_loading = loading;
426: loading = 0;
427: cond = CANY;
428: input = fi;
429: sourcing++;
430: return(0);
431: }
432:
433: /*
434: * Source a file, but do nothing if the file cannot be opened.
435: */
436:
437: source1(name)
438: char name[];
439: {
440: register int f;
441:
442: if ((f = open(name, 0)) < 0)
443: return(0);
444: close(f);
445: source(name);
446: }
447:
448: /*
449: * Pop the current input back to the previous level.
450: * Update the "sourcing" flag as appropriate.
451: */
452:
453: unstack()
454: {
455: if (ssp < 0) {
456: printf("\"Source\" stack over-pop.\n");
457: sourcing = 0;
458: return(1);
459: }
460: fclose(input);
461: if (cond != CANY)
462: printf("Unmatched \"if\"\n");
463: cond = sstack[ssp].s_cond;
464: loading = sstack[ssp].s_loading;
465: input = sstack[ssp--].s_file;
466: if (ssp < 0)
467: sourcing = loading;
468: return(0);
469: }
470:
471: /*
472: * Touch the indicated file.
473: * This is nifty for the shell.
474: * If we have the utime() system call, this is better served
475: * by using that, since it will work for empty files.
476: * On non-utime systems, we must sleep a second, then read.
477: */
478:
479: alter(name)
480: char name[];
481: {
482: #ifdef UTIME
483: struct stat statb;
484: long time();
485: time_t time_p[2];
486: #else
487: register int pid, f;
488: char w;
489: #endif UTIME
490:
491: #ifdef UTIME
492: if (stat(name, &statb) < 0)
493: return;
494: time_p[0] = time((long *) 0) + 1;
495: time_p[1] = statb.st_mtime;
496: utime(name, time_p);
497: #else
498: sleep(1);
499: if ((f = open(name, 0)) < 0)
500: return;
501: read(f, &w, 1);
502: exit(0);
503: #endif
504: }
505:
506: /*
507: * Examine the passed line buffer and
508: * return true if it is all blanks and tabs.
509: */
510:
511: blankline(linebuf)
512: char linebuf[];
513: {
514: register char *cp;
515:
516: for (cp = linebuf; *cp; cp++)
517: if (!any(*cp, " \t"))
518: return(0);
519: return(1);
520: }
521:
522: /*
523: * Get sender's name from this message. If the message has
524: * a bunch of arpanet stuff in it, we may have to skin the name
525: * before returning it.
526: */
527: char *
528: nameof(mp, reptype)
529: register struct message *mp;
530: {
531: register char *cp, *cp2;
532:
533: cp = skin(name1(mp, reptype));
534: if (reptype != 0 || charcount(cp, '!') < 2)
535: return(cp);
536: cp2 = rindex(cp, '!');
537: cp2--;
538: while (cp2 > cp && *cp2 != '!')
539: cp2--;
540: if (*cp2 == '!')
541: return(cp2 + 1);
542: return(cp);
543: }
544:
545: /*
546: * Skin an arpa net address according to the RFC 733 interpretation
547: * of "host-phrase."
548: */
549: char *
550: skin(name)
551: char *name;
552: {
553: register int c;
554: register char *cp, *cp2;
555: int gotlt, lastsp;
556: char nbuf[BUFSIZ];
557:
558: if (name == NOSTR)
559: return(NOSTR);
560: if (index(name, '(') == NOSTR && index(name, '<') == NOSTR
561: && index(name, ' ') == NOSTR)
562: return(name);
563: gotlt = 0;
564: lastsp = 0;
565: for (cp = name, cp2 = nbuf; c = *cp++; ) {
566: switch (c) {
567: case '(':
568: while (*cp != ')' && *cp != 0)
569: cp++;
570: if (*cp)
571: cp++;
572: lastsp = 0;
573: break;
574:
575: case ' ':
576: if (cp[0] == 'a' && cp[1] == 't' && cp[2] == ' ')
577: cp += 3, *cp2++ = '@';
578: else
579: if (cp[0] == '@' && cp[1] == ' ')
580: cp += 2, *cp2++ = '@';
581: else
582: lastsp = 1;
583: break;
584:
585: case '<':
586: cp2 = nbuf;
587: gotlt++;
588: lastsp = 0;
589: break;
590:
591: case '>':
592: if (gotlt)
593: goto done;
594:
595: /* Fall into . . . */
596:
597: default:
598: if (lastsp) {
599: lastsp = 0;
600: *cp2++ = ' ';
601: }
602: *cp2++ = c;
603: break;
604: }
605: }
606: done:
607: *cp2 = 0;
608:
609: return(savestr(nbuf));
610: }
611:
612: /*
613: * Fetch the sender's name from the passed message.
614: * Reptype can be
615: * 0 -- get sender's name for display purposes
616: * 1 -- get sender's name for reply
617: * 2 -- get sender's name for Reply
618: * 3 -- get sender's name for back-to-you-bud
619: */
620:
621: char *
622: name1(mp, reptype)
623: register struct message *mp;
624: {
625: char namebuf[LINESIZE];
626: char linebuf[LINESIZE];
627: register char *cp, *cp2;
628: register FILE *ibuf;
629: int first = 1;
630:
631: if (reptype != 3)
632: {
633: if ((cp = hfield("from", mp)) != NOSTR)
634: return(cp);
635: }
636: if (reptype == 0 && (cp = hfield("sender", mp)) != NOSTR)
637: return(cp);
638: ibuf = setinput(mp);
639: copy("", namebuf);
640: if (readline(ibuf, linebuf) <= 0)
641: return(savestr(namebuf));
642: newname:
643: for (cp = linebuf; *cp != ' '; cp++)
644: ;
645: while (any(*cp, " \t"))
646: cp++;
647: for (cp2 = &namebuf[strlen(namebuf)]; *cp && !any(*cp, " \t") &&
648: cp2-namebuf < LINESIZE-1; *cp2++ = *cp++)
649: ;
650: *cp2 = '\0';
651: if (readline(ibuf, linebuf) <= 0)
652: return(savestr(namebuf));
653: if ((cp = index(linebuf, 'F')) == NULL)
654: return(savestr(namebuf));
655: if (strncmp(cp, "From", 4) != 0)
656: return(savestr(namebuf));
657: while ((cp = index(cp, 'r')) != NULL) {
658: if (strncmp(cp, "remote", 6) == 0) {
659: if ((cp = index(cp, 'f')) == NULL)
660: break;
661: if (strncmp(cp, "from", 4) != 0)
662: break;
663: if ((cp = index(cp, ' ')) == NULL)
664: break;
665: cp++;
666: if (first) {
667: copy(cp, namebuf);
668: first = 0;
669: } else
670: strcpy(rindex(namebuf, '!')+1, cp);
671: strcat(namebuf, "!");
672: goto newname;
673: }
674: cp++;
675: }
676: return(savestr(namebuf));
677: }
678:
679: /*
680: * Count the occurances of c in str
681: */
682: charcount(str, c)
683: char *str;
684: {
685: register char *cp;
686: register int i;
687:
688: for (i = 0, cp = str; *cp; cp++)
689: if (*cp == c)
690: i++;
691: return(i);
692: }
693:
694: /*
695: * Find the rightmost pointer to an instance of the
696: * character in the string and return it.
697: */
698: char *
699: rindex(str, c)
700: char str[];
701: register int c;
702: {
703: register char *cp, *cp2;
704:
705: for (cp = str, cp2 = NOSTR; *cp; cp++)
706: if (c == *cp)
707: cp2 = cp;
708: return(cp2);
709: }
710:
711: /*
712: * See if the string is a number.
713: */
714:
715: numeric(str)
716: char str[];
717: {
718: register char *cp = str;
719:
720: while (*cp)
721: if (!isdigit(*cp++))
722: return(0);
723: return(1);
724: }
725:
726: /*
727: * Are any of the characters in the two strings the same?
728: */
729:
730: anyof(s1, s2)
731: register char *s1, *s2;
732: {
733: register int c;
734:
735: while (c = *s1++)
736: if (any(c, s2))
737: return(1);
738: return(0);
739: }
740:
741: /*
742: * Determine the leftmost index of the character
743: * in the string.
744: */
745:
746: char *
747: index(str, ch)
748: char *str;
749: {
750: register char *cp;
751: register int c;
752:
753: for (c = ch, cp = str; *cp; cp++)
754: if (*cp == c)
755: return(cp);
756: return(NOSTR);
757: }
758:
759: /*
760: * String compare two strings of bounded length.
761: */
762:
763: strncmp(as1, as2, an)
764: char *as1, *as2;
765: {
766: register char *s1, *s2;
767: register int n;
768:
769: s1 = as1;
770: s2 = as2;
771: n = an;
772: while (--n >= 0 && *s1 == *s2++)
773: if (*s1++ == '\0')
774: return(0);
775: return(n<0 ? 0 : *s1 - *--s2);
776: }
777:
778: /*
779: * See if the given header field is supposed to be ignored.
780: */
781: isign(field)
782: char *field;
783: {
784: char realfld[BUFSIZ];
785: register int h;
786: register struct ignore *igp;
787:
788: istrcpy(realfld, field);
789: h = hash(realfld);
790: for (igp = ignore[h]; igp != 0; igp = igp->i_link)
791: if (strcmp(igp->i_field, realfld) == 0)
792: return(1);
793: return(0);
794: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.