source: trunk/third/sendmail/src/mci.c @ 12554

/*
 * Copyright (c) 1998 Sendmail, Inc.  All rights reserved.
 * Copyright (c) 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.
 *
 */

#ifndef lint
static char sccsid[] = "@(#)mci.c       8.83 (Berkeley) 10/13/1998";
#endif /* not lint */

#include "sendmail.h"
#include <arpa/inet.h>
#include <dirent.h>

/*
**  Mail Connection Information (MCI) Caching Module.
**
**      There are actually two separate things cached.  The first is
**      the set of all open connections -- these are stored in a
**      (small) list.  The second is stored in the symbol table; it
**      has the overall status for all hosts, whether or not there
**      is a connection open currently.
**
**      There should never be too many connections open (since this
**      could flood the socket table), nor should a connection be
**      allowed to sit idly for too long.
**
**      MaxMciCache is the maximum number of open connections that
**      will be supported.
**
**      MciCacheTimeout is the time (in seconds) that a connection
**      is permitted to survive without activity.
**
**      We actually try any cached connections by sending a NOOP
**      before we use them; if the NOOP fails we close down the
**      connection and reopen it.  Note that this means that a
**      server SMTP that doesn't support NOOP will hose the
**      algorithm -- but that doesn't seem too likely.
**
**      The persistent MCI code is donated by Mark Lovell and Paul
**      Vixie.  It is based on the long term host status code in KJS
**      written by Paul but has been adapted by Mark to fit into the
**      MCI structure.
*/

MCI     **MciCache;             /* the open connection cache */

extern int      mci_generate_persistent_path __P((const char *, char *, int, bool));
extern bool     mci_load_persistent __P((MCI *));
extern void     mci_uncache __P((MCI **, bool));
/*
**  MCI_CACHE -- enter a connection structure into the open connection cache
**
**      This may cause something else to be flushed.
**
**      Parameters:
**              mci -- the connection to cache.
**
**      Returns:
**              none.
*/

void
mci_cache(mci)
        register MCI *mci;
{
        register MCI **mcislot;

        /*
        **  Find the best slot.  This may cause expired connections
        **  to be closed.
        */

        mcislot = mci_scan(mci);
        if (mcislot == NULL)
        {
                /* we don't support caching */
                return;
        }

        if (mci->mci_host == NULL)
                return;

        /* if this is already cached, we are done */
        if (bitset(MCIF_CACHED, mci->mci_flags))
                return;

        /* otherwise we may have to clear the slot */
        if (*mcislot != NULL)
                mci_uncache(mcislot, TRUE);

        if (tTd(42, 5))
                printf("mci_cache: caching %lx (%s) in slot %d\n",
                        (u_long) mci, mci->mci_host, (int)(mcislot - MciCache));
        if (tTd(91, 100))
                sm_syslog(LOG_DEBUG, CurEnv->e_id,
                        "mci_cache: caching %x (%.100s) in slot %d",
                        mci, mci->mci_host, mcislot - MciCache);

        *mcislot = mci;
        mci->mci_flags |= MCIF_CACHED;
}
/*
**  MCI_SCAN -- scan the cache, flush junk, and return best slot
**
**      Parameters:
**              savemci -- never flush this one.  Can be null.
**
**      Returns:
**              The LRU (or empty) slot.
*/

MCI **
mci_scan(savemci)
        MCI *savemci;
{
        time_t now;
        register MCI **bestmci;
        register MCI *mci;
        register int i;

        if (MaxMciCache <= 0)
        {
                /* we don't support caching */
                return NULL;
        }

        if (MciCache == NULL)
        {
                /* first call */
                MciCache = (MCI **) xalloc(MaxMciCache * sizeof *MciCache);
                bzero((char *) MciCache, MaxMciCache * sizeof *MciCache);
                return (&MciCache[0]);
        }

        now = curtime();
        bestmci = &MciCache[0];
        for (i = 0; i < MaxMciCache; i++)
        {
                mci = MciCache[i];
                if (mci == NULL || mci->mci_state == MCIS_CLOSED)
                {
                        bestmci = &MciCache[i];
                        continue;
                }
                if (mci->mci_lastuse + MciCacheTimeout < now && mci != savemci)
                {
                        /* connection idle too long -- close it */
                        bestmci = &MciCache[i];
                        mci_uncache(bestmci, TRUE);
                        continue;
                }
                if (*bestmci == NULL)
                        continue;
                if (mci->mci_lastuse < (*bestmci)->mci_lastuse)
                        bestmci = &MciCache[i];
        }
        return bestmci;
}
/*
**  MCI_UNCACHE -- remove a connection from a slot.
**
**      May close a connection.
**
**      Parameters:
**              mcislot -- the slot to empty.
**              doquit -- if TRUE, send QUIT protocol on this connection.
**                        if FALSE, we are assumed to be in a forked child;
**                              all we want to do is close the file(s).
**
**      Returns:
**              none.
*/

