mail.local.c revision 168520 
1/*
2 * Copyright (c) 1998-2004 Sendmail, Inc. and its suppliers.
3 *	All rights reserved.
4 * Copyright (c) 1990, 1993, 1994
5 *	The Regents of the University of California.  All rights reserved.
6 *
7 * By using this file, you agree to the terms and conditions set
8 * forth in the LICENSE file which can be found at the top level of
9 * the sendmail distribution.
10 *
11 * $FreeBSD: head/contrib/sendmail/mail.local/mail.local.c 168520 2007-04-09 01:44:16Z gshapiro $
12 *
13 */
14
15#include <sm/gen.h>
16
17SM_IDSTR(copyright,
18"@(#) Copyright (c) 1998-2004 Sendmail, Inc. and its suppliers.\n\
19	All rights reserved.\n\
20     Copyright (c) 1990, 1993, 1994\n\
21	The Regents of the University of California.  All rights reserved.\n")
22
23SM_IDSTR(id, "@(#)$Id: mail.local.c,v 8.254 2006/10/12 22:23:45 ca Exp $")
24
25#include <stdlib.h>
26#include <sm/errstring.h>
27#include <sm/io.h>
28#include <sm/limits.h>
29# include <unistd.h>
30# ifdef EX_OK
31#  undef EX_OK		/* unistd.h may have another use for this */
32# endif /* EX_OK */
33# define LOCKFILE_PMODE 0
34#include <sm/mbdb.h>
35#include <sm/sysexits.h>
36
37#ifndef HASHSPOOL
38# define HASHSPOOL	0
39#endif /* ! HASHSPOOL */
40#ifndef HASHSPOOLMD5
41# define HASHSPOOLMD5	0
42#endif /* ! HASHSPOOLMD5 */
43
44/*
45**  This is not intended to work on System V derived systems
46**  such as Solaris or HP-UX, since they use a totally different
47**  approach to mailboxes (essentially, they have a set-group-ID program
48**  rather than set-user-ID, and they rely on the ability to "give away"
49**  files to do their work).  IT IS NOT A BUG that this doesn't
50**  work on such architectures.
51*/
52
53
54#include <stdio.h>
55#include <errno.h>
56#include <fcntl.h>
57#include <sys/types.h>
58#include <sys/stat.h>
59#include <time.h>
60#include <stdlib.h>
61# include <sys/socket.h>
62# include <sys/file.h>
63# include <netinet/in.h>
64# include <arpa/nameser.h>
65# include <netdb.h>
66# include <pwd.h>
67
68#include <sm/string.h>
69#include <syslog.h>
70#include <ctype.h>
71
72#include <sm/conf.h>
73#include <sendmail/pathnames.h>
74
75#if HASHSPOOL
76# define HASH_NONE	0
77# define HASH_USER	1
78# if HASHSPOOLMD5
79#  define HASH_MD5	2
80#  include <openssl/md5.h>
81# endif /* HASHSPOOLMD5 */
82#endif /* HASHSPOOL */
83
84
85#ifndef LOCKTO_RM
86# define LOCKTO_RM	300	/* timeout for stale lockfile removal */
87#endif /* ! LOCKTO_RM */
88#ifndef LOCKTO_GLOB
89# define LOCKTO_GLOB	400	/* global timeout for lockfile creation */
90#endif /* ! LOCKTO_GLOB */
91
92/* define a realloc() which works for NULL pointers */
93#define REALLOC(ptr, size)	(((ptr) == NULL) ? malloc(size) : realloc(ptr, size))
94
95/*
96**  If you don't have flock, you could try using lockf instead.
97*/
98
99#ifdef LDA_USE_LOCKF
100# define flock(a, b)	lockf(a, b, 0)
101# ifdef LOCK_EX
102#  undef LOCK_EX
103# endif /* LOCK_EX */
104# define LOCK_EX	F_LOCK
105#endif /* LDA_USE_LOCKF */
106
107#ifndef LOCK_EX
108# include <sys/file.h>
109#endif /* ! LOCK_EX */
110
111/*
112**  If you don't have setreuid, and you have saved uids, and you have
113**  a seteuid() call that doesn't try to emulate using setuid(), then
114**  you can try defining LDA_USE_SETEUID.
115*/
116
117#ifdef LDA_USE_SETEUID
118# define setreuid(r, e)		seteuid(e)
119#endif /* LDA_USE_SETEUID */
120
121#ifdef LDA_CONTENTLENGTH
122# define CONTENTLENGTH	1
123#endif /* LDA_CONTENTLENGTH */
124
125#ifndef INADDRSZ
126# define INADDRSZ	4		/* size of an IPv4 address in bytes */
127#endif /* ! INADDRSZ */
128
129#ifdef MAILLOCK
130# include <maillock.h>
131#endif /* MAILLOCK */
132
133#ifndef MAILER_DAEMON
134# define MAILER_DAEMON	"MAILER-DAEMON"
135#endif /* ! MAILER_DAEMON */
136
137#ifdef CONTENTLENGTH
138char	ContentHdr[40] = "Content-Length: ";
139off_t	HeaderLength;
140off_t	BodyLength;
141#endif /* CONTENTLENGTH */
142
143bool	EightBitMime = true;		/* advertise 8BITMIME in LMTP */
144char	ErrBuf[10240];			/* error buffer */
145int	ExitVal = EX_OK;		/* sysexits.h error value. */
146bool	nobiff = false;
147bool	nofsync = false;
148bool	HoldErrs = false;		/* Hold errors in ErrBuf */
149bool	LMTPMode = false;
150bool	BounceQuota = false;		/* permanent error when over quota */
151bool	CloseMBDB = false;
152char	*HomeMailFile = NULL;		/* store mail in homedir */
153
154#if HASHSPOOL
155int	HashType = HASH_NONE;
156int	HashDepth = 0;
157bool	StripRcptDomain = true;
158#else /* HASHSPOOL */
159# define StripRcptDomain true
160#endif /* HASHSPOOL */
161char	SpoolPath[MAXPATHLEN];
162
163char	*parseaddr __P((char *, bool));
164char	*process_recipient __P((char *));
165void	dolmtp __P((void));
166void	deliver __P((int, char *));
167int	e_to_sys __P((int));
168void	notifybiff __P((char *));
169int	store __P((char *, bool *));
170void	usage __P((void));
171int	lockmbox __P((char *));
172void	unlockmbox __P((void));
173void	mailerr __P((const char *, const char *, ...));
174void	flush_error __P((void));
175#if HASHSPOOL
176const char	*hashname __P((char *));
177#endif /* HASHSPOOL */
178
179
180static void sm_exit __P((int));
181
182static void
183sm_exit(status)
184	int status;
185{
186	if (CloseMBDB)
187	{
188		sm_mbdb_terminate();
189		CloseMBDB = false;	/* not really necessary, but ... */
190	}
191	exit(status);
192}
193
194int
195main(argc, argv)
196	int argc;
197	char *argv[];
198{
199	struct passwd *pw;
200	int ch, fd;
201	uid_t uid;
202	char *from;
203	char *mbdbname = "pw";
204	int err;
205	extern char *optarg;
206	extern int optind;
207
208
209	/* make sure we have some open file descriptors */
210	for (fd = 10; fd < 30; fd++)
211		(void) close(fd);
212
213	/* use a reasonable umask */
214	(void) umask(0077);
215
216# ifdef LOG_MAIL
217	openlog("mail.local", 0, LOG_MAIL);
218# else /* LOG_MAIL */
219	openlog("mail.local", 0);
220# endif /* LOG_MAIL */
221
222	from = NULL;
223
224	/* XXX can this be converted to a compile time check? */
225	if (sm_strlcpy(SpoolPath, _PATH_MAILDIR, sizeof(SpoolPath)) >=
226	    sizeof(SpoolPath))
227	{
228		mailerr("421", "Configuration error: _PATH_MAILDIR too large");
229		sm_exit(EX_CONFIG);
230	}
231#if HASHSPOOL
232	while ((ch = getopt(argc, argv, "7BbdD:f:h:r:lH:p:ns")) != -1)
233#else /* HASHSPOOL */
234	while ((ch = getopt(argc, argv, "7BbdD:f:h:r:ls")) != -1)
235#endif /* HASHSPOOL */
236	{
237		switch(ch)
238		{
239		  case '7':		/* Do not advertise 8BITMIME */
240			EightBitMime = false;
241			break;
242
243		  case 'B':
244			nobiff = true;
245			break;
246
247		  case 'b':		/* bounce mail when over quota. */
248			BounceQuota = true;
249			break;
250
251		  case 'd':		/* Backward compatible. */
252			break;
253
254		  case 'D':		/* mailbox database type */
255			mbdbname = optarg;
256			break;
257
258		  case 'f':
259		  case 'r':		/* Backward compatible. */
260			if (from != NULL)
261			{
262				mailerr(NULL, "Multiple -f options");
263				usage();
264			}
265			from = optarg;
266			break;
267
268		  case 'h':
269			if (optarg != NULL || *optarg != '\0')
270				HomeMailFile = optarg;
271			else
272			{
273				mailerr(NULL, "-h: missing filename");
274				usage();
275			}
276			break;
277
278		  case 'l':
279			LMTPMode = true;
280			break;
281
282		  case 's':
283			nofsync++;
284			break;
285
286#if HASHSPOOL
287		  case 'H':
288			if (optarg == NULL || *optarg == '\0')
289			{
290				mailerr(NULL, "-H: missing hashinfo");
291				usage();
292			}
293			switch(optarg[0])
294			{
295			  case 'u':
296				HashType = HASH_USER;
297				break;
298
299# if HASHSPOOLMD5
300			  case 'm':
301				HashType = HASH_MD5;
302				break;
303# endif /* HASHSPOOLMD5 */
304
305			  default:
306				mailerr(NULL, "-H: unknown hash type");
307				usage();
308			}
309			if (optarg[1] == '\0')
310			{
311				mailerr(NULL, "-H: invalid hash depth");
312				usage();
313			}
314			HashDepth = atoi(&optarg[1]);
315			if ((HashDepth <= 0) || ((HashDepth * 2) >= MAXPATHLEN))
316			{
317				mailerr(NULL, "-H: invalid hash depth");
318				usage();
319			}
320			break;
321
322		  case 'p':
323			if (optarg == NULL || *optarg == '\0')
324			{
325				mailerr(NULL, "-p: missing spool path");
326				usage();
327			}
328			if (sm_strlcpy(SpoolPath, optarg, sizeof(SpoolPath)) >=
329			    sizeof(SpoolPath))
330			{
331				mailerr(NULL, "-p: invalid spool path");
332				usage();
333			}
334			break;
335
336		  case 'n':
337			StripRcptDomain = false;
338			break;
339#endif /* HASHSPOOL */
340
341		  case '?':
342		  default:
343			usage();
344		}
345	}
346	argc -= optind;
347	argv += optind;
348
349	/* initialize biff structures */
350	if (!nobiff)
351		notifybiff(NULL);
352
353	err = sm_mbdb_initialize(mbdbname);
354	if (err != EX_OK)
355	{
356		char *errcode = "521";
357
358		if (err == EX_TEMPFAIL)
359			errcode = "421";
360
361		mailerr(errcode, "Can not open mailbox database %s: %s",
362			mbdbname, sm_strexit(err));
363		sm_exit(err);
364	}
365	CloseMBDB = true;
366
367	if (LMTPMode)
368	{
369		if (argc > 0)
370		{
371			mailerr("421", "Users should not be specified in command line if LMTP required");
372			sm_exit(EX_TEMPFAIL);
373		}
374
375		dolmtp();
376		/* NOTREACHED */
377		sm_exit(EX_OK);
378	}
379
380	/* Non-LMTP from here on out */
381	if (*argv == '\0')
382		usage();
383
384	/*
385	**  If from not specified, use the name from getlogin() if the
386	**  uid matches, otherwise, use the name from the password file
387	**  corresponding to the uid.
388	*/
389
390	uid = getuid();
391	if (from == NULL && ((from = getlogin()) == NULL ||
392			     (pw = getpwnam(from)) == NULL ||
393			     pw->pw_uid != uid))
394		from = (pw = getpwuid(uid)) != NULL ? pw->pw_name : "???";
395
396	/*
397	**  There is no way to distinguish the error status of one delivery
398	**  from the rest of the deliveries.  So, if we failed hard on one
399	**  or more deliveries, but had no failures on any of the others, we
400	**  return a hard failure.  If we failed temporarily on one or more
401	**  deliveries, we return a temporary failure regardless of the other
402	**  failures.  This results in the delivery being reattempted later
403	**  at the expense of repeated failures and multiple deliveries.
404	*/
405
406	HoldErrs = true;
407	fd = store(from, NULL);
408	HoldErrs = false;
409	if (fd < 0)
410	{
411		flush_error();
412		sm_exit(ExitVal);
413	}
414	for (; *argv != NULL; ++argv)
415		deliver(fd, *argv);
416	sm_exit(ExitVal);
417	/* NOTREACHED */
418	return ExitVal;
419}
420
421char *
422parseaddr(s, rcpt)
423	char *s;
424	bool rcpt;
425{
426	char *p;
427	int l;
428
429	if (*s++ != '<')
430		return NULL;
431
432	p = s;
433
434	/* at-domain-list */
435	while (*p == '@')
436	{
437		p++;
438		while (*p != ',' && *p != ':' && *p != '\0')
439			p++;
440		if (*p == '\0')
441			return NULL;
442
443		/* Skip over , or : */
444		p++;
445	}
446
447	s = p;
448
449	/* local-part */
450	while (*p != '\0' && *p != '@' && *p != '>')
451	{
452		if (*p == '\\')
453		{
454			if (*++p == '\0')
455				return NULL;
456		}
457		else if (*p == '\"')
458		{
459			p++;
460			while (*p != '\0' && *p != '\"')
461			{
462				if (*p == '\\')
463				{
464					if (*++p == '\0')
465						return NULL;
466				}
467				p++;
468			}
469			if (*p == '\0' || *(p + 1) == '\0')
470				return NULL;
471		}
472		/* +detail ? */
473		if (*p == '+' && rcpt)
474			*p = '\0';
475		p++;
476	}
477
478	/* @domain */
479	if (*p == '@')
480	{
481		if (rcpt)
482			*p++ = '\0';
483		while (*p != '\0' && *p != '>')
484			p++;
485	}
486
487	if (*p != '>')
488		return NULL;
489	else
490		*p = '\0';
491	p++;
492
493	if (*p != '\0' && *p != ' ')
494		return NULL;
495
496	if (*s == '\0')
497		s = MAILER_DAEMON;
498
499	l = strlen(s) + 1;
500	if (l < 0)
501		return NULL;
502	p = malloc(l);
503	if (p == NULL)
504	{
505		mailerr("421 4.3.0", "Memory exhausted");
506		sm_exit(EX_TEMPFAIL);
507	}
508
509	(void) sm_strlcpy(p, s, l);
510	return p;
511}
512
513char *
514process_recipient(addr)
515	char *addr;
516{
517	SM_MBDB_T user;
518
519	switch (sm_mbdb_lookup(addr, &user))
520	{
521	  case EX_OK:
522		return NULL;
523
524	  case EX_NOUSER:
525		return "550 5.1.1 User unknown";
526
527	  case EX_TEMPFAIL:
528		return "451 4.3.0 User database failure; retry later";
529
530	  default:
531		return "550 5.3.0 User database failure";
532	}
533}
534
535#define RCPT_GROW	30
536
537void
538dolmtp()
539{
540	char *return_path = NULL;
541	char **rcpt_addr = NULL;
542	int rcpt_num = 0;
543	int rcpt_alloc = 0;
544	bool gotlhlo = false;
545	char *err;
546	int msgfd;
547	char *p;
548	int i;
549	char myhostname[1024];
550	char buf[4096];
551
552	memset(myhostname, '\0', sizeof myhostname);
553	(void) gethostname(myhostname, sizeof myhostname - 1);
554	if (myhostname[0] == '\0')
555		sm_strlcpy(myhostname, "localhost", sizeof myhostname);
556
557	printf("220 %s LMTP ready\r\n", myhostname);
558	for (;;)
559	{
560		(void) fflush(stdout);
561		if (fgets(buf, sizeof(buf) - 1, stdin) == NULL)
562			sm_exit(EX_OK);
563		p = buf + strlen(buf) - 1;
564		if (p >= buf && *p == '\n')
565			*p-- = '\0';
566		if (p >= buf && *p == '\r')
567			*p-- = '\0';
568
569		switch (buf[0])
570		{
571		  case 'd':
572		  case 'D':
573			if (sm_strcasecmp(buf, "data") == 0)
574			{
575				bool inbody = false;
576
577				if (rcpt_num == 0)
578				{
579					mailerr("503 5.5.1", "No recipients");
580					continue;
581				}
582				HoldErrs = true;
583				msgfd = store(return_path, &inbody);
584				HoldErrs = false;
585				if (msgfd < 0 && !inbody)
586				{
587					flush_error();
588					continue;
589				}
590
591				for (i = 0; i < rcpt_num; i++)
592				{
593					if (msgfd < 0)
594					{
595						/* print error for rcpt */
596						flush_error();
597						continue;
598					}
599					p = strchr(rcpt_addr[i], '+');
600					if (p != NULL)
601						*p = '\0';
602					deliver(msgfd, rcpt_addr[i]);
603				}
604				if (msgfd >= 0)
605					(void) close(msgfd);
606				goto rset;
607			}
608			goto syntaxerr;
609			/* NOTREACHED */
610			break;
611
612		  case 'l':
613		  case 'L':
614			if (sm_strncasecmp(buf, "lhlo ", 5) == 0)
615			{
616				/* check for duplicate per RFC 1651 4.2 */
617				if (gotlhlo)
618				{
619					mailerr("503", "%s Duplicate LHLO",
620					       myhostname);
621					continue;
622				}
623				gotlhlo = true;
624				printf("250-%s\r\n", myhostname);
625				if (EightBitMime)
626					printf("250-8BITMIME\r\n");
627				printf("250-ENHANCEDSTATUSCODES\r\n");
628				printf("250 PIPELINING\r\n");
629				continue;
630			}
631			goto syntaxerr;
632			/* NOTREACHED */
633			break;
634
635		  case 'm':
636		  case 'M':
637			if (sm_strncasecmp(buf, "mail ", 5) == 0)
638			{
639				if (return_path != NULL)
640				{
641					mailerr("503 5.5.1",
642						"Nested MAIL command");
643					continue;
644				}
645				if (sm_strncasecmp(buf + 5, "from:", 5) != 0 ||
646				    ((return_path = parseaddr(buf + 10,
647							      false)) == NULL))
648				{
649					mailerr("501 5.5.4",
650						"Syntax error in parameters");
651					continue;
652				}
653				printf("250 2.5.0 Ok\r\n");
654				continue;
655			}
656			goto syntaxerr;
657			/* NOTREACHED */
658			break;
659
660		  case 'n':
661		  case 'N':
662			if (sm_strcasecmp(buf, "noop") == 0)
663			{
664				printf("250 2.0.0 Ok\r\n");
665				continue;
666			}
667			goto syntaxerr;
668			/* NOTREACHED */
669			break;
670
671		  case 'q':
672		  case 'Q':
673			if (sm_strcasecmp(buf, "quit") == 0)
674			{
675				printf("221 2.0.0 Bye\r\n");
676				sm_exit(EX_OK);
677			}
678			goto syntaxerr;
679			/* NOTREACHED */
680			break;
681
682		  case 'r':
683		  case 'R':
684			if (sm_strncasecmp(buf, "rcpt ", 5) == 0)
685			{
686				if (return_path == NULL)
687				{
688					mailerr("503 5.5.1",
689						"Need MAIL command");
690					continue;
691				}
692				if (rcpt_num >= rcpt_alloc)
693				{
694					rcpt_alloc += RCPT_GROW;
695					rcpt_addr = (char **)
696						REALLOC((char *) rcpt_addr,
697							rcpt_alloc *
698							sizeof(char **));
699					if (rcpt_addr == NULL)
700					{
701						mailerr("421 4.3.0",
702							"Memory exhausted");
703						sm_exit(EX_TEMPFAIL);
704					}
705				}
706				if (sm_strncasecmp(buf + 5, "to:", 3) != 0 ||
707				    ((rcpt_addr[rcpt_num] = parseaddr(buf + 8,
708								      StripRcptDomain)) == NULL))
709				{
710					mailerr("501 5.5.4",
711						"Syntax error in parameters");
712					continue;
713				}
714				err = process_recipient(rcpt_addr[rcpt_num]);
715				if (err != NULL)
716				{
717					mailerr(NULL, "%s", err);
718					continue;
719				}
720				rcpt_num++;
721				printf("250 2.1.5 Ok\r\n");
722				continue;
723			}
724			else if (sm_strcasecmp(buf, "rset") == 0)
725			{
726				printf("250 2.0.0 Ok\r\n");
727
728rset:
729				while (rcpt_num > 0)
730					free(rcpt_addr[--rcpt_num]);
731				if (return_path != NULL)
732					free(return_path);
733				return_path = NULL;
734				continue;
735			}
736			goto syntaxerr;
737			/* NOTREACHED */
738			break;
739
740		  case 'v':
741		  case 'V':
742			if (sm_strncasecmp(buf, "vrfy ", 5) == 0)
743			{
744				printf("252 2.3.3 Try RCPT to attempt delivery\r\n");
745				continue;
746			}
747			goto syntaxerr;
748			/* NOTREACHED */
749			break;
750
751		  default:
752  syntaxerr:
753			mailerr("500 5.5.2", "Syntax error");
754			continue;
755			/* NOTREACHED */
756			break;
757		}
758	}
759}
760
761int
762store(from, inbody)
763	char *from;
764	bool *inbody;
765{
766	FILE *fp = NULL;
767	time_t tval;
768	bool eline;		/* previous line was empty */
769	bool fullline = true;	/* current line is terminated */
770	bool prevfl;		/* previous line was terminated */
771	char line[2048];
772	int fd;
773	char tmpbuf[sizeof _PATH_LOCTMP + 1];
774
775	if (inbody != NULL)
776		*inbody = false;
777
778	(void) umask(0077);
779	(void) sm_strlcpy(tmpbuf, _PATH_LOCTMP, sizeof tmpbuf);
780	if ((fd = mkstemp(tmpbuf)) < 0 || (fp = fdopen(fd, "w+")) == NULL)
781	{
782		if (fd >= 0)
783			(void) close(fd);
784		mailerr("451 4.3.0", "Unable to open temporary file");
785		return -1;
786	}
787	(void) unlink(tmpbuf);
788
789	if (LMTPMode)
790	{
791		printf("354 Go ahead\r\n");
792		(void) fflush(stdout);
793	}
794	if (inbody != NULL)
795		*inbody = true;
796
797	(void) time(&tval);
798	(void) fprintf(fp, "From %s %s", from, ctime(&tval));
799
800#ifdef CONTENTLENGTH
801	HeaderLength = 0;
802	BodyLength = -1;
803#endif /* CONTENTLENGTH */
804
805	line[0] = '\0';
806	eline = true;
807	while (fgets(line, sizeof(line), stdin) != (char *) NULL)
808	{
809		size_t line_len = 0;
810		int peek;
811
812		prevfl = fullline;	/* preserve state of previous line */
813		while (line[line_len] != '\n' && line_len < sizeof(line) - 2)
814			line_len++;
815		line_len++;
816
817		/* Check for dot-stuffing */
818		if (prevfl && LMTPMode && line[0] == '.')
819		{
820			if (line[1] == '\n' ||
821			    (line[1] == '\r' && line[2] == '\n'))
822				goto lmtpdot;
823			memcpy(line, line + 1, line_len);
824			line_len--;
825		}
826
827		/* Check to see if we have the full line from fgets() */
828		fullline = false;
829		if (line_len > 0)
830		{
831			if (line[line_len - 1] == '\n')
832			{
833				if (line_len >= 2 &&
834				    line[line_len - 2] == '\r')
835				{
836					line[line_len - 2] = '\n';
837					line[line_len - 1] = '\0';
838					line_len--;
839				}
840				fullline = true;
841			}
842			else if (line[line_len - 1] == '\r')
843			{
844				/* Did we just miss the CRLF? */
845				peek = fgetc(stdin);
846				if (peek == '\n')
847				{
848					line[line_len - 1] = '\n';
849					fullline = true;
850				}
851				else
852					(void) ungetc(peek, stdin);
853			}
854		}
855		else
856			fullline = true;
857
858#ifdef CONTENTLENGTH
859		if (prevfl && line[0] == '\n' && HeaderLength == 0)
860		{
861			eline = false;
862			if (fp != NULL)
863				HeaderLength = ftell(fp);
864			if (HeaderLength <= 0)
865			{
866				/*
867				**  shouldn't happen, unless ftell() is
868				**  badly broken
869				*/
870
871				HeaderLength = -1;
872			}
873		}
874#else /* CONTENTLENGTH */
875		if (prevfl && line[0] == '\n')
876			eline = true;
877#endif /* CONTENTLENGTH */
878		else
879		{
880			if (eline && line[0] == 'F' &&
881			    fp != NULL &&
882			    !memcmp(line, "From ", 5))
883				(void) putc('>', fp);
884			eline = false;
885#ifdef CONTENTLENGTH
886			/* discard existing "Content-Length:" headers */
887			if (prevfl && HeaderLength == 0 &&
888			    (line[0] == 'C' || line[0] == 'c') &&
889			    sm_strncasecmp(line, ContentHdr, 15) == 0)
890			{
891				/*
892				**  be paranoid: clear the line
893				**  so no "wrong matches" may occur later
894				*/
895				line[0] = '\0';
896				continue;
897			}
898#endif /* CONTENTLENGTH */
899
900		}
901		if (fp != NULL)
902		{
903			(void) fwrite(line, sizeof(char), line_len, fp);
904			if (ferror(fp))
905			{
906				mailerr("451 4.3.0",
907					"Temporary file write error");
908				(void) fclose(fp);
909				fp = NULL;
910				continue;
911			}
912		}
913	}
914
915	/* check if an error occurred */
916	if (fp == NULL)
917		return -1;
918
919	if (LMTPMode)
920	{
921		/* Got a premature EOF -- toss message and exit */
922		sm_exit(EX_OK);
923	}
924
925	/* If message not newline terminated, need an extra. */
926	if (fp != NULL && strchr(line, '\n') == NULL)
927		(void) putc('\n', fp);
928
929  lmtpdot:
930
931#ifdef CONTENTLENGTH
932	if (fp != NULL)
933		BodyLength = ftell(fp);
934	if (HeaderLength == 0 && BodyLength > 0)	/* empty body */
935	{
936		HeaderLength = BodyLength;
937		BodyLength = 0;
938	}
939	else
940		BodyLength = BodyLength - HeaderLength - 1 ;
941
942	if (HeaderLength > 0 && BodyLength >= 0)
943	{
944		(void) sm_snprintf(line, sizeof line, "%lld\n",
945				   (LONGLONG_T) BodyLength);
946		(void) sm_strlcpy(&ContentHdr[16], line,
947				  sizeof(ContentHdr) - 16);
948	}
949	else
950		BodyLength = -1;	/* Something is wrong here */
951#endif /* CONTENTLENGTH */
952
953	/* Output a newline; note, empty messages are allowed. */
954	if (fp != NULL)
955		(void) putc('\n', fp);
956
957	if (fp == NULL || fflush(fp) == EOF || ferror(fp) != 0)
958	{
959		mailerr("451 4.3.0", "Temporary file write error");
960		if (fp != NULL)
961			(void) fclose(fp);
962		return -1;
963	}
964	return fd;
965}
966
967void
968deliver(fd, name)
969	int fd;
970	char *name;
971{
972	struct stat fsb;
973	struct stat sb;
974	char path[MAXPATHLEN];
975	int mbfd = -1, nr = 0, nw, off;
976	int exitval;
977	char *p;
978	char *errcode;
979	off_t curoff, cursize;
980#ifdef CONTENTLENGTH
981	off_t headerbytes;
982	int readamount;
983#endif /* CONTENTLENGTH */
984	char biffmsg[100], buf[8 * 1024];
985	SM_MBDB_T user;
986
987	/*
988	**  Disallow delivery to unknown names -- special mailboxes can be
989	**  handled in the sendmail aliases file.
990	*/
991
992	exitval = sm_mbdb_lookup(name, &user);
993	switch (exitval)
994	{
995	  case EX_OK:
996		break;
997
998	  case EX_NOUSER:
999		exitval = EX_UNAVAILABLE;
1000		mailerr("550 5.1.1", "%s: User unknown", name);
1001		break;
1002
1003	  case EX_TEMPFAIL:
1004		mailerr("451 4.3.0", "%s: User database failure; retry later",
1005			name);
1006		break;
1007
1008	  default:
1009		exitval = EX_UNAVAILABLE;
1010		mailerr("550 5.3.0", "%s: User database failure", name);
1011		break;
1012	}
1013
1014	if (exitval != EX_OK)
1015	{
1016		if (ExitVal != EX_TEMPFAIL)
1017			ExitVal = exitval;
1018		return;
1019	}
1020
1021	endpwent();
1022
1023	/*
1024	**  Keep name reasonably short to avoid buffer overruns.
1025	**	This isn't necessary on BSD because of the proper
1026	**	definition of snprintf(), but it can cause problems
1027	**	on other systems.
1028	**  Also, clear out any bogus characters.
1029	*/
1030
1031#if !HASHSPOOL
1032	if (strlen(name) > 40)
1033		name[40] = '\0';
1034	for (p = name; *p != '\0'; p++)
1035	{
1036		if (!isascii(*p))
1037			*p &= 0x7f;
1038		else if (!isprint(*p))
1039			*p = '.';
1040	}
1041#endif /* !HASHSPOOL */
1042
1043
1044	if (HomeMailFile == NULL)
1045	{
1046		if (sm_strlcpyn(path, sizeof(path),
1047#if HASHSPOOL
1048				4,
1049#else /* HASHSPOOL */
1050				3,
1051#endif /* HASHSPOOL */
1052				SpoolPath, "/",
1053#if HASHSPOOL
1054				hashname(name),
1055#endif /* HASHSPOOL */
1056				name) >= sizeof(path))
1057		{
1058			exitval = EX_UNAVAILABLE;
1059			mailerr("550 5.1.1", "%s: Invalid mailbox path", name);
1060			return;
1061		}
1062	}
1063	else if (*user.mbdb_homedir == '\0')
1064	{
1065		exitval = EX_UNAVAILABLE;
1066		mailerr("550 5.1.1", "%s: User missing home directory", name);
1067		return;
1068	}
1069	else if (sm_snprintf(path, sizeof(path), "%s/%s",
1070			     user.mbdb_homedir, HomeMailFile) >= sizeof(path))
1071	{
1072		exitval = EX_UNAVAILABLE;
1073		mailerr("550 5.1.1", "%s: Invalid mailbox path", name);
1074		return;
1075	}
1076
1077
1078	/*
1079	**  If the mailbox is linked or a symlink, fail.  There's an obvious
1080	**  race here, that the file was replaced with a symbolic link after
1081	**  the lstat returned, but before the open.  We attempt to detect
1082	**  this by comparing the original stat information and information
1083	**  returned by an fstat of the file descriptor returned by the open.
1084	**
1085	**  NB: this is a symptom of a larger problem, that the mail spooling
1086	**  directory is writeable by the wrong users.  If that directory is
1087	**  writeable, system security is compromised for other reasons, and
1088	**  it cannot be fixed here.
1089	**
1090	**  If we created the mailbox, set the owner/group.  If that fails,
1091	**  just return.  Another process may have already opened it, so we
1092	**  can't unlink it.  Historically, binmail set the owner/group at
1093	**  each mail delivery.  We no longer do this, assuming that if the
1094	**  ownership or permissions were changed there was a reason.
1095	**
1096	**  XXX
1097	**  open(2) should support flock'ing the file.
1098	*/
1099
1100tryagain:
1101#ifdef MAILLOCK
1102	p = name;
1103#else /* MAILLOCK */
1104	p = path;
1105#endif /* MAILLOCK */
1106	if ((off = lockmbox(p)) != 0)
1107	{
1108		if (off == EX_TEMPFAIL || e_to_sys(off) == EX_TEMPFAIL)
1109		{
1110			ExitVal = EX_TEMPFAIL;
1111			errcode = "451 4.3.0";
1112		}
1113		else
1114			errcode = "551 5.3.0";
1115
1116		mailerr(errcode, "lockmailbox %s failed; error code %d %s",
1117			p, off, errno > 0 ? sm_errstring(errno) : "");
1118		return;
1119	}
1120
1121	if (lstat(path, &sb) < 0)
1122	{
1123		int save_errno;
1124		int mode = S_IRUSR|S_IWUSR;
1125		gid_t gid = user.mbdb_gid;
1126
1127#ifdef MAILGID
1128		(void) umask(0007);
1129		gid = MAILGID;
1130		mode |= S_IRGRP|S_IWGRP;
1131#endif /* MAILGID */
1132
1133		mbfd = open(path, O_APPEND|O_CREAT|O_EXCL|O_WRONLY,
1134			    mode);
1135		save_errno = errno;
1136
1137		if (lstat(path, &sb) < 0)
1138		{
1139			ExitVal = EX_CANTCREAT;
1140			mailerr("550 5.2.0",
1141				"%s: lstat: file changed after open", path);
1142			goto err1;
1143		}
1144		if (mbfd < 0)
1145		{
1146			if (save_errno == EEXIST)
1147				goto tryagain;
1148
1149			/* open failed, don't try again */
1150			mailerr("450 4.2.0", "%s: %s", path,
1151				sm_errstring(save_errno));
1152			goto err0;
1153		}
1154		else if (fchown(mbfd, user.mbdb_uid, gid) < 0)
1155		{
1156			mailerr("451 4.3.0", "chown %u.%u: %s",
1157				user.mbdb_uid, gid, name);
1158			goto err1;
1159		}
1160		else
1161		{
1162			/*
1163			**  open() was successful, now close it so can
1164			**  be opened as the right owner again.
1165			**  Paranoia: reset mbdf since the file descriptor
1166			**  is no longer valid; better safe than sorry.
1167			*/
1168
1169			sb.st_uid = user.mbdb_uid;
1170			(void) close(mbfd);
1171			mbfd = -1;
1172		}
1173	}
1174	else if (sb.st_nlink != 1)
1175	{
1176		mailerr("550 5.2.0", "%s: too many links", path);
1177		goto err0;
1178	}
1179	else if (!S_ISREG(sb.st_mode))
1180	{
1181		mailerr("550 5.2.0", "%s: irregular file", path);
1182		goto err0;
1183	}
1184	else if (sb.st_uid != user.mbdb_uid)
1185	{
1186		ExitVal = EX_CANTCREAT;
1187		mailerr("550 5.2.0", "%s: wrong ownership (%d)",
1188			path, (int) sb.st_uid);
1189		goto err0;
1190	}
1191
1192	/* change UID for quota checks */
1193	if (setreuid(0, user.mbdb_uid) < 0)
1194	{
1195		mailerr("450 4.2.0", "setreuid(0, %d): %s (r=%d, e=%d)",
1196			(int) user.mbdb_uid, sm_errstring(errno),
1197			(int) getuid(), (int) geteuid());
1198		goto err1;
1199	}
1200#ifdef DEBUG
1201	fprintf(stderr, "new euid = %d\n", (int) geteuid());
1202#endif /* DEBUG */
1203	mbfd = open(path, O_APPEND|O_WRONLY, 0);
1204	if (mbfd < 0)
1205	{
1206		mailerr("450 4.2.0", "%s: %s", path, sm_errstring(errno));
1207		goto err0;
1208	}
1209	else if (fstat(mbfd, &fsb) < 0 ||
1210		 fsb.st_nlink != 1 ||
1211		 sb.st_nlink != 1 ||
1212		 !S_ISREG(fsb.st_mode) ||
1213		 sb.st_dev != fsb.st_dev ||
1214		 sb.st_ino != fsb.st_ino ||
1215# if HAS_ST_GEN && 0		/* AFS returns random values for st_gen */
1216		 sb.st_gen != fsb.st_gen ||
1217# endif /* HAS_ST_GEN && 0 */
1218		 sb.st_uid != fsb.st_uid)
1219	{
1220		ExitVal = EX_TEMPFAIL;
1221		mailerr("550 5.2.0", "%s: fstat: file changed after open",
1222			path);
1223		goto err1;
1224	}
1225
1226#if 0
1227	/*
1228	**  This code could be reused if we decide to add a
1229	**  per-user quota field to the sm_mbdb interface.
1230	*/
1231
1232	/*
1233	**  Fail if the user has a quota specified, and delivery of this
1234	**  message would exceed that quota.  We bounce such failures using
1235	**  EX_UNAVAILABLE, unless there were internal problems, since
1236	**  storing immense messages for later retries can cause queueing
1237	**  issues.
1238	*/
1239
1240	if (ui.quota > 0)
1241	{
1242		struct stat dsb;
1243
1244		if (fstat(fd, &dsb) < 0)
1245		{
1246			ExitVal = EX_TEMPFAIL;
1247			mailerr("451 4.3.0",
1248				"%s: fstat: can't stat temporary storage: %s",
1249				ui.mailspool, sm_errstring(errno));
1250			goto err1;
1251		}
1252
1253		if (dsb.st_size + sb.st_size + 1 > ui.quota)
1254		{
1255			ExitVal = EX_UNAVAILABLE;
1256			mailerr("551 5.2.2",
1257				"%s: Mailbox full or quota exceeded",
1258				ui.mailspool);
1259			goto err1;
1260		}
1261	}
1262#endif /* 0 */
1263
1264	/* Wait until we can get a lock on the file. */
1265	if (flock(mbfd, LOCK_EX) < 0)
1266	{
1267		mailerr("450 4.2.0", "%s: %s", path, sm_errstring(errno));
1268		goto err1;
1269	}
1270
1271	/* Get the starting offset of the new message */
1272	curoff = lseek(mbfd, (off_t) 0, SEEK_END);
1273
1274	if (!nobiff)
1275	{
1276		(void) sm_snprintf(biffmsg, sizeof(biffmsg), "%s@%lld\n",
1277				   name, (LONGLONG_T) curoff);
1278	}
1279
1280	/* Copy the message into the file. */
1281	if (lseek(fd, (off_t) 0, SEEK_SET) == (off_t) -1)
1282	{
1283		mailerr("450 4.2.0", "Temporary file: %s",
1284			sm_errstring(errno));
1285		goto err1;
1286	}
1287#ifdef DEBUG
1288	fprintf(stderr, "before writing: euid = %d\n", (int) geteuid());
1289#endif /* DEBUG */
1290#ifdef CONTENTLENGTH
1291	headerbytes = (BodyLength >= 0) ? HeaderLength : -1 ;
1292	for (;;)
1293	{
1294		if (headerbytes == 0)
1295		{
1296			(void) sm_snprintf(buf, sizeof buf, "%s", ContentHdr);
1297			nr = strlen(buf);
1298			headerbytes = -1;
1299			readamount = 0;
1300		}
1301		else if (headerbytes > sizeof(buf) || headerbytes < 0)
1302			readamount = sizeof(buf);
1303		else
1304			readamount = headerbytes;
1305		if (readamount != 0)
1306			nr = read(fd, buf, readamount);
1307		if (nr <= 0)
1308			break;
1309		if (headerbytes > 0)
1310			headerbytes -= nr ;
1311
1312#else /* CONTENTLENGTH */
1313	while ((nr = read(fd, buf, sizeof(buf))) > 0)
1314	{
1315#endif /* CONTENTLENGTH */
1316		for (off = 0; off < nr; off += nw)
1317		{
1318			if ((nw = write(mbfd, buf + off, nr - off)) < 0)
1319			{
1320				errcode = "450 4.2.0";
1321#ifdef EDQUOT
1322				if (errno == EDQUOT && BounceQuota)
1323					errcode = "552 5.2.2";
1324#endif /* EDQUOT */
1325				mailerr(errcode, "%s: %s",
1326					path, sm_errstring(errno));
1327				goto err3;
1328			}
1329		}
1330	}
1331	if (nr < 0)
1332	{
1333		mailerr("450 4.2.0", "Temporary file: %s",
1334			sm_errstring(errno));
1335		goto err3;
1336	}
1337
1338	/* Flush to disk, don't wait for update. */
1339	if (!nofsync && fsync(mbfd) < 0)
1340	{
1341		mailerr("450 4.2.0", "%s: %s", path, sm_errstring(errno));
1342err3:
1343#ifdef DEBUG
1344		fprintf(stderr, "reset euid = %d\n", (int) geteuid());
1345#endif /* DEBUG */
1346		if (mbfd >= 0)
1347			(void) ftruncate(mbfd, curoff);
1348err1:		if (mbfd >= 0)
1349			(void) close(mbfd);
1350err0:		(void) setreuid(0, 0);
1351		unlockmbox();
1352		return;
1353	}
1354
1355	/*
1356	**  Save the current size so if the close() fails below
1357	**  we can make sure no other process has changed the mailbox
1358	**  between the failed close and the re-open()/re-lock().
1359	**  If something else has changed the size, we shouldn't
1360	**  try to truncate it as we may do more harm then good
1361	**  (e.g., truncate a later message delivery).
1362	*/
1363
1364	if (fstat(mbfd, &sb) < 0)
1365		cursize = 0;
1366	else
1367		cursize = sb.st_size;
1368
1369
1370	/* Close and check -- NFS doesn't write until the close. */
1371	if (close(mbfd))
1372	{
1373		errcode = "450 4.2.0";
1374#ifdef EDQUOT
1375		if (errno == EDQUOT && BounceQuota)
1376			errcode = "552 5.2.2";
1377#endif /* EDQUOT */
1378		mailerr(errcode, "%s: %s", path, sm_errstring(errno));
1379		mbfd = open(path, O_WRONLY, 0);
1380		if (mbfd < 0 ||
1381		    cursize == 0
1382		    || flock(mbfd, LOCK_EX) < 0 ||
1383		    fstat(mbfd, &sb) < 0 ||
1384		    sb.st_size != cursize ||
1385		    sb.st_nlink != 1 ||
1386		    !S_ISREG(sb.st_mode) ||
1387		    sb.st_dev != fsb.st_dev ||
1388		    sb.st_ino != fsb.st_ino ||
1389# if HAS_ST_GEN && 0		/* AFS returns random values for st_gen */
1390		    sb.st_gen != fsb.st_gen ||
1391# endif /* HAS_ST_GEN && 0 */
1392		    sb.st_uid != fsb.st_uid
1393		   )
1394		{
1395			/* Don't use a bogus file */
1396			if (mbfd >= 0)
1397			{
1398				(void) close(mbfd);
1399				mbfd = -1;
1400			}
1401		}
1402
1403		/* Attempt to truncate back to pre-write size */
1404		goto err3;
1405	}
1406	else if (!nobiff)
1407		notifybiff(biffmsg);
1408
1409	if (setreuid(0, 0) < 0)
1410	{
1411		mailerr("450 4.2.0", "setreuid(0, 0): %s",
1412			sm_errstring(errno));
1413		goto err0;
1414	}
1415#ifdef DEBUG
1416	fprintf(stderr, "reset euid = %d\n", (int) geteuid());
1417#endif /* DEBUG */
1418	unlockmbox();
1419	if (LMTPMode)
1420		printf("250 2.1.5 %s Ok\r\n", name);
1421}
1422
1423/*
1424**  user.lock files are necessary for compatibility with other
1425**  systems, e.g., when the mail spool file is NFS exported.
1426**  Alas, mailbox locking is more than just a local matter.
1427**  EPA 11/94.
1428*/
1429
1430bool	Locked = false;
1431
1432#ifdef MAILLOCK
1433int
1434lockmbox(name)
1435	char *name;
1436{
1437	int r = 0;
1438
1439	if (Locked)
1440		return 0;
1441	if ((r = maillock(name, 15)) == L_SUCCESS)
1442	{
1443		Locked = true;
1444		return 0;
1445	}
1446	switch (r)
1447	{
1448	  case L_TMPLOCK:	/* Can't create tmp file */
1449	  case L_TMPWRITE:	/* Can't write pid into lockfile */
1450	  case L_MAXTRYS:	/* Failed after retrycnt attempts */
1451		errno = 0;
1452		r = EX_TEMPFAIL;
1453		break;
1454	  case L_ERROR:		/* Check errno for reason */
1455		r = errno;
1456		break;
1457	  default:		/* other permanent errors */
1458		errno = 0;
1459		r = EX_UNAVAILABLE;
1460		break;
1461	}
1462	return r;
1463}
1464
1465void
1466unlockmbox()
1467{
1468	if (Locked)
1469		mailunlock();
1470	Locked = false;
1471}
1472#else /* MAILLOCK */
1473
1474char	LockName[MAXPATHLEN];
1475
1476int
1477lockmbox(path)
1478	char *path;
1479{
1480	int statfailed = 0;
1481	time_t start;
1482
1483	if (Locked)
1484		return 0;
1485	if (strlen(path) + 6 > sizeof LockName)
1486		return EX_SOFTWARE;
1487	(void) sm_snprintf(LockName, sizeof LockName, "%s.lock", path);
1488	(void) time(&start);
1489	for (; ; sleep(5))
1490	{
1491		int fd;
1492		struct stat st;
1493		time_t now;
1494
1495		/* global timeout */
1496		(void) time(&now);
1497		if (now > start + LOCKTO_GLOB)
1498		{
1499			errno = 0;
1500			return EX_TEMPFAIL;
1501		}
1502		fd = open(LockName, O_WRONLY|O_EXCL|O_CREAT, LOCKFILE_PMODE);
1503		if (fd >= 0)
1504		{
1505			/* defeat lock checking programs which test pid */
1506			(void) write(fd, "0", 2);
1507			Locked = true;
1508			(void) close(fd);
1509			return 0;
1510		}
1511		if (stat(LockName, &st) < 0)
1512		{
1513			if (statfailed++ > 5)
1514			{
1515				errno = 0;
1516				return EX_TEMPFAIL;
1517			}
1518			continue;
1519		}
1520		statfailed = 0;
1521		(void) time(&now);
1522		if (now < st.st_ctime + LOCKTO_RM)
1523			continue;
1524
1525		/* try to remove stale lockfile */
1526		if (unlink(LockName) < 0)
1527			return errno;
1528	}
1529}
1530
1531void
1532unlockmbox()
1533{
1534	if (!Locked)
1535		return;
1536	(void) unlink(LockName);
1537	Locked = false;
1538}
1539#endif /* MAILLOCK */
1540
1541void
1542notifybiff(msg)
1543	char *msg;
1544{
1545	static bool initialized = false;
1546	static int f = -1;
1547	struct hostent *hp;
1548	struct servent *sp;
1549	int len;
1550	static struct sockaddr_in addr;
1551
1552	if (!initialized)
1553	{
1554		initialized = true;
1555
1556		/* Be silent if biff service not available. */
1557		if ((sp = getservbyname("biff", "udp")) == NULL ||
1558		    (hp = gethostbyname("localhost")) == NULL ||
1559		    hp->h_length != INADDRSZ)
1560			return;
1561
1562		addr.sin_family = hp->h_addrtype;
1563		memcpy(&addr.sin_addr, hp->h_addr, INADDRSZ);
1564		addr.sin_port = sp->s_port;
1565	}
1566
1567	/* No message, just return */
1568	if (msg == NULL)
1569		return;
1570
1571	/* Couldn't initialize addr struct */
1572	if (addr.sin_family == AF_UNSPEC)
1573		return;
1574
1575	if (f < 0 && (f = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
1576		return;
1577	len = strlen(msg) + 1;
1578	(void) sendto(f, msg, len, 0, (struct sockaddr *) &addr, sizeof(addr));
1579}
1580
1581void
1582usage()
1583{
1584	ExitVal = EX_USAGE;
1585	mailerr(NULL, "usage: mail.local [-7] [-B] [-b] [-d] [-l] [-s] [-f from|-r from] [-h filename] user ...");
1586	sm_exit(ExitVal);
1587}
1588
1589void
1590/*VARARGS2*/
1591#ifdef __STDC__
1592mailerr(const char *hdr, const char *fmt, ...)
1593#else /* __STDC__ */
1594mailerr(hdr, fmt, va_alist)
1595	const char *hdr;
1596	const char *fmt;
1597	va_dcl
1598#endif /* __STDC__ */
1599{
1600	size_t len = 0;
1601	SM_VA_LOCAL_DECL
1602
1603	(void) e_to_sys(errno);
1604
1605	SM_VA_START(ap, fmt);
1606
1607	if (LMTPMode && hdr != NULL)
1608	{
1609		sm_snprintf(ErrBuf, sizeof ErrBuf, "%s ", hdr);
1610		len = strlen(ErrBuf);
1611	}
1612	(void) sm_vsnprintf(&ErrBuf[len], sizeof ErrBuf - len, fmt, ap);
1613	SM_VA_END(ap);
1614
1615	if (!HoldErrs)
1616		flush_error();
1617
1618	/* Log the message to syslog. */
1619	if (!LMTPMode)
1620		syslog(LOG_ERR, "%s", ErrBuf);
1621}
1622
1623void
1624flush_error()
1625{
1626	if (LMTPMode)
1627		printf("%s\r\n", ErrBuf);
1628	else
1629	{
1630		if (ExitVal != EX_USAGE)
1631			(void) fprintf(stderr, "mail.local: ");
1632		fprintf(stderr, "%s\n", ErrBuf);
1633	}
1634}
1635
1636#if HASHSPOOL
1637const char *
1638hashname(name)
1639	char *name;
1640{
1641	static char p[MAXPATHLEN];
1642	int i;
1643	int len;
1644	char *str;
1645# if HASHSPOOLMD5
1646	char Base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+_";
1647	MD5_CTX ctx;
1648	unsigned char md5[18];
1649#  if MAXPATHLEN <= 24
1650    ERROR _MAXPATHLEN <= 24
1651#  endif /* MAXPATHLEN <= 24 */
1652	char b64[24];
1653	MD5_LONG bits;
1654	int j;
1655# endif /* HASHSPOOLMD5 */
1656
1657	if (HashType == HASH_NONE || HashDepth * 2 >= MAXPATHLEN)
1658	{
1659		p[0] = '\0';
1660		return p;
1661	}
1662
1663	switch(HashType)
1664	{
1665	  case HASH_USER:
1666		str = name;
1667		break;
1668
1669# if HASHSPOOLMD5
1670	  case HASH_MD5:
1671		MD5_Init(&ctx);
1672		MD5_Update(&ctx, name, strlen(name));
1673		MD5_Final(md5, &ctx);
1674		md5[16] = 0;
1675		md5[17] = 0;
1676
1677		for (i = 0; i < 6; i++)
1678		{
1679			bits = (unsigned) md5[(3 * i)] << 16;
1680			bits |= (unsigned) md5[(3 * i) + 1] << 8;
1681			bits |= (unsigned) md5[(3 * i) + 2];
1682
1683			for (j = 3; j >= 0; j--)
1684			{
1685				b64[(4 * i) + j] = Base64[(bits & 0x3f)];
1686				bits >>= 6;
1687			}
1688		}
1689		b64[22] = '\0';
1690		str = b64;
1691		break;
1692# endif /* HASHSPOOLMD5 */
1693	}
1694
1695	len = strlen(str);
1696	for (i = 0; i < HashDepth; i++)
1697	{
1698		if (i < len)
1699			p[i * 2] = str[i];
1700		else
1701			p[i * 2] = '_';
1702		p[(i * 2) + 1] = '/';
1703	}
1704	p[HashDepth * 2] = '\0';
1705	return p;
1706}
1707#endif /* HASHSPOOL */
1708
1709/*
1710 * e_to_sys --
1711 *	Guess which errno's are temporary.  Gag me.
1712 */
1713
1714int
1715e_to_sys(num)
1716	int num;
1717{
1718	/* Temporary failures override hard errors. */
1719	if (ExitVal == EX_TEMPFAIL)
1720		return ExitVal;
1721
1722	switch (num)		/* Hopefully temporary errors. */
1723	{
1724#ifdef EDQUOT
1725	  case EDQUOT:		/* Disc quota exceeded */
1726		if (BounceQuota)
1727		{
1728			ExitVal = EX_UNAVAILABLE;
1729			break;
1730		}
1731		/* FALLTHROUGH */
1732#endif /* EDQUOT */
1733#ifdef EAGAIN
1734	  case EAGAIN:		/* Resource temporarily unavailable */
1735#endif /* EAGAIN */
1736#ifdef EBUSY
1737	  case EBUSY:		/* Device busy */
1738#endif /* EBUSY */
1739#ifdef EPROCLIM
1740	  case EPROCLIM:	/* Too many processes */
1741#endif /* EPROCLIM */
1742#ifdef EUSERS
1743	  case EUSERS:		/* Too many users */
1744#endif /* EUSERS */
1745#ifdef ECONNABORTED
1746	  case ECONNABORTED:	/* Software caused connection abort */
1747#endif /* ECONNABORTED */
1748#ifdef ECONNREFUSED
1749	  case ECONNREFUSED:	/* Connection refused */
1750#endif /* ECONNREFUSED */
1751#ifdef ECONNRESET
1752	  case ECONNRESET:	/* Connection reset by peer */
1753#endif /* ECONNRESET */
1754#ifdef EDEADLK
1755	  case EDEADLK:		/* Resource deadlock avoided */
1756#endif /* EDEADLK */
1757#ifdef EFBIG
1758	  case EFBIG:		/* File too large */
1759#endif /* EFBIG */
1760#ifdef EHOSTDOWN
1761	  case EHOSTDOWN:	/* Host is down */
1762#endif /* EHOSTDOWN */
1763#ifdef EHOSTUNREACH
1764	  case EHOSTUNREACH:	/* No route to host */
1765#endif /* EHOSTUNREACH */
1766#ifdef EMFILE
1767	  case EMFILE:		/* Too many open files */
1768#endif /* EMFILE */
1769#ifdef ENETDOWN
1770	  case ENETDOWN:	/* Network is down */
1771#endif /* ENETDOWN */
1772#ifdef ENETRESET
1773	  case ENETRESET:	/* Network dropped connection on reset */
1774#endif /* ENETRESET */
1775#ifdef ENETUNREACH
1776	  case ENETUNREACH:	/* Network is unreachable */
1777#endif /* ENETUNREACH */
1778#ifdef ENFILE
1779	  case ENFILE:		/* Too many open files in system */
1780#endif /* ENFILE */
1781#ifdef ENOBUFS
1782	  case ENOBUFS:		/* No buffer space available */
1783#endif /* ENOBUFS */
1784#ifdef ENOMEM
1785	  case ENOMEM:		/* Cannot allocate memory */
1786#endif /* ENOMEM */
1787#ifdef ENOSPC
1788	  case ENOSPC:		/* No space left on device */
1789#endif /* ENOSPC */
1790#ifdef EROFS
1791	  case EROFS:		/* Read-only file system */
1792#endif /* EROFS */
1793#ifdef ESTALE
1794	  case ESTALE:		/* Stale NFS file handle */
1795#endif /* ESTALE */
1796#ifdef ETIMEDOUT
1797	  case ETIMEDOUT:	/* Connection timed out */
1798#endif /* ETIMEDOUT */
1799#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN && EWOULDBLOCK != EDEADLK
1800	  case EWOULDBLOCK:	/* Operation would block. */
1801#endif /* defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN && EWOULDBLOCK != EDEADLK */
1802		ExitVal = EX_TEMPFAIL;
1803		break;
1804
1805	  default:
1806		ExitVal = EX_UNAVAILABLE;
1807		break;
1808	}
1809	return ExitVal;
1810}
1811
1812#if defined(ultrix) || defined(_CRAY)
1813/*
1814 * Copyright (c) 1987, 1993
1815 *	The Regents of the University of California.  All rights reserved.
1816 *
1817 * Redistribution and use in source and binary forms, with or without
1818 * modification, are permitted provided that the following conditions
1819 * are met:
1820 * 1. Redistributions of source code must retain the above copyright
1821 *    notice, this list of conditions and the following disclaimer.
1822 * 2. Redistributions in binary form must reproduce the above copyright
1823 *    notice, this list of conditions and the following disclaimer in the
1824 *    documentation and/or other materials provided with the distribution.
1825 * 3. All advertising materials mentioning features or use of this software
1826 *    must display the following acknowledgement:
1827 *	This product includes software developed by the University of
1828 *	California, Berkeley and its contributors.
1829 * 4. Neither the name of the University nor the names of its contributors
1830 *    may be used to endorse or promote products derived from this software
1831 *    without specific prior written permission.
1832 *
1833 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
1834 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1835 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1836 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
1837 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1838 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
1839 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
1840 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
1841 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
1842 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
1843 * SUCH DAMAGE.
1844 */
1845
1846# if defined(LIBC_SCCS) && !defined(lint)
1847static char sccsid[] = "@(#)mktemp.c	8.1 (Berkeley) 6/4/93";
1848# endif /* defined(LIBC_SCCS) && !defined(lint) */
1849
1850# include <sys/types.h>
1851# include <sys/stat.h>
1852# include <fcntl.h>
1853# include <errno.h>
1854# include <stdio.h>
1855# include <ctype.h>
1856
1857static int _gettemp();
1858
1859mkstemp(path)
1860	char *path;
1861{
1862	int fd;
1863
1864	return (_gettemp(path, &fd) ? fd : -1);
1865}
1866
1867static
1868_gettemp(path, doopen)
1869	char *path;
1870	register int *doopen;
1871{
1872	extern int errno;
1873	register char *start, *trv;
1874	struct stat sbuf;
1875	unsigned int pid;
1876
1877	pid = getpid();
1878	for (trv = path; *trv; ++trv);		/* extra X's get set to 0's */
1879	while (*--trv == 'X')
1880	{
1881		*trv = (pid % 10) + '0';
1882		pid /= 10;
1883	}
1884
1885	/*
1886	 * check the target directory; if you have six X's and it
1887	 * doesn't exist this runs for a *very* long time.
1888	 */
1889	for (start = trv + 1;; --trv)
1890	{
1891		if (trv <= path)
1892			break;
1893		if (*trv == '/')
1894		{
1895			*trv = '\0';
1896			if (stat(path, &sbuf) < 0)
1897				return(0);
1898			if (!S_ISDIR(sbuf.st_mode))
1899			{
1900				errno = ENOTDIR;
1901				return(0);
1902			}
1903			*trv = '/';
1904			break;
1905		}
1906	}
1907
1908	for (;;)
1909	{
1910		if (doopen)
1911		{
1912			if ((*doopen = open(path, O_CREAT|O_EXCL|O_RDWR,
1913					    0600)) >= 0)
1914				return(1);
1915			if (errno != EEXIST)
1916				return(0);
1917		}
1918		else if (stat(path, &sbuf) < 0)
1919			return(errno == ENOENT ? 1 : 0);
1920
1921		/* tricky little algorithm for backward compatibility */
1922		for (trv = start;;)
1923		{
1924			if (!*trv)
1925				return(0);
1926			if (*trv == 'z')
1927				*trv++ = 'a';
1928			else
1929			{
1930				if (isascii(*trv) && isdigit(*trv))
1931					*trv = 'a';
1932				else
1933					++*trv;
1934				break;
1935			}
1936		}
1937	}
1938	/* NOTREACHED */
1939}
1940#endif /* defined(ultrix) || defined(_CRAY) */
1941