![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to names.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / Mail|
Return to names.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / Mail |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that this notice is preserved and that due credit is given
7: * to the University of California at Berkeley. The name of the University
8: * may not be used to endorse or promote products derived from this
9: * software without specific prior written permission. This software
10: * is provided ``as is'' without express or implied warranty.
11: */
12:
13: #ifdef notdef
14: static char sccsid[] = "@(#)names.c 5.6 (Berkeley) 2/18/88";
15: #endif /* notdef */
16:
17: /*
18: * Mail -- a mail program
19: *
20: * Handle name lists.
21: */
22:
23: #include "rcv.h"
24: #include <sys/wait.h>
25:
26: /*
27: * Allocate a single element of a name list,
28: * initialize its name field to the passed
29: * name and return it.
30: */
31:
32: struct name *
33: nalloc(str)
34: char str[];
35: {
36: register struct name *np;
37:
38: np = (struct name *) salloc(sizeof *np);
39: np->n_flink = NIL;
40: np->n_blink = NIL;
41: np->n_type = -1;
42: np->n_name = savestr(str);
43: return(np);
44: }
45:
46: /*
47: * Find the tail of a list and return it.
48: */
49:
50: struct name *
51: tailof(name)
52: struct name *name;
53: {
54: register struct name *np;
55:
56: np = name;
57: if (np == NIL)
58: return(NIL);
59: while (np->n_flink != NIL)
60: np = np->n_flink;
61: return(np);
62: }
63:
64: /*
65: * Extract a list of names from a line,
66: * and make a list of names from it.
67: * Return the list or NIL if none found.
68: */
69:
70: struct name *
71: extract(line, ntype)
72: char line[];
73: {
74: register char *cp;
75: register struct name *top, *np, *t;
76: char nbuf[BUFSIZ], abuf[BUFSIZ];
77:
78: if (line == NOSTR || strlen(line) == 0)
79: return(NIL);
80: top = NIL;
81: np = NIL;
82: cp = line;
83: while ((cp = yankword(cp, nbuf)) != NOSTR) {
84: if (np != NIL && equal(nbuf, "at")) {
85: (void) strcpy(abuf, nbuf);
86: if ((cp = yankword(cp, nbuf)) == NOSTR) {
87: (void) strcpy(nbuf, abuf);
88: goto normal;
89: }
90: (void) strcpy(abuf, np->n_name);
91: stradd(abuf, '@');
92: (void) strcat(abuf, nbuf);
93: np->n_name = savestr(abuf);
94: continue;
95: }
96: normal:
97: t = nalloc(nbuf);
98: t->n_type = ntype;
99: if (top == NIL)
100: top = t;
101: else
102: np->n_flink = t;
103: t->n_blink = np;
104: np = t;
105: }
106: return(top);
107: }
108:
109: /*
110: * Turn a list of names into a string of the same names.
111: */
112:
113: char *
114: detract(np, ntype)
115: register struct name *np;
116: {
117: register int s;
118: register char *cp, *top;
119: register struct name *p;
120: register int comma;
121:
122: comma = ntype & GCOMMA;
123: if (np == NIL)
124: return(NOSTR);
125: ntype &= ~GCOMMA;
126: s = 0;
127: if (debug && comma)
128: fprintf(stderr, "detract asked to insert commas\n");
129: for (p = np; p != NIL; p = p->n_flink) {
130: if (ntype && (p->n_type & GMASK) != ntype)
131: continue;
132: s += strlen(p->n_name) + 1;
133: if (comma)
134: s++;
135: }
136: if (s == 0)
137: return(NOSTR);
138: s += 2;
139: top = salloc(s);
140: cp = top;
141: for (p = np; p != NIL; p = p->n_flink) {
142: if (ntype && (p->n_type & GMASK) != ntype)
143: continue;
144: cp = copy(p->n_name, cp);
145: if (comma && p->n_flink != NIL)
146: *cp++ = ',';
147: *cp++ = ' ';
148: }
149: *--cp = 0;
150: if (comma && *--cp == ',')
151: *cp = 0;
152: return(top);
153: }
154:
155: /*
156: * Grab a single word (liberal word)
157: * Throw away things between ()'s.
158: */
159:
160: char *
161: yankword(ap, wbuf)
162: char *ap, wbuf[];
163: {
164: register char *cp, *cp2;
165:
166: cp = ap;
167: do {
168: while (*cp && any(*cp, " \t,"))
169: cp++;
170: if (*cp == '(') {
171: register int nesting = 0;
172:
173: while (*cp != '\0') {
174: switch (*cp++) {
175: case '(':
176: nesting++;
177: break;
178: case ')':
179: --nesting;
180: break;
181: }
182: if (nesting <= 0)
183: break;
184: }
185: }
186: if (*cp == '\0')
187: return(NOSTR);
188: } while (any(*cp, " \t,("));
189: for (cp2 = wbuf; *cp && !any(*cp, " \t,("); *cp2++ = *cp++)
190: ;
191: *cp2 = '\0';
192: return(cp);
193: }
194:
195: /*
196: * Verify that all the users in the list of names are
197: * legitimate. Bitch about and delink those who aren't.
198: */
199:
200: struct name *
201: verify(names)
202: struct name *names;
203: {
204: #ifdef SENDMAIL
205:
206: return(names);
207: #else
208: register struct name *np, *top, *t, *x;
209: register char *cp;
210:
211: top = names;
212: np = names;
213: while (np != NIL) {
214: if (np->n_type & GDEL) {
215: np = np->n_flink;
216: continue;
217: }
218: for (cp = "!:@^"; *cp; cp++)
219: if (any(*cp, np->n_name))
220: break;
221: if (*cp != 0) {
222: np = np->n_flink;
223: continue;
224: }
225: cp = np->n_name;
226: while (*cp == '\\')
227: cp++;
228: if (equal(cp, "msgs") ||
229: getuserid(cp) != -1) {
230: np = np->n_flink;
231: continue;
232: }
233: fprintf(stderr, "Can't send to %s\n", np->n_name);
234: senderr++;
235: if (np == top) {
236: top = np->n_flink;
237: if (top != NIL)
238: top->n_blink = NIL;
239: np = top;
240: continue;
241: }
242: x = np->n_blink;
243: t = np->n_flink;
244: x->n_flink = t;
245: if (t != NIL)
246: t->n_blink = x;
247: np = t;
248: }
249: return(top);
250: #endif
251: }
252:
253: /*
254: * For each recipient in the passed name list with a /
255: * in the name, append the message to the end of the named file
256: * and remove him from the recipient list.
257: *
258: * Recipients whose name begins with | are piped through the given
259: * program and removed.
260: */
261:
262: struct name *
263: outof(names, fo, hp)
264: struct name *names;
265: FILE *fo;
266: struct header *hp;
267: {
268: register int c;
269: register struct name *np, *top;
270: #ifdef CRAZYWOW
271: register struct name *t, *x;
272: #endif
273: time_t now, time();
274: char *date, *fname, *shell, *ctime();
275: FILE *fout, *fin;
276: int ispipe;
277: extern char tempEdit[];
278: union wait s;
279:
280: top = names;
281: np = names;
282: (void) time(&now);
283: date = ctime(&now);
284: while (np != NIL) {
285: if (!isfileaddr(np->n_name) && np->n_name[0] != '|') {
286: np = np->n_flink;
287: continue;
288: }
289: ispipe = np->n_name[0] == '|';
290: if (ispipe)
291: fname = np->n_name+1;
292: else
293: fname = expand(np->n_name);
294:
295: /*
296: * See if we have copied the complete message out yet.
297: * If not, do so.
298: */
299:
300: if (image < 0) {
301: if ((fout = fopen(tempEdit, "a")) == NULL) {
302: perror(tempEdit);
303: senderr++;
304: goto cant;
305: }
306: image = open(tempEdit, 2);
307: (void) unlink(tempEdit);
308: if (image < 0) {
309: perror(tempEdit);
310: senderr++;
311: goto cant;
312: }
313: else {
314: rewind(fo);
315: fprintf(fout, "From %s %s", myname, date);
316: puthead(hp, fout, GTO|GSUBJECT|GCC|GNL);
317: while ((c = getc(fo)) != EOF)
318: (void) putc(c, fout);
319: rewind(fo);
320: (void) putc('\n', fout);
321: (void) fflush(fout);
322: if (ferror(fout))
323: perror(tempEdit);
324: (void) fclose(fout);
325: }
326: }
327:
328: /*
329: * Now either copy "image" to the desired file
330: * or give it as the standard input to the desired
331: * program as appropriate.
332: */
333:
334: if (ispipe) {
335: (void) wait(&s);
336: switch (fork()) {
337: case 0:
338: (void) signal(SIGHUP, SIG_IGN);
339: (void) signal(SIGINT, SIG_IGN);
340: (void) signal(SIGQUIT, SIG_IGN);
341: (void) close(0);
342: (void) dup(image);
343: (void) close(image);
344: if ((shell = value("SHELL")) == NOSTR)
345: shell = SHELL;
346: execl(shell, shell, "-c", fname, 0);
347: perror(shell);
348: exit(1);
349: break;
350:
351: case -1:
352: perror("fork");
353: senderr++;
354: goto cant;
355: }
356: }
357: else {
358: if ((fout = fopen(fname, "a")) == NULL) {
359: perror(fname);
360: senderr++;
361: goto cant;
362: }
363: fin = Fdopen(image, "r");
364: if (fin == NULL) {
365: fprintf(stderr, "Can't reopen image\n");
366: (void) fclose(fout);
367: senderr++;
368: goto cant;
369: }
370: rewind(fin);
371: while ((c = getc(fin)) != EOF)
372: (void) putc(c, fout);
373: if (ferror(fout))
374: senderr++, perror(fname);
375: (void) fclose(fout);
376: (void) fclose(fin);
377: }
378:
379: cant:
380:
381: /*
382: * In days of old we removed the entry from the
383: * the list; now for sake of header expansion
384: * we leave it in and mark it as deleted.
385: */
386:
387: #ifdef CRAZYWOW
388: if (np == top) {
389: top = np->n_flink;
390: if (top != NIL)
391: top->n_blink = NIL;
392: np = top;
393: continue;
394: }
395: x = np->n_blink;
396: t = np->n_flink;
397: x->n_flink = t;
398: if (t != NIL)
399: t->n_blink = x;
400: np = t;
401: #endif
402:
403: np->n_type |= GDEL;
404: np = np->n_flink;
405: }
406: if (image >= 0) {
407: (void) close(image);
408: image = -1;
409: }
410: return(top);
411: }
412:
413: /*
414: * Determine if the passed address is a local "send to file" address.
415: * If any of the network metacharacters precedes any slashes, it can't
416: * be a filename. We cheat with .'s to allow path names like ./...
417: */
418: isfileaddr(name)
419: char *name;
420: {
421: register char *cp;
422: extern char *metanet;
423:
424: if (any('@', name))
425: return(0);
426: if (*name == '+')
427: return(1);
428: for (cp = name; *cp; cp++) {
429: if (*cp == '.')
430: continue;
431: if (any(*cp, metanet))
432: return(0);
433: if (*cp == '/')
434: return(1);
435: }
436: return(0);
437: }
438:
439: /*
440: * Map all of the aliased users in the invoker's mailrc
441: * file and insert them into the list.
442: * Changed after all these months of service to recursively
443: * expand names (2/14/80).
444: */
445:
446: struct name *
447: usermap(names)
448: struct name *names;
449: {
450: register struct name *new, *np, *cp;
451: struct grouphead *gh;
452: register int metoo;
453:
454: new = NIL;
455: np = names;
456: metoo = (value("metoo") != NOSTR);
457: while (np != NIL) {
458: if (np->n_name[0] == '\\') {
459: cp = np->n_flink;
460: new = put(new, np);
461: np = cp;
462: continue;
463: }
464: gh = findgroup(np->n_name);
465: cp = np->n_flink;
466: if (gh != NOGRP)
467: new = gexpand(new, gh, metoo, np->n_type);
468: else
469: new = put(new, np);
470: np = cp;
471: }
472: return(new);
473: }
474:
475: /*
476: * Recursively expand a group name. We limit the expansion to some
477: * fixed level to keep things from going haywire.
478: * Direct recursion is not expanded for convenience.
479: */
480:
481: struct name *
482: gexpand(nlist, gh, metoo, ntype)
483: struct name *nlist;
484: struct grouphead *gh;
485: {
486: struct group *gp;
487: struct grouphead *ngh;
488: struct name *np;
489: static int depth;
490: char *cp;
491:
492: if (depth > MAXEXP) {
493: printf("Expanding alias to depth larger than %d\n", MAXEXP);
494: return(nlist);
495: }
496: depth++;
497: for (gp = gh->g_list; gp != NOGE; gp = gp->ge_link) {
498: cp = gp->ge_name;
499: if (*cp == '\\')
500: goto quote;
501: if (strcmp(cp, gh->g_name) == 0)
502: goto quote;
503: if ((ngh = findgroup(cp)) != NOGRP) {
504: nlist = gexpand(nlist, ngh, metoo, ntype);
505: continue;
506: }
507: quote:
508: np = nalloc(cp);
509: np->n_type = ntype;
510: /*
511: * At this point should allow to expand
512: * to self if only person in group
513: */
514: if (gp == gh->g_list && gp->ge_link == NOGE)
515: goto skip;
516: if (!metoo && strcmp(cp, myname) == 0)
517: np->n_type |= GDEL;
518: skip:
519: nlist = put(nlist, np);
520: }
521: depth--;
522: return(nlist);
523: }
524:
525:
526:
527: /*
528: * Compute the length of the passed name list and
529: * return it.
530: */
531:
532: lengthof(name)
533: struct name *name;
534: {
535: register struct name *np;
536: register int c;
537:
538: for (c = 0, np = name; np != NIL; c++, np = np->n_flink)
539: ;
540: return(c);
541: }
542:
543: /*
544: * Concatenate the two passed name lists, return the result.
545: */
546:
547: struct name *
548: cat(n1, n2)
549: struct name *n1, *n2;
550: {
551: register struct name *tail;
552:
553: if (n1 == NIL)
554: return(n2);
555: if (n2 == NIL)
556: return(n1);
557: tail = tailof(n1);
558: tail->n_flink = n2;
559: n2->n_blink = tail;
560: return(n1);
561: }
562:
563: /*
564: * Unpack the name list onto a vector of strings.
565: * Return an error if the name list won't fit.
566: */
567:
568: char **
569: unpack(np)
570: struct name *np;
571: {
572: register char **ap, **top;
573: register struct name *n;
574: char hbuf[10];
575: int t, extra, metoo, verbose;
576:
577: n = np;
578: if ((t = lengthof(n)) == 0)
579: panic("No names to unpack");
580:
581: /*
582: * Compute the number of extra arguments we will need.
583: * We need at least two extra -- one for "mail" and one for
584: * the terminating 0 pointer. Additional spots may be needed
585: * to pass along -r and -f to the host mailer.
586: */
587:
588: extra = 2;
589: if (rflag != NOSTR)
590: extra += 2;
591: #ifdef SENDMAIL
592: extra++;
593: metoo = value("metoo") != NOSTR;
594: if (metoo)
595: extra++;
596: verbose = value("verbose") != NOSTR;
597: if (verbose)
598: extra++;
599: #endif SENDMAIL
600: if (hflag)
601: extra += 2;
602: top = (char **) salloc((t + extra) * sizeof *top);
603: ap = top;
604: *ap++ = "send-mail";
605: if (rflag != NOSTR) {
606: *ap++ = "-r";
607: *ap++ = rflag;
608: }
609: #ifdef SENDMAIL
610: *ap++ = "-i";
611: if (metoo)
612: *ap++ = "-m";
613: if (verbose)
614: *ap++ = "-v";
615: #endif SENDMAIL
616: if (hflag) {
617: *ap++ = "-h";
618: *ap++ = savestr(sprintf(hbuf, "%d", hflag));
619: }
620: while (n != NIL) {
621: if (n->n_type & GDEL) {
622: n = n->n_flink;
623: continue;
624: }
625: *ap++ = n->n_name;
626: n = n->n_flink;
627: }
628: *ap = NOSTR;
629: return(top);
630: }
631:
632: /*
633: * See if the user named himself as a destination
634: * for outgoing mail. If so, set the global flag
635: * selfsent so that we avoid removing his mailbox.
636: */
637:
638: mechk(names)
639: struct name *names;
640: {
641: register struct name *np;
642:
643: for (np = names; np != NIL; np = np->n_flink)
644: if ((np->n_type & GDEL) == 0 && equal(np->n_name, myname)) {
645: selfsent++;
646: return;
647: }
648: }
649:
650: /*
651: * Remove all of the duplicates from the passed name list by
652: * insertion sorting them, then checking for dups.
653: * Return the head of the new list.
654: */
655:
656: struct name *
657: elide(names)
658: struct name *names;
659: {
660: register struct name *np, *t, *new;
661: struct name *x;
662:
663: if (names == NIL)
664: return(NIL);
665: new = names;
666: np = names;
667: np = np->n_flink;
668: if (np != NIL)
669: np->n_blink = NIL;
670: new->n_flink = NIL;
671: while (np != NIL) {
672: t = new;
673: while (nstrcmp(t->n_name, np->n_name) < 0) {
674: if (t->n_flink == NIL)
675: break;
676: t = t->n_flink;
677: }
678:
679: /*
680: * If we ran out of t's, put the new entry after
681: * the current value of t.
682: */
683:
684: if (nstrcmp(t->n_name, np->n_name) < 0) {
685: t->n_flink = np;
686: np->n_blink = t;
687: t = np;
688: np = np->n_flink;
689: t->n_flink = NIL;
690: continue;
691: }
692:
693: /*
694: * Otherwise, put the new entry in front of the
695: * current t. If at the front of the list,
696: * the new guy becomes the new head of the list.
697: */
698:
699: if (t == new) {
700: t = np;
701: np = np->n_flink;
702: t->n_flink = new;
703: new->n_blink = t;
704: t->n_blink = NIL;
705: new = t;
706: continue;
707: }
708:
709: /*
710: * The normal case -- we are inserting into the
711: * middle of the list.
712: */
713:
714: x = np;
715: np = np->n_flink;
716: x->n_flink = t;
717: x->n_blink = t->n_blink;
718: t->n_blink->n_flink = x;
719: t->n_blink = x;
720: }
721:
722: /*
723: * Now the list headed up by new is sorted.
724: * Go through it and remove duplicates.
725: */
726:
727: np = new;
728: while (np != NIL) {
729: t = np;
730: while (t->n_flink!=NIL &&
731: icequal(np->n_name,t->n_flink->n_name))
732: t = t->n_flink;
733: if (t == np || t == NIL) {
734: np = np->n_flink;
735: continue;
736: }
737:
738: /*
739: * Now t points to the last entry with the same name
740: * as np. Make np point beyond t.
741: */
742:
743: np->n_flink = t->n_flink;
744: if (t->n_flink != NIL)
745: t->n_flink->n_blink = np;
746: np = np->n_flink;
747: }
748: return(new);
749: }
750:
751: /*
752: * Version of strcmp which ignores case differences.
753: */
754:
755: nstrcmp(s1, s2)
756: register char *s1, *s2;
757: {
758: register int c1, c2;
759:
760: do {
761: c1 = *s1++;
762: c2 = *s2++;
763: } while (c1 && c1 == c2);
764: return(c1 - c2);
765: }
766:
767: /*
768: * Put another node onto a list of names and return
769: * the list.
770: */
771:
772: struct name *
773: put(list, node)
774: struct name *list, *node;
775: {
776: node->n_flink = list;
777: node->n_blink = NIL;
778: if (list != NIL)
779: list->n_blink = node;
780: return(node);
781: }
782:
783: /*
784: * Determine the number of elements in
785: * a name list and return it.
786: */
787:
788: count(np)
789: register struct name *np;
790: {
791: register int c = 0;
792:
793: while (np != NIL) {
794: c++;
795: np = np->n_flink;
796: }
797: return(c);
798: }
799:
800: /*
801: * Delete the given name from a namelist, using the passed
802: * function to compare the names.
803: */
804: struct name *
805: delname(np, name, cmpfun)
806: register struct name *np;
807: char name[];
808: int (* cmpfun)();
809: {
810: register struct name *p;
811:
812: for (p = np; p != NIL; p = p->n_flink)
813: if ((* cmpfun)(p->n_name, name)) {
814: if (p->n_blink == NIL) {
815: if (p->n_flink != NIL)
816: p->n_flink->n_blink = NIL;
817: np = p->n_flink;
818: continue;
819: }
820: if (p->n_flink == NIL) {
821: if (p->n_blink != NIL)
822: p->n_blink->n_flink = NIL;
823: continue;
824: }
825: p->n_blink->n_flink = p->n_flink;
826: p->n_flink->n_blink = p->n_blink;
827: }
828: return(np);
829: }
830:
831: /*
832: * Call the given routine on each element of the name
833: * list, replacing said value if need be.
834: */
835:
836: mapf(np, from)
837: register struct name *np;
838: char *from;
839: {
840: register struct name *p;
841:
842: for (p = np; p != NIL; p = p->n_flink)
843: p->n_name = netmap(p->n_name, from);
844: }
845:
846: /*
847: * Pretty print a name list
848: * Uncomment it if you need it.
849: */
850:
851: /*
852: prettyprint(name)
853: struct name *name;
854: {
855: register struct name *np;
856:
857: np = name;
858: while (np != NIL) {
859: fprintf(stderr, "%s(%d) ", np->n_name, np->n_type);
860: np = np->n_flink;
861: }
862: fprintf(stderr, "\n");
863: }
864: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.