void
mci_uncache(mcislot, doquit)
        register MCI **mcislot;
        bool doquit;
{
        register MCI *mci;
        extern ENVELOPE BlankEnvelope;

        mci = *mcislot;
        if (mci == NULL)
                return;
        *mcislot = NULL;
        if (mci->mci_host == NULL)
                return;

        mci_unlock_host(mci);

        if (tTd(42, 5))
                printf("mci_uncache: uncaching %lx (%s) from slot %d (%d)\n",
                        (u_long) mci, mci->mci_host,
                        (int)(mcislot - MciCache), doquit);
        if (tTd(91, 100))
                sm_syslog(LOG_DEBUG, CurEnv->e_id,
                        "mci_uncache: uncaching %x (%.100s) from slot %d (%d)",
                        mci, mci->mci_host, mcislot - MciCache, doquit);

#if SMTP
        if (doquit)
        {
                message("Closing connection to %s", mci->mci_host);

                mci->mci_flags &= ~MCIF_CACHED;

                /* only uses the envelope to flush the transcript file */
                if (mci->mci_state != MCIS_CLOSED)
                        smtpquit(mci->mci_mailer, mci, &BlankEnvelope);
#ifdef XLA
                xla_host_end(mci->mci_host);
#endif
        }
        else
#endif
        {
                if (mci->mci_in != NULL)
                        xfclose(mci->mci_in, "mci_uncache", "mci_in");
                if (mci->mci_out != NULL)
                        xfclose(mci->mci_out, "mci_uncache", "mci_out");
                mci->mci_in = mci->mci_out = NULL;
                mci->mci_state = MCIS_CLOSED;
                mci->mci_exitstat = EX_OK;
                mci->mci_errno = 0;
                mci->mci_flags = 0;
        }
}
/*
**  MCI_FLUSH -- flush the entire cache
**
**      Parameters:
**              doquit -- if TRUE, send QUIT protocol.
**                        if FALSE, just close the connection.
**              allbut -- but leave this one open.
**
**      Returns:
**              none.
*/

void
mci_flush(doquit, allbut)
        bool doquit;
        MCI *allbut;
{
        register int i;

        if (MciCache == NULL)
                return;

        for (i = 0; i < MaxMciCache; i++)
                if (allbut != MciCache[i])
                        mci_uncache(&MciCache[i], doquit);
}
/*
**  MCI_GET -- get information about a particular host
*/

MCI *
mci_get(host, m)
        char *host;
        MAILER *m;
{
        register MCI *mci;
        register STAB *s;

#if DAEMON
        extern SOCKADDR CurHostAddr;

        /* clear CurHostAddr so we don't get a bogus address with this name */
        bzero(&CurHostAddr, sizeof CurHostAddr);
#endif

        /* clear out any expired connections */
        (void) mci_scan(NULL);

        if (m->m_mno < 0)
                syserr("negative mno %d (%s)", m->m_mno, m->m_name);
        s = stab(host, ST_MCI + m->m_mno, ST_ENTER);
        mci = &s->s_mci;
        mci->mci_host = s->s_name;

        if (!mci_load_persistent(mci))
        {
                if (tTd(42, 2))
                        printf("mci_get(%s %s): lock failed\n", host, m->m_name);
                mci->mci_exitstat = EX_TEMPFAIL;
                mci->mci_state = MCIS_CLOSED;
                mci->mci_statfile = NULL;
                return mci;
        }

        if (tTd(42, 2))
        {
                printf("mci_get(%s %s): mci_state=%d, _flags=%x, _exitstat=%d, _errno=%d\n",
                        host, m->m_name, mci->mci_state, mci->mci_flags,
                        mci->mci_exitstat, mci->mci_errno);
        }

#if SMTP
        if (mci->mci_state == MCIS_OPEN)
        {
                extern int smtpprobe __P((MCI *));

                /* poke the connection to see if it's still alive */
                (void) smtpprobe(mci);

                /* reset the stored state in the event of a timeout */
                if (mci->mci_state != MCIS_OPEN)
                {
                        mci->mci_errno = 0;
                        mci->mci_exitstat = EX_OK;
                        mci->mci_state = MCIS_CLOSED;
                }
# if DAEMON
                else
                {
                        /* get peer host address for logging reasons only */
                        /* (this should really be in the mci struct) */
                        SOCKADDR_LEN_T socklen = sizeof CurHostAddr;

                        (void) getpeername(fileno(mci->mci_in),
                                (struct sockaddr *) &CurHostAddr, &socklen);
                }
# endif
        }
#endif
        if (mci->mci_state == MCIS_CLOSED)
        {
                time_t now = curtime();

                /* if this info is stale, ignore it */
                if (now > mci->mci_lastuse + MciInfoTimeout)
                {
                        mci->mci_lastuse = now;
                        mci->mci_errno = 0;
                        mci->mci_exitstat = EX_OK;
                }
        }

        return mci;
}
/*
**  MCI_SETSTAT -- set status codes in MCI structure.
**
**      Parameters:
**              mci -- the MCI structure to set.
**              xstat -- the exit status code.
**              dstat -- the DSN status code.
**              rstat -- the SMTP status code.
**
**      Returns:
**              none.
*/

