[unix-history] / usr / src / usr.sbin / sendmail / src / util.c

/*
* Copyright (c) 1983 Eric P. Allman
* Copyright (c) 1988, 1993
*      The Regents of the University of California.  All rights reserved.
*
* %sccs.include.redist.c%
*/

#ifndef lint
static char sccsid[] = "@(#)util.c      8.19 (Berkeley) %G%";
#endif /* not lint */

# include "sendmail.h"
# include <sysexits.h>
# include "conf.h"
\f/*
**  STRIPQUOTES -- Strip quotes & quote bits from a string.
**
**      Runs through a string and strips off unquoted quote
**      characters and quote bits.  This is done in place.
**
**      Parameters:
**              s -- the string to strip.
**
**      Returns:
**              none.
**
**      Side Effects:
**              none.
**
**      Called By:
**              deliver
*/

stripquotes(s)
       char *s;
{
       register char *p;
       register char *q;
       register char c;

       if (s == NULL)
               return;

       p = q = s;
       do
       {
               c = *p++;
               if (c == '\\')
                       c = *p++;
               else if (c == '"')
                       continue;
               *q++ = c;
       } while (c != '\0');
}
\f/*
**  XALLOC -- Allocate memory and bitch wildly on failure.
**
**      THIS IS A CLUDGE.  This should be made to give a proper
**      error -- but after all, what can we do?
**
**      Parameters:
**              sz -- size of area to allocate.
**
**      Returns:
**              pointer to data region.
**
**      Side Effects:
**              Memory is allocated.
*/

char *
xalloc(sz)
       register int sz;
{
       register char *p;

       p = malloc((unsigned) sz);
       if (p == NULL)
       {
               syserr("Out of memory!!");
               abort();
               /* exit(EX_UNAVAILABLE); */
       }
       return (p);
}
\f/*
**  COPYPLIST -- copy list of pointers.
**
**      This routine is the equivalent of newstr 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.
**
**      Returns:
**              a copy of 'list'.
**
**      Side Effects:
**              none.
*/

char **
copyplist(list, copycont)
       char **list;
       bool copycont;
{
       register char **vp;
       register char **newvp;

       for (vp = list; *vp != NULL; vp++)
               continue;

       vp++;

       newvp = (char **) xalloc((int) (vp - list) * sizeof *vp);
       bcopy((char *) list, (char *) newvp, (int) (vp - list) * sizeof *vp);

       if (copycont)
       {
               for (vp = newvp; *vp != NULL; vp++)
                       *vp = newstr(*vp);
       }

       return (newvp);
}
\f/*
**  COPYQUEUE -- copy address queue.
**
**      This routine is the equivalent of newstr for address queues
**      addresses marked with QDONTSEND aren't copied
**
**      Parameters:
**              addr -- list of address structures to copy.
**
**      Returns:
**              a copy of 'addr'.
**
**      Side Effects:
**              none.
*/

ADDRESS *
copyqueue(addr)
       ADDRESS *addr;
{
       register ADDRESS *newaddr;
       ADDRESS *ret;
       register ADDRESS **tail = &ret;

       while (addr != NULL)
       {
               if (!bitset(QDONTSEND, addr->q_flags))
               {
                       newaddr = (ADDRESS *) xalloc(sizeof(ADDRESS));
                       STRUCTCOPY(*addr, *newaddr);
                       *tail = newaddr;
                       tail = &newaddr->q_next;
               }
               addr = addr->q_next;
       }
       *tail = NULL;
       
       return ret;
}
\f/*
**  PRINTAV -- print argument vector.
**
**      Parameters:
**              av -- argument vector.
**
**      Returns:
**              none.
**
**      Side Effects:
**              prints av.
*/

printav(av)
       register char **av;
{
       while (*av != NULL)
       {
               if (tTd(0, 44))
                       printf("\n\t%08x=", *av);
               else
                       (void) putchar(' ');
               xputs(*av++);
       }
       (void) putchar('\n');
}
\f/*
**  LOWER -- turn letter into lower case.
**
**      Parameters:
**              c -- character to turn into lower case.
**
**      Returns:
**              c, in lower case.
**
**      Side Effects:
**              none.
*/

