sendmail/src/stab.c

	stab.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * Copyright (c) 1998-2001, 2003 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.
 *
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include <sendmail.h>

SM_RCSID("@(#)$Id: stab.c,v 8.88 2003/05/21 15:36:30 ca Exp $")

/*
**  STAB -- manage the symbol table
**
**  Parameters:
**      name -- the name to be looked up or inserted.
**      type -- the type of symbol.
**      op -- what to do:
**          ST_ENTER -- enter the name if not already present.
**          ST_FIND -- find it only.
**
**  Returns:
**      pointer to a STAB entry for this name.
**      NULL if not found and not entered.
**
**  Side Effects:
**      can update the symbol table.
*/

#define STABSIZE    2003
#define SM_LOWER(c) ((isascii(c) && isupper(c)) ? tolower(c) : (c))

static STAB *SymTab[STABSIZE];

STAB *
stab(name, type, op)
    char *name;
    int type;
    int op;
{
    register STAB *s;
    register STAB **ps;
    register int hfunc;
    register char *p;
    int len;

    if (tTd(36, 5))
        sm_dprintf("STAB: %s %d ", name, type);

    /*
    **  Compute the hashing function
    */

    hfunc = type;
    for (p = name; *p != '\0'; p++)
        hfunc = ((hfunc << 1) ^ (SM_LOWER(*p) & 0377)) % STABSIZE;

    if (tTd(36, 9))
        sm_dprintf("(hfunc=%d) ", hfunc);

    ps = &SymTab[hfunc];
    if (type == ST_MACRO || type == ST_RULESET)
    {
        while ((s = *ps) != NULL &&
               (s->s_symtype != type || strcmp(name, s->s_name)))
            ps = &s->s_next;
    }
    else
    {
        while ((s = *ps) != NULL &&
               (s->s_symtype != type || sm_strcasecmp(name, s->s_name)))
            ps = &s->s_next;
    }

    /*
    **  Dispose of the entry.
    */

    if (s != NULL || op == ST_FIND)
    {
        if (tTd(36, 5))
        {
            if (s == NULL)
                sm_dprintf("not found\n");
            else
            {
                long *lp = (long *) s->s_class;

                sm_dprintf("type %d val %lx %lx %lx %lx\n",
                    s->s_symtype, lp[0], lp[1], lp[2], lp[3]);
            }
        }
        return s;
    }

    /*
    **  Make a new entry and link it in.
    */

    if (tTd(36, 5))
        sm_dprintf("entered\n");

    /* determine size of new entry */
    switch (type)
    {
      case ST_CLASS:
        len = sizeof s->s_class;
        break;

      case ST_ADDRESS:
        len = sizeof s->s_address;
        break;

      case ST_MAILER:
        len = sizeof s->s_mailer;
        break;

      case ST_ALIAS:
        len = sizeof s->s_alias;
        break;

      case ST_MAPCLASS:
        len = sizeof s->s_mapclass;
        break;

      case ST_MAP:
        len = sizeof s->s_map;
        break;

      case ST_HOSTSIG:
        len = sizeof s->s_hostsig;
        break;

      case ST_NAMECANON:
        len = sizeof s->s_namecanon;
        break;

      case ST_MACRO:
        len = sizeof s->s_macro;
        break;

      case ST_RULESET:
        len = sizeof s->s_ruleset;
        break;

      case ST_HEADER:
        len = sizeof s->s_header;
        break;

      case ST_SERVICE:
        len = sizeof s->s_service;
        break;

#if LDAPMAP
      case ST_LMAP:
        len = sizeof s->s_lmap;
        break;
#endif /* LDAPMAP */

#if MILTER
      case ST_MILTER:
        len = sizeof s->s_milter;
        break;
#endif /* MILTER */

      case ST_QUEUE:
        len = sizeof s->s_quegrp;
        break;

#if SOCKETMAP
      case ST_SOCKETMAP:
        len = sizeof s->s_socketmap;
        break;
#endif /* SOCKETMAP */

      default:
        /*
        **  Each mailer has its own MCI stab entry:
        **
        **  s = stab(host, ST_MCI + m->m_mno, ST_ENTER);
        **
        **  Therefore, anything ST_MCI or larger is an s_mci.
        */

        if (type >= ST_MCI)
            len = sizeof s->s_mci;
        else
        {
            syserr("stab: unknown symbol type %d", type);
            len = sizeof s->s_value;
        }
        break;
    }
    len += sizeof *s - sizeof s->s_value;

    if (tTd(36, 15))
        sm_dprintf("size of stab entry: %d\n", len);

    /* make new entry */
    s = (STAB *) sm_pmalloc_x(len);
    memset((char *) s, '\0', len);
    s->s_name = sm_pstrdup_x(name);
    s->s_symtype = type;

    /* link it in */
    *ps = s;

    /* set a default value for rulesets */
    if (type == ST_RULESET)
        s->s_ruleset = -1;

    return s;
}
/*
**  STABAPPLY -- apply function to all stab entries
**
**  Parameters:
**      func -- the function to apply.  It will be given two
**          parameters (the stab entry and the arg).
**      arg -- an arbitrary argument, passed to func.
**
**  Returns:
**      none.
*/

void
stabapply(func, arg)
    void (*func)__P((STAB *, int));
    int arg;
{
    register STAB **shead;
    register STAB *s;

    for (shead = SymTab; shead < &SymTab[STABSIZE]; shead++)
    {
        for (s = *shead; s != NULL; s = s->s_next)
        {
            if (tTd(36, 90))
                sm_dprintf("stabapply: trying %d/%s\n",
                    s->s_symtype, s->s_name);
            func(s, arg);
        }
    }
}
/*
**  QUEUEUP_MACROS -- queueup the macros in a class
**
**  Write the macros listed in the specified class into the
**  file referenced by qfp.
**
**  Parameters:
**      class -- class ID.
**      qfp -- file pointer to the queue file.
**      e -- the envelope.
**
**  Returns:
**      none.
*/