void
mci_setstat(mci, xstat, dstat, rstat)
        MCI *mci;
        int xstat;
        char *dstat;
        char *rstat;
{
        /* protocol errors should never be interpreted as sticky */
        if (xstat != EX_NOTSTICKY && xstat != EX_PROTOCOL)
                mci->mci_exitstat = xstat;

        mci->mci_status = dstat;
        if (mci->mci_rstatus != NULL)
                free(mci->mci_rstatus);
        if (rstat != NULL)
                rstat = newstr(rstat);
        mci->mci_rstatus = rstat;
}
/*
**  MCI_DUMP -- dump the contents of an MCI structure.
**
**      Parameters:
**              mci -- the MCI structure to dump.
**
**      Returns:
**              none.
**
**      Side Effects:
**              none.
*/

struct mcifbits
{
        int     mcif_bit;       /* flag bit */
        char    *mcif_name;     /* flag name */
};
struct mcifbits MciFlags[] =
{
        { MCIF_VALID,           "VALID"         },
        { MCIF_TEMP,            "TEMP"          },
        { MCIF_CACHED,          "CACHED"        },
        { MCIF_ESMTP,           "ESMTP"         },
        { MCIF_EXPN,            "EXPN"          },
        { MCIF_SIZE,            "SIZE"          },
        { MCIF_8BITMIME,        "8BITMIME"      },
        { MCIF_7BIT,            "7BIT"          },
        { MCIF_MULTSTAT,        "MULTSTAT"      },
        { MCIF_INHEADER,        "INHEADER"      },
        { MCIF_CVT8TO7,         "CVT8TO7"       },
        { MCIF_DSN,             "DSN"           },
        { MCIF_8BITOK,          "8BITOK"        },
        { MCIF_CVT7TO8,         "CVT7TO8"       },
        { MCIF_INMIME,          "INMIME"        },
        { 0,                    NULL }
};


void
mci_dump(mci, logit)
        register MCI *mci;
        bool logit;
{
        register char *p;
        char *sep;
        char buf[4000];
        extern char *ctime();

        sep = logit ? " " : "\n\t";
        p = buf;
        snprintf(p, SPACELEFT(buf, p), "MCI@%x: ", mci);
        p += strlen(p);
        if (mci == NULL)
        {
                snprintf(p, SPACELEFT(buf, p), "NULL");
                goto printit;
        }
        snprintf(p, SPACELEFT(buf, p), "flags=%x", mci->mci_flags);
        p += strlen(p);
        if (mci->mci_flags != 0)
        {
                struct mcifbits *f;

                *p++ = '<';
                for (f = MciFlags; f->mcif_bit != 0; f++)
                {
                        if (!bitset(f->mcif_bit, mci->mci_flags))
                                continue;
                        snprintf(p, SPACELEFT(buf, p), "%s,", f->mcif_name);
                        p += strlen(p);
                }
                p[-1] = '>';
        }
        snprintf(p, SPACELEFT(buf, p),
                ",%serrno=%d, herrno=%d, exitstat=%d, state=%d, pid=%d,%s",
                sep, mci->mci_errno, mci->mci_herrno,
                mci->mci_exitstat, mci->mci_state, mci->mci_pid, sep);
        p += strlen(p);
        snprintf(p, SPACELEFT(buf, p),
                "maxsize=%ld, phase=%s, mailer=%s,%s",
                mci->mci_maxsize,
                mci->mci_phase == NULL ? "NULL" : mci->mci_phase,
                mci->mci_mailer == NULL ? "NULL" : mci->mci_mailer->m_name,
                sep);
        p += strlen(p);
        snprintf(p, SPACELEFT(buf, p),
                "status=%s, rstatus=%s,%s",
                mci->mci_status == NULL ? "NULL" : mci->mci_status,
                mci->mci_rstatus == NULL ? "NULL" : mci->mci_rstatus,
                sep);
        p += strlen(p);
        snprintf(p, SPACELEFT(buf, p),
                "host=%s, lastuse=%s",
                mci->mci_host == NULL ? "NULL" : mci->mci_host,
                ctime(&mci->mci_lastuse));
printit:
        if (logit)
                sm_syslog(LOG_DEBUG, CurEnv->e_id, "%.1000s", buf);
        else
                printf("%s\n", buf);
}
/*
**  MCI_DUMP_ALL -- print the entire MCI cache
**
**      Parameters:
**              logit -- if set, log the result instead of printing
**                      to stdout.
**
**      Returns:
**              none.
*/

