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