char
lower(c)
       register char c;
{
       return((isascii(c) && isupper(c)) ? tolower(c) : c);
}
\f/*
**  XPUTS -- put string doing control escapes.
**
**      Parameters:
**              s -- string to put.
**
**      Returns:
**              none.
**
**      Side Effects:
**              output to stdout
*/

xputs(s)
       register char *s;
{
       register int c;
       register struct metamac *mp;
       extern struct metamac MetaMacros[];

       if (s == NULL)
       {
               printf("<null>");
               return;
       }
       while ((c = (*s++ & 0377)) != '\0')
       {
               if (!isascii(c))
               {
                       if (c == MATCHREPL || c == MACROEXPAND)
                       {
                               putchar('$');
                               continue;
                       }
                       for (mp = MetaMacros; mp->metaname != '\0'; mp++)
                       {
                               if ((mp->metaval & 0377) == c)
                               {
                                       printf("$%c", mp->metaname);
                                       break;
                               }
                       }
                       if (mp->metaname != '\0')
                               continue;
                       (void) putchar('\\');
                       c &= 0177;
               }
               if (isprint(c))
               {
                       putchar(c);
                       continue;
               }

               /* wasn't a meta-macro -- find another way to print it */
               switch (c)
               {
                 case '\0':
                       continue;

                 case '\n':
                       c = 'n';
                       break;

                 case '\r':
                       c = 'r';
                       break;

                 case '\t':
                       c = 't';
                       break;

                 default:
                       (void) putchar('^');
                       (void) putchar(c ^ 0100);
                       continue;
               }
       }
       (void) fflush(stdout);
}
\f/*
**  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.
**
**      Called By:
**              parse
*/

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);
}
\f/*
**  FULLNAME -- extract full name from a passwd file entry.
**
**      Parameters:
**              pw -- password entry to start from.
**              buf -- buffer to store result in.
**
**      Returns:
**              TRUE -- if the resulting message should be a MIME format.
**              FALSE -- if MIME is not necessary.
**
**      Side Effects:
**              none.
*/

/* values for should_quote */
#define NO_QUOTE        0
#define SHOULD_QUOTE    1
#define SHOULD_MIME     2

int
       register unsigned char *gecos;
       const unsigned char *login;
       unsigned char *buf;
{
       register unsigned char *bp = buf;
       unsigned char *p;
       int should_quote = NO_QUOTE;
       register char *p = pw->pw_gecos;

       /* make sure specials, SPACE and CTLs are quoted within " " */
       for (p = gecos; *p && *p != ',' && *p != ';' && *p != '%'; p++)
       {
               if (*p >= 0200)
               {
                       should_quote = SHOULD_MIME;
                       break;
               }
               switch (*p)
               {
                 case '(':
                 case ')':
                 case '<':
                 case '>':
                 case '@':
                 case ':':
                 case '\\':
                 case '"':
                 case '.':
                 case '[':
                 case ']':
                       should_quote = SHOULD_QUOTE;
                       break;
               }       
       }
       if (should_quote == SHOULD_MIME)
       {
               strcpy (bp, "=?iso-8859-1?Q?");
               bp += 15;
               for (p = gecos; *p && *p != ',' && *p != ';' && *p != '%'; p++)
               {
                       if (*p == ' ')
                               *bp++ = '_';
                       else if (*p == '&')
                       {
                               (void) strcpy(bp, login);
                               *bp = toupper(*bp);
                               bp += strlen (bp);
                       }
                       else if (*p < 040 || *p >= 200 || 
                                strchr("_?()<>@:\\\".[]", *p) != NULL)
                       {
                               *bp++ = '=';
                               *bp++ = "0123456789ABCDEF"[(*p >> 4) & 0xf];
                               *bp++ = "0123456789ABCDEF"[*p & 0xf];
                       }
                       else
                               *bp++ = *p;
               }
               strcpy (bp, "?= ");
               bp += 3;
       }
       else
       {
               if (should_quote)
                       *bp++ = '"';
               for (p = gecos; *p && *p != ',' && *p != ';' && *p != '%'; p++)
               {
                       if (*p == '&')
                       {
                               (void) strcpy(bp, login);
                               *bp = toupper(*bp);
                               while (*bp != '\0')
                                       bp++;
                       }
                       else
                       {
                               if (*p == '"')
                                       *bp++ = '\\';
                               *bp++ = *p;
                       }
               }
               if (bp[-1] == '\\')
                       *bp++ = '\\';
               if (should_quote)
                       *bp++ = '"';
       }

       *bp = '\0';
       return should_quote == SHOULD_MIME;
}
\f/*
**  SAFEFILE -- return true if a file exists and is safe for a user.
**
**      Parameters:
**              fn -- filename to check.
**              uid -- user id to compare against.
**              gid -- group id to compare against.
**              uname -- user name to compare against (used for group
**                      sets).
**              flags -- modifiers:
**                      SF_MUSTOWN -- "uid" must own this file.
**                      SF_NOSLINK -- file cannot be a symbolic link.
**              mode -- mode bits that must match.
**
**      Returns:
**              0 if fn exists, is owned by uid, and matches mode.
**              An errno otherwise.  The actual errno is cleared.
**
**      Side Effects:
**              none.
*/