void
mci_dump_all(logit)
        bool logit;
{
        register int i;

        if (MciCache == NULL)
                return;

        for (i = 0; i < MaxMciCache; i++)
                mci_dump(MciCache[i], logit);
}
/*
**  MCI_LOCK_HOST -- Lock host while sending.
**
**      If we are contacting a host, we'll need to
**      update the status information in the host status
**      file, and if we want to do that, we ought to have
**      locked it. This has the (according to some)
**      desirable effect of serializing connectivity with
**      remote hosts -- i.e.: one connection to a give
**      host at a time.
**
**      Parameters:
**              mci -- containing the host we want to lock.
**
**      Returns:
**              EX_OK      -- got the lock.
**              EX_TEMPFAIL -- didn't get the lock.
*/

int
mci_lock_host(mci)
        MCI *mci;
{
        if (mci == NULL)
        {
                if (tTd(56, 1))
                        printf("mci_lock_host: NULL mci\n");
                return EX_OK;
        }

        if (!SingleThreadDelivery)
                return EX_OK;

        return mci_lock_host_statfile(mci);
}

int
mci_lock_host_statfile(mci)
        MCI *mci;
{
        int savedErrno = errno;
        int retVal = EX_OK;
        char fname[MAXPATHLEN+1];

        if (HostStatDir == NULL || mci->mci_host == NULL)
                return EX_OK;

        if (tTd(56, 2))
                printf("mci_lock_host: attempting to lock %s\n",
                        mci->mci_host);

        if (mci_generate_persistent_path(mci->mci_host, fname, sizeof fname, TRUE) < 0)
        {
                /* of course this should never happen */
                if (tTd(56, 2))
                        printf("mci_lock_host: Failed to generate host path for %s\n",
                               mci->mci_host);

                retVal = EX_TEMPFAIL;
                goto cleanup;
        }

        mci->mci_statfile = safefopen(fname, O_RDWR, FileMode,
                   SFF_NOLOCK|SFF_NOLINK|SFF_OPENASROOT|SFF_REGONLY|SFF_SAFEDIRPATH|SFF_CREAT);

        if (mci->mci_statfile == NULL)
        {
                syserr("mci_lock_host: cannot create host lock file %s",
                               fname);
                goto cleanup;
        }

        if (!lockfile(fileno(mci->mci_statfile), fname, "", LOCK_EX|LOCK_NB))
        {
                if (tTd(56, 2))
                        printf("mci_lock_host: couldn't get lock on %s\n",
                               fname);
                fclose(mci->mci_statfile);
                mci->mci_statfile = NULL;
                retVal = EX_TEMPFAIL;
                goto cleanup;
        }

        if (tTd(56, 12) && mci->mci_statfile != NULL)
                printf("mci_lock_host: Sanity check -- lock is good\n");

cleanup:
        errno = savedErrno;
        return retVal;
}
/*
**  MCI_UNLOCK_HOST -- unlock host
**
**      Clean up the lock on a host, close the file, let
**      someone else use it.
**
**      Parameters:
**              mci -- us.
**
**      Returns:
**              nothing.
*/

