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