1 /*
2  * Copyright (c) 1983 Eric P. Allman
3  * Copyright (c) 1988 Regents of the University of California.
4  * All rights reserved.
5  *
6  * %sccs.include.redist.c%
7  */
8 
9 #ifndef lint
10 static char sccsid[] = "@(#)envelope.c	6.12 (Berkeley) 02/23/93";
11 #endif /* not lint */
12 
13 #include <sys/types.h>
14 #include <sys/time.h>
15 #include <sys/stat.h>
16 #include <pwd.h>
17 #include <fcntl.h>
18 #include "sendmail.h"
19 
20 /*
21 **  NEWENVELOPE -- allocate a new envelope
22 **
23 **	Supports inheritance.
24 **
25 **	Parameters:
26 **		e -- the new envelope to fill in.
27 **
28 **	Returns:
29 **		e.
30 **
31 **	Side Effects:
32 **		none.
33 */
34 
35 ENVELOPE *
36 newenvelope(e)
37 	register ENVELOPE *e;
38 {
39 	register ENVELOPE *parent;
40 	extern putheader(), putbody();
41 	extern ENVELOPE BlankEnvelope;
42 
43 	parent = CurEnv;
44 	if (e == CurEnv && e->e_parent != NULL)
45 		parent = e->e_parent;
46 	clearenvelope(e, TRUE);
47 	if (e == CurEnv)
48 		bcopy((char *) &NullAddress, (char *) &e->e_from, sizeof e->e_from);
49 	else
50 		bcopy((char *) &CurEnv->e_from, (char *) &e->e_from, sizeof e->e_from);
51 	e->e_parent = parent;
52 	e->e_ctime = curtime();
53 	if (parent != NULL)
54 		e->e_msgpriority = parent->e_msgsize;
55 	e->e_puthdr = putheader;
56 	e->e_putbody = putbody;
57 	if (CurEnv->e_xfp != NULL)
58 		(void) fflush(CurEnv->e_xfp);
59 
60 	return (e);
61 }
62 /*
63 **  DROPENVELOPE -- deallocate an envelope.
64 **
65 **	Parameters:
66 **		e -- the envelope to deallocate.
67 **
68 **	Returns:
69 **		none.
70 **
71 **	Side Effects:
72 **		housekeeping necessary to dispose of an envelope.
73 **		Unlocks this queue file.
74 */
75 
76 dropenvelope(e)
77 	register ENVELOPE *e;
78 {
79 	bool queueit = FALSE;
80 	register ADDRESS *q;
81 	char *id = e->e_id;
82 
83 	if (tTd(50, 1))
84 	{
85 		printf("dropenvelope %x id=", e);
86 		xputs(e->e_id);
87 		printf(" flags=%o\n", e->e_flags);
88 	}
89 
90 	if (id == NULL)
91 		id = "(none)";
92 
93 #ifdef LOG
94 	if (LogLevel > 84)
95 		syslog(LOG_DEBUG, "dropenvelope, id=%s, flags=%o, pid=%d",
96 				  id, e->e_flags, getpid());
97 #endif /* LOG */
98 
99 	/* we must have an id to remove disk files */
100 	if (e->e_id == NULL)
101 		return;
102 
103 	/*
104 	**  Extract state information from dregs of send list.
105 	*/
106 
107 	for (q = e->e_sendqueue; q != NULL; q = q->q_next)
108 	{
109 		if (bitset(QQUEUEUP, q->q_flags))
110 			queueit = TRUE;
111 	}
112 
113 	/*
114 	**  Send back return receipts as requested.
115 	*/
116 
117 	if (e->e_receiptto != NULL && bitset(EF_SENDRECEIPT, e->e_flags))
118 	{
119 		auto ADDRESS *rlist = NULL;
120 
121 		(void) sendtolist(e->e_receiptto, (ADDRESS *) NULL, &rlist, e);
122 		(void) returntosender("Return receipt", rlist, FALSE, e);
123 	}
124 
125 	/*
126 	**  Arrange to send error messages if there are fatal errors.
127 	*/
128 
129 	if (bitset(EF_FATALERRS|EF_TIMEOUT, e->e_flags) && ErrorMode != EM_QUIET)
130 		savemail(e);
131 
132 	/*
133 	**  Instantiate or deinstantiate the queue.
134 	*/
135 
136 	if ((!queueit && !bitset(EF_KEEPQUEUE, e->e_flags)) ||
137 	    bitset(EF_CLRQUEUE, e->e_flags))
138 	{
139 		if (e->e_df != NULL)
140 			xunlink(e->e_df);
141 		xunlink(queuename(e, 'q'));
142 	}
143 	else if (queueit || !bitset(EF_INQUEUE, e->e_flags))
144 	{
145 #ifdef QUEUE
146 		queueup(e, FALSE, FALSE);
147 #else /* QUEUE */
148 		syserr("554 dropenvelope: queueup");
149 #endif /* QUEUE */
150 	}
151 
152 	/* now unlock the job */
153 	closexscript(e);
154 	unlockqueue(e);
155 
156 	/* make sure that this envelope is marked unused */
157 	e->e_id = e->e_df = NULL;
158 	if (e->e_dfp != NULL)
159 		(void) fclose(e->e_dfp);
160 	e->e_dfp = NULL;
161 
162 #ifdef LOG
163 	if (LogLevel > 74)
164 		syslog(LOG_INFO, "%s: done", id);
165 #endif /* LOG */
166 }
167 /*
168 **  CLEARENVELOPE -- clear an envelope without unlocking
169 **
170 **	This is normally used by a child process to get a clean
171 **	envelope without disturbing the parent.
172 **
173 **	Parameters:
174 **		e -- the envelope to clear.
175 **		fullclear - if set, the current envelope is total
176 **			garbage and should be ignored; otherwise,
177 **			release any resources it may indicate.
178 **
179 **	Returns:
180 **		none.
181 **
182 **	Side Effects:
183 **		Closes files associated with the envelope.
184 **		Marks the envelope as unallocated.
185 */
186 
187 clearenvelope(e, fullclear)
188 	register ENVELOPE *e;
189 	bool fullclear;
190 {
191 	register HDR *bh;
192 	register HDR **nhp;
193 	extern ENVELOPE BlankEnvelope;
194 
195 	if (!fullclear)
196 	{
197 		/* clear out any file information */
198 		if (e->e_xfp != NULL)
199 			(void) fclose(e->e_xfp);
200 		if (e->e_dfp != NULL)
201 			(void) fclose(e->e_dfp);
202 	}
203 
204 	/* now clear out the data */
205 	STRUCTCOPY(BlankEnvelope, *e);
206 	bh = BlankEnvelope.e_header;
207 	nhp = &e->e_header;
208 	while (bh != NULL)
209 	{
210 		*nhp = (HDR *) xalloc(sizeof *bh);
211 		bcopy((char *) bh, (char *) *nhp, sizeof *bh);
212 		bh = bh->h_link;
213 		nhp = &(*nhp)->h_link;
214 	}
215 }
216 /*
217 **  INITSYS -- initialize instantiation of system
218 **
219 **	In Daemon mode, this is done in the child.
220 **
221 **	Parameters:
222 **		none.
223 **
224 **	Returns:
225 **		none.
226 **
227 **	Side Effects:
228 **		Initializes the system macros, some global variables,
229 **		etc.  In particular, the current time in various
230 **		forms is set.
231 */
232 
233 initsys(e)
234 	register ENVELOPE *e;
235 {
236 	static char cbuf[5];			/* holds hop count */
237 	static char pbuf[10];			/* holds pid */
238 #ifdef TTYNAME
239 	static char ybuf[10];			/* holds tty id */
240 	register char *p;
241 #endif /* TTYNAME */
242 	extern char *ttyname();
243 	extern char *macvalue();
244 	extern char Version[];
245 
246 	/*
247 	**  Give this envelope a reality.
248 	**	I.e., an id, a transcript, and a creation time.
249 	*/
250 
251 	openxscript(e);
252 	e->e_ctime = curtime();
253 
254 	/*
255 	**  Set OutChannel to something useful if stdout isn't it.
256 	**	This arranges that any extra stuff the mailer produces
257 	**	gets sent back to the user on error (because it is
258 	**	tucked away in the transcript).
259 	*/
260 
261 	if (OpMode == MD_DAEMON && QueueRun && e->e_xfp != NULL)
262 		OutChannel = e->e_xfp;
263 
264 	/*
265 	**  Set up some basic system macros.
266 	*/
267 
268 	/* process id */
269 	(void) sprintf(pbuf, "%d", getpid());
270 	define('p', pbuf, e);
271 
272 	/* hop count */
273 	(void) sprintf(cbuf, "%d", e->e_hopcount);
274 	define('c', cbuf, e);
275 
276 	/* time as integer, unix time, arpa time */
277 	settime(e);
278 
279 #ifdef TTYNAME
280 	/* tty name */
281 	if (macvalue('y', e) == NULL)
282 	{
283 		p = ttyname(2);
284 		if (p != NULL)
285 		{
286 			if (strrchr(p, '/') != NULL)
287 				p = strrchr(p, '/') + 1;
288 			(void) strcpy(ybuf, p);
289 			define('y', ybuf, e);
290 		}
291 	}
292 #endif /* TTYNAME */
293 }
294 /*
295 **  SETTIME -- set the current time.
296 **
297 **	Parameters:
298 **		none.
299 **
300 **	Returns:
301 **		none.
302 **
303 **	Side Effects:
304 **		Sets the various time macros -- $a, $b, $d, $t.
305 */
306 
307 settime(e)
308 	register ENVELOPE *e;
309 {
310 	register char *p;
311 	auto time_t now;
312 	static char tbuf[20];			/* holds "current" time */
313 	static char dbuf[30];			/* holds ctime(tbuf) */
314 	register struct tm *tm;
315 	extern char *arpadate();
316 	extern struct tm *gmtime();
317 	extern char *macvalue();
318 
319 	now = curtime();
320 	tm = gmtime(&now);
321 	(void) sprintf(tbuf, "%04d%02d%02d%02d%02d", tm->tm_year + 1900,
322 			tm->tm_mon+1, tm->tm_mday, tm->tm_hour, tm->tm_min);
323 	define('t', tbuf, e);
324 	(void) strcpy(dbuf, ctime(&now));
325 	p = strchr(dbuf, '\n');
326 	if (p != NULL)
327 		*p = '\0';
328 	define('d', dbuf, e);
329 	p = newstr(arpadate(dbuf));
330 	if (macvalue('a', e) == NULL)
331 		define('a', p, e);
332 	define('b', p, e);
333 }
334 /*
335 **  OPENXSCRIPT -- Open transcript file
336 **
337 **	Creates a transcript file for possible eventual mailing or
338 **	sending back.
339 **
340 **	Parameters:
341 **		e -- the envelope to create the transcript in/for.
342 **
343 **	Returns:
344 **		none
345 **
346 **	Side Effects:
347 **		Creates the transcript file.
348 */
349 
350 openxscript(e)
351 	register ENVELOPE *e;
352 {
353 	register char *p;
354 	int fd;
355 
356 	if (e->e_xfp != NULL)
357 		return;
358 	p = queuename(e, 'x');
359 	fd = open(p, O_WRONLY|O_CREAT, 0644);
360 	if (fd < 0)
361 		syserr("Can't create %s", p);
362 	else
363 		e->e_xfp = fdopen(fd, "w");
364 }
365 /*
366 **  CLOSEXSCRIPT -- close the transcript file.
367 **
368 **	Parameters:
369 **		e -- the envelope containing the transcript to close.
370 **
371 **	Returns:
372 **		none.
373 **
374 **	Side Effects:
375 **		none.
376 */
377 
378 closexscript(e)
379 	register ENVELOPE *e;
380 {
381 	if (e->e_xfp == NULL)
382 		return;
383 	(void) fclose(e->e_xfp);
384 	e->e_xfp = NULL;
385 }
386 /*
387 **  SETSENDER -- set the person who this message is from
388 **
389 **	Under certain circumstances allow the user to say who
390 **	s/he is (using -f or -r).  These are:
391 **	1.  The user's uid is zero (root).
392 **	2.  The user's login name is in an approved list (typically
393 **	    from a network server).
394 **	3.  The address the user is trying to claim has a
395 **	    "!" character in it (since #2 doesn't do it for
396 **	    us if we are dialing out for UUCP).
397 **	A better check to replace #3 would be if the
398 **	effective uid is "UUCP" -- this would require me
399 **	to rewrite getpwent to "grab" uucp as it went by,
400 **	make getname more nasty, do another passwd file
401 **	scan, or compile the UID of "UUCP" into the code,
402 **	all of which are reprehensible.
403 **
404 **	Assuming all of these fail, we figure out something
405 **	ourselves.
406 **
407 **	Parameters:
408 **		from -- the person we would like to believe this message
409 **			is from, as specified on the command line.
410 **		e -- the envelope in which we would like the sender set.
411 **
412 **	Returns:
413 **		none.
414 **
415 **	Side Effects:
416 **		sets sendmail's notion of who the from person is.
417 */
418 
419 setsender(from, e)
420 	char *from;
421 	register ENVELOPE *e;
422 {
423 	register char **pvp;
424 	char *realname = NULL;
425 	register struct passwd *pw;
426 	char buf[MAXNAME];
427 	char pvpbuf[PSBUFSIZE];
428 	extern struct passwd *getpwnam();
429 	extern char *macvalue();
430 	extern char **prescan();
431 	extern bool safefile();
432 	extern char *FullName;
433 
434 	if (tTd(45, 1))
435 		printf("setsender(%s)\n", from == NULL ? "" : from);
436 
437 	/*
438 	**  Figure out the real user executing us.
439 	**	Username can return errno != 0 on non-errors.
440 	*/
441 
442 	if (QueueRun || OpMode == MD_SMTP)
443 		realname = from;
444 	if (realname == NULL || realname[0] == '\0')
445 	{
446 		extern char *username();
447 
448 		realname = username();
449 	}
450 
451 	/*
452 	**  Determine if this real person is allowed to alias themselves.
453 	*/
454 
455 	if (from != NULL)
456 	{
457 		extern bool trusteduser();
458 
459 		if (!trusteduser(realname) && getuid() != geteuid() &&
460 		    strchr(from, '!') == NULL && getuid() != 0)
461 		{
462 			/* network sends -r regardless (why why why?) */
463 			/* syserr("501 %s, you cannot use the -f flag", realname); */
464 			from = NULL;
465 		}
466 	}
467 
468 /*
469 	SuprErrs = TRUE;
470 */
471 	if (from == NULL || parseaddr(from, &e->e_from, 1, '\0', e) == NULL)
472 	{
473 		/* log garbage addresses for traceback */
474 # ifdef LOG
475 		if (from != NULL && LogLevel > 2)
476 		{
477 			char *host = RealHostName;
478 
479 			if (host == NULL)
480 				host = MyHostName;
481 			syslog(LOG_NOTICE,
482 				"from=%s unparseable, received from %s@%s",
483 				from, realname, host);
484 		}
485 # endif /* LOG */
486 		if (from != NULL)
487 			SuprErrs = TRUE;
488 		if (from == realname ||
489 		    parseaddr(from = newstr(realname), &e->e_from, 1, '\0', e) == NULL)
490 		{
491 			SuprErrs = TRUE;
492 			if (parseaddr("postmaster", &e->e_from, 1, '\0', e) == NULL)
493 				syserr("553 setsender: can't even parse postmaster!");
494 		}
495 	}
496 	else
497 		FromFlag = TRUE;
498 	e->e_from.q_flags |= QDONTSEND;
499 	if (tTd(45, 5))
500 	{
501 		printf("setsender: QDONTSEND ");
502 		printaddr(&e->e_from, FALSE);
503 	}
504 	loweraddr(&e->e_from);
505 	SuprErrs = FALSE;
506 
507 	pvp = NULL;
508 	if (e->e_from.q_mailer == LocalMailer)
509 	{
510 # ifdef USERDB
511 		register char *p;
512 		extern char *udbsender();
513 # endif
514 
515 		/* if the user has given fullname already, don't redefine */
516 		if (FullName == NULL)
517 			FullName = macvalue('x', e);
518 		if (FullName != NULL && FullName[0] == '\0')
519 			FullName = NULL;
520 
521 # ifdef USERDB
522 		p = udbsender(from);
523 
524 		if (p != NULL)
525 		{
526 			/*
527 			**  We have an alternate address for the sender
528 			*/
529 
530 			pvp = prescan(p, '\0', pvpbuf);
531 		}
532 # endif /* USERDB */
533 
534 		if ((pw = getpwnam(e->e_from.q_user)) != NULL)
535 		{
536 			/*
537 			**  Process passwd file entry.
538 			*/
539 
540 
541 			/* extract home directory */
542 			e->e_from.q_home = newstr(pw->pw_dir);
543 			define('z', e->e_from.q_home, e);
544 
545 			/* extract user and group id */
546 			e->e_from.q_uid = pw->pw_uid;
547 			e->e_from.q_gid = pw->pw_gid;
548 
549 			/* extract full name from passwd file */
550 			if (FullName == NULL && pw->pw_gecos != NULL &&
551 			    strcmp(pw->pw_name, e->e_from.q_user) == 0)
552 			{
553 				buildfname(pw->pw_gecos, e->e_from.q_user, buf);
554 				if (buf[0] != '\0')
555 					FullName = newstr(buf);
556 			}
557 		}
558 		if (FullName != NULL)
559 			define('x', FullName, e);
560 	}
561 	else
562 	{
563 		if (e->e_from.q_home == NULL)
564 			e->e_from.q_home = getenv("HOME");
565 		e->e_from.q_uid = getuid();
566 		e->e_from.q_gid = getgid();
567 	}
568 
569 	/*
570 	**  Rewrite the from person to dispose of possible implicit
571 	**	links in the net.
572 	*/
573 
574 	if (pvp == NULL)
575 		pvp = prescan(from, '\0', pvpbuf);
576 	if (pvp == NULL)
577 	{
578 # ifdef LOG
579 		if (LogLevel > 2)
580 			syslog(LOG_NOTICE, "cannot prescan from (%s)", from);
581 # endif
582 		usrerr("553 cannot prescan from (%s)", from);
583 		finis();
584 	}
585 	rewrite(pvp, 3);
586 	rewrite(pvp, 1);
587 	rewrite(pvp, 4);
588 	cataddr(pvp, buf, sizeof buf, '\0');
589 	e->e_sender = e->e_returnpath = newstr(buf);
590 
591 	define('f', e->e_sender, e);
592 
593 	/* save the domain spec if this mailer wants it */
594 	if (e->e_from.q_mailer != NULL &&
595 	    bitnset(M_CANONICAL, e->e_from.q_mailer->m_flags))
596 	{
597 		extern char **copyplist();
598 
599 		while (*pvp != NULL && strcmp(*pvp, "@") != 0)
600 			pvp++;
601 		if (*pvp != NULL)
602 			e->e_fromdomain = copyplist(pvp, TRUE);
603 	}
604 }
605 /*
606 **  TRUSTEDUSER -- tell us if this user is to be trusted.
607 **
608 **	Parameters:
609 **		user -- the user to be checked.
610 **
611 **	Returns:
612 **		TRUE if the user is in an approved list.
613 **		FALSE otherwise.
614 **
615 **	Side Effects:
616 **		none.
617 */
618 
619 bool
620 trusteduser(user)
621 	char *user;
622 {
623 	register char **ulist;
624 	extern char *TrustedUsers[];
625 
626 	for (ulist = TrustedUsers; *ulist != NULL; ulist++)
627 		if (strcmp(*ulist, user) == 0)
628 			return (TRUE);
629 	return (FALSE);
630 }
631