void
mci_unlock_host(mci)
        MCI *mci;
{
        int saveErrno = errno;

        if (mci == NULL)
        {
                if (tTd(56, 1))
                        printf("mci_unlock_host: NULL mci\n");
                return;
        }

        if (HostStatDir == NULL || mci->mci_host == NULL)
                return;

        if (!SingleThreadDelivery && mci_lock_host_statfile(mci) == EX_TEMPFAIL)
        {
                if (tTd(56, 1))
                        printf("mci_unlock_host: stat file already locked\n");
        }
        else
        {
                if (tTd(56, 2))
                        printf("mci_unlock_host: store prior to unlock\n");

                mci_store_persistent(mci);
        }

        if (mci->mci_statfile != NULL)
        {
                fclose(mci->mci_statfile);
                mci->mci_statfile = NULL;
        }

        errno = saveErrno;
}
/*
**  MCI_LOAD_PERSISTENT -- load persistent host info
**
**      Load information about host that is kept
**      in common for all running sendmails.
**
**      Parameters:
**              mci -- the host/connection to load persistent info
**                         for.
**
**      Returns:
**              TRUE -- lock was successful
**              FALSE -- lock failed
*/

bool
mci_load_persistent(mci)
        MCI *mci;
{
        int saveErrno = errno;
        bool locked = TRUE;
        FILE *fp;
        char fname[MAXPATHLEN+1];

        if (mci == NULL)
        {
                if (tTd(56, 1))
                        printf("mci_load_persistent: NULL mci\n");
                return TRUE;
        }

        if (IgnoreHostStatus || HostStatDir == NULL || mci->mci_host == NULL)
                return TRUE;
        
        /* Already have the persistent information in memory */
        if (SingleThreadDelivery && mci->mci_statfile != NULL)
                return TRUE;

        if (tTd(56, 1))
                printf("mci_load_persistent: Attempting to load persistent information for %s\n",
                       mci->mci_host);
                
        if (mci_generate_persistent_path(mci->mci_host, fname, sizeof fname, FALSE) < 0)
        {
                /* Not much we can do if the file isn't there... */
                if (tTd(56, 1))
                        printf("mci_load_persistent: Couldn't generate host path\n");
                goto cleanup;
        }

        fp = safefopen(fname, O_RDONLY, FileMode,
                       SFF_NOLOCK|SFF_NOLINK|SFF_OPENASROOT|SFF_REGONLY|SFF_SAFEDIRPATH);
        if (fp == NULL)
        {
                /* I can't think of any reason this should ever happen */
                if (tTd(56, 1))
                        printf("mci_load_persistent: open(%s): %s\n",
                                fname, errstring(errno));
                goto cleanup;
        }

        FileName = fname;
        locked = lockfile(fileno(fp), fname, "", LOCK_SH|LOCK_NB);
        (void) mci_read_persistent(fp, mci);
        FileName = NULL;
        if (locked)
                lockfile(fileno(fp), fname, "", LOCK_UN);
        fclose(fp);

cleanup:
        errno = saveErrno;
        return locked;
}
/*
**  MCI_READ_PERSISTENT -- read persistent host status file
**
**      Parameters:
**              fp -- the file pointer to read.
**              mci -- the pointer to fill in.
**
**      Returns:
**              -1 -- if the file was corrupt.
**              0 -- otherwise.
**
**      Warning:
**              This code makes the assumption that this data
**              will be read in an atomic fashion, and that the data
**              was written in an atomic fashion.  Any other functioning
**              may lead to some form of insanity.  This should be
**              perfectly safe due to underlying stdio buffering.
*/

int
mci_read_persistent(fp, mci)
        FILE *fp;
        register MCI *mci;
{
        int ver;
        register char *p;
        int saveLineNumber = LineNumber;
        char buf[MAXLINE];

        if (fp == NULL)
                syserr("mci_read_persistent: NULL fp");
        if (mci == NULL)
                syserr("mci_read_persistent: NULL mci");
        if (tTd(56, 93))
        {
                printf("mci_read_persistent: fp=%lx, mci=", (u_long) fp);
                mci_dump(mci, FALSE);
        }

        mci->mci_status = NULL;
        if (mci->mci_rstatus != NULL)
                free(mci->mci_rstatus);
        mci->mci_rstatus = NULL;

        rewind(fp);
        ver = -1;
        LineNumber = 0;
        while (fgets(buf, sizeof buf, fp) != NULL)
        {
                LineNumber++;
                p = strchr(buf, '\n');
                if (p != NULL)
                        *p = '\0';
                switch (buf[0])
                {
                  case 'V':             /* version stamp */
                        ver = atoi(&buf[1]);
                        if (ver < 0 || ver > 0)
                                syserr("Unknown host status version %d: %d max",
                                        ver, 0);
                        break;

                  case 'E':             /* UNIX error number */
                        mci->mci_errno = atoi(&buf[1]);
                        break;

                  case 'H':             /* DNS error number */
                        mci->mci_herrno = atoi(&buf[1]);
                        break;

                  case 'S':             /* UNIX exit status */
                        mci->mci_exitstat = atoi(&buf[1]);
                        break;

                  case 'D':             /* DSN status */
                        mci->mci_status = newstr(&buf[1]);
                        break;

                  case 'R':             /* SMTP status */
                        mci->mci_rstatus = newstr(&buf[1]);
                        break;

                  case 'U':             /* last usage time */
                        mci->mci_lastuse = atol(&buf[1]);
                        break;

                  case '.':             /* end of file */
                        return 0;

                  default:
                        sm_syslog(LOG_CRIT, NOQID,
                                  "%s: line %d: Unknown host status line \"%s\"",
                                  FileName == NULL ? mci->mci_host : FileName,
                                  LineNumber, buf);
                        LineNumber = saveLineNumber;
                        return -1;
                }
        }
        LineNumber = saveLineNumber;
        if (ver < 0)
                return -1;
        return 0;
}
/*
**  MCI_STORE_PERSISTENT -- Store persistent MCI information
**
**      Store information about host that is kept
**      in common for all running sendmails.
**
**      Parameters:
**              mci -- the host/connection to store persistent info for.
**
**      Returns:
**              none.
*/