void
queueup_macros(class, qfp, e)
    int class;
    SM_FILE_T *qfp;
    ENVELOPE *e;
{
    register STAB **shead;
    register STAB *s;

    if (e == NULL)
        return;

    class = bitidx(class);
    for (shead = SymTab; shead < &SymTab[STABSIZE]; shead++)
    {
        for (s = *shead; s != NULL; s = s->s_next)
        {
            int m;
            char *p;

            if (s->s_symtype == ST_CLASS &&
                bitnset(bitidx(class), s->s_class) &&
                (m = macid(s->s_name)) != 0 &&
                (p = macvalue(m, e)) != NULL)
            {
                (void) sm_io_fprintf(qfp, SM_TIME_DEFAULT,
                              "$%s%s\n",
                              s->s_name,
                              denlstring(p, true,
                                 false));
            }
        }
    }
}
/*
**  COPY_CLASS -- copy class members from one class to another
**
**  Parameters:
**      src -- source class.
**      dst -- destination class.
**
**  Returns:
**      none.
*/

void
copy_class(src, dst)
    int src;
    int dst;
{
    register STAB **shead;
    register STAB *s;

    src = bitidx(src);
    dst = bitidx(dst);
    for (shead = SymTab; shead < &SymTab[STABSIZE]; shead++)
    {
        for (s = *shead; s != NULL; s = s->s_next)
        {
            if (s->s_symtype == ST_CLASS &&
                bitnset(src, s->s_class))
                setbitn(dst, s->s_class);
        }
    }
}

/*
**  RMEXPSTAB -- remove expired entries from SymTab.
**
**  These entries need to be removed in long-running processes,
**  e.g., persistent queue runners, to avoid consuming memory.
**
**  XXX It might be useful to restrict the maximum TTL to avoid
**      caching data very long.
**
**  Parameters:
**      none.
**
**  Returns:
**      none.
**
**  Side Effects:
**      can remove entries from the symbol table.
*/

#define SM_STAB_FREE(x) \
    do \
    { \
        char *o = (x); \
        (x) = NULL; \
        if (o != NULL) \
            sm_free(o); \
    } while (0)

void
rmexpstab()
{
    int i;
    STAB *s, *p, *f;
    time_t now;

    now = curtime();
    for (i = 0; i < STABSIZE; i++)
    {
        p = NULL;
        s = SymTab[i];
        while (s != NULL)
        {
            switch (s->s_symtype)
            {
              case ST_HOSTSIG:
                if (s->s_hostsig.hs_exp >= now)
                    goto next;  /* not expired */
                SM_STAB_FREE(s->s_hostsig.hs_sig); /* XXX */
                break;

              case ST_NAMECANON:
                if (s->s_namecanon.nc_exp >= now)
                    goto next;  /* not expired */
                SM_STAB_FREE(s->s_namecanon.nc_cname); /* XXX */
                break;

              default:
                if (s->s_symtype >= ST_MCI)
                {
                    /* call mci_uncache? */
                    SM_STAB_FREE(s->s_mci.mci_status);
                    SM_STAB_FREE(s->s_mci.mci_rstatus);
                    SM_STAB_FREE(s->s_mci.mci_heloname);
#if 0
                    /* not dynamically allocated */
                    SM_STAB_FREE(s->s_mci.mci_host);
                    SM_STAB_FREE(s->s_mci.mci_tolist);
#endif /* 0 */
#if SASL
                    /* should always by NULL */
                    SM_STAB_FREE(s->s_mci.mci_sasl_string);
#endif /* SASL */
                    if (s->s_mci.mci_rpool != NULL)
                    {
                        sm_rpool_free(s->s_mci.mci_rpool);
                        s->s_mci.mci_macro.mac_rpool = NULL;
                        s->s_mci.mci_rpool = NULL;
                    }
                    break;
                }
  next:
                p = s;
                s = s->s_next;
                continue;
            }

            /* remove entry */
            SM_STAB_FREE(s->s_name); /* XXX */
            f = s;
            s = s->s_next;
            sm_free(f); /* XXX */
            if (p == NULL)
                SymTab[i] = s;
            else
                p->s_next = s;
        }
    }
}

#if SM_HEAP_CHECK
/*
**  DUMPSTAB -- dump symbol table.
**
**  For debugging.
*/

#define MAXSTTYPES  (ST_MCI + 1)

void
dumpstab()
{
    int i, t, total, types[MAXSTTYPES];
    STAB *s;
    static int prevt[MAXSTTYPES], prev = 0;

    total = 0;
    for (i = 0; i < MAXSTTYPES; i++)
        types[i] = 0;
    for (i = 0; i < STABSIZE; i++)
    {
        s = SymTab[i];
        while (s != NULL)
        {
            ++total;
            t = s->s_symtype;
            if (t > MAXSTTYPES - 1)
                t = MAXSTTYPES - 1;
            types[t]++;
            s = s->s_next;
        }
    }
    sm_syslog(LOG_INFO, NOQID, "stab: total=%d (%d)", total, total - prev);
    prev = total;
    for (i = 0; i < MAXSTTYPES; i++)
    {
        if (types[i] != 0)
        {
            sm_syslog(LOG_INFO, NOQID, "stab: type[%2d]=%2d (%d)",
                i, types[i], types[i] - prevt[i]);
        }
        prevt[i] = types[i];
    }
}
#endif /* SM_HEAP_CHECK */