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