void
mci_store_persistent(mci)
        MCI *mci;
{
        int saveErrno = errno;

        if (mci == NULL)
        {
                if (tTd(56, 1))
                        printf("mci_store_persistent: NULL mci\n");
                return;
        }

        if (HostStatDir == NULL || mci->mci_host == NULL)
                return;

        if (tTd(56, 1))
                printf("mci_store_persistent: Storing information for %s\n",
                           mci->mci_host);

        if (mci->mci_statfile == NULL)
        {
                if (tTd(56, 1))
                        printf("mci_store_persistent: no statfile\n");
                return;
        }

        rewind(mci->mci_statfile);
#if !NOFTRUNCATE
        (void) ftruncate(fileno(mci->mci_statfile), (off_t) 0);
#endif

        fprintf(mci->mci_statfile, "V0\n");
        fprintf(mci->mci_statfile, "E%d\n", mci->mci_errno);
        fprintf(mci->mci_statfile, "H%d\n", mci->mci_herrno);
        fprintf(mci->mci_statfile, "S%d\n", mci->mci_exitstat);
        if (mci->mci_status != NULL)
                fprintf(mci->mci_statfile, "D%.80s\n",
                        denlstring(mci->mci_status, TRUE, FALSE));
        if (mci->mci_rstatus != NULL)
                fprintf(mci->mci_statfile, "R%.80s\n",
                        denlstring(mci->mci_rstatus, TRUE, FALSE));
        fprintf(mci->mci_statfile, "U%ld\n", (long)(mci->mci_lastuse));
        fprintf(mci->mci_statfile, ".\n");

        fflush(mci->mci_statfile);

        errno = saveErrno;
        return;
}
/*
**  MCI_TRAVERSE_PERSISTENT -- walk persistent status tree
**
**      Recursively find all the mci host files in `pathname'.  Default to
**              main host status directory if no path is provided.
**      Call (*action)(pathname, host) for each file found.
**
**      Note: all information is collected in a list before it is processed.
**      This may not be the best way to do it, but it seems safest, since
**      the file system would be touched while we are attempting to traverse
**      the directory tree otherwise (during purges).
**
**      Parameters:
**              action -- function to call on each node.  If returns < 0,
**                      return immediately.
**              pathname -- root of tree.  If null, use main host status
**                      directory.
**
**      Returns:
**              < 0 -- if any action routine returns a negative value, that
**                      value is returned.
**              0 -- if we successfully went to completion.
*/