#include <grp.h>

#ifndef S_IXOTH
# define S_IXOTH        (S_IEXEC >> 6)
#endif

#ifndef S_IXGRP
# define S_IXGRP        (S_IEXEC >> 3)
#endif

#ifndef S_IXUSR
# define S_IXUSR        (S_IEXEC)
#endif

int
safefile(fn, uid, gid, uname, flags, mode)
       char *fn;
       uid_t uid;
       gid_t gid;
       char *uname;
       int flags;
       int mode;
{
       register char *p;
       register struct group *gr = NULL;
       struct stat stbuf;

       if (tTd(54, 4))
               printf("safefile(%s, uid=%d, gid=%d, flags=%x, mode=%o):\n",
                       fn, uid, gid, flags, mode);
       errno = 0;

       for (p = fn; (p = strchr(++p, '/')) != NULL; *p = '/')
       {
               *p = '\0';
               if (stat(fn, &stbuf) < 0)
                       break;
               if (stbuf.st_uid == uid && bitset(S_IXUSR, stbuf.st_mode))
                       continue;
               if (stbuf.st_gid == gid && bitset(S_IXGRP, stbuf.st_mode))
                       continue;
#ifndef NO_GROUP_SET
               if (uname != NULL &&
                   ((gr != NULL && gr->gr_gid == stbuf.st_gid) ||
                    (gr = getgrgid(stbuf.st_gid)) != NULL))
               {
                       register char **gp;

                       for (gp = gr->gr_mem; *gp != NULL; gp++)
                               if (strcmp(*gp, uname) == 0)
                                       break;
                       if (*gp != NULL && bitset(S_IXGRP, stbuf.st_mode))
                               continue;
               }
#endif
               if (!bitset(S_IXOTH, stbuf.st_mode))
                       break;
       }
       if (p != NULL)
       {
               int ret = errno;

               if (ret == 0)
                       ret = EACCES;
               if (tTd(54, 4))
                       printf("\t[dir %s] %s\n", fn, errstring(ret));
               *p = '/';
               return ret;
       }

#ifdef HASLSTAT
       if ((bitset(SF_NOSLINK, flags) ? lstat(fn, &stbuf)
                                      : stat(fn, &stbuf)) < 0)
#else
       if (stat(fn, &stbuf) < 0)
#endif
       {
               int ret = errno;

               if (tTd(54, 4))
                       printf("\t%s\n", errstring(ret));

               errno = 0;
               return ret;
       }

#ifdef S_ISLNK
       if (bitset(SF_NOSLINK, flags) && S_ISLNK(stbuf.st_mode))
       {
               if (tTd(54, 4))
                       printf("\t[mode %o]\tEPERM\n");
               return EPERM;
       }
#endif

       if (uid == 0)
               mode >>= 6;
       else if (stbuf.st_uid != uid)
       {
               mode >>= 3;
               if (stbuf.st_gid == gid)
                       ;
#ifndef NO_GROUP_SET
               else if (uname != NULL &&
                        ((gr != NULL && gr->gr_gid == stbuf.st_gid) ||
                         (gr = getgrgid(stbuf.st_gid)) != NULL))
               {
                       register char **gp;

                       for (gp = gr->gr_mem; *gp != NULL; gp++)
                               if (strcmp(*gp, uname) == 0)
                                       break;
                       if (*gp == NULL)
                               mode >>= 3;
               }
#endif
               else
                       mode >>= 3;
       }
       if (tTd(54, 4))
               printf("\t[uid %d, stat %o, mode %o] ",
                       stbuf.st_uid, stbuf.st_mode, mode);
       if ((stbuf.st_uid == uid || stbuf.st_uid == 0 ||
            !bitset(SF_MUSTOWN, flags)) &&
           (stbuf.st_mode & mode) == mode)
       {
               if (tTd(54, 4))
                       printf("\tOK\n");
               return 0;
       }
       if (tTd(54, 4))
               printf("\tEACCES\n");
       return EACCES;
}
\f/*
**  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.
*/

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';
}
\f/*
**  DFOPEN -- determined file open
**
**      This routine has the semantics of fopen, except that it will
**      keep trying a few times to make this happen.  The idea is that
**      on very loaded systems, we may run out of resources (inodes,
**      whatever), so this tries to get around it.
*/

