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