int
mci_traverse_persistent(action, pathname)
        int (*action)();
        char *pathname;
{
        struct stat statbuf;
        DIR *d;
        int ret;

        if (pathname == NULL)
                pathname = HostStatDir;
        if (pathname == NULL)
                return -1;

        if (tTd(56, 1))
                printf("mci_traverse: pathname is %s\n", pathname);

        ret = stat(pathname, &statbuf);
        if (ret < 0)
        {
                if (tTd(56, 2))
                        printf("mci_traverse: Failed to stat %s: %s\n",
                                pathname, errstring(errno));
                return ret;
        }
        if (S_ISDIR(statbuf.st_mode))
        {
                struct dirent *e;
                char *newptr;
                char newpath[MAXPATHLEN+1];

                if ((d = opendir(pathname)) == NULL)
                {
                        if (tTd(56, 2))
                                printf("mci_traverse: opendir %s: %s\n",
                                        pathname, errstring(errno));
                        return -1;
                }

                if (strlen(pathname) >= sizeof newpath - MAXNAMLEN - 3)
                {
                        if (tTd(56, 2))
                                printf("mci_traverse: path \"%s\" too long",
                                        pathname);
                        return -1;
                }
                strcpy(newpath, pathname);
                newptr = newpath + strlen(newpath);
                *newptr++ = '/';

                while ((e = readdir(d)) != NULL)
                {
                        if (e->d_name[0] == '.')
                                continue;

                        strncpy(newptr, e->d_name,
                                sizeof newpath - (newptr - newpath) - 1);
                        newpath[sizeof newpath - 1] = '\0';

                        ret = mci_traverse_persistent(action, newpath);
                        if (ret < 0)
                                break;

                        /*
                        **  The following appears to be
                        **  necessary during purges, since
                        **  we modify the directory structure
                        */

                        if (action == mci_purge_persistent)
                                rewinddir(d);
                }

                /* purge (or whatever) the directory proper */
                *--newptr = '\0';
                ret = (*action)(newpath, NULL);
                closedir(d);
        }
        else if (S_ISREG(statbuf.st_mode))
        {
                char *end = pathname + strlen(pathname) - 1;
                char *start;
                char *scan;
                char host[MAXHOSTNAMELEN];
                char *hostptr = host;
                
                /*
                **  Reconstruct the host name from the path to the
                **  persistent information.
                */

                do
                {
                        if (hostptr != host)
                                *(hostptr++) = '.';
                        start = end;
                        while (*(start - 1) != '/')
                                start--;

                        if (*end == '.')
                                end--;

                        for (scan = start; scan <= end; scan++)
                                *(hostptr++) = *scan;

                        end = start - 2;
                } while (*end == '.');

                *hostptr = '\0';

                /*
                **  Do something with the file containing the persistent
                **  information.
                */
                ret = (*action)(pathname, host);
        }

        return ret;
}
/*
**  MCI_PRINT_PERSISTENT -- print persisten info
**
**      Dump the persistent information in the file 'pathname'
**
**      Parameters:
**              pathname -- the pathname to the status file.
**              hostname -- the corresponding host name.
**
**      Returns:
**              0
*/

int
mci_print_persistent(pathname, hostname)
        char *pathname;
        char *hostname;
{
        static int initflag = FALSE;
        FILE *fp;
        int width = Verbose ? 78 : 25;
        bool locked;
        MCI mcib;

        /* skip directories */
        if (hostname == NULL)
                return 0;

        if (!initflag)
        {
                initflag = TRUE;
                printf(" -------------- Hostname --------------- How long ago ---------Results---------\n");
        }

        fp = safefopen(pathname, O_RDWR, FileMode,
                       SFF_NOLOCK|SFF_NOLINK|SFF_OPENASROOT|SFF_REGONLY|SFF_SAFEDIRPATH);

        if (fp == NULL)
        {
                if (tTd(56, 1))
                        printf("mci_print_persistent: cannot open %s: %s\n",
                                pathname, errstring(errno));
                return 0;
        }

        FileName = pathname;
        bzero(&mcib, sizeof mcib);
        if (mci_read_persistent(fp, &mcib) < 0)
        {
                syserr("%s: could not read status file", pathname);
                fclose(fp);
                FileName = NULL;
                return 0;
        }

        locked = !lockfile(fileno(fp), pathname, "", LOCK_EX|LOCK_NB);
        fclose(fp);
        FileName = NULL;

        printf("%c%-39s %12s ",
                locked ? '*' : ' ', hostname,
                pintvl(curtime() - mcib.mci_lastuse, TRUE));
        if (mcib.mci_rstatus != NULL)
                printf("%.*s\n", width, mcib.mci_rstatus);
        else if (mcib.mci_exitstat == EX_TEMPFAIL && mcib.mci_errno != 0)
                printf("Deferred: %.*s\n", width - 10, errstring(mcib.mci_errno));
        else if (mcib.mci_exitstat != 0)
        {
                int i = mcib.mci_exitstat - EX__BASE;
                extern int N_SysEx;
                extern char *SysExMsg[];

                if (i < 0 || i >= N_SysEx)
                {
                        char buf[80];

                        snprintf(buf, sizeof buf, "Unknown mailer error %d",
                                mcib.mci_exitstat);
                        printf("%.*s\n", width, buf);
                }
                else
                        printf("%.*s\n", width, &(SysExMsg[i])[5]);
        }
        else if (mcib.mci_errno == 0)
                printf("OK\n");
        else
                printf("OK: %.*s\n", width - 4, errstring(mcib.mci_errno));

        return 0;
}
/*
**  MCI_PURGE_PERSISTENT -- Remove a persistence status file.
**
**      Parameters:
**              pathname -- path to the status file.
**              hostname -- name of host corresponding to that file.
**                      NULL if this is a directory (domain).
**
**      Returns:
**              0
*/

