1 /*
2 * Copyright (c) 1998-2007, 2009 Proofpoint, Inc. and its suppliers.
3 * All rights reserved.
4 * Copyright (c) 1983, 1995-1997 Eric P. Allman. All rights reserved.
5 * Copyright (c) 1988, 1993
6 * The Regents of the University of California. All rights reserved.
7 *
8 * By using this file, you agree to the terms and conditions set
9 * forth in the LICENSE file which can be found at the top level of
10 * the sendmail distribution.
11 *
12 */
13
14 #include <sendmail.h>
15
16 SM_RCSID("@(#)$Id: util.c,v 8.427 2013-11-22 20:51:57 ca Exp $")
17
18 #include <sm/sendmail.h>
19 #include <sysexits.h>
20 #include <sm/xtrap.h>
21
22 /*
23 ** NEWSTR -- Create a copy of a C string
24 **
25 ** Parameters:
26 ** s -- the string to copy.
27 **
28 ** Returns:
29 ** pointer to newly allocated string.
30 */
31
32 char *
33 newstr(s)
34 const char *s;
35 {
36 size_t l;
37 char *n;
38
39 l = strlen(s);
40 SM_ASSERT(l + 1 > l);
41 n = xalloc(l + 1);
42 sm_strlcpy(n, s, l + 1);
43 return n;
44 }
45
46 /*
47 ** ADDQUOTES -- Adds quotes & quote bits to a string.
48 **
49 ** Runs through a string and adds backslashes and quote bits.
50 **
51 ** Parameters:
52 ** s -- the string to modify.
53 ** rpool -- resource pool from which to allocate result
54 **
55 ** Returns:
56 ** pointer to quoted string.
57 */
58
59 char *
addquotes(s,rpool)60 addquotes(s, rpool)
61 char *s;
62 SM_RPOOL_T *rpool;
63 {
64 int len = 0;
65 char c;
66 char *p = s, *q, *r;
67
68 if (s == NULL)
69 return NULL;
70
71 /* Find length of quoted string */
72 while ((c = *p++) != '\0')
73 {
74 len++;
75 if (c == '\\' || c == '"')
76 len++;
77 }
78
79 q = r = sm_rpool_malloc_x(rpool, len + 3);
80 p = s;
81
82 /* add leading quote */
83 *q++ = '"';
84 while ((c = *p++) != '\0')
85 {
86 /* quote \ or " */
87 if (c == '\\' || c == '"')
88 *q++ = '\\';
89 *q++ = c;
90 }
91 *q++ = '"';
92 *q = '\0';
93 return r;
94 }
95
96 /*
97 ** STRIPBACKSLASH -- Strip all leading backslashes from a string, provided
98 ** the following character is alpha-numerical.
99 **
100 ** This is done in place.
101 **
102 ** Parameters:
103 ** s -- the string to strip.
104 **
105 ** Returns:
106 ** none.
107 */
108
109 void
stripbackslash(s)110 stripbackslash(s)
111 char *s;
112 {
113 char *p, *q, c;
114
115 if (s == NULL || *s == '\0')
116 return;
117 p = q = s;
118 while (*p == '\\' && (p[1] == '\\' || (isascii(p[1]) && isalnum(p[1]))))
119 p++;
120 do
121 {
122 c = *q++ = *p++;
123 } while (c != '\0');
124 }
125
126 /*
127 ** RFC822_STRING -- Checks string for proper RFC822 string quoting.
128 **
129 ** Runs through a string and verifies RFC822 special characters
130 ** are only found inside comments, quoted strings, or backslash
131 ** escaped. Also verified balanced quotes and parenthesis.
132 **
133 ** Parameters:
134 ** s -- the string to modify.
135 **
136 ** Returns:
137 ** true iff the string is RFC822 compliant, false otherwise.
138 */
139
140 bool
rfc822_string(s)141 rfc822_string(s)
142 char *s;
143 {
144 bool quoted = false;
145 int commentlev = 0;
146 char *c = s;
147
148 if (s == NULL)
149 return false;
150
151 while (*c != '\0')
152 {
153 /* escaped character */
154 if (*c == '\\')
155 {
156 c++;
157 if (*c == '\0')
158 return false;
159 }
160 else if (commentlev == 0 && *c == '"')
161 quoted = !quoted;
162 else if (!quoted)
163 {
164 if (*c == ')')
165 {
166 /* unbalanced ')' */
167 if (commentlev == 0)
168 return false;
169 else
170 commentlev--;
171 }
172 else if (*c == '(')
173 commentlev++;
174 else if (commentlev == 0 &&
175 strchr(MustQuoteChars, *c) != NULL)
176 return false;
177 }
178 c++;
179 }
180
181 /* unbalanced '"' or '(' */
182 return !quoted && commentlev == 0;
183 }
184
185 /*
186 ** SHORTEN_RFC822_STRING -- Truncate and rebalance an RFC822 string
187 **
188 ** Arbitrarily shorten (in place) an RFC822 string and rebalance
189 ** comments and quotes.
190 **
191 ** Parameters:
192 ** string -- the string to shorten
193 ** length -- the maximum size, 0 if no maximum
194 **
195 ** Returns:
196 ** true if string is changed, false otherwise
197 **
198 ** Side Effects:
199 ** Changes string in place, possibly resulting
200 ** in a shorter string.
201 */
202
203 bool
shorten_rfc822_string(string,length)204 shorten_rfc822_string(string, length)
205 char *string;
206 size_t length;
207 {
208 bool backslash = false;
209 bool modified = false;
210 bool quoted = false;
211 size_t slen;
212 int parencount = 0;
213 char *ptr = string;
214
215 /*
216 ** If have to rebalance an already short enough string,
217 ** need to do it within allocated space.
218 */
219
220 slen = strlen(string);
221 if (length == 0 || slen < length)
222 length = slen;
223
224 while (*ptr != '\0')
225 {
226 if (backslash)
227 {
228 backslash = false;
229 goto increment;
230 }
231
232 if (*ptr == '\\')
233 backslash = true;
234 else if (*ptr == '(')
235 {
236 if (!quoted)
237 parencount++;
238 }
239 else if (*ptr == ')')
240 {
241 if (--parencount < 0)
242 parencount = 0;
243 }
244
245 /* Inside a comment, quotes don't matter */
246 if (parencount <= 0 && *ptr == '"')
247 quoted = !quoted;
248
249 increment:
250 /* Check for sufficient space for next character */
251 if (length - (ptr - string) <= (size_t) ((backslash ? 1 : 0) +
252 parencount +
253 (quoted ? 1 : 0)))
254 {
255 /* Not enough, backtrack */
256 if (*ptr == '\\')
257 backslash = false;
258 else if (*ptr == '(' && !quoted)
259 parencount--;
260 else if (*ptr == '"' && parencount == 0)
261 quoted = false;
262 break;
263 }
264 ptr++;
265 }
266
267 /* Rebalance */
268 while (parencount-- > 0)
269 {
270 if (*ptr != ')')
271 {
272 modified = true;
273 *ptr = ')';
274 }
275 ptr++;
276 }
277 if (quoted)
278 {
279 if (*ptr != '"')
280 {
281 modified = true;
282 *ptr = '"';
283 }
284 ptr++;
285 }
286 if (*ptr != '\0')
287 {
288 modified = true;
289 *ptr = '\0';
290 }
291 return modified;
292 }
293
294 /*
295 ** FIND_CHARACTER -- find an unquoted character in an RFC822 string
296 **
297 ** Find an unquoted, non-commented character in an RFC822
298 ** string and return a pointer to its location in the
299 ** string.
300 **
301 ** Parameters:
302 ** string -- the string to search
303 ** character -- the character to find
304 **
305 ** Returns:
306 ** pointer to the character, or
307 ** a pointer to the end of the line if character is not found
308 */
309
310 char *
find_character(string,character)311 find_character(string, character)
312 char *string;
313 int character;
314 {
315 bool backslash = false;
316 bool quoted = false;
317 int parencount = 0;
318
319 while (string != NULL && *string != '\0')
320 {
321 if (backslash)
322 {
323 backslash = false;
324 if (!quoted && character == '\\' && *string == '\\')
325 break;
326 string++;
327 continue;
328 }
329 switch (*string)
330 {
331 case '\\':
332 backslash = true;
333 break;
334
335 case '(':
336 if (!quoted)
337 parencount++;
338 break;
339
340 case ')':
341 if (--parencount < 0)
342 parencount = 0;
343 break;
344 }
345
346 /* Inside a comment, nothing matters */
347 if (parencount > 0)
348 {
349 string++;
350 continue;
351 }
352
353 if (*string == '"')
354 quoted = !quoted;
355 else if (*string == character && !quoted)
356 break;
357 string++;
358 }
359
360 /* Return pointer to the character */
361 return string;
362 }
363
364 /*
365 ** CHECK_BODYTYPE -- check bodytype parameter
366 **
367 ** Parameters:
368 ** bodytype -- bodytype parameter
369 **
370 ** Returns:
371 ** BODYTYPE_* according to parameter
372 **
373 */
374
375 int
check_bodytype(bodytype)376 check_bodytype(bodytype)
377 char *bodytype;
378 {
379 /* check body type for legality */
380 if (bodytype == NULL)
381 return BODYTYPE_NONE;
382 if (sm_strcasecmp(bodytype, "7BIT") == 0)
383 return BODYTYPE_7BIT;
384 if (sm_strcasecmp(bodytype, "8BITMIME") == 0)
385 return BODYTYPE_8BITMIME;
386 return BODYTYPE_ILLEGAL;
387 }
388
389 /*
390 ** TRUNCATE_AT_DELIM -- truncate string at a delimiter and append "..."
391 **
392 ** Parameters:
393 ** str -- string to truncate
394 ** len -- maximum length (including '\0') (0 for unlimited)
395 ** delim -- delimiter character
396 **
397 ** Returns:
398 ** None.
399 */
400
401 void
truncate_at_delim(str,len,delim)402 truncate_at_delim(str, len, delim)
403 char *str;
404 size_t len;
405 int delim;
406 {
407 char *p;
408
409 if (str == NULL || len == 0 || strlen(str) < len)
410 return;
411
412 *(str + len - 1) = '\0';
413 while ((p = strrchr(str, delim)) != NULL)
414 {
415 *p = '\0';
416 if (p - str + 4 < len)
417 {
418 *p++ = (char) delim;
419 *p = '\0';
420 (void) sm_strlcat(str, "...", len);
421 return;
422 }
423 }
424
425 /* Couldn't find a place to append "..." */
426 if (len > 3)
427 (void) sm_strlcpy(str, "...", len);
428 else
429 str[0] = '\0';
430 }
431
432 /*
433 ** XALLOC -- Allocate memory, raise an exception on error
434 **
435 ** Parameters:
436 ** sz -- size of area to allocate.
437 **
438 ** Returns:
439 ** pointer to data region.
440 **
441 ** Exceptions:
442 ** SmHeapOutOfMemory (F:sm.heap) -- cannot allocate memory
443 **
444 ** Side Effects:
445 ** Memory is allocated.
446 */
447
448 char *
449 #if SM_HEAP_CHECK
xalloc_tagged(sz,file,line)450 xalloc_tagged(sz, file, line)
451 register int sz;
452 char *file;
453 int line;
454 #else /* SM_HEAP_CHECK */
455 xalloc(sz)
456 register int sz;
457 #endif /* SM_HEAP_CHECK */
458 {
459 register char *p;
460
461 SM_REQUIRE(sz >= 0);
462
463 /* some systems can't handle size zero mallocs */
464 if (sz <= 0)
465 sz = 1;
466
467 /* scaffolding for testing error handling code */
468 sm_xtrap_raise_x(&SmHeapOutOfMemory);
469
470 p = sm_malloc_tagged((unsigned) sz, file, line, sm_heap_group());
471 if (p == NULL)
472 {
473 sm_exc_raise_x(&SmHeapOutOfMemory);
474 }
475 return p;
476 }
477
478 /*
479 ** COPYPLIST -- copy list of pointers.
480 **
481 ** This routine is the equivalent of strdup for lists of
482 ** pointers.
483 **
484 ** Parameters:
485 ** list -- list of pointers to copy.
486 ** Must be NULL terminated.
487 ** copycont -- if true, copy the contents of the vector
488 ** (which must be a string) also.
489 ** rpool -- resource pool from which to allocate storage,
490 ** or NULL
491 **
492 ** Returns:
493 ** a copy of 'list'.
494 */
495
496 char **
copyplist(list,copycont,rpool)497 copyplist(list, copycont, rpool)
498 char **list;
499 bool copycont;
500 SM_RPOOL_T *rpool;
501 {
502 register char **vp;
503 register char **newvp;
504
505 for (vp = list; *vp != NULL; vp++)
506 continue;
507
508 vp++;
509
510 newvp = (char **) sm_rpool_malloc_x(rpool, (vp - list) * sizeof(*vp));
511 memmove((char *) newvp, (char *) list, (int) (vp - list) * sizeof(*vp));
512
513 if (copycont)
514 {
515 for (vp = newvp; *vp != NULL; vp++)
516 *vp = sm_rpool_strdup_x(rpool, *vp);
517 }
518
519 return newvp;
520 }
521
522 /*
523 ** COPYQUEUE -- copy address queue.
524 **
525 ** This routine is the equivalent of strdup for address queues;
526 ** addresses marked as QS_IS_DEAD() aren't copied
527 **
528 ** Parameters:
529 ** addr -- list of address structures to copy.
530 ** rpool -- resource pool from which to allocate storage
531 **
532 ** Returns:
533 ** a copy of 'addr'.
534 */
535
536 ADDRESS *
copyqueue(addr,rpool)537 copyqueue(addr, rpool)
538 ADDRESS *addr;
539 SM_RPOOL_T *rpool;
540 {
541 register ADDRESS *newaddr;
542 ADDRESS *ret;
543 register ADDRESS **tail = &ret;
544
545 while (addr != NULL)
546 {
547 if (!QS_IS_DEAD(addr->q_state))
548 {
549 newaddr = (ADDRESS *) sm_rpool_malloc_x(rpool,
550 sizeof(*newaddr));
551 STRUCTCOPY(*addr, *newaddr);
552 *tail = newaddr;
553 tail = &newaddr->q_next;
554 }
555 addr = addr->q_next;
556 }
557 *tail = NULL;
558
559 return ret;
560 }
561
562 /*
563 ** LOG_SENDMAIL_PID -- record sendmail pid and command line.
564 **
565 ** Parameters:
566 ** e -- the current envelope.
567 **
568 ** Returns:
569 ** none.
570 **
571 ** Side Effects:
572 ** writes pidfile, logs command line.
573 ** keeps file open and locked to prevent overwrite of active file
574 */
575
576 static SM_FILE_T *Pidf = NULL;
577
578 void
log_sendmail_pid(e)579 log_sendmail_pid(e)
580 ENVELOPE *e;
581 {
582 long sff;
583 char pidpath[MAXPATHLEN];
584 extern char *CommandLineArgs;
585
586 /* write the pid to the log file for posterity */
587 sff = SFF_NOLINK|SFF_ROOTOK|SFF_REGONLY|SFF_CREAT|SFF_NBLOCK;
588 if (TrustedUid != 0 && RealUid == TrustedUid)
589 sff |= SFF_OPENASROOT;
590 expand(PidFile, pidpath, sizeof(pidpath), e);
591 Pidf = safefopen(pidpath, O_WRONLY|O_TRUNC, FileMode, sff);
592 if (Pidf == NULL)
593 {
594 if (errno == EWOULDBLOCK)
595 sm_syslog(LOG_ERR, NOQID,
596 "unable to write pid to %s: file in use by another process",
597 pidpath);
598 else
599 sm_syslog(LOG_ERR, NOQID,
600 "unable to write pid to %s: %s",
601 pidpath, sm_errstring(errno));
602 }
603 else
604 {
605 PidFilePid = getpid();
606
607 /* write the process id on line 1 */
608 (void) sm_io_fprintf(Pidf, SM_TIME_DEFAULT, "%ld\n",
609 (long) PidFilePid);
610
611 /* line 2 contains all command line flags */
612 (void) sm_io_fprintf(Pidf, SM_TIME_DEFAULT, "%s\n",
613 CommandLineArgs);
614
615 /* flush */
616 (void) sm_io_flush(Pidf, SM_TIME_DEFAULT);
617
618 /*
619 ** Leave pid file open until process ends
620 ** so it's not overwritten by another
621 ** process.
622 */
623 }
624 if (LogLevel > 9)
625 sm_syslog(LOG_INFO, NOQID, "started as: %s", CommandLineArgs);
626 }
627
628 /*
629 ** CLOSE_SENDMAIL_PID -- close sendmail pid file
630 **
631 ** Parameters:
632 ** none.
633 **
634 ** Returns:
635 ** none.
636 */
637
638 void
close_sendmail_pid()639 close_sendmail_pid()
640 {
641 if (Pidf == NULL)
642 return;
643
644 (void) sm_io_close(Pidf, SM_TIME_DEFAULT);
645 Pidf = NULL;
646 }
647
648 /*
649 ** SET_DELIVERY_MODE -- set and record the delivery mode
650 **
651 ** Parameters:
652 ** mode -- delivery mode
653 ** e -- the current envelope.
654 **
655 ** Returns:
656 ** none.
657 **
658 ** Side Effects:
659 ** sets {deliveryMode} macro
660 */
661
662 void
set_delivery_mode(mode,e)663 set_delivery_mode(mode, e)
664 int mode;
665 ENVELOPE *e;
666 {
667 char buf[2];
668
669 e->e_sendmode = (char) mode;
670 buf[0] = (char) mode;
671 buf[1] = '\0';
672 macdefine(&e->e_macro, A_TEMP, macid("{deliveryMode}"), buf);
673 }
674
675 /*
676 ** SET_OP_MODE -- set and record the op mode
677 **
678 ** Parameters:
679 ** mode -- op mode
680 ** e -- the current envelope.
681 **
682 ** Returns:
683 ** none.
684 **
685 ** Side Effects:
686 ** sets {opMode} macro
687 */
688
689 void
set_op_mode(mode)690 set_op_mode(mode)
691 int mode;
692 {
693 char buf[2];
694 extern ENVELOPE BlankEnvelope;
695
696 OpMode = (char) mode;
697 buf[0] = (char) mode;
698 buf[1] = '\0';
699 macdefine(&BlankEnvelope.e_macro, A_TEMP, MID_OPMODE, buf);
700 }
701
702 /*
703 ** PRINTAV -- print argument vector.
704 **
705 ** Parameters:
706 ** fp -- output file pointer.
707 ** av -- argument vector.
708 **
709 ** Returns:
710 ** none.
711 **
712 ** Side Effects:
713 ** prints av.
714 */
715
716 void
printav(fp,av)717 printav(fp, av)
718 SM_FILE_T *fp;
719 char **av;
720 {
721 while (*av != NULL)
722 {
723 if (tTd(0, 44))
724 sm_dprintf("\n\t%08lx=", (unsigned long) *av);
725 else
726 (void) sm_io_putc(fp, SM_TIME_DEFAULT, ' ');
727 if (tTd(0, 99))
728 sm_dprintf("%s", str2prt(*av++));
729 else
730 xputs(fp, *av++);
731 }
732 (void) sm_io_putc(fp, SM_TIME_DEFAULT, '\n');
733 }
734
735 /*
736 ** XPUTS -- put string doing control escapes.
737 **
738 ** Parameters:
739 ** fp -- output file pointer.
740 ** s -- string to put.
741 **
742 ** Returns:
743 ** none.
744 **
745 ** Side Effects:
746 ** output to stdout
747 */
748
749 void
xputs(fp,s)750 xputs(fp, s)
751 SM_FILE_T *fp;
752 const char *s;
753 {
754 int c;
755 struct metamac *mp;
756 bool shiftout = false;
757 extern struct metamac MetaMacros[];
758 static SM_DEBUG_T DebugANSI = SM_DEBUG_INITIALIZER("ANSI",
759 "@(#)$Debug: ANSI - enable reverse video in debug output $");
760
761 /*
762 ** TermEscape is set here, rather than in main(),
763 ** because ANSI mode can be turned on or off at any time
764 ** if we are in -bt rule testing mode.
765 */
766
767 if (sm_debug_unknown(&DebugANSI))
768 {
769 if (sm_debug_active(&DebugANSI, 1))
770 {
771 TermEscape.te_rv_on = "\033[7m";
772 TermEscape.te_normal = "\033[0m";
773 }
774 else
775 {
776 TermEscape.te_rv_on = "";
777 TermEscape.te_normal = "";
778 }
779 }
780
781 if (s == NULL)
782 {
783 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s<null>%s",
784 TermEscape.te_rv_on, TermEscape.te_normal);
785 return;
786 }
787 while ((c = (*s++ & 0377)) != '\0')
788 {
789 if (shiftout)
790 {
791 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s",
792 TermEscape.te_normal);
793 shiftout = false;
794 }
795 if (!isascii(c) && !tTd(84, 1))
796 {
797 if (c == MATCHREPL)
798 {
799 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
800 "%s$",
801 TermEscape.te_rv_on);
802 shiftout = true;
803 if (*s == '\0')
804 continue;
805 c = *s++ & 0377;
806 goto printchar;
807 }
808 if (c == MACROEXPAND || c == MACRODEXPAND)
809 {
810 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
811 "%s$",
812 TermEscape.te_rv_on);
813 if (c == MACRODEXPAND)
814 (void) sm_io_putc(fp,
815 SM_TIME_DEFAULT, '&');
816 shiftout = true;
817 if (*s == '\0')
818 continue;
819 if (strchr("=~&?", *s) != NULL)
820 (void) sm_io_putc(fp,
821 SM_TIME_DEFAULT,
822 *s++);
823 if (bitset(0200, *s))
824 (void) sm_io_fprintf(fp,
825 SM_TIME_DEFAULT,
826 "{%s}",
827 macname(bitidx(*s++)));
828 else
829 (void) sm_io_fprintf(fp,
830 SM_TIME_DEFAULT,
831 "%c",
832 *s++);
833 continue;
834 }
835 for (mp = MetaMacros; mp->metaname != '\0'; mp++)
836 {
837 if (bitidx(mp->metaval) == c)
838 {
839 (void) sm_io_fprintf(fp,
840 SM_TIME_DEFAULT,
841 "%s$%c",
842 TermEscape.te_rv_on,
843 mp->metaname);
844 shiftout = true;
845 break;
846 }
847 }
848 if (c == MATCHCLASS || c == MATCHNCLASS)
849 {
850 if (bitset(0200, *s))
851 (void) sm_io_fprintf(fp,
852 SM_TIME_DEFAULT,
853 "{%s}",
854 macname(bitidx(*s++)));
855 else if (*s != '\0')
856 (void) sm_io_fprintf(fp,
857 SM_TIME_DEFAULT,
858 "%c",
859 *s++);
860 }
861 if (mp->metaname != '\0')
862 continue;
863
864 /* unrecognized meta character */
865 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%sM-",
866 TermEscape.te_rv_on);
867 shiftout = true;
868 c &= 0177;
869 }
870 printchar:
871 if (isascii(c) && isprint(c))
872 {
873 (void) sm_io_putc(fp, SM_TIME_DEFAULT, c);
874 continue;
875 }
876
877 /* wasn't a meta-macro -- find another way to print it */
878 switch (c)
879 {
880 case '\n':
881 c = 'n';
882 break;
883
884 case '\r':
885 c = 'r';
886 break;
887
888 case '\t':
889 c = 't';
890 break;
891 }
892 if (!shiftout)
893 {
894 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s",
895 TermEscape.te_rv_on);
896 shiftout = true;
897 }
898 if (isascii(c) && isprint(c))
899 {
900 (void) sm_io_putc(fp, SM_TIME_DEFAULT, '\\');
901 (void) sm_io_putc(fp, SM_TIME_DEFAULT, c);
902 }
903 else if (tTd(84, 2))
904 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, " %o ", c);
905 else if (tTd(84, 1))
906 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, " %#x ", c);
907 else if (!isascii(c) && !tTd(84, 1))
908 {
909 (void) sm_io_putc(fp, SM_TIME_DEFAULT, '^');
910 (void) sm_io_putc(fp, SM_TIME_DEFAULT, c ^ 0100);
911 }
912 }
913 if (shiftout)
914 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s",
915 TermEscape.te_normal);
916 (void) sm_io_flush(fp, SM_TIME_DEFAULT);
917 }
918
919 /*
920 ** MAKELOWER -- Translate a line into lower case
921 **
922 ** Parameters:
923 ** p -- the string to translate. If NULL, return is
924 ** immediate.
925 **
926 ** Returns:
927 ** none.
928 **
929 ** Side Effects:
930 ** String pointed to by p is translated to lower case.
931 */
932
933 void
makelower(p)934 makelower(p)
935 register char *p;
936 {
937 register char c;
938
939 if (p == NULL)
940 return;
941 for (; (c = *p) != '\0'; p++)
942 if (isascii(c) && isupper(c))
943 *p = tolower(c);
944 }
945
946 /*
947 ** FIXCRLF -- fix <CR><LF> in line.
948 **
949 ** Looks for the <CR><LF> combination and turns it into the
950 ** UNIX canonical <NL> character. It only takes one line,
951 ** i.e., it is assumed that the first <NL> found is the end
952 ** of the line.
953 **
954 ** Parameters:
955 ** line -- the line to fix.
956 ** stripnl -- if true, strip the newline also.
957 **
958 ** Returns:
959 ** none.
960 **
961 ** Side Effects:
962 ** line is changed in place.
963 */
964
965 void
fixcrlf(line,stripnl)966 fixcrlf(line, stripnl)
967 char *line;
968 bool stripnl;
969 {
970 register char *p;
971
972 p = strchr(line, '\n');
973 if (p == NULL)
974 return;
975 if (p > line && p[-1] == '\r')
976 p--;
977 if (!stripnl)
978 *p++ = '\n';
979 *p = '\0';
980 }
981
982 /*
983 ** PUTLINE -- put a line like fputs obeying SMTP conventions
984 **
985 ** This routine always guarantees outputing a newline (or CRLF,
986 ** as appropriate) at the end of the string.
987 **
988 ** Parameters:
989 ** l -- line to put.
990 ** mci -- the mailer connection information.
991 **
992 ** Returns:
993 ** true iff line was written successfully
994 **
995 ** Side Effects:
996 ** output of l to mci->mci_out.
997 */
998
999 bool
putline(l,mci)1000 putline(l, mci)
1001 register char *l;
1002 register MCI *mci;
1003 {
1004 return putxline(l, strlen(l), mci, PXLF_MAPFROM);
1005 }
1006
1007 /*
1008 ** PUTXLINE -- putline with flags bits.
1009 **
1010 ** This routine always guarantees outputing a newline (or CRLF,
1011 ** as appropriate) at the end of the string.
1012 **
1013 ** Parameters:
1014 ** l -- line to put.
1015 ** len -- the length of the line.
1016 ** mci -- the mailer connection information.
1017 ** pxflags -- flag bits:
1018 ** PXLF_MAPFROM -- map From_ to >From_.
1019 ** PXLF_STRIP8BIT -- strip 8th bit.
1020 ** PXLF_HEADER -- map bare newline in header to newline space.
1021 ** PXLF_NOADDEOL -- don't add an EOL if one wasn't present.
1022 ** PXLF_STRIPMQUOTE -- strip METAQUOTE bytes.
1023 **
1024 ** Returns:
1025 ** true iff line was written successfully
1026 **
1027 ** Side Effects:
1028 ** output of l to mci->mci_out.
1029 */
1030
1031
1032 #define PUTX(limit) \
1033 do \
1034 { \
1035 quotenext = false; \
1036 while (l < limit) \
1037 { \
1038 unsigned char c = (unsigned char) *l++; \
1039 \
1040 if (bitset(PXLF_STRIPMQUOTE, pxflags) && \
1041 !quotenext && c == METAQUOTE) \
1042 { \
1043 quotenext = true; \
1044 continue; \
1045 } \
1046 quotenext = false; \
1047 if (strip8bit) \
1048 c &= 0177; \
1049 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, \
1050 c) == SM_IO_EOF) \
1051 { \
1052 dead = true; \
1053 break; \
1054 } \
1055 if (TrafficLogFile != NULL) \
1056 (void) sm_io_putc(TrafficLogFile, \
1057 SM_TIME_DEFAULT, \
1058 c); \
1059 } \
1060 } while (0)
1061
1062 bool
putxline(l,len,mci,pxflags)1063 putxline(l, len, mci, pxflags)
1064 register char *l;
1065 size_t len;
1066 register MCI *mci;
1067 int pxflags;
1068 {
1069 register char *p, *end;
1070 int slop;
1071 bool dead, quotenext, strip8bit;
1072
1073 /* strip out 0200 bits -- these can look like TELNET protocol */
1074 strip8bit = bitset(MCIF_7BIT, mci->mci_flags) ||
1075 bitset(PXLF_STRIP8BIT, pxflags);
1076 dead = false;
1077 slop = 0;
1078
1079 end = l + len;
1080 do
1081 {
1082 bool noeol = false;
1083
1084 /* find the end of the line */
1085 p = memchr(l, '\n', end - l);
1086 if (p == NULL)
1087 {
1088 p = end;
1089 noeol = true;
1090 }
1091
1092 if (TrafficLogFile != NULL)
1093 (void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT,
1094 "%05d >>> ", (int) CurrentPid);
1095
1096 /* check for line overflow */
1097 while (mci->mci_mailer->m_linelimit > 0 &&
1098 (p - l + slop) > mci->mci_mailer->m_linelimit)
1099 {
1100 register char *q = &l[mci->mci_mailer->m_linelimit - slop - 1];
1101
1102 if (l[0] == '.' && slop == 0 &&
1103 bitnset(M_XDOT, mci->mci_mailer->m_flags))
1104 {
1105 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
1106 '.') == SM_IO_EOF)
1107 dead = true;
1108 if (TrafficLogFile != NULL)
1109 (void) sm_io_putc(TrafficLogFile,
1110 SM_TIME_DEFAULT, '.');
1111 }
1112 else if (l[0] == 'F' && slop == 0 &&
1113 bitset(PXLF_MAPFROM, pxflags) &&
1114 strncmp(l, "From ", 5) == 0 &&
1115 bitnset(M_ESCFROM, mci->mci_mailer->m_flags))
1116 {
1117 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
1118 '>') == SM_IO_EOF)
1119 dead = true;
1120 if (TrafficLogFile != NULL)
1121 (void) sm_io_putc(TrafficLogFile,
1122 SM_TIME_DEFAULT,
1123 '>');
1124 }
1125 if (dead)
1126 break;
1127
1128 PUTX(q);
1129 if (dead)
1130 break;
1131
1132 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
1133 '!') == SM_IO_EOF ||
1134 sm_io_fputs(mci->mci_out, SM_TIME_DEFAULT,
1135 mci->mci_mailer->m_eol) == SM_IO_EOF ||
1136 sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
1137 ' ') == SM_IO_EOF)
1138 {
1139 dead = true;
1140 break;
1141 }
1142 if (TrafficLogFile != NULL)
1143 {
1144 (void) sm_io_fprintf(TrafficLogFile,
1145 SM_TIME_DEFAULT,
1146 "!\n%05d >>> ",
1147 (int) CurrentPid);
1148 }
1149 slop = 1;
1150 }
1151
1152 if (dead)
1153 break;
1154
1155 /* output last part */
1156 if (l[0] == '.' && slop == 0 &&
1157 bitnset(M_XDOT, mci->mci_mailer->m_flags) &&
1158 !bitset(MCIF_INLONGLINE, mci->mci_flags))
1159 {
1160 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, '.') ==
1161 SM_IO_EOF)
1162 {
1163 dead = true;
1164 break;
1165 }
1166 if (TrafficLogFile != NULL)
1167 (void) sm_io_putc(TrafficLogFile,
1168 SM_TIME_DEFAULT, '.');
1169 }
1170 else if (l[0] == 'F' && slop == 0 &&
1171 bitset(PXLF_MAPFROM, pxflags) &&
1172 strncmp(l, "From ", 5) == 0 &&
1173 bitnset(M_ESCFROM, mci->mci_mailer->m_flags) &&
1174 !bitset(MCIF_INLONGLINE, mci->mci_flags))
1175 {
1176 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, '>') ==
1177 SM_IO_EOF)
1178 {
1179 dead = true;
1180 break;
1181 }
1182 if (TrafficLogFile != NULL)
1183 (void) sm_io_putc(TrafficLogFile,
1184 SM_TIME_DEFAULT, '>');
1185 }
1186 PUTX(p);
1187 if (dead)
1188 break;
1189
1190 if (TrafficLogFile != NULL)
1191 (void) sm_io_putc(TrafficLogFile, SM_TIME_DEFAULT,
1192 '\n');
1193 if ((!bitset(PXLF_NOADDEOL, pxflags) || !noeol))
1194 {
1195 mci->mci_flags &= ~MCIF_INLONGLINE;
1196 if (sm_io_fputs(mci->mci_out, SM_TIME_DEFAULT,
1197 mci->mci_mailer->m_eol) == SM_IO_EOF)
1198 {
1199 dead = true;
1200 break;
1201 }
1202 }
1203 else
1204 mci->mci_flags |= MCIF_INLONGLINE;
1205
1206 if (l < end && *l == '\n')
1207 {
1208 if (*++l != ' ' && *l != '\t' && *l != '\0' &&
1209 bitset(PXLF_HEADER, pxflags))
1210 {
1211 if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
1212 ' ') == SM_IO_EOF)
1213 {
1214 dead = true;
1215 break;
1216 }
1217
1218 if (TrafficLogFile != NULL)
1219 (void) sm_io_putc(TrafficLogFile,
1220 SM_TIME_DEFAULT, ' ');
1221 }
1222 }
1223
1224 } while (l < end);
1225 return !dead;
1226 }
1227
1228 /*
1229 ** XUNLINK -- unlink a file, doing logging as appropriate.
1230 **
1231 ** Parameters:
1232 ** f -- name of file to unlink.
1233 **
1234 ** Returns:
1235 ** return value of unlink()
1236 **
1237 ** Side Effects:
1238 ** f is unlinked.
1239 */
1240
1241 int
xunlink(f)1242 xunlink(f)
1243 char *f;
1244 {
1245 register int i;
1246 int save_errno;
1247
1248 if (LogLevel > 98)
1249 sm_syslog(LOG_DEBUG, CurEnv->e_id, "unlink %s", f);
1250
1251 i = unlink(f);
1252 save_errno = errno;
1253 if (i < 0 && LogLevel > 97)
1254 sm_syslog(LOG_DEBUG, CurEnv->e_id, "%s: unlink-fail %d",
1255 f, errno);
1256 if (i >= 0)
1257 SYNC_DIR(f, false);
1258 errno = save_errno;
1259 return i;
1260 }
1261
1262 /*
1263 ** SFGETS -- "safe" fgets -- times out and ignores random interrupts.
1264 **
1265 ** Parameters:
1266 ** buf -- place to put the input line.
1267 ** siz -- size of buf.
1268 ** fp -- file to read from.
1269 ** timeout -- the timeout before error occurs.
1270 ** during -- what we are trying to read (for error messages).
1271 **
1272 ** Returns:
1273 ** NULL on error (including timeout). This may also leave
1274 ** buf containing a null string.
1275 ** buf otherwise.
1276 */
1277
1278
1279 char *
sfgets(buf,siz,fp,timeout,during)1280 sfgets(buf, siz, fp, timeout, during)
1281 char *buf;
1282 int siz;
1283 SM_FILE_T *fp;
1284 time_t timeout;
1285 char *during;
1286 {
1287 register char *p;
1288 int save_errno, io_timeout, l;
1289
1290 SM_REQUIRE(siz > 0);
1291 SM_REQUIRE(buf != NULL);
1292
1293 if (fp == NULL)
1294 {
1295 buf[0] = '\0';
1296 errno = EBADF;
1297 return NULL;
1298 }
1299
1300 /* try to read */
1301 l = -1;
1302 errno = 0;
1303
1304 /* convert the timeout to sm_io notation */
1305 io_timeout = (timeout <= 0) ? SM_TIME_DEFAULT : timeout * 1000;
1306 while (!sm_io_eof(fp) && !sm_io_error(fp))
1307 {
1308 errno = 0;
1309 l = sm_io_fgets(fp, io_timeout, buf, siz);
1310 if (l < 0 && errno == EAGAIN)
1311 {
1312 /* The sm_io_fgets() call timedout */
1313 if (LogLevel > 1)
1314 sm_syslog(LOG_NOTICE, CurEnv->e_id,
1315 "timeout waiting for input from %.100s during %s",
1316 CURHOSTNAME,
1317 during);
1318 buf[0] = '\0';
1319 #if XDEBUG
1320 checkfd012(during);
1321 #endif /* XDEBUG */
1322 if (TrafficLogFile != NULL)
1323 (void) sm_io_fprintf(TrafficLogFile,
1324 SM_TIME_DEFAULT,
1325 "%05d <<< [TIMEOUT]\n",
1326 (int) CurrentPid);
1327 errno = ETIMEDOUT;
1328 return NULL;
1329 }
1330 if (l >= 0 || errno != EINTR)
1331 break;
1332 (void) sm_io_clearerr(fp);
1333 }
1334 save_errno = errno;
1335
1336 /* clean up the books and exit */
1337 LineNumber++;
1338 if (l < 0)
1339 {
1340 buf[0] = '\0';
1341 if (TrafficLogFile != NULL)
1342 (void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT,
1343 "%05d <<< [EOF]\n",
1344 (int) CurrentPid);
1345 errno = save_errno;
1346 return NULL;
1347 }
1348 if (TrafficLogFile != NULL)
1349 (void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT,
1350 "%05d <<< %s", (int) CurrentPid, buf);
1351 if (SevenBitInput)
1352 {
1353 for (p = buf; *p != '\0'; p++)
1354 *p &= ~0200;
1355 }
1356 else if (!HasEightBits)
1357 {
1358 for (p = buf; *p != '\0'; p++)
1359 {
1360 if (bitset(0200, *p))
1361 {
1362 HasEightBits = true;
1363 break;
1364 }
1365 }
1366 }
1367 return buf;
1368 }
1369
1370 /*
1371 ** FGETFOLDED -- like fgets, but knows about folded lines.
1372 **
1373 ** Parameters:
1374 ** buf -- place to put result.
1375 ** np -- pointer to bytes available; will be updated with
1376 ** the actual buffer size (not number of bytes filled)
1377 ** on return.
1378 ** f -- file to read from.
1379 **
1380 ** Returns:
1381 ** input line(s) on success, NULL on error or SM_IO_EOF.
1382 ** This will normally be buf -- unless the line is too
1383 ** long, when it will be sm_malloc_x()ed.
1384 **
1385 ** Side Effects:
1386 ** buf gets lines from f, with continuation lines (lines
1387 ** with leading white space) appended. CRLF's are mapped
1388 ** into single newlines. Any trailing NL is stripped.
1389 */
1390
1391 char *
fgetfolded(buf,np,f)1392 fgetfolded(buf, np, f)
1393 char *buf;
1394 int *np;
1395 SM_FILE_T *f;
1396 {
1397 register char *p = buf;
1398 char *bp = buf;
1399 register int i;
1400 int n;
1401
1402 SM_REQUIRE(np != NULL);
1403 n = *np;
1404 SM_REQUIRE(n > 0);
1405 SM_REQUIRE(buf != NULL);
1406 if (f == NULL)
1407 {
1408 buf[0] = '\0';
1409 errno = EBADF;
1410 return NULL;
1411 }
1412
1413 n--;
1414 while ((i = sm_io_getc(f, SM_TIME_DEFAULT)) != SM_IO_EOF)
1415 {
1416 if (i == '\r')
1417 {
1418 i = sm_io_getc(f, SM_TIME_DEFAULT);
1419 if (i != '\n')
1420 {
1421 if (i != SM_IO_EOF)
1422 (void) sm_io_ungetc(f, SM_TIME_DEFAULT,
1423 i);
1424 i = '\r';
1425 }
1426 }
1427 if (--n <= 0)
1428 {
1429 /* allocate new space */
1430 char *nbp;
1431 int nn;
1432
1433 nn = (p - bp);
1434 if (nn < MEMCHUNKSIZE)
1435 nn *= 2;
1436 else
1437 nn += MEMCHUNKSIZE;
1438 nbp = sm_malloc_x(nn);
1439 memmove(nbp, bp, p - bp);
1440 p = &nbp[p - bp];
1441 if (bp != buf)
1442 sm_free(bp);
1443 bp = nbp;
1444 n = nn - (p - bp);
1445 *np = nn;
1446 }
1447 *p++ = i;
1448 if (i == '\n')
1449 {
1450 LineNumber++;
1451 i = sm_io_getc(f, SM_TIME_DEFAULT);
1452 if (i != SM_IO_EOF)
1453 (void) sm_io_ungetc(f, SM_TIME_DEFAULT, i);
1454 if (i != ' ' && i != '\t')
1455 break;
1456 }
1457 }
1458 if (p == bp)
1459 return NULL;
1460 if (p[-1] == '\n')
1461 p--;
1462 *p = '\0';
1463 return bp;
1464 }
1465
1466 /*
1467 ** CURTIME -- return current time.
1468 **
1469 ** Parameters:
1470 ** none.
1471 **
1472 ** Returns:
1473 ** the current time.
1474 */
1475
1476 time_t
curtime()1477 curtime()
1478 {
1479 auto time_t t;
1480
1481 (void) time(&t);
1482 return t;
1483 }
1484
1485 /*
1486 ** ATOBOOL -- convert a string representation to boolean.
1487 **
1488 ** Defaults to false
1489 **
1490 ** Parameters:
1491 ** s -- string to convert. Takes "tTyY", empty, and NULL as true,
1492 ** others as false.
1493 **
1494 ** Returns:
1495 ** A boolean representation of the string.
1496 */
1497
1498 bool
atobool(s)1499 atobool(s)
1500 register char *s;
1501 {
1502 if (s == NULL || *s == '\0' || strchr("tTyY", *s) != NULL)
1503 return true;
1504 return false;
1505 }
1506
1507 /*
1508 ** ATOOCT -- convert a string representation to octal.
1509 **
1510 ** Parameters:
1511 ** s -- string to convert.
1512 **
1513 ** Returns:
1514 ** An integer representing the string interpreted as an
1515 ** octal number.
1516 */
1517
1518 int
atooct(s)1519 atooct(s)
1520 register char *s;
1521 {
1522 register int i = 0;
1523
1524 while (*s >= '0' && *s <= '7')
1525 i = (i << 3) | (*s++ - '0');
1526 return i;
1527 }
1528
1529 /*
1530 ** BITINTERSECT -- tell if two bitmaps intersect
1531 **
1532 ** Parameters:
1533 ** a, b -- the bitmaps in question
1534 **
1535 ** Returns:
1536 ** true if they have a non-null intersection
1537 ** false otherwise
1538 */
1539
1540 bool
bitintersect(a,b)1541 bitintersect(a, b)
1542 BITMAP256 a;
1543 BITMAP256 b;
1544 {
1545 int i;
1546
1547 for (i = BITMAPBYTES / sizeof(int); --i >= 0; )
1548 {
1549 if ((a[i] & b[i]) != 0)
1550 return true;
1551 }
1552 return false;
1553 }
1554
1555 /*
1556 ** BITZEROP -- tell if a bitmap is all zero
1557 **
1558 ** Parameters:
1559 ** map -- the bit map to check
1560 **
1561 ** Returns:
1562 ** true if map is all zero.
1563 ** false if there are any bits set in map.
1564 */
1565
1566 bool
bitzerop(map)1567 bitzerop(map)
1568 BITMAP256 map;
1569 {
1570 int i;
1571
1572 for (i = BITMAPBYTES / sizeof(int); --i >= 0; )
1573 {
1574 if (map[i] != 0)
1575 return false;
1576 }
1577 return true;
1578 }
1579
1580 /*
1581 ** STRCONTAINEDIN -- tell if one string is contained in another
1582 **
1583 ** Parameters:
1584 ** icase -- ignore case?
1585 ** a -- possible substring.
1586 ** b -- possible superstring.
1587 **
1588 ** Returns:
1589 ** true if a is contained in b (case insensitive).
1590 ** false otherwise.
1591 */
1592
1593 bool
strcontainedin(icase,a,b)1594 strcontainedin(icase, a, b)
1595 bool icase;
1596 register char *a;
1597 register char *b;
1598 {
1599 int la;
1600 int lb;
1601 int c;
1602
1603 la = strlen(a);
1604 lb = strlen(b);
1605 c = *a;
1606 if (icase && isascii(c) && isupper(c))
1607 c = tolower(c);
1608 for (; lb-- >= la; b++)
1609 {
1610 if (icase)
1611 {
1612 if (*b != c &&
1613 isascii(*b) && isupper(*b) && tolower(*b) != c)
1614 continue;
1615 if (sm_strncasecmp(a, b, la) == 0)
1616 return true;
1617 }
1618 else
1619 {
1620 if (*b != c)
1621 continue;
1622 if (strncmp(a, b, la) == 0)
1623 return true;
1624 }
1625 }
1626 return false;
1627 }
1628
1629 /*
1630 ** CHECKFD012 -- check low numbered file descriptors
1631 **
1632 ** File descriptors 0, 1, and 2 should be open at all times.
1633 ** This routine verifies that, and fixes it if not true.
1634 **
1635 ** Parameters:
1636 ** where -- a tag printed if the assertion failed
1637 **
1638 ** Returns:
1639 ** none
1640 */
1641
1642 void
checkfd012(where)1643 checkfd012(where)
1644 char *where;
1645 {
1646 #if XDEBUG
1647 register int i;
1648
1649 for (i = 0; i < 3; i++)
1650 fill_fd(i, where);
1651 #endif /* XDEBUG */
1652 }
1653
1654 /*
1655 ** CHECKFDOPEN -- make sure file descriptor is open -- for extended debugging
1656 **
1657 ** Parameters:
1658 ** fd -- file descriptor to check.
1659 ** where -- tag to print on failure.
1660 **
1661 ** Returns:
1662 ** none.
1663 */
1664
1665 void
checkfdopen(fd,where)1666 checkfdopen(fd, where)
1667 int fd;
1668 char *where;
1669 {
1670 #if XDEBUG
1671 struct stat st;
1672
1673 if (fstat(fd, &st) < 0 && errno == EBADF)
1674 {
1675 syserr("checkfdopen(%d): %s not open as expected!", fd, where);
1676 printopenfds(true);
1677 }
1678 #endif /* XDEBUG */
1679 }
1680
1681 /*
1682 ** CHECKFDS -- check for new or missing file descriptors
1683 **
1684 ** Parameters:
1685 ** where -- tag for printing. If null, take a base line.
1686 **
1687 ** Returns:
1688 ** none
1689 **
1690 ** Side Effects:
1691 ** If where is set, shows changes since the last call.
1692 */
1693
1694 void
checkfds(where)1695 checkfds(where)
1696 char *where;
1697 {
1698 int maxfd;
1699 register int fd;
1700 bool printhdr = true;
1701 int save_errno = errno;
1702 static BITMAP256 baseline;
1703 extern int DtableSize;
1704
1705 if (DtableSize > BITMAPBITS)
1706 maxfd = BITMAPBITS;
1707 else
1708 maxfd = DtableSize;
1709 if (where == NULL)
1710 clrbitmap(baseline);
1711
1712 for (fd = 0; fd < maxfd; fd++)
1713 {
1714 struct stat stbuf;
1715
1716 if (fstat(fd, &stbuf) < 0 && errno != EOPNOTSUPP)
1717 {
1718 if (!bitnset(fd, baseline))
1719 continue;
1720 clrbitn(fd, baseline);
1721 }
1722 else if (!bitnset(fd, baseline))
1723 setbitn(fd, baseline);
1724 else
1725 continue;
1726
1727 /* file state has changed */
1728 if (where == NULL)
1729 continue;
1730 if (printhdr)
1731 {
1732 sm_syslog(LOG_DEBUG, CurEnv->e_id,
1733 "%s: changed fds:",
1734 where);
1735 printhdr = false;
1736 }
1737 dumpfd(fd, true, true);
1738 }
1739 errno = save_errno;
1740 }
1741
1742 /*
1743 ** PRINTOPENFDS -- print the open file descriptors (for debugging)
1744 **
1745 ** Parameters:
1746 ** logit -- if set, send output to syslog; otherwise
1747 ** print for debugging.
1748 **
1749 ** Returns:
1750 ** none.
1751 */
1752
1753 #if NETINET || NETINET6
1754 # include <arpa/inet.h>
1755 #endif /* NETINET || NETINET6 */
1756
1757 void
printopenfds(logit)1758 printopenfds(logit)
1759 bool logit;
1760 {
1761 register int fd;
1762 extern int DtableSize;
1763
1764 for (fd = 0; fd < DtableSize; fd++)
1765 dumpfd(fd, false, logit);
1766 }
1767
1768 /*
1769 ** DUMPFD -- dump a file descriptor
1770 **
1771 ** Parameters:
1772 ** fd -- the file descriptor to dump.
1773 ** printclosed -- if set, print a notification even if
1774 ** it is closed; otherwise print nothing.
1775 ** logit -- if set, use sm_syslog instead of sm_dprintf()
1776 **
1777 ** Returns:
1778 ** none.
1779 */
1780
1781 void
dumpfd(fd,printclosed,logit)1782 dumpfd(fd, printclosed, logit)
1783 int fd;
1784 bool printclosed;
1785 bool logit;
1786 {
1787 register char *p;
1788 char *hp;
1789 #ifdef S_IFSOCK
1790 SOCKADDR sa;
1791 #endif /* S_IFSOCK */
1792 auto SOCKADDR_LEN_T slen;
1793 int i;
1794 #if STAT64 > 0
1795 struct stat64 st;
1796 #else /* STAT64 > 0 */
1797 struct stat st;
1798 #endif /* STAT64 > 0 */
1799 char buf[200];
1800
1801 p = buf;
1802 (void) sm_snprintf(p, SPACELEFT(buf, p), "%3d: ", fd);
1803 p += strlen(p);
1804
1805 if (
1806 #if STAT64 > 0
1807 fstat64(fd, &st)
1808 #else /* STAT64 > 0 */
1809 fstat(fd, &st)
1810 #endif /* STAT64 > 0 */
1811 < 0)
1812 {
1813 if (errno != EBADF)
1814 {
1815 (void) sm_snprintf(p, SPACELEFT(buf, p),
1816 "CANNOT STAT (%s)",
1817 sm_errstring(errno));
1818 goto printit;
1819 }
1820 else if (printclosed)
1821 {
1822 (void) sm_snprintf(p, SPACELEFT(buf, p), "CLOSED");
1823 goto printit;
1824 }
1825 return;
1826 }
1827
1828 i = fcntl(fd, F_GETFL, 0);
1829 if (i != -1)
1830 {
1831 (void) sm_snprintf(p, SPACELEFT(buf, p), "fl=0x%x, ", i);
1832 p += strlen(p);
1833 }
1834
1835 (void) sm_snprintf(p, SPACELEFT(buf, p), "mode=%o: ",
1836 (unsigned int) st.st_mode);
1837 p += strlen(p);
1838 switch (st.st_mode & S_IFMT)
1839 {
1840 #ifdef S_IFSOCK
1841 case S_IFSOCK:
1842 (void) sm_snprintf(p, SPACELEFT(buf, p), "SOCK ");
1843 p += strlen(p);
1844 memset(&sa, '\0', sizeof(sa));
1845 slen = sizeof(sa);
1846 if (getsockname(fd, &sa.sa, &slen) < 0)
1847 (void) sm_snprintf(p, SPACELEFT(buf, p), "(%s)",
1848 sm_errstring(errno));
1849 else
1850 {
1851 hp = hostnamebyanyaddr(&sa);
1852 if (hp == NULL)
1853 {
1854 /* EMPTY */
1855 /* do nothing */
1856 }
1857 # if NETINET
1858 else if (sa.sa.sa_family == AF_INET)
1859 (void) sm_snprintf(p, SPACELEFT(buf, p),
1860 "%s/%d", hp, ntohs(sa.sin.sin_port));
1861 # endif /* NETINET */
1862 # if NETINET6
1863 else if (sa.sa.sa_family == AF_INET6)
1864 (void) sm_snprintf(p, SPACELEFT(buf, p),
1865 "%s/%d", hp, ntohs(sa.sin6.sin6_port));
1866 # endif /* NETINET6 */
1867 else
1868 (void) sm_snprintf(p, SPACELEFT(buf, p),
1869 "%s", hp);
1870 }
1871 p += strlen(p);
1872 (void) sm_snprintf(p, SPACELEFT(buf, p), "->");
1873 p += strlen(p);
1874 slen = sizeof(sa);
1875 if (getpeername(fd, &sa.sa, &slen) < 0)
1876 (void) sm_snprintf(p, SPACELEFT(buf, p), "(%s)",
1877 sm_errstring(errno));
1878 else
1879 {
1880 hp = hostnamebyanyaddr(&sa);
1881 if (hp == NULL)
1882 {
1883 /* EMPTY */
1884 /* do nothing */
1885 }
1886 # if NETINET
1887 else if (sa.sa.sa_family == AF_INET)
1888 (void) sm_snprintf(p, SPACELEFT(buf, p),
1889 "%s/%d", hp, ntohs(sa.sin.sin_port));
1890 # endif /* NETINET */
1891 # if NETINET6
1892 else if (sa.sa.sa_family == AF_INET6)
1893 (void) sm_snprintf(p, SPACELEFT(buf, p),
1894 "%s/%d", hp, ntohs(sa.sin6.sin6_port));
1895 # endif /* NETINET6 */
1896 else
1897 (void) sm_snprintf(p, SPACELEFT(buf, p),
1898 "%s", hp);
1899 }
1900 break;
1901 #endif /* S_IFSOCK */
1902
1903 case S_IFCHR:
1904 (void) sm_snprintf(p, SPACELEFT(buf, p), "CHR: ");
1905 p += strlen(p);
1906 goto defprint;
1907
1908 #ifdef S_IFBLK
1909 case S_IFBLK:
1910 (void) sm_snprintf(p, SPACELEFT(buf, p), "BLK: ");
1911 p += strlen(p);
1912 goto defprint;
1913 #endif /* S_IFBLK */
1914
1915 #if defined(S_IFIFO) && (!defined(S_IFSOCK) || S_IFIFO != S_IFSOCK)
1916 case S_IFIFO:
1917 (void) sm_snprintf(p, SPACELEFT(buf, p), "FIFO: ");
1918 p += strlen(p);
1919 goto defprint;
1920 #endif /* defined(S_IFIFO) && (!defined(S_IFSOCK) || S_IFIFO != S_IFSOCK) */
1921
1922 #ifdef S_IFDIR
1923 case S_IFDIR:
1924 (void) sm_snprintf(p, SPACELEFT(buf, p), "DIR: ");
1925 p += strlen(p);
1926 goto defprint;
1927 #endif /* S_IFDIR */
1928
1929 #ifdef S_IFLNK
1930 case S_IFLNK:
1931 (void) sm_snprintf(p, SPACELEFT(buf, p), "LNK: ");
1932 p += strlen(p);
1933 goto defprint;
1934 #endif /* S_IFLNK */
1935
1936 default:
1937 defprint:
1938 (void) sm_snprintf(p, SPACELEFT(buf, p),
1939 "dev=%ld/%ld, ino=%llu, nlink=%d, u/gid=%ld/%ld, ",
1940 (long) major(st.st_dev), (long) minor(st.st_dev),
1941 (ULONGLONG_T) st.st_ino,
1942 (int) st.st_nlink, (long) st.st_uid,
1943 (long) st.st_gid);
1944 p += strlen(p);
1945 (void) sm_snprintf(p, SPACELEFT(buf, p), "size=%llu",
1946 (ULONGLONG_T) st.st_size);
1947 break;
1948 }
1949
1950 printit:
1951 if (logit)
1952 sm_syslog(LOG_DEBUG, CurEnv ? CurEnv->e_id : NULL,
1953 "%.800s", buf);
1954 else
1955 sm_dprintf("%s\n", buf);
1956 }
1957
1958 /*
1959 ** SHORTEN_HOSTNAME -- strip local domain information off of hostname.
1960 **
1961 ** Parameters:
1962 ** host -- the host to shorten (stripped in place).
1963 **
1964 ** Returns:
1965 ** place where string was truncated, NULL if not truncated.
1966 */
1967
1968 char *
shorten_hostname(host)1969 shorten_hostname(host)
1970 char host[];
1971 {
1972 register char *p;
1973 char *mydom;
1974 int i;
1975 bool canon = false;
1976
1977 /* strip off final dot */
1978 i = strlen(host);
1979 p = &host[(i == 0) ? 0 : i - 1];
1980 if (*p == '.')
1981 {
1982 *p = '\0';
1983 canon = true;
1984 }
1985
1986 /* see if there is any domain at all -- if not, we are done */
1987 p = strchr(host, '.');
1988 if (p == NULL)
1989 return NULL;
1990
1991 /* yes, we have a domain -- see if it looks like us */
1992 mydom = macvalue('m', CurEnv);
1993 if (mydom == NULL)
1994 mydom = "";
1995 i = strlen(++p);
1996 if ((canon ? sm_strcasecmp(p, mydom)
1997 : sm_strncasecmp(p, mydom, i)) == 0 &&
1998 (mydom[i] == '.' || mydom[i] == '\0'))
1999 {
2000 *--p = '\0';
2001 return p;
2002 }
2003 return NULL;
2004 }
2005
2006 /*
2007 ** PROG_OPEN -- open a program for reading
2008 **
2009 ** Parameters:
2010 ** argv -- the argument list.
2011 ** pfd -- pointer to a place to store the file descriptor.
2012 ** e -- the current envelope.
2013 **
2014 ** Returns:
2015 ** pid of the process -- -1 if it failed.
2016 */
2017
2018 pid_t
prog_open(argv,pfd,e)2019 prog_open(argv, pfd, e)
2020 char **argv;
2021 int *pfd;
2022 ENVELOPE *e;
2023 {
2024 pid_t pid;
2025 int save_errno;
2026 int sff;
2027 int ret;
2028 int fdv[2];
2029 char *p, *q;
2030 char buf[MAXPATHLEN];
2031 extern int DtableSize;
2032
2033 if (pipe(fdv) < 0)
2034 {
2035 syserr("%s: cannot create pipe for stdout", argv[0]);
2036 return -1;
2037 }
2038 pid = fork();
2039 if (pid < 0)
2040 {
2041 syserr("%s: cannot fork", argv[0]);
2042 (void) close(fdv[0]);
2043 (void) close(fdv[1]);
2044 return -1;
2045 }
2046 if (pid > 0)
2047 {
2048 /* parent */
2049 (void) close(fdv[1]);
2050 *pfd = fdv[0];
2051 return pid;
2052 }
2053
2054 /* Reset global flags */
2055 RestartRequest = NULL;
2056 RestartWorkGroup = false;
2057 ShutdownRequest = NULL;
2058 PendingSignal = 0;
2059 CurrentPid = getpid();
2060
2061 /*
2062 ** Initialize exception stack and default exception
2063 ** handler for child process.
2064 */
2065
2066 sm_exc_newthread(fatal_error);
2067
2068 /* child -- close stdin */
2069 (void) close(0);
2070
2071 /* stdout goes back to parent */
2072 (void) close(fdv[0]);
2073 if (dup2(fdv[1], 1) < 0)
2074 {
2075 syserr("%s: cannot dup2 for stdout", argv[0]);
2076 _exit(EX_OSERR);
2077 }
2078 (void) close(fdv[1]);
2079
2080 /* stderr goes to transcript if available */
2081 if (e->e_xfp != NULL)
2082 {
2083 int xfd;
2084
2085 xfd = sm_io_getinfo(e->e_xfp, SM_IO_WHAT_FD, NULL);
2086 if (xfd >= 0 && dup2(xfd, 2) < 0)
2087 {
2088 syserr("%s: cannot dup2 for stderr", argv[0]);
2089 _exit(EX_OSERR);
2090 }
2091 }
2092
2093 /* this process has no right to the queue file */
2094 if (e->e_lockfp != NULL)
2095 {
2096 int fd;
2097
2098 fd = sm_io_getinfo(e->e_lockfp, SM_IO_WHAT_FD, NULL);
2099 if (fd >= 0)
2100 (void) close(fd);
2101 else
2102 syserr("%s: lockfp does not have a fd", argv[0]);
2103 }
2104
2105 /* chroot to the program mailer directory, if defined */
2106 if (ProgMailer != NULL && ProgMailer->m_rootdir != NULL)
2107 {
2108 expand(ProgMailer->m_rootdir, buf, sizeof(buf), e);
2109 if (chroot(buf) < 0)
2110 {
2111 syserr("prog_open: cannot chroot(%s)", buf);
2112 exit(EX_TEMPFAIL);
2113 }
2114 if (chdir("/") < 0)
2115 {
2116 syserr("prog_open: cannot chdir(/)");
2117 exit(EX_TEMPFAIL);
2118 }
2119 }
2120
2121 /* run as default user */
2122 endpwent();
2123 sm_mbdb_terminate();
2124 #if _FFR_MEMSTAT
2125 (void) sm_memstat_close();
2126 #endif /* _FFR_MEMSTAT */
2127 if (setgid(DefGid) < 0 && geteuid() == 0)
2128 {
2129 syserr("prog_open: setgid(%ld) failed", (long) DefGid);
2130 exit(EX_TEMPFAIL);
2131 }
2132 if (setuid(DefUid) < 0 && geteuid() == 0)
2133 {
2134 syserr("prog_open: setuid(%ld) failed", (long) DefUid);
2135 exit(EX_TEMPFAIL);
2136 }
2137
2138 /* run in some directory */
2139 if (ProgMailer != NULL)
2140 p = ProgMailer->m_execdir;
2141 else
2142 p = NULL;
2143 for (; p != NULL; p = q)
2144 {
2145 q = strchr(p, ':');
2146 if (q != NULL)
2147 *q = '\0';
2148 expand(p, buf, sizeof(buf), e);
2149 if (q != NULL)
2150 *q++ = ':';
2151 if (buf[0] != '\0' && chdir(buf) >= 0)
2152 break;
2153 }
2154 if (p == NULL)
2155 {
2156 /* backup directories */
2157 if (chdir("/tmp") < 0)
2158 (void) chdir("/");
2159 }
2160
2161 /* Check safety of program to be run */
2162 sff = SFF_ROOTOK|SFF_EXECOK;
2163 if (!bitnset(DBS_RUNWRITABLEPROGRAM, DontBlameSendmail))
2164 sff |= SFF_NOGWFILES|SFF_NOWWFILES;
2165 if (bitnset(DBS_RUNPROGRAMINUNSAFEDIRPATH, DontBlameSendmail))
2166 sff |= SFF_NOPATHCHECK;
2167 else
2168 sff |= SFF_SAFEDIRPATH;
2169 ret = safefile(argv[0], DefUid, DefGid, DefUser, sff, 0, NULL);
2170 if (ret != 0)
2171 sm_syslog(LOG_INFO, e->e_id,
2172 "Warning: prog_open: program %s unsafe: %s",
2173 argv[0], sm_errstring(ret));
2174
2175 /* arrange for all the files to be closed */
2176 sm_close_on_exec(STDERR_FILENO + 1, DtableSize);
2177
2178 /* now exec the process */
2179 (void) execve(argv[0], (ARGV_T) argv, (ARGV_T) UserEnviron);
2180
2181 /* woops! failed */
2182 save_errno = errno;
2183 syserr("%s: cannot exec", argv[0]);
2184 if (transienterror(save_errno))
2185 _exit(EX_OSERR);
2186 _exit(EX_CONFIG);
2187 return -1; /* avoid compiler warning on IRIX */
2188 }
2189
2190 /*
2191 ** GET_COLUMN -- look up a Column in a line buffer
2192 **
2193 ** Parameters:
2194 ** line -- the raw text line to search.
2195 ** col -- the column number to fetch.
2196 ** delim -- the delimiter between columns. If null,
2197 ** use white space.
2198 ** buf -- the output buffer.
2199 ** buflen -- the length of buf.
2200 **
2201 ** Returns:
2202 ** buf if successful.
2203 ** NULL otherwise.
2204 */
2205
2206 char *
get_column(line,col,delim,buf,buflen)2207 get_column(line, col, delim, buf, buflen)
2208 char line[];
2209 int col;
2210 int delim;
2211 char buf[];
2212 int buflen;
2213 {
2214 char *p;
2215 char *begin, *end;
2216 int i;
2217 char delimbuf[4];
2218
2219 if ((char) delim == '\0')
2220 (void) sm_strlcpy(delimbuf, "\n\t ", sizeof(delimbuf));
2221 else
2222 {
2223 delimbuf[0] = (char) delim;
2224 delimbuf[1] = '\0';
2225 }
2226
2227 p = line;
2228 if (*p == '\0')
2229 return NULL; /* line empty */
2230 if (*p == (char) delim && col == 0)
2231 return NULL; /* first column empty */
2232
2233 begin = line;
2234
2235 if (col == 0 && (char) delim == '\0')
2236 {
2237 while (*begin != '\0' && isascii(*begin) && isspace(*begin))
2238 begin++;
2239 }
2240
2241 for (i = 0; i < col; i++)
2242 {
2243 if ((begin = strpbrk(begin, delimbuf)) == NULL)
2244 return NULL; /* no such column */
2245 begin++;
2246 if ((char) delim == '\0')
2247 {
2248 while (*begin != '\0' && isascii(*begin) && isspace(*begin))
2249 begin++;
2250 }
2251 }
2252
2253 end = strpbrk(begin, delimbuf);
2254 if (end == NULL)
2255 i = strlen(begin);
2256 else
2257 i = end - begin;
2258 if (i >= buflen)
2259 i = buflen - 1;
2260 (void) sm_strlcpy(buf, begin, i + 1);
2261 return buf;
2262 }
2263
2264 /*
2265 ** CLEANSTRCPY -- copy string keeping out bogus characters
2266 **
2267 ** Parameters:
2268 ** t -- "to" string.
2269 ** f -- "from" string.
2270 ** l -- length of space available in "to" string.
2271 **
2272 ** Returns:
2273 ** none.
2274 */
2275
2276 void
cleanstrcpy(t,f,l)2277 cleanstrcpy(t, f, l)
2278 register char *t;
2279 register char *f;
2280 int l;
2281 {
2282 /* check for newlines and log if necessary */
2283 (void) denlstring(f, true, true);
2284
2285 if (l <= 0)
2286 syserr("!cleanstrcpy: length == 0");
2287
2288 l--;
2289 while (l > 0 && *f != '\0')
2290 {
2291 if (isascii(*f) &&
2292 (isalnum(*f) || strchr("!#$%&'*+-./^_`{|}~", *f) != NULL))
2293 {
2294 l--;
2295 *t++ = *f;
2296 }
2297 f++;
2298 }
2299 *t = '\0';
2300 }
2301
2302 /*
2303 ** DENLSTRING -- convert newlines in a string to spaces
2304 **
2305 ** Parameters:
2306 ** s -- the input string
2307 ** strict -- if set, don't permit continuation lines.
2308 ** logattacks -- if set, log attempted attacks.
2309 **
2310 ** Returns:
2311 ** A pointer to a version of the string with newlines
2312 ** mapped to spaces. This should be copied.
2313 */
2314
2315 char *
denlstring(s,strict,logattacks)2316 denlstring(s, strict, logattacks)
2317 char *s;
2318 bool strict;
2319 bool logattacks;
2320 {
2321 register char *p;
2322 int l;
2323 static char *bp = NULL;
2324 static int bl = 0;
2325
2326 p = s;
2327 while ((p = strchr(p, '\n')) != NULL)
2328 if (strict || (*++p != ' ' && *p != '\t'))
2329 break;
2330 if (p == NULL)
2331 return s;
2332
2333 l = strlen(s) + 1;
2334 if (bl < l)
2335 {
2336 /* allocate more space */
2337 char *nbp = sm_pmalloc_x(l);
2338
2339 if (bp != NULL)
2340 sm_free(bp);
2341 bp = nbp;
2342 bl = l;
2343 }
2344 (void) sm_strlcpy(bp, s, l);
2345 for (p = bp; (p = strchr(p, '\n')) != NULL; )
2346 *p++ = ' ';
2347
2348 if (logattacks)
2349 {
2350 sm_syslog(LOG_NOTICE, CurEnv ? CurEnv->e_id : NULL,
2351 "POSSIBLE ATTACK from %.100s: newline in string \"%s\"",
2352 RealHostName == NULL ? "[UNKNOWN]" : RealHostName,
2353 shortenstring(bp, MAXSHORTSTR));
2354 }
2355
2356 return bp;
2357 }
2358
2359 /*
2360 ** STRREPLNONPRT -- replace "unprintable" characters in a string with subst
2361 **
2362 ** Parameters:
2363 ** s -- string to manipulate (in place)
2364 ** subst -- character to use as replacement
2365 **
2366 ** Returns:
2367 ** true iff string did not contain "unprintable" characters
2368 */
2369
2370 bool
strreplnonprt(s,c)2371 strreplnonprt(s, c)
2372 char *s;
2373 int c;
2374 {
2375 bool ok;
2376
2377 ok = true;
2378 if (s == NULL)
2379 return ok;
2380 while (*s != '\0')
2381 {
2382 if (!(isascii(*s) && isprint(*s)))
2383 {
2384 *s = c;
2385 ok = false;
2386 }
2387 ++s;
2388 }
2389 return ok;
2390 }
2391
2392 /*
2393 ** PATH_IS_DIR -- check to see if file exists and is a directory.
2394 **
2395 ** There are some additional checks for security violations in
2396 ** here. This routine is intended to be used for the host status
2397 ** support.
2398 **
2399 ** Parameters:
2400 ** pathname -- pathname to check for directory-ness.
2401 ** createflag -- if set, create directory if needed.
2402 **
2403 ** Returns:
2404 ** true -- if the indicated pathname is a directory
2405 ** false -- otherwise
2406 */
2407
2408 bool
path_is_dir(pathname,createflag)2409 path_is_dir(pathname, createflag)
2410 char *pathname;
2411 bool createflag;
2412 {
2413 struct stat statbuf;
2414
2415 #if HASLSTAT
2416 if (lstat(pathname, &statbuf) < 0)
2417 #else /* HASLSTAT */
2418 if (stat(pathname, &statbuf) < 0)
2419 #endif /* HASLSTAT */
2420 {
2421 if (errno != ENOENT || !createflag)
2422 return false;
2423 if (mkdir(pathname, 0755) < 0)
2424 return false;
2425 return true;
2426 }
2427 if (!S_ISDIR(statbuf.st_mode))
2428 {
2429 errno = ENOTDIR;
2430 return false;
2431 }
2432
2433 /* security: don't allow writable directories */
2434 if (bitset(S_IWGRP|S_IWOTH, statbuf.st_mode))
2435 {
2436 errno = EACCES;
2437 return false;
2438 }
2439 return true;
2440 }
2441
2442 /*
2443 ** PROC_LIST_ADD -- add process id to list of our children
2444 **
2445 ** Parameters:
2446 ** pid -- pid to add to list.
2447 ** task -- task of pid.
2448 ** type -- type of process.
2449 ** count -- number of processes.
2450 ** other -- other information for this type.
2451 **
2452 ** Returns:
2453 ** none
2454 **
2455 ** Side Effects:
2456 ** May increase CurChildren. May grow ProcList.
2457 */
2458
2459 typedef struct procs PROCS_T;
2460
2461 struct procs
2462 {
2463 pid_t proc_pid;
2464 char *proc_task;
2465 int proc_type;
2466 int proc_count;
2467 int proc_other;
2468 SOCKADDR proc_hostaddr;
2469 };
2470
2471 static PROCS_T *volatile ProcListVec = NULL;
2472 static int ProcListSize = 0;
2473
2474 void
proc_list_add(pid,task,type,count,other,hostaddr)2475 proc_list_add(pid, task, type, count, other, hostaddr)
2476 pid_t pid;
2477 char *task;
2478 int type;
2479 int count;
2480 int other;
2481 SOCKADDR *hostaddr;
2482 {
2483 int i;
2484
2485 for (i = 0; i < ProcListSize; i++)
2486 {
2487 if (ProcListVec[i].proc_pid == NO_PID)
2488 break;
2489 }
2490 if (i >= ProcListSize)
2491 {
2492 /* probe the existing vector to avoid growing infinitely */
2493 proc_list_probe();
2494
2495 /* now scan again */
2496 for (i = 0; i < ProcListSize; i++)
2497 {
2498 if (ProcListVec[i].proc_pid == NO_PID)
2499 break;
2500 }
2501 }
2502 if (i >= ProcListSize)
2503 {
2504 /* grow process list */
2505 int chldwasblocked;
2506 PROCS_T *npv;
2507
2508 SM_ASSERT(ProcListSize < INT_MAX - PROC_LIST_SEG);
2509 npv = (PROCS_T *) sm_pmalloc_x((sizeof(*npv)) *
2510 (ProcListSize + PROC_LIST_SEG));
2511
2512 /* Block SIGCHLD so reapchild() doesn't mess with us */
2513 chldwasblocked = sm_blocksignal(SIGCHLD);
2514 if (ProcListSize > 0)
2515 {
2516 memmove(npv, ProcListVec,
2517 ProcListSize * sizeof(PROCS_T));
2518 sm_free(ProcListVec);
2519 }
2520
2521 /* XXX just use memset() to initialize this part? */
2522 for (i = ProcListSize; i < ProcListSize + PROC_LIST_SEG; i++)
2523 {
2524 npv[i].proc_pid = NO_PID;
2525 npv[i].proc_task = NULL;
2526 npv[i].proc_type = PROC_NONE;
2527 }
2528 i = ProcListSize;
2529 ProcListSize += PROC_LIST_SEG;
2530 ProcListVec = npv;
2531 if (chldwasblocked == 0)
2532 (void) sm_releasesignal(SIGCHLD);
2533 }
2534 ProcListVec[i].proc_pid = pid;
2535 PSTRSET(ProcListVec[i].proc_task, task);
2536 ProcListVec[i].proc_type = type;
2537 ProcListVec[i].proc_count = count;
2538 ProcListVec[i].proc_other = other;
2539 if (hostaddr != NULL)
2540 ProcListVec[i].proc_hostaddr = *hostaddr;
2541 else
2542 memset(&ProcListVec[i].proc_hostaddr, 0,
2543 sizeof(ProcListVec[i].proc_hostaddr));
2544
2545 /* if process adding itself, it's not a child */
2546 if (pid != CurrentPid)
2547 {
2548 SM_ASSERT(CurChildren < INT_MAX);
2549 CurChildren++;
2550 }
2551 }
2552
2553 /*
2554 ** PROC_LIST_SET -- set pid task in process list
2555 **
2556 ** Parameters:
2557 ** pid -- pid to set
2558 ** task -- task of pid
2559 **
2560 ** Returns:
2561 ** none.
2562 */
2563
2564 void
proc_list_set(pid,task)2565 proc_list_set(pid, task)
2566 pid_t pid;
2567 char *task;
2568 {
2569 int i;
2570
2571 for (i = 0; i < ProcListSize; i++)
2572 {
2573 if (ProcListVec[i].proc_pid == pid)
2574 {
2575 PSTRSET(ProcListVec[i].proc_task, task);
2576 break;
2577 }
2578 }
2579 }
2580
2581 /*
2582 ** PROC_LIST_DROP -- drop pid from process list
2583 **
2584 ** Parameters:
2585 ** pid -- pid to drop
2586 ** st -- process status
2587 ** other -- storage for proc_other (return).
2588 **
2589 ** Returns:
2590 ** none.
2591 **
2592 ** Side Effects:
2593 ** May decrease CurChildren, CurRunners, or
2594 ** set RestartRequest or ShutdownRequest.
2595 **
2596 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
2597 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
2598 ** DOING.
2599 */
2600
2601 void
proc_list_drop(pid,st,other)2602 proc_list_drop(pid, st, other)
2603 pid_t pid;
2604 int st;
2605 int *other;
2606 {
2607 int i;
2608 int type = PROC_NONE;
2609
2610 for (i = 0; i < ProcListSize; i++)
2611 {
2612 if (ProcListVec[i].proc_pid == pid)
2613 {
2614 ProcListVec[i].proc_pid = NO_PID;
2615 type = ProcListVec[i].proc_type;
2616 if (other != NULL)
2617 *other = ProcListVec[i].proc_other;
2618 if (CurChildren > 0)
2619 CurChildren--;
2620 break;
2621 }
2622 }
2623
2624
2625 if (type == PROC_CONTROL && WIFEXITED(st))
2626 {
2627 /* if so, see if we need to restart or shutdown */
2628 if (WEXITSTATUS(st) == EX_RESTART)
2629 RestartRequest = "control socket";
2630 else if (WEXITSTATUS(st) == EX_SHUTDOWN)
2631 ShutdownRequest = "control socket";
2632 }
2633 else if (type == PROC_QUEUE_CHILD && !WIFSTOPPED(st) &&
2634 ProcListVec[i].proc_other > -1)
2635 {
2636 /* restart this persistent runner */
2637 mark_work_group_restart(ProcListVec[i].proc_other, st);
2638 }
2639 else if (type == PROC_QUEUE)
2640 {
2641 CurRunners -= ProcListVec[i].proc_count;
2642
2643 /* CHK_CUR_RUNNERS() can't be used here: uses syslog() */
2644 if (CurRunners < 0)
2645 CurRunners = 0;
2646 }
2647 }
2648
2649 /*
2650 ** PROC_LIST_CLEAR -- clear the process list
2651 **
2652 ** Parameters:
2653 ** none.
2654 **
2655 ** Returns:
2656 ** none.
2657 **
2658 ** Side Effects:
2659 ** Sets CurChildren to zero.
2660 */
2661
2662 void
proc_list_clear()2663 proc_list_clear()
2664 {
2665 int i;
2666
2667 /* start from 1 since 0 is the daemon itself */
2668 for (i = 1; i < ProcListSize; i++)
2669 ProcListVec[i].proc_pid = NO_PID;
2670 CurChildren = 0;
2671 }
2672
2673 /*
2674 ** PROC_LIST_PROBE -- probe processes in the list to see if they still exist
2675 **
2676 ** Parameters:
2677 ** none
2678 **
2679 ** Returns:
2680 ** none
2681 **
2682 ** Side Effects:
2683 ** May decrease CurChildren.
2684 */
2685
2686 void
proc_list_probe()2687 proc_list_probe()
2688 {
2689 int i, children;
2690 int chldwasblocked;
2691 pid_t pid;
2692
2693 children = 0;
2694 chldwasblocked = sm_blocksignal(SIGCHLD);
2695
2696 /* start from 1 since 0 is the daemon itself */
2697 for (i = 1; i < ProcListSize; i++)
2698 {
2699 pid = ProcListVec[i].proc_pid;
2700 if (pid == NO_PID || pid == CurrentPid)
2701 continue;
2702 if (kill(pid, 0) < 0)
2703 {
2704 if (LogLevel > 3)
2705 sm_syslog(LOG_DEBUG, CurEnv->e_id,
2706 "proc_list_probe: lost pid %d",
2707 (int) ProcListVec[i].proc_pid);
2708 ProcListVec[i].proc_pid = NO_PID;
2709 SM_FREE_CLR(ProcListVec[i].proc_task);
2710
2711 if (ProcListVec[i].proc_type == PROC_QUEUE)
2712 {
2713 CurRunners -= ProcListVec[i].proc_count;
2714 CHK_CUR_RUNNERS("proc_list_probe", i,
2715 ProcListVec[i].proc_count);
2716 }
2717
2718 CurChildren--;
2719 }
2720 else
2721 {
2722 ++children;
2723 }
2724 }
2725 if (CurChildren < 0)
2726 CurChildren = 0;
2727 if (chldwasblocked == 0)
2728 (void) sm_releasesignal(SIGCHLD);
2729 if (LogLevel > 10 && children != CurChildren && CurrentPid == DaemonPid)
2730 {
2731 sm_syslog(LOG_ERR, NOQID,
2732 "proc_list_probe: found %d children, expected %d",
2733 children, CurChildren);
2734 }
2735 }
2736
2737 /*
2738 ** PROC_LIST_DISPLAY -- display the process list
2739 **
2740 ** Parameters:
2741 ** out -- output file pointer
2742 ** prefix -- string to output in front of each line.
2743 **
2744 ** Returns:
2745 ** none.
2746 */
2747
2748 void
proc_list_display(out,prefix)2749 proc_list_display(out, prefix)
2750 SM_FILE_T *out;
2751 char *prefix;
2752 {
2753 int i;
2754
2755 for (i = 0; i < ProcListSize; i++)
2756 {
2757 if (ProcListVec[i].proc_pid == NO_PID)
2758 continue;
2759
2760 (void) sm_io_fprintf(out, SM_TIME_DEFAULT, "%s%d %s%s\n",
2761 prefix,
2762 (int) ProcListVec[i].proc_pid,
2763 ProcListVec[i].proc_task != NULL ?
2764 ProcListVec[i].proc_task : "(unknown)",
2765 (OpMode == MD_SMTP ||
2766 OpMode == MD_DAEMON ||
2767 OpMode == MD_ARPAFTP) ? "\r" : "");
2768 }
2769 }
2770
2771 /*
2772 ** PROC_LIST_SIGNAL -- send a signal to a type of process in the list
2773 **
2774 ** Parameters:
2775 ** type -- type of process to signal
2776 ** signal -- the type of signal to send
2777 **
2778 ** Results:
2779 ** none.
2780 **
2781 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
2782 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
2783 ** DOING.
2784 */
2785
2786 void
proc_list_signal(type,signal)2787 proc_list_signal(type, signal)
2788 int type;
2789 int signal;
2790 {
2791 int chldwasblocked;
2792 int alrmwasblocked;
2793 int i;
2794 pid_t mypid = getpid();
2795
2796 /* block these signals so that we may signal cleanly */
2797 chldwasblocked = sm_blocksignal(SIGCHLD);
2798 alrmwasblocked = sm_blocksignal(SIGALRM);
2799
2800 /* Find all processes of type and send signal */
2801 for (i = 0; i < ProcListSize; i++)
2802 {
2803 if (ProcListVec[i].proc_pid == NO_PID ||
2804 ProcListVec[i].proc_pid == mypid)
2805 continue;
2806 if (ProcListVec[i].proc_type != type)
2807 continue;
2808 (void) kill(ProcListVec[i].proc_pid, signal);
2809 }
2810
2811 /* restore the signals */
2812 if (alrmwasblocked == 0)
2813 (void) sm_releasesignal(SIGALRM);
2814 if (chldwasblocked == 0)
2815 (void) sm_releasesignal(SIGCHLD);
2816 }
2817
2818 /*
2819 ** COUNT_OPEN_CONNECTIONS
2820 **
2821 ** Parameters:
2822 ** hostaddr - ClientAddress
2823 **
2824 ** Returns:
2825 ** the number of open connections for this client
2826 **
2827 */
2828
2829 int
count_open_connections(hostaddr)2830 count_open_connections(hostaddr)
2831 SOCKADDR *hostaddr;
2832 {
2833 int i, n;
2834
2835 if (hostaddr == NULL)
2836 return 0;
2837
2838 /*
2839 ** This code gets called before proc_list_add() gets called,
2840 ** so we (the daemon child for this connection) have not yet
2841 ** counted ourselves. Hence initialize the counter to 1
2842 ** instead of 0 to compensate.
2843 */
2844
2845 n = 1;
2846 for (i = 0; i < ProcListSize; i++)
2847 {
2848 if (ProcListVec[i].proc_pid == NO_PID)
2849 continue;
2850 if (hostaddr->sa.sa_family !=
2851 ProcListVec[i].proc_hostaddr.sa.sa_family)
2852 continue;
2853 #if NETINET
2854 if (hostaddr->sa.sa_family == AF_INET &&
2855 (hostaddr->sin.sin_addr.s_addr ==
2856 ProcListVec[i].proc_hostaddr.sin.sin_addr.s_addr))
2857 n++;
2858 #endif /* NETINET */
2859 #if NETINET6
2860 if (hostaddr->sa.sa_family == AF_INET6 &&
2861 IN6_ARE_ADDR_EQUAL(&(hostaddr->sin6.sin6_addr),
2862 &(ProcListVec[i].proc_hostaddr.sin6.sin6_addr)))
2863 n++;
2864 #endif /* NETINET6 */
2865 }
2866 return n;
2867 }
2868
2869 #if _FFR_XCNCT
2870 /*
2871 ** XCONNECT -- get X-CONNECT info
2872 **
2873 ** Parameters:
2874 ** inchannel -- FILE to check
2875 **
2876 ** Returns:
2877 ** -1 on error
2878 ** 0 if X-CONNECT was not given
2879 ** >0 if X-CONNECT was used successfully (D_XCNCT*)
2880 */
2881
2882 int
xconnect(inchannel)2883 xconnect(inchannel)
2884 SM_FILE_T *inchannel;
2885 {
2886 int r, i;
2887 char *p, *b, delim, inp[MAXINPLINE];
2888 SOCKADDR addr;
2889 char **pvp;
2890 char pvpbuf[PSBUFSIZE];
2891 char *peerhostname; /* name of SMTP peer or "localhost" */
2892 extern ENVELOPE BlankEnvelope;
2893
2894 #define XCONNECT "X-CONNECT "
2895 #define XCNNCTLEN (sizeof(XCONNECT) - 1)
2896
2897 /* Ask the ruleset whether to use x-connect */
2898 pvp = NULL;
2899 peerhostname = RealHostName;
2900 if (peerhostname == NULL)
2901 peerhostname = "localhost";
2902 r = rscap("x_connect", peerhostname,
2903 anynet_ntoa(&RealHostAddr), &BlankEnvelope,
2904 &pvp, pvpbuf, sizeof(pvpbuf));
2905 if (tTd(75, 8))
2906 sm_syslog(LOG_INFO, NOQID, "x-connect: rscap=%d", r);
2907 if (r == EX_UNAVAILABLE)
2908 return 0;
2909 if (r != EX_OK)
2910 {
2911 /* ruleset error */
2912 sm_syslog(LOG_INFO, NOQID, "x-connect: rscap=%d", r);
2913 return 0;
2914 }
2915 if (pvp != NULL && pvp[0] != NULL && (pvp[0][0] & 0377) == CANONNET)
2916 {
2917 /* $#: no x-connect */
2918 if (tTd(75, 7))
2919 sm_syslog(LOG_INFO, NOQID, "x-connect: nope");
2920 return 0;
2921 }
2922
2923 p = sfgets(inp, sizeof(inp), InChannel, TimeOuts.to_nextcommand, "pre");
2924 if (tTd(75, 6))
2925 sm_syslog(LOG_INFO, NOQID, "x-connect: input=%s", p);
2926 if (p == NULL || strncasecmp(p, XCONNECT, XCNNCTLEN) != 0)
2927 return -1;
2928 p += XCNNCTLEN;
2929 while (isascii(*p) && isspace(*p))
2930 p++;
2931
2932 /* parameters: IPAddress [Hostname[ M]] */
2933 b = p;
2934 while (*p != '\0' && isascii(*p) &&
2935 (isalnum(*p) || *p == '.' || *p== ':'))
2936 p++;
2937 delim = *p;
2938 *p = '\0';
2939
2940 memset(&addr, '\0', sizeof(addr));
2941 addr.sin.sin_addr.s_addr = inet_addr(b);
2942 if (addr.sin.sin_addr.s_addr != INADDR_NONE)
2943 {
2944 addr.sa.sa_family = AF_INET;
2945 memcpy(&RealHostAddr, &addr, sizeof(addr));
2946 if (tTd(75, 2))
2947 sm_syslog(LOG_INFO, NOQID, "x-connect: addr=%s",
2948 anynet_ntoa(&RealHostAddr));
2949 }
2950 # if NETINET6
2951 else if ((r = inet_pton(AF_INET6, b, &addr.sin6.sin6_addr)) == 1)
2952 {
2953 addr.sa.sa_family = AF_INET6;
2954 memcpy(&RealHostAddr, &addr, sizeof(addr));
2955 }
2956 # endif /* NETINET6 */
2957 else
2958 return -1;
2959
2960 /* more parameters? */
2961 if (delim != ' ')
2962 return D_XCNCT;
2963 while (*p != '\0' && isascii(*p) && isspace(*p))
2964 p++;
2965
2966 for (b = ++p, i = 0;
2967 *p != '\0' && isascii(*p) && (isalnum(*p) || *p == '.' || *p == '-');
2968 p++, i++)
2969 ;
2970 if (i == 0)
2971 return D_XCNCT;
2972 delim = *p;
2973 if (i > MAXNAME)
2974 b[MAXNAME] = '\0';
2975 else
2976 b[i] = '\0';
2977 SM_FREE_CLR(RealHostName);
2978 RealHostName = newstr(b);
2979 if (tTd(75, 2))
2980 sm_syslog(LOG_INFO, NOQID, "x-connect: host=%s", b);
2981 *p = delim;
2982
2983 b = p;
2984 if (*p != ' ')
2985 return D_XCNCT;
2986
2987 while (*p != '\0' && isascii(*p) && isspace(*p))
2988 p++;
2989
2990 if (tTd(75, 4))
2991 {
2992 char *e;
2993
2994 e = strpbrk(p, "\r\n");
2995 if (e != NULL)
2996 *e = '\0';
2997 sm_syslog(LOG_INFO, NOQID, "x-connect: rest=%s", p);
2998 }
2999 if (*p == 'M')
3000 return D_XCNCT_M;
3001
3002 return D_XCNCT;
3003 }
3004 #endif /* _FFR_XCNCT */
3005