#ifndef O_ACCMODE
# define O_ACCMODE      (O_RDONLY|O_WRONLY|O_RDWR)
#endif

struct omodes
{
       int     mask;
       int     mode;
       char    *farg;
} OpenModes[] =
{
       O_ACCMODE,              O_RDONLY,               "r",
       O_ACCMODE|O_APPEND,     O_WRONLY,               "w",
       O_ACCMODE|O_APPEND,     O_WRONLY|O_APPEND,      "a",
       O_TRUNC,                0,                      "w+",
       O_APPEND,               O_APPEND,               "a+",
       0,                      0,                      "r+",
};

FILE *
dfopen(filename, omode, cmode)
       char *filename;
       int omode;
       int cmode;
{
       register int tries;
       int fd;
       register struct omodes *om;
       struct stat st;

       for (om = OpenModes; om->mask != 0; om++)
               if ((omode & om->mask) == om->mode)
                       break;

       for (tries = 0; tries < 10; tries++)
       {
               sleep((unsigned) (10 * tries));
               errno = 0;
               fd = open(filename, omode, cmode);
               if (fd >= 0)
                       break;
               if (errno != ENFILE && errno != EINTR)
                       break;
       }
       if (fd >= 0 && fstat(fd, &st) >= 0 && S_ISREG(st.st_mode))
       {
               int locktype;

               /* lock the file to avoid accidental conflicts */
               if ((omode & O_ACCMODE) != O_RDONLY)
                       locktype = LOCK_EX;
               else
                       locktype = LOCK_SH;
               (void) lockfile(fd, filename, NULL, locktype);
               errno = 0;
       }
       if (fd < 0)
               return NULL;
       else
               return fdopen(fd, om->farg);
}
\f/*
**  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.
**              fp -- file to put it onto.
**              m -- the mailer used to control output.
**
**      Returns:
**              none
**
**      Side Effects:
**              output of l to fp.
*/

putline(l, fp, m)
       register char *l;
       FILE *fp;
       MAILER *m;
{
       register char *p;
       register char svchar;

       /* strip out 0200 bits -- these can look like TELNET protocol */
       if (bitnset(M_7BITS, m->m_flags))
       {
               for (p = l; (svchar = *p) != '\0'; ++p)
                       if (bitset(0200, svchar))
                               *p = svchar &~ 0200;
       }

       do
       {
               /* find the end of the line */
               p = strchr(l, '\n');
               if (p == NULL)
                       p = &l[strlen(l)];

               if (TrafficLogFile != NULL)
                       fprintf(TrafficLogFile, "%05d >>> ", getpid());

               /* check for line overflow */
               while (m->m_linelimit > 0 && (p - l) > m->m_linelimit)
               {
                       register char *q = &l[m->m_linelimit - 1];

                       svchar = *q;
                       *q = '\0';
                       if (l[0] == '.' && bitnset(M_XDOT, m->m_flags))
                       {
                               (void) putc('.', fp);
                               if (TrafficLogFile != NULL)
                                       (void) putc('.', TrafficLogFile);
                       }
                       fputs(l, fp);
                       (void) putc('!', fp);
                       fputs(m->m_eol, fp);
                       if (TrafficLogFile != NULL)
                               fprintf(TrafficLogFile, "%s!\n%05d >>> ",
                                       l, getpid());
                       *q = svchar;
                       l = q;
               }

               /* output last part */
               if (l[0] == '.' && bitnset(M_XDOT, m->m_flags))
               {
                       (void) putc('.', fp);
                       if (TrafficLogFile != NULL)
                               (void) putc('.', TrafficLogFile);
               }
               if (TrafficLogFile != NULL)
                       fprintf(TrafficLogFile, "%.*s\n", p - l, l);
               for ( ; l < p; ++l)
                       (void) putc(*l, fp);
               fputs(m->m_eol, fp);
               if (*l == '\n')
                       ++l;
       } while (l[0] != '\0');
}
\f/*
**  XUNLINK -- unlink a file, doing logging as appropriate.
**
**      Parameters:
**              f -- name of file to unlink.
**
**      Returns:
**              none.
**
**      Side Effects:
**              f is unlinked.
*/

