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.7 (Berkeley) 02/14/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 > 12)
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 		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("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 >= 10)
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)
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 	*strchr(dbuf, '\n') = '\0';
326 	if (macvalue('d', e) == NULL)
327 		define('d', dbuf, e);
328 	p = newstr(arpadate(dbuf));
329 	if (macvalue('a', e) == NULL)
330 		define('a', p, e);
331 	define('b', p, e);
332 }
333 /*
334 **  OPENXSCRIPT -- Open transcript file
335 **
336 **	Creates a transcript file for possible eventual mailing or
337 **	sending back.
338 **
339 **	Parameters:
340 **		e -- the envelope to create the transcript in/for.
341 **
342 **	Returns:
343 **		none
344 **
345 **	Side Effects:
346 **		Creates the transcript file.
347 */
348 
349 openxscript(e)
350 	register ENVELOPE *e;
351 {
352 	register char *p;
353 	int fd;
354 
355 	if (e->e_xfp != NULL)
356 		return;
357 	p = queuename(e, 'x');
358 	fd = open(p, O_WRONLY|O_CREAT, 0644);
359 	if (fd < 0)
360 		syserr("Can't create %s", p);
361 	else
362 		e->e_xfp = fdopen(fd, "w");
363 }
364 /*
365 **  CLOSEXSCRIPT -- close the transcript file.
366 **
367 **	Parameters:
368 **		e -- the envelope containing the transcript to close.
369 **
370 **	Returns:
371 **		none.
372 **
373 **	Side Effects:
374 **		none.
375 */
376 
377 closexscript(e)
378 	register ENVELOPE *e;
379 {
380 	if (e->e_xfp == NULL)
381 		return;
382 	(void) fclose(e->e_xfp);
383 	e->e_xfp = NULL;
384 }
385 /*
386 **  SETSENDER -- set the person who this message is from
387 **
388 **	Under certain circumstances allow the user to say who
389 **	s/he is (using -f or -r).  These are:
390 **	1.  The user's uid is zero (root).
391 **	2.  The user's login name is in an approved list (typically
392 **	    from a network server).
393 **	3.  The address the user is trying to claim has a
394 **	    "!" character in it (since #2 doesn't do it for
395 **	    us if we are dialing out for UUCP).
396 **	A better check to replace #3 would be if the
397 **	effective uid is "UUCP" -- this would require me
398 **	to rewrite getpwent to "grab" uucp as it went by,
399 **	make getname more nasty, do another passwd file
400 **	scan, or compile the UID of "UUCP" into the code,
401 **	all of which are reprehensible.
402 **
403 **	Assuming all of these fail, we figure out something
404 **	ourselves.
405 **
406 **	Parameters:
407 **		from -- the person we would like to believe this message
408 **			is from, as specified on the command line.
409 **		e -- the envelope in which we would like the sender set.
410 **
411 **	Returns:
412 **		none.
413 **
414 **	Side Effects:
415 **		sets sendmail's notion of who the from person is.
416 */
417 
418 setsender(from, e)
419 	char *from;
420 	register ENVELOPE *e;
421 {
422 	register char **pvp;
423 	char *realname = NULL;
424 	register struct passwd *pw;
425 	char buf[MAXNAME];
426 	char pvpbuf[PSBUFSIZE];
427 	extern struct passwd *getpwnam();
428 	extern char *macvalue();
429 	extern char **prescan();
430 	extern bool safefile();
431 	extern char *FullName;
432 
433 	if (tTd(45, 1))
434 		printf("setsender(%s)\n", from == NULL ? "" : from);
435 
436 	/*
437 	**  Figure out the real user executing us.
438 	**	Username can return errno != 0 on non-errors.
439 	*/
440 
441 	if (QueueRun || OpMode == MD_SMTP)
442 		realname = from;
443 	if (realname == NULL || realname[0] == '\0')
444 	{
445 		extern char *username();
446 
447 		realname = username();
448 	}
449 
450 	/*
451 	**  Determine if this real person is allowed to alias themselves.
452 	*/
453 
454 	if (from != NULL)
455 	{
456 		extern bool trusteduser();
457 
458 		if (!trusteduser(realname) && getuid() != geteuid() &&
459 		    strchr(from, '!') == NULL && getuid() != 0)
460 		{
461 			/* network sends -r regardless (why why why?) */
462 			/* syserr("%s, you cannot use the -f flag", realname); */
463 			from = NULL;
464 		}
465 	}
466 
467 /*
468 	SuprErrs = TRUE;
469 */
470 	if (from == NULL || parseaddr(from, &e->e_from, 1, '\0', e) == NULL)
471 	{
472 		/* log garbage addresses for traceback */
473 # ifdef LOG
474 		if (from != NULL && LogLevel >= 1)
475 		{
476 			char *host = RealHostName;
477 
478 			if (host == NULL)
479 				host = MyHostName;
480 			syslog(LOG_NOTICE,
481 				"from=%s unparseable, received from %s@%s",
482 				from, realname, host);
483 		}
484 # endif /* LOG */
485 		if (from != NULL)
486 			SuprErrs = TRUE;
487 		if (from == realname ||
488 		    parseaddr(from = newstr(realname), &e->e_from, 1, '\0', e) == NULL)
489 		{
490 			SuprErrs = TRUE;
491 			if (parseaddr("postmaster", &e->e_from, 1, '\0', e) == NULL)
492 				syserr("setsender: can't even parse postmaster!");
493 		}
494 	}
495 	else
496 		FromFlag = TRUE;
497 	e->e_from.q_flags |= QDONTSEND;
498 	if (tTd(45, 5))
499 	{
500 		printf("setsender: QDONTSEND ");
501 		printaddr(&e->e_from, FALSE);
502 	}
503 	loweraddr(&e->e_from);
504 	SuprErrs = FALSE;
505 
506 	pvp = NULL;
507 	if (e->e_from.q_mailer == LocalMailer)
508 	{
509 # ifdef USERDB
510 		register char *p;
511 		extern char *udbsender();
512 # endif
513 
514 		/* if the user has given fullname already, don't redefine */
515 		if (FullName == NULL)
516 			FullName = macvalue('x', e);
517 		if (FullName != NULL && FullName[0] == '\0')
518 			FullName = NULL;
519 
520 # ifdef USERDB
521 		p = udbsender(from);
522 
523 		if (p != NULL)
524 		{
525 			/*
526 			**  We have an alternate address for the sender
527 			*/
528 
529 			pvp = prescan(p, '\0', pvpbuf);
530 		}
531 # endif /* USERDB */
532 
533 		if ((pw = getpwnam(e->e_from.q_user)) != NULL)
534 		{
535 			/*
536 			**  Process passwd file entry.
537 			*/
538 
539 
540 			/* extract home directory */
541 			e->e_from.q_home = newstr(pw->pw_dir);
542 			define('z', e->e_from.q_home, e);
543 
544 			/* extract user and group id */
545 			e->e_from.q_uid = pw->pw_uid;
546 			e->e_from.q_gid = pw->pw_gid;
547 
548 			/* extract full name from passwd file */
549 			if (FullName == NULL && pw->pw_gecos != NULL &&
550 			    strcmp(pw->pw_name, e->e_from.q_user) == 0)
551 			{
552 				buildfname(pw->pw_gecos, e->e_from.q_user, buf);
553 				if (buf[0] != '\0')
554 					FullName = newstr(buf);
555 			}
556 		}
557 		if (FullName != NULL)
558 			define('x', FullName, e);
559 	}
560 	else
561 	{
562 		if (e->e_from.q_home == NULL)
563 			e->e_from.q_home = getenv("HOME");
564 		e->e_from.q_uid = getuid();
565 		e->e_from.q_gid = getgid();
566 	}
567 
568 	/*
569 	**  Rewrite the from person to dispose of possible implicit
570 	**	links in the net.
571 	*/
572 
573 	if (pvp == NULL)
574 		pvp = prescan(from, '\0', pvpbuf);
575 	if (pvp == NULL)
576 	{
577 # ifdef LOG
578 		if (LogLevel >= 1)
579 			syslog(LOG_NOTICE, "cannot prescan from (%s)", from);
580 # endif
581 		usrerr("cannot prescan from (%s)", from);
582 		finis();
583 	}
584 	rewrite(pvp, 3);
585 	rewrite(pvp, 1);
586 	rewrite(pvp, 4);
587 	cataddr(pvp, buf, sizeof buf);
588 	e->e_sender = e->e_returnpath = newstr(buf);
589 
590 	define('f', e->e_sender, e);
591 
592 	/* save the domain spec if this mailer wants it */
593 	if (e->e_from.q_mailer != NULL &&
594 	    bitnset(M_CANONICAL, e->e_from.q_mailer->m_flags))
595 	{
596 		extern char **copyplist();
597 
598 		while (*pvp != NULL && strcmp(*pvp, "@") != 0)
599 			pvp++;
600 		if (*pvp != NULL)
601 			e->e_fromdomain = copyplist(pvp, TRUE);
602 	}
603 }
604 /*
605 **  TRUSTEDUSER -- tell us if this user is to be trusted.
606 **
607 **	Parameters:
608 **		user -- the user to be checked.
609 **
610 **	Returns:
611 **		TRUE if the user is in an approved list.
612 **		FALSE otherwise.
613 **
614 **	Side Effects:
615 **		none.
616 */
617 
618 bool
619 trusteduser(user)
620 	char *user;
621 {
622 	register char **ulist;
623 	extern char *TrustedUsers[];
624 
625 	for (ulist = TrustedUsers; *ulist != NULL; ulist++)
626 		if (strcmp(*ulist, user) == 0)
627 			return (TRUE);
628 	return (FALSE);
629 }
630