| Current Path : /compat/linux/proc/self/root/usr/src/contrib/sendmail/src/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
| Current File : //compat/linux/proc/self/root/usr/src/contrib/sendmail/src/util.c |
/*
* Copyright (c) 1998-2007, 2009 Sendmail, Inc. and its suppliers.
* All rights reserved.
* Copyright (c) 1983, 1995-1997 Eric P. Allman. All rights reserved.
* Copyright (c) 1988, 1993
* The Regents of the University of California. All rights reserved.
*
* By using this file, you agree to the terms and conditions set
* forth in the LICENSE file which can be found at the top level of
* the sendmail distribution.
*
*/
#include <sendmail.h>
SM_RCSID("@(#)$Id: util.c,v 8.416 2009/12/18 17:05:26 ca Exp $")
#include <sm/sendmail.h>
#include <sysexits.h>
#include <sm/xtrap.h>
/*
** NEWSTR -- Create a copy of a C string
**
** Parameters:
** s -- the string to copy.
**
** Returns:
** pointer to newly allocated string.
*/
char *
newstr(s)
const char *s;
{
size_t l;
char *n;
l = strlen(s);
SM_ASSERT(l + 1 > l);
n = xalloc(l + 1);
sm_strlcpy(n, s, l + 1);
return n;
}
/*
** ADDQUOTES -- Adds quotes & quote bits to a string.
**
** Runs through a string and adds backslashes and quote bits.
**
** Parameters:
** s -- the string to modify.
** rpool -- resource pool from which to allocate result
**
** Returns:
** pointer to quoted string.
*/
char *
addquotes(s, rpool)
char *s;
SM_RPOOL_T *rpool;
{
int len = 0;
char c;
char *p = s, *q, *r;
if (s == NULL)
return NULL;
/* Find length of quoted string */
while ((c = *p++) != '\0')
{
len++;
if (c == '\\' || c == '"')
len++;
}
q = r = sm_rpool_malloc_x(rpool, len + 3);
p = s;
/* add leading quote */
*q++ = '"';
while ((c = *p++) != '\0')
{
/* quote \ or " */
if (c == '\\' || c == '"')
*q++ = '\\';
*q++ = c;
}
*q++ = '"';
*q = '\0';
return r;
}
/*
** STRIPBACKSLASH -- Strip all leading backslashes from a string, provided
** the following character is alpha-numerical.
**
** This is done in place.
**
** Parameters:
** s -- the string to strip.
**
** Returns:
** none.
*/
void
stripbackslash(s)
char *s;
{
char *p, *q, c;
if (s == NULL || *s == '\0')
return;
p = q = s;
while (*p == '\\' && (p[1] == '\\' || (isascii(p[1]) && isalnum(p[1]))))
p++;
do
{
c = *q++ = *p++;
} while (c != '\0');
}
/*
** RFC822_STRING -- Checks string for proper RFC822 string quoting.
**
** Runs through a string and verifies RFC822 special characters
** are only found inside comments, quoted strings, or backslash
** escaped. Also verified balanced quotes and parenthesis.
**
** Parameters:
** s -- the string to modify.
**
** Returns:
** true iff the string is RFC822 compliant, false otherwise.
*/
bool
rfc822_string(s)
char *s;
{
bool quoted = false;
int commentlev = 0;
char *c = s;
if (s == NULL)
return false;
while (*c != '\0')
{
/* escaped character */
if (*c == '\\')
{
c++;
if (*c == '\0')
return false;
}
else if (commentlev == 0 && *c == '"')
quoted = !quoted;
else if (!quoted)
{
if (*c == ')')
{
/* unbalanced ')' */
if (commentlev == 0)
return false;
else
commentlev--;
}
else if (*c == '(')
commentlev++;
else if (commentlev == 0 &&
strchr(MustQuoteChars, *c) != NULL)
return false;
}
c++;
}
/* unbalanced '"' or '(' */
return !quoted && commentlev == 0;
}
/*
** SHORTEN_RFC822_STRING -- Truncate and rebalance an RFC822 string
**
** Arbitrarily shorten (in place) an RFC822 string and rebalance
** comments and quotes.
**
** Parameters:
** string -- the string to shorten
** length -- the maximum size, 0 if no maximum
**
** Returns:
** true if string is changed, false otherwise
**
** Side Effects:
** Changes string in place, possibly resulting
** in a shorter string.
*/
bool
shorten_rfc822_string(string, length)
char *string;
size_t length;
{
bool backslash = false;
bool modified = false;
bool quoted = false;
size_t slen;
int parencount = 0;
char *ptr = string;
/*
** If have to rebalance an already short enough string,
** need to do it within allocated space.
*/
slen = strlen(string);
if (length == 0 || slen < length)
length = slen;
while (*ptr != '\0')
{
if (backslash)
{
backslash = false;
goto increment;
}
if (*ptr == '\\')
backslash = true;
else if (*ptr == '(')
{
if (!quoted)
parencount++;
}
else if (*ptr == ')')
{
if (--parencount < 0)
parencount = 0;
}
/* Inside a comment, quotes don't matter */
if (parencount <= 0 && *ptr == '"')
quoted = !quoted;
increment:
/* Check for sufficient space for next character */
if (length - (ptr - string) <= (size_t) ((backslash ? 1 : 0) +
parencount +
(quoted ? 1 : 0)))
{
/* Not enough, backtrack */
if (*ptr == '\\')
backslash = false;
else if (*ptr == '(' && !quoted)
parencount--;
else if (*ptr == '"' && parencount == 0)
quoted = false;
break;
}
ptr++;
}
/* Rebalance */
while (parencount-- > 0)
{
if (*ptr != ')')
{
modified = true;
*ptr = ')';
}
ptr++;
}
if (quoted)
{
if (*ptr != '"')
{
modified = true;
*ptr = '"';
}
ptr++;
}
if (*ptr != '\0')
{
modified = true;
*ptr = '\0';
}
return modified;
}
/*
** FIND_CHARACTER -- find an unquoted character in an RFC822 string
**
** Find an unquoted, non-commented character in an RFC822
** string and return a pointer to its location in the
** string.
**
** Parameters:
** string -- the string to search
** character -- the character to find
**
** Returns:
** pointer to the character, or
** a pointer to the end of the line if character is not found
*/
char *
find_character(string, character)
char *string;
int character;
{
bool backslash = false;
bool quoted = false;
int parencount = 0;
while (string != NULL && *string != '\0')
{
if (backslash)
{
backslash = false;
if (!quoted && character == '\\' && *string == '\\')
break;
string++;
continue;
}
switch (*string)
{
case '\\':
backslash = true;
break;
case '(':
if (!quoted)
parencount++;
break;
case ')':
if (--parencount < 0)
parencount = 0;
break;
}
/* Inside a comment, nothing matters */
if (parencount > 0)
{
string++;
continue;
}
if (*string == '"')
quoted = !quoted;
else if (*string == character && !quoted)
break;
string++;
}
/* Return pointer to the character */
return string;
}
/*
** CHECK_BODYTYPE -- check bodytype parameter
**
** Parameters:
** bodytype -- bodytype parameter
**
** Returns:
** BODYTYPE_* according to parameter
**
*/
int
check_bodytype(bodytype)
char *bodytype;
{
/* check body type for legality */
if (bodytype == NULL)
return BODYTYPE_NONE;
if (sm_strcasecmp(bodytype, "7BIT") == 0)
return BODYTYPE_7BIT;
if (sm_strcasecmp(bodytype, "8BITMIME") == 0)
return BODYTYPE_8BITMIME;
return BODYTYPE_ILLEGAL;
}
/*
** TRUNCATE_AT_DELIM -- truncate string at a delimiter and append "..."
**
** Parameters:
** str -- string to truncate
** len -- maximum length (including '\0') (0 for unlimited)
** delim -- delimiter character
**
** Returns:
** None.
*/
void
truncate_at_delim(str, len, delim)
char *str;
size_t len;
int delim;
{
char *p;
if (str == NULL || len == 0 || strlen(str) < len)
return;
*(str + len - 1) = '\0';
while ((p = strrchr(str, delim)) != NULL)
{
*p = '\0';
if (p - str + 4 < len)
{
*p++ = (char) delim;
*p = '\0';
(void) sm_strlcat(str, "...", len);
return;
}
}
/* Couldn't find a place to append "..." */
if (len > 3)
(void) sm_strlcpy(str, "...", len);
else
str[0] = '\0';
}
/*
** XALLOC -- Allocate memory, raise an exception on error
**
** Parameters:
** sz -- size of area to allocate.
**
** Returns:
** pointer to data region.
**
** Exceptions:
** SmHeapOutOfMemory (F:sm.heap) -- cannot allocate memory
**
** Side Effects:
** Memory is allocated.
*/
char *
#if SM_HEAP_CHECK
xalloc_tagged(sz, file, line)
register int sz;
char *file;
int line;
#else /* SM_HEAP_CHECK */
xalloc(sz)
register int sz;
#endif /* SM_HEAP_CHECK */
{
register char *p;
SM_REQUIRE(sz >= 0);
/* some systems can't handle size zero mallocs */
if (sz <= 0)
sz = 1;
/* scaffolding for testing error handling code */
sm_xtrap_raise_x(&SmHeapOutOfMemory);
p = sm_malloc_tagged((unsigned) sz, file, line, sm_heap_group());
if (p == NULL)
{
sm_exc_raise_x(&SmHeapOutOfMemory);
}
return p;
}
/*
** COPYPLIST -- copy list of pointers.
**
** This routine is the equivalent of strdup for lists of
** pointers.
**
** Parameters:
** list -- list of pointers to copy.
** Must be NULL terminated.
** copycont -- if true, copy the contents of the vector
** (which must be a string) also.
** rpool -- resource pool from which to allocate storage,
** or NULL
**
** Returns:
** a copy of 'list'.
*/
char **
copyplist(list, copycont, rpool)
char **list;
bool copycont;
SM_RPOOL_T *rpool;
{
register char **vp;
register char **newvp;
for (vp = list; *vp != NULL; vp++)
continue;
vp++;
newvp = (char **) sm_rpool_malloc_x(rpool, (vp - list) * sizeof(*vp));
memmove((char *) newvp, (char *) list, (int) (vp - list) * sizeof(*vp));
if (copycont)
{
for (vp = newvp; *vp != NULL; vp++)
*vp = sm_rpool_strdup_x(rpool, *vp);
}
return newvp;
}
/*
** COPYQUEUE -- copy address queue.
**
** This routine is the equivalent of strdup for address queues;
** addresses marked as QS_IS_DEAD() aren't copied
**
** Parameters:
** addr -- list of address structures to copy.
** rpool -- resource pool from which to allocate storage
**
** Returns:
** a copy of 'addr'.
*/
ADDRESS *
copyqueue(addr, rpool)
ADDRESS *addr;
SM_RPOOL_T *rpool;
{
register ADDRESS *newaddr;
ADDRESS *ret;
register ADDRESS **tail = &ret;
while (addr != NULL)
{
if (!QS_IS_DEAD(addr->q_state))
{
newaddr = (ADDRESS *) sm_rpool_malloc_x(rpool,
sizeof(*newaddr));
STRUCTCOPY(*addr, *newaddr);
*tail = newaddr;
tail = &newaddr->q_next;
}
addr = addr->q_next;
}
*tail = NULL;
return ret;
}
/*
** LOG_SENDMAIL_PID -- record sendmail pid and command line.
**
** Parameters:
** e -- the current envelope.
**
** Returns:
** none.
**
** Side Effects:
** writes pidfile, logs command line.
** keeps file open and locked to prevent overwrite of active file
*/
static SM_FILE_T *Pidf = NULL;
void
log_sendmail_pid(e)
ENVELOPE *e;
{
long sff;
char pidpath[MAXPATHLEN];
extern char *CommandLineArgs;
/* write the pid to the log file for posterity */
sff = SFF_NOLINK|SFF_ROOTOK|SFF_REGONLY|SFF_CREAT|SFF_NBLOCK;
if (TrustedUid != 0 && RealUid == TrustedUid)
sff |= SFF_OPENASROOT;
expand(PidFile, pidpath, sizeof(pidpath), e);
Pidf = safefopen(pidpath, O_WRONLY|O_TRUNC, FileMode, sff);
if (Pidf == NULL)
{
if (errno == EWOULDBLOCK)
sm_syslog(LOG_ERR, NOQID,
"unable to write pid to %s: file in use by another process",
pidpath);
else
sm_syslog(LOG_ERR, NOQID,
"unable to write pid to %s: %s",
pidpath, sm_errstring(errno));
}
else
{
PidFilePid = getpid();
/* write the process id on line 1 */
(void) sm_io_fprintf(Pidf, SM_TIME_DEFAULT, "%ld\n",
(long) PidFilePid);
/* line 2 contains all command line flags */
(void) sm_io_fprintf(Pidf, SM_TIME_DEFAULT, "%s\n",
CommandLineArgs);
/* flush */
(void) sm_io_flush(Pidf, SM_TIME_DEFAULT);
/*
** Leave pid file open until process ends
** so it's not overwritten by another
** process.
*/
}
if (LogLevel > 9)
sm_syslog(LOG_INFO, NOQID, "started as: %s", CommandLineArgs);
}
/*
** CLOSE_SENDMAIL_PID -- close sendmail pid file
**
** Parameters:
** none.
**
** Returns:
** none.
*/
void
close_sendmail_pid()
{
if (Pidf == NULL)
return;
(void) sm_io_close(Pidf, SM_TIME_DEFAULT);
Pidf = NULL;
}
/*
** SET_DELIVERY_MODE -- set and record the delivery mode
**
** Parameters:
** mode -- delivery mode
** e -- the current envelope.
**
** Returns:
** none.
**
** Side Effects:
** sets {deliveryMode} macro
*/
void
set_delivery_mode(mode, e)
int mode;
ENVELOPE *e;
{
char buf[2];
e->e_sendmode = (char) mode;
buf[0] = (char) mode;
buf[1] = '\0';
macdefine(&e->e_macro, A_TEMP, macid("{deliveryMode}"), buf);
}
/*
** SET_OP_MODE -- set and record the op mode
**
** Parameters:
** mode -- op mode
** e -- the current envelope.
**
** Returns:
** none.
**
** Side Effects:
** sets {opMode} macro
*/
void
set_op_mode(mode)
int mode;
{
char buf[2];
extern ENVELOPE BlankEnvelope;
OpMode = (char) mode;
buf[0] = (char) mode;
buf[1] = '\0';
macdefine(&BlankEnvelope.e_macro, A_TEMP, MID_OPMODE, buf);
}
/*
** PRINTAV -- print argument vector.
**
** Parameters:
** fp -- output file pointer.
** av -- argument vector.
**
** Returns:
** none.
**
** Side Effects:
** prints av.
*/
void
printav(fp, av)
SM_FILE_T *fp;
char **av;
{
while (*av != NULL)
{
if (tTd(0, 44))
sm_dprintf("\n\t%08lx=", (unsigned long) *av);
else
(void) sm_io_putc(fp, SM_TIME_DEFAULT, ' ');
if (tTd(0, 99))
sm_dprintf("%s", str2prt(*av++));
else
xputs(fp, *av++);
}
(void) sm_io_putc(fp, SM_TIME_DEFAULT, '\n');
}
/*
** XPUTS -- put string doing control escapes.
**
** Parameters:
** fp -- output file pointer.
** s -- string to put.
**
** Returns:
** none.
**
** Side Effects:
** output to stdout
*/
void
xputs(fp, s)
SM_FILE_T *fp;
const char *s;
{
int c;
struct metamac *mp;
bool shiftout = false;
extern struct metamac MetaMacros[];
static SM_DEBUG_T DebugANSI = SM_DEBUG_INITIALIZER("ANSI",
"@(#)$Debug: ANSI - enable reverse video in debug output $");
/*
** TermEscape is set here, rather than in main(),
** because ANSI mode can be turned on or off at any time
** if we are in -bt rule testing mode.
*/
if (sm_debug_unknown(&DebugANSI))
{
if (sm_debug_active(&DebugANSI, 1))
{
TermEscape.te_rv_on = "\033[7m";
TermEscape.te_normal = "\033[0m";
}
else
{
TermEscape.te_rv_on = "";
TermEscape.te_normal = "";
}
}
if (s == NULL)
{
(void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s<null>%s",
TermEscape.te_rv_on, TermEscape.te_normal);
return;
}
while ((c = (*s++ & 0377)) != '\0')
{
if (shiftout)
{
(void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s",
TermEscape.te_normal);
shiftout = false;
}
if (!isascii(c) && !tTd(84, 1))
{
if (c == MATCHREPL)
{
(void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
"%s$",
TermEscape.te_rv_on);
shiftout = true;
if (*s == '\0')
continue;
c = *s++ & 0377;
goto printchar;
}
if (c == MACROEXPAND || c == MACRODEXPAND)
{
(void) sm_io_fprintf(fp, SM_TIME_DEFAULT,
"%s$",
TermEscape.te_rv_on);
if (c == MACRODEXPAND)
(void) sm_io_putc(fp,
SM_TIME_DEFAULT, '&');
shiftout = true;
if (*s == '\0')
continue;
if (strchr("=~&?", *s) != NULL)
(void) sm_io_putc(fp,
SM_TIME_DEFAULT,
*s++);
if (bitset(0200, *s))
(void) sm_io_fprintf(fp,
SM_TIME_DEFAULT,
"{%s}",
macname(bitidx(*s++)));
else
(void) sm_io_fprintf(fp,
SM_TIME_DEFAULT,
"%c",
*s++);
continue;
}
for (mp = MetaMacros; mp->metaname != '\0'; mp++)
{
if (bitidx(mp->metaval) == c)
{
(void) sm_io_fprintf(fp,
SM_TIME_DEFAULT,
"%s$%c",
TermEscape.te_rv_on,
mp->metaname);
shiftout = true;
break;
}
}
if (c == MATCHCLASS || c == MATCHNCLASS)
{
if (bitset(0200, *s))
(void) sm_io_fprintf(fp,
SM_TIME_DEFAULT,
"{%s}",
macname(bitidx(*s++)));
else if (*s != '\0')
(void) sm_io_fprintf(fp,
SM_TIME_DEFAULT,
"%c",
*s++);
}
if (mp->metaname != '\0')
continue;
/* unrecognized meta character */
(void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%sM-",
TermEscape.te_rv_on);
shiftout = true;
c &= 0177;
}
printchar:
if (isascii(c) && isprint(c))
{
(void) sm_io_putc(fp, SM_TIME_DEFAULT, c);
continue;
}
/* wasn't a meta-macro -- find another way to print it */
switch (c)
{
case '\n':
c = 'n';
break;
case '\r':
c = 'r';
break;
case '\t':
c = 't';
break;
}
if (!shiftout)
{
(void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s",
TermEscape.te_rv_on);
shiftout = true;
}
if (isascii(c) && isprint(c))
{
(void) sm_io_putc(fp, SM_TIME_DEFAULT, '\\');
(void) sm_io_putc(fp, SM_TIME_DEFAULT, c);
}
else if (tTd(84, 2))
(void) sm_io_fprintf(fp, SM_TIME_DEFAULT, " %o ", c);
else if (tTd(84, 1))
(void) sm_io_fprintf(fp, SM_TIME_DEFAULT, " %#x ", c);
else if (!isascii(c) && !tTd(84, 1))
{
(void) sm_io_putc(fp, SM_TIME_DEFAULT, '^');
(void) sm_io_putc(fp, SM_TIME_DEFAULT, c ^ 0100);
}
}
if (shiftout)
(void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s",
TermEscape.te_normal);
(void) sm_io_flush(fp, SM_TIME_DEFAULT);
}
/*
** MAKELOWER -- Translate a line into lower case
**
** Parameters:
** p -- the string to translate. If NULL, return is
** immediate.
**
** Returns:
** none.
**
** Side Effects:
** String pointed to by p is translated to lower case.
*/
void
makelower(p)
register char *p;
{
register char c;
if (p == NULL)
return;
for (; (c = *p) != '\0'; p++)
if (isascii(c) && isupper(c))
*p = tolower(c);
}
/*
** FIXCRLF -- fix <CR><LF> in line.
**
** Looks for the <CR><LF> combination and turns it into the
** UNIX canonical <NL> character. It only takes one line,
** i.e., it is assumed that the first <NL> found is the end
** of the line.
**
** Parameters:
** line -- the line to fix.
** stripnl -- if true, strip the newline also.
**
** Returns:
** none.
**
** Side Effects:
** line is changed in place.
*/
void
fixcrlf(line, stripnl)
char *line;
bool stripnl;
{
register char *p;
p = strchr(line, '\n');
if (p == NULL)
return;
if (p > line && p[-1] == '\r')
p--;
if (!stripnl)
*p++ = '\n';
*p = '\0';
}
/*
** PUTLINE -- put a line like fputs obeying SMTP conventions
**
** This routine always guarantees outputing a newline (or CRLF,
** as appropriate) at the end of the string.
**
** Parameters:
** l -- line to put.
** mci -- the mailer connection information.
**
** Returns:
** true iff line was written successfully
**
** Side Effects:
** output of l to mci->mci_out.
*/
bool
putline(l, mci)
register char *l;
register MCI *mci;
{
return putxline(l, strlen(l), mci, PXLF_MAPFROM);
}
/*
** PUTXLINE -- putline with flags bits.
**
** This routine always guarantees outputing a newline (or CRLF,
** as appropriate) at the end of the string.
**
** Parameters:
** l -- line to put.
** len -- the length of the line.
** mci -- the mailer connection information.
** pxflags -- flag bits:
** PXLF_MAPFROM -- map From_ to >From_.
** PXLF_STRIP8BIT -- strip 8th bit.
** PXLF_HEADER -- map bare newline in header to newline space.
** PXLF_NOADDEOL -- don't add an EOL if one wasn't present.
** PXLF_STRIPMQUOTE -- strip METAQUOTE bytes.
**
** Returns:
** true iff line was written successfully
**
** Side Effects:
** output of l to mci->mci_out.
*/
#define PUTX(limit) \
do \
{ \
quotenext = false; \
while (l < limit) \
{ \
unsigned char c = (unsigned char) *l++; \
\
if (bitset(PXLF_STRIPMQUOTE, pxflags) && \
!quotenext && c == METAQUOTE) \
{ \
quotenext = true; \
continue; \
} \
quotenext = false; \
if (strip8bit) \
c &= 0177; \
if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, \
c) == SM_IO_EOF) \
{ \
dead = true; \
break; \
} \
if (TrafficLogFile != NULL) \
(void) sm_io_putc(TrafficLogFile, \
SM_TIME_DEFAULT, \
c); \
} \
} while (0)
bool
putxline(l, len, mci, pxflags)
register char *l;
size_t len;
register MCI *mci;
int pxflags;
{
register char *p, *end;
int slop;
bool dead, quotenext, strip8bit;
/* strip out 0200 bits -- these can look like TELNET protocol */
strip8bit = bitset(MCIF_7BIT, mci->mci_flags) ||
bitset(PXLF_STRIP8BIT, pxflags);
dead = false;
slop = 0;
end = l + len;
do
{
bool noeol = false;
/* find the end of the line */
p = memchr(l, '\n', end - l);
if (p == NULL)
{
p = end;
noeol = true;
}
if (TrafficLogFile != NULL)
(void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT,
"%05d >>> ", (int) CurrentPid);
/* check for line overflow */
while (mci->mci_mailer->m_linelimit > 0 &&
(p - l + slop) > mci->mci_mailer->m_linelimit)
{
register char *q = &l[mci->mci_mailer->m_linelimit - slop - 1];
if (l[0] == '.' && slop == 0 &&
bitnset(M_XDOT, mci->mci_mailer->m_flags))
{
if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
'.') == SM_IO_EOF)
dead = true;
if (TrafficLogFile != NULL)
(void) sm_io_putc(TrafficLogFile,
SM_TIME_DEFAULT, '.');
}
else if (l[0] == 'F' && slop == 0 &&
bitset(PXLF_MAPFROM, pxflags) &&
strncmp(l, "From ", 5) == 0 &&
bitnset(M_ESCFROM, mci->mci_mailer->m_flags))
{
if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
'>') == SM_IO_EOF)
dead = true;
if (TrafficLogFile != NULL)
(void) sm_io_putc(TrafficLogFile,
SM_TIME_DEFAULT,
'>');
}
if (dead)
break;
PUTX(q);
if (dead)
break;
if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
'!') == SM_IO_EOF ||
sm_io_fputs(mci->mci_out, SM_TIME_DEFAULT,
mci->mci_mailer->m_eol) == SM_IO_EOF ||
sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
' ') == SM_IO_EOF)
{
dead = true;
break;
}
if (TrafficLogFile != NULL)
{
(void) sm_io_fprintf(TrafficLogFile,
SM_TIME_DEFAULT,
"!\n%05d >>> ",
(int) CurrentPid);
}
slop = 1;
}
if (dead)
break;
/* output last part */
if (l[0] == '.' && slop == 0 &&
bitnset(M_XDOT, mci->mci_mailer->m_flags) &&
!bitset(MCIF_INLONGLINE, mci->mci_flags))
{
if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, '.') ==
SM_IO_EOF)
{
dead = true;
break;
}
if (TrafficLogFile != NULL)
(void) sm_io_putc(TrafficLogFile,
SM_TIME_DEFAULT, '.');
}
else if (l[0] == 'F' && slop == 0 &&
bitset(PXLF_MAPFROM, pxflags) &&
strncmp(l, "From ", 5) == 0 &&
bitnset(M_ESCFROM, mci->mci_mailer->m_flags) &&
!bitset(MCIF_INLONGLINE, mci->mci_flags))
{
if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT, '>') ==
SM_IO_EOF)
{
dead = true;
break;
}
if (TrafficLogFile != NULL)
(void) sm_io_putc(TrafficLogFile,
SM_TIME_DEFAULT, '>');
}
PUTX(p);
if (dead)
break;
if (TrafficLogFile != NULL)
(void) sm_io_putc(TrafficLogFile, SM_TIME_DEFAULT,
'\n');
if ((!bitset(PXLF_NOADDEOL, pxflags) || !noeol))
{
mci->mci_flags &= ~MCIF_INLONGLINE;
if (sm_io_fputs(mci->mci_out, SM_TIME_DEFAULT,
mci->mci_mailer->m_eol) == SM_IO_EOF)
{
dead = true;
break;
}
}
else
mci->mci_flags |= MCIF_INLONGLINE;
if (l < end && *l == '\n')
{
if (*++l != ' ' && *l != '\t' && *l != '\0' &&
bitset(PXLF_HEADER, pxflags))
{
if (sm_io_putc(mci->mci_out, SM_TIME_DEFAULT,
' ') == SM_IO_EOF)
{
dead = true;
break;
}
if (TrafficLogFile != NULL)
(void) sm_io_putc(TrafficLogFile,
SM_TIME_DEFAULT, ' ');
}
}
} while (l < end);
return !dead;
}
/*
** XUNLINK -- unlink a file, doing logging as appropriate.
**
** Parameters:
** f -- name of file to unlink.
**
** Returns:
** return value of unlink()
**
** Side Effects:
** f is unlinked.
*/
int
xunlink(f)
char *f;
{
register int i;
int save_errno;
if (LogLevel > 98)
sm_syslog(LOG_DEBUG, CurEnv->e_id, "unlink %s", f);
i = unlink(f);
save_errno = errno;
if (i < 0 && LogLevel > 97)
sm_syslog(LOG_DEBUG, CurEnv->e_id, "%s: unlink-fail %d",
f, errno);
if (i >= 0)
SYNC_DIR(f, false);
errno = save_errno;
return i;
}
/*
** SFGETS -- "safe" fgets -- times out and ignores random interrupts.
**
** Parameters:
** buf -- place to put the input line.
** siz -- size of buf.
** fp -- file to read from.
** timeout -- the timeout before error occurs.
** during -- what we are trying to read (for error messages).
**
** Returns:
** NULL on error (including timeout). This may also leave
** buf containing a null string.
** buf otherwise.
*/
char *
sfgets(buf, siz, fp, timeout, during)
char *buf;
int siz;
SM_FILE_T *fp;
time_t timeout;
char *during;
{
register char *p;
int save_errno;
int io_timeout;
SM_REQUIRE(siz > 0);
SM_REQUIRE(buf != NULL);
if (fp == NULL)
{
buf[0] = '\0';
errno = EBADF;
return NULL;
}
/* try to read */
p = NULL;
errno = 0;
/* convert the timeout to sm_io notation */
io_timeout = (timeout <= 0) ? SM_TIME_DEFAULT : timeout * 1000;
while (!sm_io_eof(fp) && !sm_io_error(fp))
{
errno = 0;
p = sm_io_fgets(fp, io_timeout, buf, siz);
if (p == NULL && errno == EAGAIN)
{
/* The sm_io_fgets() call timedout */
if (LogLevel > 1)
sm_syslog(LOG_NOTICE, CurEnv->e_id,
"timeout waiting for input from %.100s during %s",
CURHOSTNAME,
during);
buf[0] = '\0';
#if XDEBUG
checkfd012(during);
#endif /* XDEBUG */
if (TrafficLogFile != NULL)
(void) sm_io_fprintf(TrafficLogFile,
SM_TIME_DEFAULT,
"%05d <<< [TIMEOUT]\n",
(int) CurrentPid);
errno = ETIMEDOUT;
return NULL;
}
if (p != NULL || errno != EINTR)
break;
(void) sm_io_clearerr(fp);
}
save_errno = errno;
/* clean up the books and exit */
LineNumber++;
if (p == NULL)
{
buf[0] = '\0';
if (TrafficLogFile != NULL)
(void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT,
"%05d <<< [EOF]\n",
(int) CurrentPid);
errno = save_errno;
return NULL;
}
if (TrafficLogFile != NULL)
(void) sm_io_fprintf(TrafficLogFile, SM_TIME_DEFAULT,
"%05d <<< %s", (int) CurrentPid, buf);
if (SevenBitInput)
{
for (p = buf; *p != '\0'; p++)
*p &= ~0200;
}
else if (!HasEightBits)
{
for (p = buf; *p != '\0'; p++)
{
if (bitset(0200, *p))
{
HasEightBits = true;
break;
}
}
}
return buf;
}
/*
** FGETFOLDED -- like fgets, but knows about folded lines.
**
** Parameters:
** buf -- place to put result.
** np -- pointer to bytes available; will be updated with
** the actual buffer size (not number of bytes filled)
** on return.
** f -- file to read from.
**
** Returns:
** input line(s) on success, NULL on error or SM_IO_EOF.
** This will normally be buf -- unless the line is too
** long, when it will be sm_malloc_x()ed.
**
** Side Effects:
** buf gets lines from f, with continuation lines (lines
** with leading white space) appended. CRLF's are mapped
** into single newlines. Any trailing NL is stripped.
*/
char *
fgetfolded(buf, np, f)
char *buf;
int *np;
SM_FILE_T *f;
{
register char *p = buf;
char *bp = buf;
register int i;
int n;
SM_REQUIRE(np != NULL);
n = *np;
SM_REQUIRE(n > 0);
SM_REQUIRE(buf != NULL);
if (f == NULL)
{
buf[0] = '\0';
errno = EBADF;
return NULL;
}
n--;
while ((i = sm_io_getc(f, SM_TIME_DEFAULT)) != SM_IO_EOF)
{
if (i == '\r')
{
i = sm_io_getc(f, SM_TIME_DEFAULT);
if (i != '\n')
{
if (i != SM_IO_EOF)
(void) sm_io_ungetc(f, SM_TIME_DEFAULT,
i);
i = '\r';
}
}
if (--n <= 0)
{
/* allocate new space */
char *nbp;
int nn;
nn = (p - bp);
if (nn < MEMCHUNKSIZE)
nn *= 2;
else
nn += MEMCHUNKSIZE;
nbp = sm_malloc_x(nn);
memmove(nbp, bp, p - bp);
p = &nbp[p - bp];
if (bp != buf)
sm_free(bp);
bp = nbp;
n = nn - (p - bp);
*np = nn;
}
*p++ = i;
if (i == '\n')
{
LineNumber++;
i = sm_io_getc(f, SM_TIME_DEFAULT);
if (i != SM_IO_EOF)
(void) sm_io_ungetc(f, SM_TIME_DEFAULT, i);
if (i != ' ' && i != '\t')
break;
}
}
if (p == bp)
return NULL;
if (p[-1] == '\n')
p--;
*p = '\0';
return bp;
}
/*
** CURTIME -- return current time.
**
** Parameters:
** none.
**
** Returns:
** the current time.
*/
time_t
curtime()
{
auto time_t t;
(void) time(&t);
return t;
}
/*
** ATOBOOL -- convert a string representation to boolean.
**
** Defaults to false
**
** Parameters:
** s -- string to convert. Takes "tTyY", empty, and NULL as true,
** others as false.
**
** Returns:
** A boolean representation of the string.
*/
bool
atobool(s)
register char *s;
{
if (s == NULL || *s == '\0' || strchr("tTyY", *s) != NULL)
return true;
return false;
}
/*
** ATOOCT -- convert a string representation to octal.
**
** Parameters:
** s -- string to convert.
**
** Returns:
** An integer representing the string interpreted as an
** octal number.
*/
int
atooct(s)
register char *s;
{
register int i = 0;
while (*s >= '0' && *s <= '7')
i = (i << 3) | (*s++ - '0');
return i;
}
/*
** BITINTERSECT -- tell if two bitmaps intersect
**
** Parameters:
** a, b -- the bitmaps in question
**
** Returns:
** true if they have a non-null intersection
** false otherwise
*/
bool
bitintersect(a, b)
BITMAP256 a;
BITMAP256 b;
{
int i;
for (i = BITMAPBYTES / sizeof(int); --i >= 0; )
{
if ((a[i] & b[i]) != 0)
return true;
}
return false;
}
/*
** BITZEROP -- tell if a bitmap is all zero
**
** Parameters:
** map -- the bit map to check
**
** Returns:
** true if map is all zero.
** false if there are any bits set in map.
*/
bool
bitzerop(map)
BITMAP256 map;
{
int i;
for (i = BITMAPBYTES / sizeof(int); --i >= 0; )
{
if (map[i] != 0)
return false;
}
return true;
}
/*
** STRCONTAINEDIN -- tell if one string is contained in another
**
** Parameters:
** icase -- ignore case?
** a -- possible substring.
** b -- possible superstring.
**
** Returns:
** true if a is contained in b (case insensitive).
** false otherwise.
*/
bool
strcontainedin(icase, a, b)
bool icase;
register char *a;
register char *b;
{
int la;
int lb;
int c;
la = strlen(a);
lb = strlen(b);
c = *a;
if (icase && isascii(c) && isupper(c))
c = tolower(c);
for (; lb-- >= la; b++)
{
if (icase)
{
if (*b != c &&
isascii(*b) && isupper(*b) && tolower(*b) != c)
continue;
if (sm_strncasecmp(a, b, la) == 0)
return true;
}
else
{
if (*b != c)
continue;
if (strncmp(a, b, la) == 0)
return true;
}
}
return false;
}
/*
** CHECKFD012 -- check low numbered file descriptors
**
** File descriptors 0, 1, and 2 should be open at all times.
** This routine verifies that, and fixes it if not true.
**
** Parameters:
** where -- a tag printed if the assertion failed
**
** Returns:
** none
*/
void
checkfd012(where)
char *where;
{
#if XDEBUG
register int i;
for (i = 0; i < 3; i++)
fill_fd(i, where);
#endif /* XDEBUG */
}
/*
** CHECKFDOPEN -- make sure file descriptor is open -- for extended debugging
**
** Parameters:
** fd -- file descriptor to check.
** where -- tag to print on failure.
**
** Returns:
** none.
*/
void
checkfdopen(fd, where)
int fd;
char *where;
{
#if XDEBUG
struct stat st;
if (fstat(fd, &st) < 0 && errno == EBADF)
{
syserr("checkfdopen(%d): %s not open as expected!", fd, where);
printopenfds(true);
}
#endif /* XDEBUG */
}
/*
** CHECKFDS -- check for new or missing file descriptors
**
** Parameters:
** where -- tag for printing. If null, take a base line.
**
** Returns:
** none
**
** Side Effects:
** If where is set, shows changes since the last call.
*/
void
checkfds(where)
char *where;
{
int maxfd;
register int fd;
bool printhdr = true;
int save_errno = errno;
static BITMAP256 baseline;
extern int DtableSize;
if (DtableSize > BITMAPBITS)
maxfd = BITMAPBITS;
else
maxfd = DtableSize;
if (where == NULL)
clrbitmap(baseline);
for (fd = 0; fd < maxfd; fd++)
{
struct stat stbuf;
if (fstat(fd, &stbuf) < 0 && errno != EOPNOTSUPP)
{
if (!bitnset(fd, baseline))
continue;
clrbitn(fd, baseline);
}
else if (!bitnset(fd, baseline))
setbitn(fd, baseline);
else
continue;
/* file state has changed */
if (where == NULL)
continue;
if (printhdr)
{
sm_syslog(LOG_DEBUG, CurEnv->e_id,
"%s: changed fds:",
where);
printhdr = false;
}
dumpfd(fd, true, true);
}
errno = save_errno;
}
/*
** PRINTOPENFDS -- print the open file descriptors (for debugging)
**
** Parameters:
** logit -- if set, send output to syslog; otherwise
** print for debugging.
**
** Returns:
** none.
*/
#if NETINET || NETINET6
# include <arpa/inet.h>
#endif /* NETINET || NETINET6 */
void
printopenfds(logit)
bool logit;
{
register int fd;
extern int DtableSize;
for (fd = 0; fd < DtableSize; fd++)
dumpfd(fd, false, logit);
}
/*
** DUMPFD -- dump a file descriptor
**
** Parameters:
** fd -- the file descriptor to dump.
** printclosed -- if set, print a notification even if
** it is closed; otherwise print nothing.
** logit -- if set, use sm_syslog instead of sm_dprintf()
**
** Returns:
** none.
*/
void
dumpfd(fd, printclosed, logit)
int fd;
bool printclosed;
bool logit;
{
register char *p;
char *hp;
#ifdef S_IFSOCK
SOCKADDR sa;
#endif /* S_IFSOCK */
auto SOCKADDR_LEN_T slen;
int i;
#if STAT64 > 0
struct stat64 st;
#else /* STAT64 > 0 */
struct stat st;
#endif /* STAT64 > 0 */
char buf[200];
p = buf;
(void) sm_snprintf(p, SPACELEFT(buf, p), "%3d: ", fd);
p += strlen(p);
if (
#if STAT64 > 0
fstat64(fd, &st)
#else /* STAT64 > 0 */
fstat(fd, &st)
#endif /* STAT64 > 0 */
< 0)
{
if (errno != EBADF)
{
(void) sm_snprintf(p, SPACELEFT(buf, p),
"CANNOT STAT (%s)",
sm_errstring(errno));
goto printit;
}
else if (printclosed)
{
(void) sm_snprintf(p, SPACELEFT(buf, p), "CLOSED");
goto printit;
}
return;
}
i = fcntl(fd, F_GETFL, 0);
if (i != -1)
{
(void) sm_snprintf(p, SPACELEFT(buf, p), "fl=0x%x, ", i);
p += strlen(p);
}
(void) sm_snprintf(p, SPACELEFT(buf, p), "mode=%o: ",
(int) st.st_mode);
p += strlen(p);
switch (st.st_mode & S_IFMT)
{
#ifdef S_IFSOCK
case S_IFSOCK:
(void) sm_snprintf(p, SPACELEFT(buf, p), "SOCK ");
p += strlen(p);
memset(&sa, '\0', sizeof(sa));
slen = sizeof(sa);
if (getsockname(fd, &sa.sa, &slen) < 0)
(void) sm_snprintf(p, SPACELEFT(buf, p), "(%s)",
sm_errstring(errno));
else
{
hp = hostnamebyanyaddr(&sa);
if (hp == NULL)
{
/* EMPTY */
/* do nothing */
}
# if NETINET
else if (sa.sa.sa_family == AF_INET)
(void) sm_snprintf(p, SPACELEFT(buf, p),
"%s/%d", hp, ntohs(sa.sin.sin_port));
# endif /* NETINET */
# if NETINET6
else if (sa.sa.sa_family == AF_INET6)
(void) sm_snprintf(p, SPACELEFT(buf, p),
"%s/%d", hp, ntohs(sa.sin6.sin6_port));
# endif /* NETINET6 */
else
(void) sm_snprintf(p, SPACELEFT(buf, p),
"%s", hp);
}
p += strlen(p);
(void) sm_snprintf(p, SPACELEFT(buf, p), "->");
p += strlen(p);
slen = sizeof(sa);
if (getpeername(fd, &sa.sa, &slen) < 0)
(void) sm_snprintf(p, SPACELEFT(buf, p), "(%s)",
sm_errstring(errno));
else
{
hp = hostnamebyanyaddr(&sa);
if (hp == NULL)
{
/* EMPTY */
/* do nothing */
}
# if NETINET
else if (sa.sa.sa_family == AF_INET)
(void) sm_snprintf(p, SPACELEFT(buf, p),
"%s/%d", hp, ntohs(sa.sin.sin_port));
# endif /* NETINET */
# if NETINET6
else if (sa.sa.sa_family == AF_INET6)
(void) sm_snprintf(p, SPACELEFT(buf, p),
"%s/%d", hp, ntohs(sa.sin6.sin6_port));
# endif /* NETINET6 */
else
(void) sm_snprintf(p, SPACELEFT(buf, p),
"%s", hp);
}
break;
#endif /* S_IFSOCK */
case S_IFCHR:
(void) sm_snprintf(p, SPACELEFT(buf, p), "CHR: ");
p += strlen(p);
goto defprint;
#ifdef S_IFBLK
case S_IFBLK:
(void) sm_snprintf(p, SPACELEFT(buf, p), "BLK: ");
p += strlen(p);
goto defprint;
#endif /* S_IFBLK */
#if defined(S_IFIFO) && (!defined(S_IFSOCK) || S_IFIFO != S_IFSOCK)
case S_IFIFO:
(void) sm_snprintf(p, SPACELEFT(buf, p), "FIFO: ");
p += strlen(p);
goto defprint;
#endif /* defined(S_IFIFO) && (!defined(S_IFSOCK) || S_IFIFO != S_IFSOCK) */
#ifdef S_IFDIR
case S_IFDIR:
(void) sm_snprintf(p, SPACELEFT(buf, p), "DIR: ");
p += strlen(p);
goto defprint;
#endif /* S_IFDIR */
#ifdef S_IFLNK
case S_IFLNK:
(void) sm_snprintf(p, SPACELEFT(buf, p), "LNK: ");
p += strlen(p);
goto defprint;
#endif /* S_IFLNK */
default:
defprint:
(void) sm_snprintf(p, SPACELEFT(buf, p),
"dev=%d/%d, ino=%llu, nlink=%d, u/gid=%d/%d, ",
major(st.st_dev), minor(st.st_dev),
(ULONGLONG_T) st.st_ino,
(int) st.st_nlink, (int) st.st_uid,
(int) st.st_gid);
p += strlen(p);
(void) sm_snprintf(p, SPACELEFT(buf, p), "size=%llu",
(ULONGLONG_T) st.st_size);
break;
}
printit:
if (logit)
sm_syslog(LOG_DEBUG, CurEnv ? CurEnv->e_id : NULL,
"%.800s", buf);
else
sm_dprintf("%s\n", buf);
}
/*
** SHORTEN_HOSTNAME -- strip local domain information off of hostname.
**
** Parameters:
** host -- the host to shorten (stripped in place).
**
** Returns:
** place where string was truncated, NULL if not truncated.
*/
char *
shorten_hostname(host)
char host[];
{
register char *p;
char *mydom;
int i;
bool canon = false;
/* strip off final dot */
i = strlen(host);
p = &host[(i == 0) ? 0 : i - 1];
if (*p == '.')
{
*p = '\0';
canon = true;
}
/* see if there is any domain at all -- if not, we are done */
p = strchr(host, '.');
if (p == NULL)
return NULL;
/* yes, we have a domain -- see if it looks like us */
mydom = macvalue('m', CurEnv);
if (mydom == NULL)
mydom = "";
i = strlen(++p);
if ((canon ? sm_strcasecmp(p, mydom)
: sm_strncasecmp(p, mydom, i)) == 0 &&
(mydom[i] == '.' || mydom[i] == '\0'))
{
*--p = '\0';
return p;
}
return NULL;
}
/*
** PROG_OPEN -- open a program for reading
**
** Parameters:
** argv -- the argument list.
** pfd -- pointer to a place to store the file descriptor.
** e -- the current envelope.
**
** Returns:
** pid of the process -- -1 if it failed.
*/
pid_t
prog_open(argv, pfd, e)
char **argv;
int *pfd;
ENVELOPE *e;
{
pid_t pid;
int save_errno;
int sff;
int ret;
int fdv[2];
char *p, *q;
char buf[MAXPATHLEN];
extern int DtableSize;
if (pipe(fdv) < 0)
{
syserr("%s: cannot create pipe for stdout", argv[0]);
return -1;
}
pid = fork();
if (pid < 0)
{
syserr("%s: cannot fork", argv[0]);
(void) close(fdv[0]);
(void) close(fdv[1]);
return -1;
}
if (pid > 0)
{
/* parent */
(void) close(fdv[1]);
*pfd = fdv[0];
return pid;
}
/* Reset global flags */
RestartRequest = NULL;
RestartWorkGroup = false;
ShutdownRequest = NULL;
PendingSignal = 0;
CurrentPid = getpid();
/*
** Initialize exception stack and default exception
** handler for child process.
*/
sm_exc_newthread(fatal_error);
/* child -- close stdin */
(void) close(0);
/* stdout goes back to parent */
(void) close(fdv[0]);
if (dup2(fdv[1], 1) < 0)
{
syserr("%s: cannot dup2 for stdout", argv[0]);
_exit(EX_OSERR);
}
(void) close(fdv[1]);
/* stderr goes to transcript if available */
if (e->e_xfp != NULL)
{
int xfd;
xfd = sm_io_getinfo(e->e_xfp, SM_IO_WHAT_FD, NULL);
if (xfd >= 0 && dup2(xfd, 2) < 0)
{
syserr("%s: cannot dup2 for stderr", argv[0]);
_exit(EX_OSERR);
}
}
/* this process has no right to the queue file */
if (e->e_lockfp != NULL)
{
int fd;
fd = sm_io_getinfo(e->e_lockfp, SM_IO_WHAT_FD, NULL);
if (fd >= 0)
(void) close(fd);
else
syserr("%s: lockfp does not have a fd", argv[0]);
}
/* chroot to the program mailer directory, if defined */
if (ProgMailer != NULL && ProgMailer->m_rootdir != NULL)
{
expand(ProgMailer->m_rootdir, buf, sizeof(buf), e);
if (chroot(buf) < 0)
{
syserr("prog_open: cannot chroot(%s)", buf);
exit(EX_TEMPFAIL);
}
if (chdir("/") < 0)
{
syserr("prog_open: cannot chdir(/)");
exit(EX_TEMPFAIL);
}
}
/* run as default user */
endpwent();
sm_mbdb_terminate();
#if _FFR_MEMSTAT
(void) sm_memstat_close();
#endif /* _FFR_MEMSTAT */
if (setgid(DefGid) < 0 && geteuid() == 0)
{
syserr("prog_open: setgid(%ld) failed", (long) DefGid);
exit(EX_TEMPFAIL);
}
if (setuid(DefUid) < 0 && geteuid() == 0)
{
syserr("prog_open: setuid(%ld) failed", (long) DefUid);
exit(EX_TEMPFAIL);
}
/* run in some directory */
if (ProgMailer != NULL)
p = ProgMailer->m_execdir;
else
p = NULL;
for (; p != NULL; p = q)
{
q = strchr(p, ':');
if (q != NULL)
*q = '\0';
expand(p, buf, sizeof(buf), e);
if (q != NULL)
*q++ = ':';
if (buf[0] != '\0' && chdir(buf) >= 0)
break;
}
if (p == NULL)
{
/* backup directories */
if (chdir("/tmp") < 0)
(void) chdir("/");
}
/* Check safety of program to be run */
sff = SFF_ROOTOK|SFF_EXECOK;
if (!bitnset(DBS_RUNWRITABLEPROGRAM, DontBlameSendmail))
sff |= SFF_NOGWFILES|SFF_NOWWFILES;
if (bitnset(DBS_RUNPROGRAMINUNSAFEDIRPATH, DontBlameSendmail))
sff |= SFF_NOPATHCHECK;
else
sff |= SFF_SAFEDIRPATH;
ret = safefile(argv[0], DefUid, DefGid, DefUser, sff, 0, NULL);
if (ret != 0)
sm_syslog(LOG_INFO, e->e_id,
"Warning: prog_open: program %s unsafe: %s",
argv[0], sm_errstring(ret));
/* arrange for all the files to be closed */
sm_close_on_exec(STDERR_FILENO + 1, DtableSize);
/* now exec the process */
(void) execve(argv[0], (ARGV_T) argv, (ARGV_T) UserEnviron);
/* woops! failed */
save_errno = errno;
syserr("%s: cannot exec", argv[0]);
if (transienterror(save_errno))
_exit(EX_OSERR);
_exit(EX_CONFIG);
return -1; /* avoid compiler warning on IRIX */
}
/*
** GET_COLUMN -- look up a Column in a line buffer
**
** Parameters:
** line -- the raw text line to search.
** col -- the column number to fetch.
** delim -- the delimiter between columns. If null,
** use white space.
** buf -- the output buffer.
** buflen -- the length of buf.
**
** Returns:
** buf if successful.
** NULL otherwise.
*/
char *
get_column(line, col, delim, buf, buflen)
char line[];
int col;
int delim;
char buf[];
int buflen;
{
char *p;
char *begin, *end;
int i;
char delimbuf[4];
if ((char) delim == '\0')
(void) sm_strlcpy(delimbuf, "\n\t ", sizeof(delimbuf));
else
{
delimbuf[0] = (char) delim;
delimbuf[1] = '\0';
}
p = line;
if (*p == '\0')
return NULL; /* line empty */
if (*p == (char) delim && col == 0)
return NULL; /* first column empty */
begin = line;
if (col == 0 && (char) delim == '\0')
{
while (*begin != '\0' && isascii(*begin) && isspace(*begin))
begin++;
}
for (i = 0; i < col; i++)
{
if ((begin = strpbrk(begin, delimbuf)) == NULL)
return NULL; /* no such column */
begin++;
if ((char) delim == '\0')
{
while (*begin != '\0' && isascii(*begin) && isspace(*begin))
begin++;
}
}
end = strpbrk(begin, delimbuf);
if (end == NULL)
i = strlen(begin);
else
i = end - begin;
if (i >= buflen)
i = buflen - 1;
(void) sm_strlcpy(buf, begin, i + 1);
return buf;
}
/*
** CLEANSTRCPY -- copy string keeping out bogus characters
**
** Parameters:
** t -- "to" string.
** f -- "from" string.
** l -- length of space available in "to" string.
**
** Returns:
** none.
*/
void
cleanstrcpy(t, f, l)
register char *t;
register char *f;
int l;
{
/* check for newlines and log if necessary */
(void) denlstring(f, true, true);
if (l <= 0)
syserr("!cleanstrcpy: length == 0");
l--;
while (l > 0 && *f != '\0')
{
if (isascii(*f) &&
(isalnum(*f) || strchr("!#$%&'*+-./^_`{|}~", *f) != NULL))
{
l--;
*t++ = *f;
}
f++;
}
*t = '\0';
}
/*
** DENLSTRING -- convert newlines in a string to spaces
**
** Parameters:
** s -- the input string
** strict -- if set, don't permit continuation lines.
** logattacks -- if set, log attempted attacks.
**
** Returns:
** A pointer to a version of the string with newlines
** mapped to spaces. This should be copied.
*/
char *
denlstring(s, strict, logattacks)
char *s;
bool strict;
bool logattacks;
{
register char *p;
int l;
static char *bp = NULL;
static int bl = 0;
p = s;
while ((p = strchr(p, '\n')) != NULL)
if (strict || (*++p != ' ' && *p != '\t'))
break;
if (p == NULL)
return s;
l = strlen(s) + 1;
if (bl < l)
{
/* allocate more space */
char *nbp = sm_pmalloc_x(l);
if (bp != NULL)
sm_free(bp);
bp = nbp;
bl = l;
}
(void) sm_strlcpy(bp, s, l);
for (p = bp; (p = strchr(p, '\n')) != NULL; )
*p++ = ' ';
if (logattacks)
{
sm_syslog(LOG_NOTICE, CurEnv ? CurEnv->e_id : NULL,
"POSSIBLE ATTACK from %.100s: newline in string \"%s\"",
RealHostName == NULL ? "[UNKNOWN]" : RealHostName,
shortenstring(bp, MAXSHORTSTR));
}
return bp;
}
/*
** STRREPLNONPRT -- replace "unprintable" characters in a string with subst
**
** Parameters:
** s -- string to manipulate (in place)
** subst -- character to use as replacement
**
** Returns:
** true iff string did not contain "unprintable" characters
*/
bool
strreplnonprt(s, c)
char *s;
int c;
{
bool ok;
ok = true;
if (s == NULL)
return ok;
while (*s != '\0')
{
if (!(isascii(*s) && isprint(*s)))
{
*s = c;
ok = false;
}
++s;
}
return ok;
}
/*
** PATH_IS_DIR -- check to see if file exists and is a directory.
**
** There are some additional checks for security violations in
** here. This routine is intended to be used for the host status
** support.
**
** Parameters:
** pathname -- pathname to check for directory-ness.
** createflag -- if set, create directory if needed.
**
** Returns:
** true -- if the indicated pathname is a directory
** false -- otherwise
*/
bool
path_is_dir(pathname, createflag)
char *pathname;
bool createflag;
{
struct stat statbuf;
#if HASLSTAT
if (lstat(pathname, &statbuf) < 0)
#else /* HASLSTAT */
if (stat(pathname, &statbuf) < 0)
#endif /* HASLSTAT */
{
if (errno != ENOENT || !createflag)
return false;
if (mkdir(pathname, 0755) < 0)
return false;
return true;
}
if (!S_ISDIR(statbuf.st_mode))
{
errno = ENOTDIR;
return false;
}
/* security: don't allow writable directories */
if (bitset(S_IWGRP|S_IWOTH, statbuf.st_mode))
{
errno = EACCES;
return false;
}
return true;
}
/*
** PROC_LIST_ADD -- add process id to list of our children
**
** Parameters:
** pid -- pid to add to list.
** task -- task of pid.
** type -- type of process.
** count -- number of processes.
** other -- other information for this type.
**
** Returns:
** none
**
** Side Effects:
** May increase CurChildren. May grow ProcList.
*/
typedef struct procs PROCS_T;
struct procs
{
pid_t proc_pid;
char *proc_task;
int proc_type;
int proc_count;
int proc_other;
SOCKADDR proc_hostaddr;
};
static PROCS_T *volatile ProcListVec = NULL;
static int ProcListSize = 0;
void
proc_list_add(pid, task, type, count, other, hostaddr)
pid_t pid;
char *task;
int type;
int count;
int other;
SOCKADDR *hostaddr;
{
int i;
for (i = 0; i < ProcListSize; i++)
{
if (ProcListVec[i].proc_pid == NO_PID)
break;
}
if (i >= ProcListSize)
{
/* probe the existing vector to avoid growing infinitely */
proc_list_probe();
/* now scan again */
for (i = 0; i < ProcListSize; i++)
{
if (ProcListVec[i].proc_pid == NO_PID)
break;
}
}
if (i >= ProcListSize)
{
/* grow process list */
int chldwasblocked;
PROCS_T *npv;
SM_ASSERT(ProcListSize < INT_MAX - PROC_LIST_SEG);
npv = (PROCS_T *) sm_pmalloc_x((sizeof(*npv)) *
(ProcListSize + PROC_LIST_SEG));
/* Block SIGCHLD so reapchild() doesn't mess with us */
chldwasblocked = sm_blocksignal(SIGCHLD);
if (ProcListSize > 0)
{
memmove(npv, ProcListVec,
ProcListSize * sizeof(PROCS_T));
sm_free(ProcListVec);
}
/* XXX just use memset() to initialize this part? */
for (i = ProcListSize; i < ProcListSize + PROC_LIST_SEG; i++)
{
npv[i].proc_pid = NO_PID;
npv[i].proc_task = NULL;
npv[i].proc_type = PROC_NONE;
}
i = ProcListSize;
ProcListSize += PROC_LIST_SEG;
ProcListVec = npv;
if (chldwasblocked == 0)
(void) sm_releasesignal(SIGCHLD);
}
ProcListVec[i].proc_pid = pid;
PSTRSET(ProcListVec[i].proc_task, task);
ProcListVec[i].proc_type = type;
ProcListVec[i].proc_count = count;
ProcListVec[i].proc_other = other;
if (hostaddr != NULL)
ProcListVec[i].proc_hostaddr = *hostaddr;
else
memset(&ProcListVec[i].proc_hostaddr, 0,
sizeof(ProcListVec[i].proc_hostaddr));
/* if process adding itself, it's not a child */
if (pid != CurrentPid)
{
SM_ASSERT(CurChildren < INT_MAX);
CurChildren++;
}
}
/*
** PROC_LIST_SET -- set pid task in process list
**
** Parameters:
** pid -- pid to set
** task -- task of pid
**
** Returns:
** none.
*/
void
proc_list_set(pid, task)
pid_t pid;
char *task;
{
int i;
for (i = 0; i < ProcListSize; i++)
{
if (ProcListVec[i].proc_pid == pid)
{
PSTRSET(ProcListVec[i].proc_task, task);
break;
}
}
}
/*
** PROC_LIST_DROP -- drop pid from process list
**
** Parameters:
** pid -- pid to drop
** st -- process status
** other -- storage for proc_other (return).
**
** Returns:
** none.
**
** Side Effects:
** May decrease CurChildren, CurRunners, or
** set RestartRequest or ShutdownRequest.
**
** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
** DOING.
*/
void
proc_list_drop(pid, st, other)
pid_t pid;
int st;
int *other;
{
int i;
int type = PROC_NONE;
for (i = 0; i < ProcListSize; i++)
{
if (ProcListVec[i].proc_pid == pid)
{
ProcListVec[i].proc_pid = NO_PID;
type = ProcListVec[i].proc_type;
if (other != NULL)
*other = ProcListVec[i].proc_other;
if (CurChildren > 0)
CurChildren--;
break;
}
}
if (type == PROC_CONTROL && WIFEXITED(st))
{
/* if so, see if we need to restart or shutdown */
if (WEXITSTATUS(st) == EX_RESTART)
RestartRequest = "control socket";
else if (WEXITSTATUS(st) == EX_SHUTDOWN)
ShutdownRequest = "control socket";
}
else if (type == PROC_QUEUE_CHILD && !WIFSTOPPED(st) &&
ProcListVec[i].proc_other > -1)
{
/* restart this persistent runner */
mark_work_group_restart(ProcListVec[i].proc_other, st);
}
else if (type == PROC_QUEUE)
CurRunners -= ProcListVec[i].proc_count;
}
/*
** PROC_LIST_CLEAR -- clear the process list
**
** Parameters:
** none.
**
** Returns:
** none.
**
** Side Effects:
** Sets CurChildren to zero.
*/
void
proc_list_clear()
{
int i;
/* start from 1 since 0 is the daemon itself */
for (i = 1; i < ProcListSize; i++)
ProcListVec[i].proc_pid = NO_PID;
CurChildren = 0;
}
/*
** PROC_LIST_PROBE -- probe processes in the list to see if they still exist
**
** Parameters:
** none
**
** Returns:
** none
**
** Side Effects:
** May decrease CurChildren.
*/
void
proc_list_probe()
{
int i, children;
int chldwasblocked;
pid_t pid;
children = 0;
chldwasblocked = sm_blocksignal(SIGCHLD);
/* start from 1 since 0 is the daemon itself */
for (i = 1; i < ProcListSize; i++)
{
pid = ProcListVec[i].proc_pid;
if (pid == NO_PID || pid == CurrentPid)
continue;
if (kill(pid, 0) < 0)
{
if (LogLevel > 3)
sm_syslog(LOG_DEBUG, CurEnv->e_id,
"proc_list_probe: lost pid %d",
(int) ProcListVec[i].proc_pid);
ProcListVec[i].proc_pid = NO_PID;
SM_FREE_CLR(ProcListVec[i].proc_task);
CurChildren--;
}
else
{
++children;
}
}
if (CurChildren < 0)
CurChildren = 0;
if (chldwasblocked == 0)
(void) sm_releasesignal(SIGCHLD);
if (LogLevel > 10 && children != CurChildren && CurrentPid == DaemonPid)
{
sm_syslog(LOG_ERR, NOQID,
"proc_list_probe: found %d children, expected %d",
children, CurChildren);
}
}
/*
** PROC_LIST_DISPLAY -- display the process list
**
** Parameters:
** out -- output file pointer
** prefix -- string to output in front of each line.
**
** Returns:
** none.
*/
void
proc_list_display(out, prefix)
SM_FILE_T *out;
char *prefix;
{
int i;
for (i = 0; i < ProcListSize; i++)
{
if (ProcListVec[i].proc_pid == NO_PID)
continue;
(void) sm_io_fprintf(out, SM_TIME_DEFAULT, "%s%d %s%s\n",
prefix,
(int) ProcListVec[i].proc_pid,
ProcListVec[i].proc_task != NULL ?
ProcListVec[i].proc_task : "(unknown)",
(OpMode == MD_SMTP ||
OpMode == MD_DAEMON ||
OpMode == MD_ARPAFTP) ? "\r" : "");
}
}
/*
** PROC_LIST_SIGNAL -- send a signal to a type of process in the list
**
** Parameters:
** type -- type of process to signal
** signal -- the type of signal to send
**
** Results:
** none.
**
** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
** DOING.
*/
void
proc_list_signal(type, signal)
int type;
int signal;
{
int chldwasblocked;
int alrmwasblocked;
int i;
pid_t mypid = getpid();
/* block these signals so that we may signal cleanly */
chldwasblocked = sm_blocksignal(SIGCHLD);
alrmwasblocked = sm_blocksignal(SIGALRM);
/* Find all processes of type and send signal */
for (i = 0; i < ProcListSize; i++)
{
if (ProcListVec[i].proc_pid == NO_PID ||
ProcListVec[i].proc_pid == mypid)
continue;
if (ProcListVec[i].proc_type != type)
continue;
(void) kill(ProcListVec[i].proc_pid, signal);
}
/* restore the signals */
if (alrmwasblocked == 0)
(void) sm_releasesignal(SIGALRM);
if (chldwasblocked == 0)
(void) sm_releasesignal(SIGCHLD);
}
/*
** COUNT_OPEN_CONNECTIONS
**
** Parameters:
** hostaddr - ClientAddress
**
** Returns:
** the number of open connections for this client
**
*/
int
count_open_connections(hostaddr)
SOCKADDR *hostaddr;
{
int i, n;
if (hostaddr == NULL)
return 0;
/*
** This code gets called before proc_list_add() gets called,
** so we (the daemon child for this connection) have not yet
** counted ourselves. Hence initialize the counter to 1
** instead of 0 to compensate.
*/
n = 1;
for (i = 0; i < ProcListSize; i++)
{
if (ProcListVec[i].proc_pid == NO_PID)
continue;
if (hostaddr->sa.sa_family !=
ProcListVec[i].proc_hostaddr.sa.sa_family)
continue;
#if NETINET
if (hostaddr->sa.sa_family == AF_INET &&
(hostaddr->sin.sin_addr.s_addr ==
ProcListVec[i].proc_hostaddr.sin.sin_addr.s_addr))
n++;
#endif /* NETINET */
#if NETINET6
if (hostaddr->sa.sa_family == AF_INET6 &&
IN6_ARE_ADDR_EQUAL(&(hostaddr->sin6.sin6_addr),
&(ProcListVec[i].proc_hostaddr.sin6.sin6_addr)))
n++;
#endif /* NETINET6 */
}
return n;
}