xunlink(f)
       char *f;
{
       register int i;

# ifdef LOG
       if (LogLevel > 98)
               syslog(LOG_DEBUG, "%s: unlink %s", CurEnv->e_id, f);
# endif /* LOG */

       i = unlink(f);
# ifdef LOG
       if (i < 0 && LogLevel > 97)
               syslog(LOG_DEBUG, "%s: unlink-fail %d", f, errno);
# endif /* LOG */
}
\f/*
**  XFCLOSE -- close a file, doing logging as appropriate.
**
**      Parameters:
**              fp -- file pointer for the file to close
**              a, b -- miscellaneous crud to print for debugging
**
**      Returns:
**              none.
**
**      Side Effects:
**              fp is closed.
*/

xfclose(fp, a, b)
       FILE *fp;
       char *a, *b;
{
       if (tTd(53, 99))
               printf("xfclose(%x) %s %s\n", fp, a, b);
#ifdef XDEBUG
       if (fileno(fp) == 1)
               syserr("xfclose(%s %s): fd = 1", a, b);
#endif
       if (fclose(fp) < 0 && tTd(53, 99))
               printf("xfclose FAILURE: %s\n", errstring(errno));
}
\f/*
**  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 will also leave
**                      buf containing a null string.
**              buf otherwise.
**
**      Side Effects:
**              none.
*/

static jmp_buf  CtxReadTimeout;
static int      readtimeout();

char *
sfgets(buf, siz, fp, timeout, during)
       char *buf;
       int siz;
       FILE *fp;
       time_t timeout;
       char *during;
{
       register EVENT *ev = NULL;
       register char *p;

       /* set the timeout */
       if (timeout != 0)
       {
               if (setjmp(CtxReadTimeout) != 0)
               {
# ifdef LOG
                       syslog(LOG_NOTICE,
                           "timeout waiting for input from %s during %s\n",
                           CurHostName? CurHostName: "local", during);
# endif
                       errno = 0;
                       usrerr("451 timeout waiting for input during %s",
                               during);
                       buf[0] = '\0';
#ifdef XDEBUG
                       checkfd012(during);
#endif
                       return (NULL);
               }
               ev = setevent(timeout, readtimeout, 0);
       }

       /* try to read */
       p = NULL;
       while (p == NULL && !feof(fp) && !ferror(fp))
       {
               errno = 0;
               p = fgets(buf, siz, fp);
               if (errno == EINTR)
                       clearerr(fp);
       }

       /* clear the event if it has not sprung */
       clrevent(ev);

       /* clean up the books and exit */
       LineNumber++;
       if (p == NULL)
       {
               buf[0] = '\0';
               if (TrafficLogFile != NULL)
                       fprintf(TrafficLogFile, "%05d <<< [EOF]\n", getpid());
               return (NULL);
       }
       if (TrafficLogFile != NULL)
               fprintf(TrafficLogFile, "%05d <<< %s", getpid(), buf);
       if (SevenBit)
               for (p = buf; *p != '\0'; p++)
                       *p &= ~0200;
       return (buf);
}