int
mci_purge_persistent(pathname, hostname)
        char *pathname;
        char *hostname;
{
        char *end = pathname + strlen(pathname) - 1;

        if (tTd(56, 1))
                printf("mci_purge_persistent: purging %s\n", pathname);

        if (hostname != NULL)
        {
                /* remove the file */
                if (unlink(pathname) < 0)
                {
                        if (tTd(56, 2))
                                printf("mci_purge_persistent: failed to unlink %s: %s\n",
                                        pathname, errstring(errno));
                }
        }
        else
        {
                /* remove the directory */
                if (*end != '.')
                        return 0;

                if (tTd(56, 1))
                        printf("mci_purge_persistent: dpurge %s\n", pathname);

                if (rmdir(pathname) < 0)
                {
                        if (tTd(56, 2))
                                printf("mci_purge_persistent: rmdir %s: %s\n",
                                        pathname, errstring(errno));
                }
                
        }

        return 0;
}
/*
**  MCI_GENERATE_PERSISTENT_PATH -- generate path from hostname
**
**      Given `host', convert from a.b.c to $QueueDir/.hoststat/c./b./a,
**      putting the result into `path'.  if `createflag' is set, intervening
**      directories will be created as needed.
**
**      Parameters:
**              host -- host name to convert from.
**              path -- place to store result.
**              pathlen -- length of path buffer.
**              createflag -- if set, create intervening directories as
**                      needed.
**
**      Returns:
**              0 -- success
**              -1 -- failure
*/

int
mci_generate_persistent_path(host, path, pathlen, createflag)
        const char *host;
        char *path;
        int pathlen;
        bool createflag;
{
        char *elem, *p, *x, ch;
        int ret = 0;
        int len;
        char t_host[MAXHOSTNAMELEN];

        /*
        **  Rationality check the arguments.
        */

        if (host == NULL)
        {
                syserr("mci_generate_persistent_path: null host");
                return -1;
        }
        if (path == NULL)
        {
                syserr("mci_generate_persistent_path: null path");
                return -1;
        }

        if (tTd(56, 80))
                printf("mci_generate_persistent_path(%s): ", host);

        if (*host == '\0' || *host == '.')
                return -1;

        /* make certain this is not a bracketed host number */
        if (strlen(host) > sizeof t_host - 1)
                return -1;
        if (host[0] == '[')
                strcpy(t_host, host + 1);
        else    
                strcpy(t_host, host);

        /*
        **  Delete any trailing dots from the hostname.
        **  Leave 'elem' pointing at the \0.
        */

        elem = t_host + strlen(t_host);
        while (elem > t_host &&
               (elem[-1] == '.' || (host[0] == '[' && elem[-1] == ']')))
                *--elem = '\0';

        /* check for bogus bracketed address */
        if (host[0] == '[' && inet_addr(t_host) == INADDR_NONE)
                return -1;

        /* check for what will be the final length of the path */
        len = strlen(HostStatDir) + 2;
        for (p = (char *) t_host; *p != '\0'; p++)
        {
                if (*p == '.')
                        len++;
                len++;
                if (p[0] == '.' && p[1] == '.')
                        return -1;
        }
        if (len > pathlen || len < 1)
                return -1;

        strcpy(path, HostStatDir);
        p = path + strlen(path);

        while (elem > t_host)
        {
                if (!path_is_dir(path, createflag))
                {
                        ret = -1;
                        break;
                }
                elem--;
                while (elem >= t_host && *elem != '.')
                        elem--;
                *p++ = '/';
                x = elem + 1;
                while ((ch = *x++) != '\0' && ch != '.')
                {
                        if (isascii(ch) && isupper(ch))
                                ch = tolower(ch);
                        if (ch == '/')
                                ch = ':';       /* / -> : */
                        *p++ = ch;
                }
                if (elem >= t_host)
                        *p++ = '.';
                *p = '\0';
        }

        if (tTd(56, 80))
        {
                if (ret < 0)
                        printf("FAILURE %d\n", ret);
                else
                        printf("SUCCESS %s\n", path);
        }

        return (ret);
}