![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to recipient.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / usr.lib / sendmail / src|
Return to recipient.c CVS log | Up to [CSRG BSD Unix] / 42BSD / usr.lib / sendmail / src |
1.1 root 1: # include <pwd.h>
2: # include "sendmail.h"
3: # include <sys/stat.h>
4:
5: SCCSID(@(#)recipient.c 4.1 7/25/83);
6:
7: /*
8: ** SENDTOLIST -- Designate a send list.
9: **
10: ** The parameter is a comma-separated list of people to send to.
11: ** This routine arranges to send to all of them.
12: **
13: ** Parameters:
14: ** list -- the send list.
15: ** ctladdr -- the address template for the person to
16: ** send to -- effective uid/gid are important.
17: ** This is typically the alias that caused this
18: ** expansion.
19: ** sendq -- a pointer to the head of a queue to put
20: ** these people into.
21: **
22: ** Returns:
23: ** none
24: **
25: ** Side Effects:
26: ** none.
27: */
28:
29: # define MAXRCRSN 10
30:
31: sendtolist(list, ctladdr, sendq)
32: char *list;
33: ADDRESS *ctladdr;
34: ADDRESS **sendq;
35: {
36: register char *p;
37: register ADDRESS *al; /* list of addresses to send to */
38: bool firstone; /* set on first address sent */
39: bool selfref; /* set if this list includes ctladdr */
40: char delimiter; /* the address delimiter */
41:
42: # ifdef DEBUG
43: if (tTd(25, 1))
44: {
45: printf("sendto: %s\n ctladdr=", list);
46: printaddr(ctladdr, FALSE);
47: }
48: # endif DEBUG
49:
50: /* heuristic to determine old versus new style addresses */
51: if (ctladdr == NULL &&
52: (index(list, ',') != NULL || index(list, ';') != NULL ||
53: index(list, '<') != NULL || index(list, '(') != NULL))
54: CurEnv->e_flags &= ~EF_OLDSTYLE;
55: delimiter = ' ';
56: if (!bitset(EF_OLDSTYLE, CurEnv->e_flags) || ctladdr != NULL)
57: delimiter = ',';
58:
59: firstone = TRUE;
60: selfref = FALSE;
61: al = NULL;
62:
63: for (p = list; *p != '\0'; )
64: {
65: register ADDRESS *a;
66: extern char *DelimChar; /* defined in prescan */
67:
68: /* parse the address */
69: while (isspace(*p) || *p == ',')
70: p++;
71: a = parseaddr(p, (ADDRESS *) NULL, 1, delimiter);
72: p = DelimChar;
73: if (a == NULL)
74: continue;
75: a->q_next = al;
76: a->q_alias = ctladdr;
77:
78: /* see if this should be marked as a primary address */
79: if (ctladdr == NULL ||
80: (firstone && *p == '\0' && bitset(QPRIMARY, ctladdr->q_flags)))
81: a->q_flags |= QPRIMARY;
82:
83: /* put on send queue or suppress self-reference */
84: if (ctladdr != NULL && sameaddr(ctladdr, a))
85: selfref = TRUE;
86: else
87: al = a;
88: firstone = FALSE;
89: }
90:
91: /* if this alias doesn't include itself, delete ctladdr */
92: if (!selfref && ctladdr != NULL)
93: ctladdr->q_flags |= QDONTSEND;
94:
95: /* arrange to send to everyone on the local send list */
96: while (al != NULL)
97: {
98: register ADDRESS *a = al;
99: extern ADDRESS *recipient();
100:
101: al = a->q_next;
102: a = recipient(a, sendq);
103:
104: /* arrange to inherit full name */
105: if (a->q_fullname == NULL && ctladdr != NULL)
106: a->q_fullname = ctladdr->q_fullname;
107: }
108:
109: CurEnv->e_to = NULL;
110: }
111: /*
112: ** RECIPIENT -- Designate a message recipient
113: **
114: ** Saves the named person for future mailing.
115: **
116: ** Parameters:
117: ** a -- the (preparsed) address header for the recipient.
118: ** sendq -- a pointer to the head of a queue to put the
119: ** recipient in. Duplicate supression is done
120: ** in this queue.
121: **
122: ** Returns:
123: ** The actual address in the queue. This will be "a" if
124: ** the address is not a duplicate, else the original address.
125: **
126: ** Side Effects:
127: ** none.
128: */
129:
130: ADDRESS *
131: recipient(a, sendq)
132: register ADDRESS *a;
133: register ADDRESS **sendq;
134: {
135: register ADDRESS *q;
136: ADDRESS **pq;
137: register struct mailer *m;
138: register char *p;
139: bool quoted = FALSE; /* set if the addr has a quote bit */
140: char buf[MAXNAME]; /* unquoted image of the user name */
141: extern ADDRESS *getctladdr();
142: extern bool safefile();
143:
144: CurEnv->e_to = a->q_paddr;
145: m = a->q_mailer;
146: errno = 0;
147: # ifdef DEBUG
148: if (tTd(26, 1))
149: {
150: printf("\nrecipient: ");
151: printaddr(a, FALSE);
152: }
153: # endif DEBUG
154:
155: /* break aliasing loops */
156: if (AliasLevel > MAXRCRSN)
157: {
158: usrerr("aliasing/forwarding loop broken");
159: return (a);
160: }
161:
162: /*
163: ** Finish setting up address structure.
164: */
165:
166: a->q_timeout = TimeOut;
167:
168: (void) strcpy(buf, a->q_user);
169: for (p = buf; *p != '\0' && !quoted; p++)
170: {
171: if (!isascii(*p) && (*p & 0377) != (SpaceSub & 0377))
172: quoted = TRUE;
173: }
174: stripquotes(buf, TRUE);
175:
176: /* do sickly crude mapping for program mailing, etc. */
177: if (m == LocalMailer && buf[0] == '|')
178: {
179: a->q_mailer = m = ProgMailer;
180: a->q_user++;
181: if (a->q_alias == NULL && !tTd(0, 1) && !QueueRun && !ForceMail)
182: {
183: usrerr("Cannot mail directly to programs");
184: a->q_flags |= QDONTSEND;
185: }
186: }
187:
188: /*
189: ** Look up this person in the recipient list.
190: ** If they are there already, return, otherwise continue.
191: ** If the list is empty, just add it. Notice the cute
192: ** hack to make from addresses suppress things correctly:
193: ** the QDONTSEND bit will be set in the send list.
194: ** [Please note: the emphasis is on "hack."]
195: */
196:
197: for (pq = sendq; (q = *pq) != NULL; pq = &q->q_next)
198: {
199: if (!ForceMail && sameaddr(q, a))
200: {
201: # ifdef DEBUG
202: if (tTd(26, 1))
203: {
204: printf("%s in sendq: ", a->q_paddr);
205: printaddr(q, FALSE);
206: }
207: # endif DEBUG
208: if (!bitset(QDONTSEND, a->q_flags))
209: message(Arpa_Info, "duplicate suppressed");
210: if (!bitset(QPRIMARY, q->q_flags))
211: q->q_flags |= a->q_flags;
212: return (q);
213: }
214: }
215:
216: /* add address on list */
217: *pq = a;
218: a->q_next = NULL;
219:
220: /*
221: ** Alias the name and handle :include: specs.
222: */
223:
224: if (m == LocalMailer && !bitset(QDONTSEND, a->q_flags))
225: {
226: if (strncmp(a->q_user, ":include:", 9) == 0)
227: {
228: a->q_flags |= QDONTSEND;
229: if (a->q_alias == NULL && !tTd(0, 1) && !QueueRun && !ForceMail)
230: usrerr("Cannot mail directly to :include:s");
231: else
232: {
233: message(Arpa_Info, "including file %s", &a->q_user[9]);
234: include(&a->q_user[9], " sending", a, sendq);
235: }
236: }
237: else
238: alias(a, sendq);
239: }
240:
241: /*
242: ** If the user is local and still being sent, verify that
243: ** the address is good. If it is, try to forward.
244: ** If the address is already good, we have a forwarding
245: ** loop. This can be broken by just sending directly to
246: ** the user (which is probably correct anyway).
247: */
248:
249: if (!bitset(QDONTSEND, a->q_flags) && m == LocalMailer)
250: {
251: struct stat stb;
252: extern bool writable();
253:
254: /* see if this is to a file */
255: if (buf[0] == '/')
256: {
257: p = rindex(buf, '/');
258: /* check if writable or creatable */
259: if (a->q_alias == NULL && !tTd(0, 1) && !QueueRun && !ForceMail)
260: {
261: usrerr("Cannot mail directly to files");
262: a->q_flags |= QDONTSEND;
263: }
264: else if ((stat(buf, &stb) >= 0) ? (!writable(&stb)) :
265: (*p = '\0', !safefile(buf, getruid(), S_IWRITE|S_IEXEC)))
266: {
267: a->q_flags |= QBADADDR;
268: giveresponse(EX_CANTCREAT, m, CurEnv);
269: }
270: }
271: else
272: {
273: register struct passwd *pw;
274: extern struct passwd *finduser();
275:
276: /* warning -- finduser may trash buf */
277: pw = finduser(buf);
278: if (pw == NULL)
279: {
280: a->q_flags |= QBADADDR;
281: giveresponse(EX_NOUSER, m, CurEnv);
282: }
283: else
284: {
285: char nbuf[MAXNAME];
286:
287: if (strcmp(a->q_user, pw->pw_name) != 0)
288: {
289: a->q_user = newstr(pw->pw_name);
290: (void) strcpy(buf, pw->pw_name);
291: }
292: a->q_home = newstr(pw->pw_dir);
293: a->q_uid = pw->pw_uid;
294: a->q_gid = pw->pw_gid;
295: a->q_flags |= QGOODUID;
296: buildfname(pw->pw_gecos, pw->pw_name, nbuf);
297: if (nbuf[0] != '\0')
298: a->q_fullname = newstr(nbuf);
299: if (!quoted)
300: forward(a, sendq);
301: }
302: }
303: }
304: return (a);
305: }
306: /*
307: ** FINDUSER -- find the password entry for a user.
308: **
309: ** This looks a lot like getpwnam, except that it may want to
310: ** do some fancier pattern matching in /etc/passwd.
311: **
312: ** This routine contains most of the time of many sendmail runs.
313: ** It deserves to be optimized.
314: **
315: ** Parameters:
316: ** name -- the name to match against.
317: **
318: ** Returns:
319: ** A pointer to a pw struct.
320: ** NULL if name is unknown or ambiguous.
321: **
322: ** Side Effects:
323: ** may modify name.
324: */
325:
326: struct passwd *
327: finduser(name)
328: char *name;
329: {
330: extern struct passwd *getpwent();
331: register struct passwd *pw;
332: register char *p;
333:
334: /*
335: ** Make name canonical.
336: */
337:
338: for (p = name; *p != '\0'; p++)
339: {
340: if (*p == (SpaceSub & 0177) || *p == '_')
341: *p = ' ';
342: }
343:
344: /* look up this login name */
345: if ((pw = getpwnam(name)) != NULL)
346: return (pw);
347:
348: /* search for a matching full name instead */
349: setpwent();
350: while ((pw = getpwent()) != NULL)
351: {
352: char buf[MAXNAME];
353: extern bool sameword();
354:
355: if (strcmp(pw->pw_name, name) == 0)
356: return (pw);
357: buildfname(pw->pw_gecos, pw->pw_name, buf);
358: if (index(buf, ' ') != NULL && sameword(buf, name))
359: {
360: message(Arpa_Info, "sending to login name %s", pw->pw_name);
361: return (pw);
362: }
363: }
364: return (NULL);
365: }
366: /*
367: ** WRITABLE -- predicate returning if the file is writable.
368: **
369: ** This routine must duplicate the algorithm in sys/fio.c.
370: ** Unfortunately, we cannot use the access call since we
371: ** won't necessarily be the real uid when we try to
372: ** actually open the file.
373: **
374: ** Notice that ANY file with ANY execute bit is automatically
375: ** not writable. This is also enforced by mailfile.
376: **
377: ** Parameters:
378: ** s -- pointer to a stat struct for the file.
379: **
380: ** Returns:
381: ** TRUE -- if we will be able to write this file.
382: ** FALSE -- if we cannot write this file.
383: **
384: ** Side Effects:
385: ** none.
386: */
387:
388: bool
389: writable(s)
390: register struct stat *s;
391: {
392: int euid, egid;
393: int bits;
394:
395: if (bitset(0111, s->st_mode))
396: return (FALSE);
397: euid = getruid();
398: egid = getrgid();
399: if (geteuid() == 0)
400: {
401: if (bitset(S_ISUID, s->st_mode))
402: euid = s->st_uid;
403: if (bitset(S_ISGID, s->st_mode))
404: egid = s->st_gid;
405: }
406:
407: if (euid == 0)
408: return (TRUE);
409: bits = S_IWRITE;
410: if (euid != s->st_uid)
411: {
412: bits >>= 3;
413: if (egid != s->st_gid)
414: bits >>= 3;
415: }
416: return ((s->st_mode & bits) != 0);
417: }
418: /*
419: ** INCLUDE -- handle :include: specification.
420: **
421: ** Parameters:
422: ** fname -- filename to include.
423: ** msg -- message to print in verbose mode.
424: ** ctladdr -- address template to use to fill in these
425: ** addresses -- effective user/group id are
426: ** the important things.
427: ** sendq -- a pointer to the head of the send queue
428: ** to put these addresses in.
429: **
430: ** Returns:
431: ** none.
432: **
433: ** Side Effects:
434: ** reads the :include: file and sends to everyone
435: ** listed in that file.
436: */
437:
438: include(fname, msg, ctladdr, sendq)
439: char *fname;
440: char *msg;
441: ADDRESS *ctladdr;
442: ADDRESS **sendq;
443: {
444: char buf[MAXLINE];
445: register FILE *fp;
446: char *oldto = CurEnv->e_to;
447: char *oldfilename = FileName;
448: int oldlinenumber = LineNumber;
449:
450: fp = fopen(fname, "r");
451: if (fp == NULL)
452: {
453: usrerr("Cannot open %s", fname);
454: return;
455: }
456: if (getctladdr(ctladdr) == NULL)
457: {
458: struct stat st;
459:
460: if (fstat(fileno(fp), &st) < 0)
461: syserr("Cannot fstat %s!", fname);
462: ctladdr->q_uid = st.st_uid;
463: ctladdr->q_gid = st.st_gid;
464: ctladdr->q_flags |= QGOODUID;
465: }
466:
467: /* read the file -- each line is a comma-separated list. */
468: FileName = fname;
469: LineNumber = 0;
470: while (fgets(buf, sizeof buf, fp) != NULL)
471: {
472: register char *p = index(buf, '\n');
473:
474: if (p != NULL)
475: *p = '\0';
476: if (buf[0] == '\0')
477: continue;
478: CurEnv->e_to = oldto;
479: message(Arpa_Info, "%s to %s", msg, buf);
480: AliasLevel++;
481: sendtolist(buf, ctladdr, sendq);
482: AliasLevel--;
483: }
484:
485: (void) fclose(fp);
486: FileName = oldfilename;
487: LineNumber = oldlinenumber;
488: }
489: /*
490: ** SENDTOARGV -- send to an argument vector.
491: **
492: ** Parameters:
493: ** argv -- argument vector to send to.
494: **
495: ** Returns:
496: ** none.
497: **
498: ** Side Effects:
499: ** puts all addresses on the argument vector onto the
500: ** send queue.
501: */
502:
503: sendtoargv(argv)
504: register char **argv;
505: {
506: register char *p;
507: extern bool sameword();
508:
509: while ((p = *argv++) != NULL)
510: {
511: if (argv[0] != NULL && argv[1] != NULL && sameword(argv[0], "at"))
512: {
513: char nbuf[MAXNAME];
514:
515: if (strlen(p) + strlen(argv[1]) + 2 > sizeof nbuf)
516: usrerr("address overflow");
517: else
518: {
519: (void) strcpy(nbuf, p);
520: (void) strcat(nbuf, "@");
521: (void) strcat(nbuf, argv[1]);
522: p = newstr(nbuf);
523: argv += 2;
524: }
525: }
526: sendtolist(p, (ADDRESS *) NULL, &CurEnv->e_sendqueue);
527: }
528: }
529: /*
530: ** GETCTLADDR -- get controlling address from an address header.
531: **
532: ** If none, get one corresponding to the effective userid.
533: **
534: ** Parameters:
535: ** a -- the address to find the controller of.
536: **
537: ** Returns:
538: ** the controlling address.
539: **
540: ** Side Effects:
541: ** none.
542: */
543:
544: ADDRESS *
545: getctladdr(a)
546: register ADDRESS *a;
547: {
548: while (a != NULL && !bitset(QGOODUID, a->q_flags))
549: a = a->q_alias;
550: return (a);
551: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.