static
readtimeout()
{
       longjmp(CtxReadTimeout, 1);
}
\f/*
**  FGETFOLDED -- like fgets, but know about folded lines.
**
**      Parameters:
**              buf -- place to put result.
**              n -- bytes available.
**              f -- file to read from.
**
**      Returns:
**              input line(s) on success, NULL on error or EOF.
**              This will normally be buf -- unless the line is too
**                      long, when it will be xalloc()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, n, f)
       char *buf;
       register int n;
       FILE *f;
{
       register char *p = buf;
       char *bp = buf;
       register int i;

       n--;
       while ((i = getc(f)) != EOF)
       {
               if (i == '\r')
               {
                       i = getc(f);
                       if (i != '\n')
                       {
                               if (i != EOF)
                                       (void) ungetc(i, f);
                               i = '\r';
                       }
               }
               if (--n <= 0)
               {
                       /* allocate new space */
                       char *nbp;
                       int nn;

                       nn = (p - bp);
                       if (nn < MEMCHUNKSIZE)
                               nn *= 2;
                       else
                               nn += MEMCHUNKSIZE;
                       nbp = xalloc(nn);
                       bcopy(bp, nbp, p - bp);
                       p = &nbp[p - bp];
                       if (bp != buf)
                               free(bp);
                       bp = nbp;
                       n = nn - (p - bp);
               }
               *p++ = i;
               if (i == '\n')
               {
                       LineNumber++;
                       i = getc(f);
                       if (i != EOF)
                               (void) ungetc(i, f);
                       if (i != ' ' && i != '\t')
                               break;
               }
       }
       if (p == bp)
               return (NULL);
       *--p = '\0';
       return (bp);
}
\f/*
**  CURTIME -- return current time.
**
**      Parameters:
**              none.
**
**      Returns:
**              the current time.
**
**      Side Effects:
**              none.
*/

time_t
curtime()
{
       auto time_t t;

       (void) time(&t);
       return (t);
}
\f/*
**  ATOBOOL -- convert a string representation to boolean.
**
**      Defaults to "TRUE"
**
**      Parameters:
**              s -- string to convert.  Takes "tTyY" as true,
**                      others as false.
**
**      Returns:
**              A boolean representation of the string.
**
**      Side Effects:
**              none.
*/

bool
atobool(s)
       register char *s;
{
       if (s == NULL || *s == '\0' || strchr("tTyY", *s) != NULL)
               return (TRUE);
       return (FALSE);
}
\f/*
**  ATOOCT -- convert a string representation to octal.
**
**      Parameters:
**              s -- string to convert.
**
**      Returns:
**              An integer representing the string interpreted as an
**              octal number.
**
**      Side Effects:
**              none.
*/

atooct(s)
       register char *s;
{
       register int i = 0;

       while (*s >= '0' && *s <= '7')
               i = (i << 3) | (*s++ - '0');
       return (i);
}
\f/*
**  WAITFOR -- wait for a particular process id.
**
**      Parameters:
**              pid -- process id to wait for.
**
**      Returns:
**              status of pid.
**              -1 if pid never shows up.
**
**      Side Effects:
**              none.
*/

int
waitfor(pid)
       int pid;
{
#ifdef WAITUNION
       union wait st;
#else
       auto int st;
#endif
       int i;

       do
       {
               errno = 0;
               i = wait(&st);
       } while ((i >= 0 || errno == EINTR) && i != pid);
       if (i < 0)
               return -1;
#ifdef WAITUNION
       return st.w_status;
#else
       return st;
#endif
}
\f/*
**  BITINTERSECT -- tell if two bitmaps intersect
**
**      Parameters:
**              a, b -- the bitmaps in question
**
**      Returns:
**              TRUE if they have a non-null intersection
**              FALSE otherwise
**
**      Side Effects:
**              none.
*/

bool
bitintersect(a, b)
       BITMAP a;
       BITMAP b;
{
       int i;

       for (i = BITMAPBYTES / sizeof (int); --i >= 0; )
               if ((a[i] & b[i]) != 0)
                       return (TRUE);
       return (FALSE);
}
\f/*
**  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.
**
**      Side Effects:
**              none.
*/

bool
bitzerop(map)
       BITMAP map;
{
       int i;

       for (i = BITMAPBYTES / sizeof (int); --i >= 0; )
               if (map[i] != 0)
                       return (FALSE);
       return (TRUE);
}
\f/*
**  STRCONTAINEDIN -- tell if one string is contained in another
**
**      Parameters:
**              a -- possible substring.
**              b -- possible superstring.
**
**      Returns:
**              TRUE if a is contained in b.
**              FALSE otherwise.
*/

bool
strcontainedin(a, b)
       register char *a;
       register char *b;
{
       int la;
       int lb;
       int c;

       la = strlen(a);
       lb = strlen(b);
       c = *a;
       if (isascii(c) && isupper(c))
               c = tolower(c);
       for (; lb-- >= la; b++)
       {
               if (*b != c && isascii(*b) && isupper(*b) && tolower(*b) != c)
                       continue;
               if (strncasecmp(a, b, la) == 0)
                       return TRUE;
       }
       return FALSE;
}
\f/*
**  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
*/

checkfd012(where)
       char *where;
{
#ifdef XDEBUG
       register int i;
       struct stat stbuf;

       for (i = 0; i < 3; i++)
       {
               if (fstat(i, &stbuf) < 0 && errno != EOPNOTSUPP)
               {
                       /* oops.... */
                       int fd;

                       syserr("%s: fd %d not open", where, i);
                       fd = open("/dev/null", i == 0 ? O_RDONLY : O_WRONLY, 0666);
                       if (fd != i)
                       {
                               (void) dup2(fd, i);
                               (void) close(fd);
                       }
               }
       }
#endif /* XDEBUG */
}
\f/*
**  PRINTOPENFDS -- print the open file descriptors (for debugging)
**
**      Parameters:
**              logit -- if set, send output to syslog; otherwise
**                      print for debugging.
**
**      Returns:
**              none.
*/

#include <netdb.h>
#include <arpa/inet.h>

printopenfds(logit)
       bool logit;
{
       register int fd;
       extern int DtableSize;

       for (fd = 0; fd < DtableSize; fd++)
               dumpfd(fd, FALSE, logit);
}
\f/*
**  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, send output to syslog instead of stdout.
*/

dumpfd(fd, printclosed, logit)
       int fd;
       bool printclosed;
       bool logit;
{
       register struct hostent *hp;
       register char *p;
       struct sockaddr_in sin;
       auto int slen;
       struct stat st;
       char buf[200];

       p = buf;
       sprintf(p, "%3d: ", fd);
       p += strlen(p);

       if (fstat(fd, &st) < 0)
       {
               if (printclosed || errno != EBADF)
               {
                       sprintf(p, "CANNOT STAT (%s)", errstring(errno));
                       goto printit;
               }
               return;
       }

       slen = fcntl(fd, F_GETFL, NULL);
       if (slen != -1)
       {
               sprintf(p, "fl=0x%x, ", slen);
               p += strlen(p);
       }

       sprintf(p, "mode=%o: ", st.st_mode);
       p += strlen(p);
       switch (st.st_mode & S_IFMT)
       {
#ifdef S_IFSOCK
         case S_IFSOCK:
               sprintf(p, "SOCK ");
               p += strlen(p);
               slen = sizeof sin;
               if (getsockname(fd, (struct sockaddr *) &sin, &slen) < 0)
                       sprintf(p, "(badsock)");
               else
               {
                       hp = gethostbyaddr((char *) &sin.sin_addr, slen, AF_INET);
                       sprintf(p, "%s/%d", hp == NULL ? inet_ntoa(sin.sin_addr)
                                                  : hp->h_name, ntohs(sin.sin_port));
               }
               p += strlen(p);
               sprintf(p, "->");
               p += strlen(p);
               slen = sizeof sin;
               if (getpeername(fd, (struct sockaddr *) &sin, &slen) < 0)
                       sprintf(p, "(badsock)");
               else
               {
                       hp = gethostbyaddr((char *) &sin.sin_addr, slen, AF_INET);
                       sprintf(p, "%s/%d", hp == NULL ? inet_ntoa(sin.sin_addr)
                                                  : hp->h_name, ntohs(sin.sin_port));
               }
               break;
#endif

         case S_IFCHR:
               sprintf(p, "CHR: ");
               p += strlen(p);
               goto defprint;

         case S_IFBLK:
               sprintf(p, "BLK: ");
               p += strlen(p);
               goto defprint;

         default:
defprint:
               sprintf(p, "dev=%d/%d, ino=%d, nlink=%d, u/gid=%d/%d, size=%ld",
                       major(st.st_dev), minor(st.st_dev), st.st_ino,
                       st.st_nlink, st.st_uid, st.st_gid, st.st_size);
               break;
       }

printit:
       if (logit)
               syslog(LOG_DEBUG, "%s", buf);
       else
               printf("%s\n", buf);
}