Quelle  mac_expand.c

/*++
/* NAME
/* mac_expand 3
/* SUMMARY
/* attribute expansion
/* SYNOPSIS
/* #include <mac_expand.h>
/*
/* int mac_expand7(result, pattern, flags, filter, lookup,
/* dont_expand, context)
/* VSTRING *result;
/* const char *pattern;
/* int flags;
/* const char *filter;
/* const char *lookup(const char *key, int mode, void *context)
/* const bool dont_parse(const char *key, void *context)
/* void *context;
/* AUXILIARY FUNCTIONS
/* int mac_expand(result, pattern, flags, filter, lookup, context)
/* VSTRING *result;
/* const char *pattern;
/* int flags;
/* const char *filter;
/* const char *lookup(const char *key, int mode, void *context)
/* void *context;
/*
/* typedef MAC_EXP_OP_RES (*MAC_EXPAND_RELOP_FN) (
/* const char *left,
/* int tok_val,
/* const char *rite)
/*
/* void mac_expand_add_relop(
/* int *tok_list,
/* const char *suffix,
/* MAC_EXPAND_RELOP_FN relop_eval)
/*
/* MAC_EXP_OP_RES mac_exp_op_res_bool[2];
/
/* typedef int (*MAC_EXPAND_NAMED_FN) (
/* VSTRING *out,
/* const char *arg)
/*
/* void mac_expand_add_named_fn(
/* const char *name,
/* MAC_EXPAND_NAMED_FN action)
/* DESCRIPTION
/* This module implements parameter-less named attribute
/* expansions, both conditional and unconditional. As of Postfix
/* 3.0 this code supports relational expression evaluation.
/*
/* In this text, an attribute is considered "undefined" when its value
/* is a null pointer.  Otherwise, the attribute is considered "defined"
/* and is expected to have as value a null-terminated string.
/*
/* In the text below, the legacy form $(...) is equivalent to
/* ${...}. The legacy form $(...) may eventually disappear
/* from documentation. In the text below, the name in $name
/* and ${name...} must contain only characters from the set
/* [a-zA-Z0-9_].
/*
/* The following substitutions are supported:
/* .IP "$name, ${name}"
/* Unconditional attribute-based substitution. The result is the
/* named attribute value (empty if the attribute is not defined)
/* after optional further named attribute substitution.
/* .IP "${name?text}, ${name?{text}}"
/* Conditional attribute-based substitution. If the named attribute
/* value is non-empty, the result is the given text, after
/* named attribute expansion and relational expression evaluation.
/* Otherwise, the result is empty.  Whitespace before or after
/* {text} is ignored.
/* .IP "${name{text}}"
/* Apply the registered function \fIname\fR to the specified text
/* after named attribute expansion and expression evaluation,
/* and replace this input with the function result. Functions are
/* registered with mac_expand_add_named_fn().
/* .IP "${name:text}, ${name:{text}}"
/* Conditional attribute-based substitution. If the attribute
/* value is empty or undefined, the expansion is the given
/* text, after named attribute expansion and relational expression
/* evaluation.  Otherwise, the result is empty.  Whitespace
/* before or after {text} is ignored.
/* .IP "${name?{text1}:{text2}}, ${name?{text1}:text2}"
/* Conditional attribute-based substitution. If the named attribute
/* value is non-empty, the result is text1.  Otherwise, the
/* result is text2. In both cases the result is subject to
/* named attribute expansion and relational expression evaluation.
/* Whitespace before or after {text1} or {text2} is ignored.
/* .IP "${{text1} == ${text2} ? {text3} : {text4}}"
/* Relational expression-based substitution.  First, the content
/* of {text1} and ${text2} is subjected to named attribute and
/* relational expression-based substitution.  Next, the relational
/* expression is evaluated. If it evaluates to "true", the
/* result is the content of {text3}, otherwise it is the content
/* of {text4}, after named attribute and relational expression-based
/* substitution. In addition to ==, this supports !=, <, <=,
/* >=, and >. Comparisons are numerical when both operands are
/* all digits, otherwise the comparisons are lexicographical.
/*
/* Arguments:
/* .IP result
/* Storage for the result of expansion. By default, the result
/* is truncated upon entry.
/* .IP pattern
/* The string to be expanded.
/* .IP flags
/* Bit-wise OR of zero or more of the following:
/* .RS
/* .IP MAC_EXP_FLAG_RECURSE
/* Expand attributes in lookup results. This should never be
/* done with data whose origin is untrusted.
/* .IP MAC_EXP_FLAG_APPEND
/* Append text to the result buffer without truncating it.
/* .IP MAC_EXP_FLAG_SCAN
/* Scan the input for named attributes, including named
/* attributes in all conditional result values.  Do not expand
/* named attributes, and do not truncate or write to the result
/* argument.
/* .IP MAC_EXP_FLAG_PRINTABLE
/* Use the printable() function instead of \fIfilter\fR.
/* .PP
/* The constant MAC_EXP_FLAG_NONE specifies a manifest null value.
/* .RE
/* .IP filter
/* A null pointer, or a null-terminated array of characters that
/* are allowed to appear in an expansion. Illegal characters are
/* replaced by underscores.
/* .IP lookup
/* The attribute lookup routine. Arguments are: the attribute name,
/* MAC_EXP_MODE_TEST to test the existence of the named attribute
/* or MAC_EXP_MODE_USE to use the value of the named attribute,
/* and the caller context that was given to mac_expand(). A null
/* result value means that the requested attribute was not defined.
/* .IP don_parse
/* An optional function that disables the MAC_EXP_FLAG_RECURSE
/* feature with lookup() results for a specific attribute. Arguments
/* are: the attribute name, and the caller context that was given
/* to mac_expand(). Specify null to disable this feature.
/* .IP context
/* Caller context that is passed on to the attribute lookup and
/* don_parse routines.
/* .PP
/* mac_expand_add_relop() registers a function that implements
/* support for custom relational operators. Custom operator names
/* such as "==xxx" have two parts: a prefix that is identical to
/* a built-in operator such as "==", and an application-specified
/* suffix such as "xxx".
/*
/* Arguments:
/* .IP tok_list
/* A null-terminated list of MAC_EXP_OP_TOK_* values that support
/* the custom operator suffix.
/* .IP suffix
/* A null-terminated alphanumeric string that specifies the custom
/* operator suffix.
/* .IP relop_eval
/* A function that compares two strings according to the
/* MAC_EXP_OP_TOK_* value specified with the tok_val argument,
/* and that returns non-zero if the custom operator evaluates to
/* true, zero otherwise.
/*
/* mac_exp_op_res_bool provides an array that converts a boolean
/* value (0 or 1) to the corresponding MAX_EXP_OP_RES_TRUE or
/* MAX_EXP_OP_RES_FALSE value.
/*
/* mac_expand_add_named_fn() registers a C function that may be
/* called as ${name{text}}. The function input is the text after
/* attribute expansion and expression evaluation. The function
/* should append its output to the specified buffer, and it
/* should return either MAC_PARSE_OK or MAC_PARSE_ERROR.
/* DIAGNOSTICS
/* Fatal errors: out of memory.  Warnings: syntax errors, unreasonable
/* recursion depth.
/*
/* The mac_expand() result value is the binary OR of zero or more
/* of the following:
/* .IP MAC_PARSE_ERROR
/* A syntax error was found in \fBpattern\fR, or some attribute had
/* an unreasonable nesting depth.
/* .IP MAC_PARSE_UNDEF
/* An attribute was expanded but its value was not defined.
/* SEE ALSO
/* mac_parse(3) locate macro references in string.
/* LICENSE
/* .ad
/* .fi
/* The Secure Mailer license must be distributed with this software.
/* AUTHOR(S)
/* Wietse Venema
/* IBM T.J. Watson Research
/* P.O. Box 704
/* Yorktown Heights, NY 10598, USA
/*
/* Wietse Venema
/* Google, Inc.
/* 111 8th Avenue
/* New York, NY 10011, USA
/*
/* Wietse Venema
/* porcupine.org
/*--*/

/* System library. */

#include <sys_defs.h>
#include <ctype.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>

/* Utility library. */

#include <msg.h>
#include <htable.h>
#include <vstring.h>
#include <mymalloc.h>
#include <stringops.h>
#include <name_code.h>
#include <sane_strtol.h>
#include <mac_parse.h>
#include <mac_expand.h>

 /*
  * Simplifies the return of common relational operator results.
  */
MAC_EXP_OP_RES mac_exp_op_res_bool[2] = {
    MAC_EXP_OP_RES_FALSE,
    MAC_EXP_OP_RES_TRUE
};

 /*
  * Little helper structure.
  */
typedef struct {
    VSTRING *result;   /* result buffer */
    int     flags;   /* features */
    const char *filter;   /* character filter */
    MAC_EXP_LOOKUP_FN lookup;  /* lookup routine */
    MAC_EXP_DONT_PARSE_FN dont_parse; /* veto routine */
    void   *context;   /* caller context */
    int     status;   /* findings */
    int     level;   /* nesting level */
} MAC_EXP_CONTEXT;

 /*
  * Support for relational expressions.
  * 
  * As of Postfix 2.2, ${attr-name?result} or ${attr-name:result} return the
  * result respectively when the parameter value is non-empty, or when the
  * parameter value is undefined or empty; support for the ternary ?:
  * operator was anticipated, but not implemented for 10 years.
  * 
  * To make ${relational-expr?result} and ${relational-expr:result} work as
  * expected without breaking the way that ? and : work, relational
  * expressions evaluate to a non-empty or empty value. It does not matter
  * what non-empty value we use for TRUE. However we must not use the
  * undefined (null pointer) value for FALSE - that would raise the
  * MAC_PARSE_UNDEF flag.
  * 
  * The value of a relational expression can be exposed with ${relational-expr},
  * i.e. a relational expression that is not followed by ? or : conditional
  * expansion.
  */
#define MAC_EXP_BVAL_TRUE "true"
#define MAC_EXP_BVAL_FALSE ""

 /*
  * Relational operators. The MAC_EXP_OP_TOK_* are defined in the header
  * file.
  */
#define MAC_EXP_OP_STR_EQ "=="
#define MAC_EXP_OP_STR_NE "!="
#define MAC_EXP_OP_STR_LT "<"
#define MAC_EXP_OP_STR_LE "<="
#define MAC_EXP_OP_STR_GE ">="
#define MAC_EXP_OP_STR_GT ">"
#define MAC_EXP_OP_STR_ANY "\"" MAC_EXP_OP_STR_EQ \
    "\" or \"" MAC_EXP_OP_STR_NE "\"" \
    "\" or \"" MAC_EXP_OP_STR_LT "\"" \
    "\" or \"" MAC_EXP_OP_STR_LE "\"" \
    "\" or \"" MAC_EXP_OP_STR_GE "\"" \
    "\" or \"" MAC_EXP_OP_STR_GT "\""

static const NAME_CODE mac_exp_op_table[] =
{
    MAC_EXP_OP_STR_EQ, MAC_EXP_OP_TOK_EQ,
    MAC_EXP_OP_STR_NE, MAC_EXP_OP_TOK_NE,
    MAC_EXP_OP_STR_LT, MAC_EXP_OP_TOK_LT,
    MAC_EXP_OP_STR_LE, MAC_EXP_OP_TOK_LE,
    MAC_EXP_OP_STR_GE, MAC_EXP_OP_TOK_GE,
    MAC_EXP_OP_STR_GT, MAC_EXP_OP_TOK_GT,
    0, MAC_EXP_OP_TOK_NONE,
};

 /*
  * The whitespace separator set.
  */
#define MAC_EXP_WHITESPACE CHARS_SPACE

 /*
  * Support for operator extensions.
  */
static HTABLE *mac_exp_ext_table;
static VSTRING *mac_exp_ext_key;

 /*
  * Support for named functions.
  */
static HTABLE *mac_exp_named_fn_table;
struct mac_exp_named_fn_entry {
    MAC_EXPAND_NAMED_FN action;
};

 /*
  * SLMs.
  */
#define STR(x) vstring_str(x)

/* atol_or_die - convert or die */

static long atol_or_die(const char *strval)
{
    long    result;
    char   *remainder;

    result = sane_strtol(strval, &remainder, 10);
    if (*strval == 0 /* can't happen */ || *remainder != 0 || errno == ERANGE)
 msg_fatal("mac_exp_eval: bad conversion: %s", strval);
    return (result);
}

/* mac_exp_eval - evaluate binary expression */

static MAC_EXP_OP_RES mac_exp_eval(const char *left, int tok_val,
               const char *rite)
{
    static const char myname[] = "mac_exp_eval";
    long    delta;

    /*
     * Numerical or string comparison.
     */
    if (alldig(left) && alldig(rite)) {
 delta = atol_or_die(left) - atol_or_die(rite);
    } else {
 delta = strcmp(left, rite);
    }
    switch (tok_val) {
    case MAC_EXP_OP_TOK_EQ:
 return (mac_exp_op_res_bool[delta == 0]);
    case MAC_EXP_OP_TOK_NE:
 return (mac_exp_op_res_bool[delta != 0]);
    case MAC_EXP_OP_TOK_LT:
 return (mac_exp_op_res_bool[delta < 0]);
    case MAC_EXP_OP_TOK_LE:
 return (mac_exp_op_res_bool[delta <= 0]);
    case MAC_EXP_OP_TOK_GE:
 return (mac_exp_op_res_bool[delta >= 0]);
    case MAC_EXP_OP_TOK_GT:
 return (mac_exp_op_res_bool[delta > 0]);
    default:
 msg_panic("%s: unknown operator: %d",
    myname, tok_val);
    }
}

/* mac_exp_parse_error - report parse error, set error flag, return status */

static int PRINTFLIKE(2, 3) mac_exp_parse_error(MAC_EXP_CONTEXT *mc,
              const char *fmt,...)
{
    va_list ap;

    va_start(ap, fmt);
    vmsg_warn(fmt, ap);
    va_end(ap);
    return (mc->status |= MAC_PARSE_ERROR);
};

/* MAC_EXP_ERR_RETURN - report parse error, set error flag, return status */

#define MAC_EXP_ERR_RETURN(mc, fmt, ...) do { \
 return (mac_exp_parse_error(mc, fmt, __VA_ARGS__)); \
    } while (0)

 /*
  * Postfix 3.0 introduces support for {text} operands. Only with these do we
  * support the ternary ?: operator and relational operators.
  * 
  * We cannot support operators in random text, because that would break Postfix
  * 2.11 compatibility. For example, with the expression "${name?value}", the
  * value is random text that may contain ':', '?', '{' and '}' characters.
  * In particular, with Postfix 2.2 .. 2.11, "${name??foo:{b}ar}" evaluates
  * to "?foo:{b}ar" or empty. There are explicit tests in this directory and
  * the postconf directory to ensure that Postfix 2.11 compatibility is
  * maintained.
  * 
  * Ideally, future Postfix configurations enclose random text operands inside
  * {} braces. These allow whitespace around operands, which improves
  * readability.
  */

/* MAC_EXP_FIND_LEFT_CURLY - skip over whitespace to '{', advance read ptr */

#define MAC_EXP_FIND_LEFT_CURLY(len, cp) \
 ((cp[len = strspn(cp, MAC_EXP_WHITESPACE)] == '{') ? \
  (cp += len) : 0)

/* mac_exp_extract_curly_payload - balance {}, skip whitespace, return payload */

static char *mac_exp_extract_curly_payload(MAC_EXP_CONTEXT *mc, char **bp,
                int strip_space)
{
    char   *payload;
    char   *cp;
    int     level;
    int     ch;

#define DO_STRIP_SPACE 1
#define NO_STRIP_SPACE 0

    /*
     * Extract the payload and balance the {}. The caller is expected to skip
     * leading whitespace before the {. See MAC_EXP_FIND_LEFT_CURLY().
     * TODO(wietse) this code pre-dates extpar() and mainly differs in how an
     * error is reported.
     */
    payload = *bp + 1;
    if (strip_space)
 payload += strspn(payload, MAC_EXP_WHITESPACE);
    for (level = 1, cp = payload; /* see below */ ; cp++) {
 if ((ch = *cp) == 0) {
     mac_exp_parse_error(mc, "unbalanced {} in attribute expression: "
    "\"%s\"",
    *bp);
     return (0);
 } else if (ch == '{') {
     level++;
 } else if (ch == '}') {
     if (--level <= 0)
  break;
 }
    }
    if (strip_space)
 trimblanks(payload, cp - payload)[0] = 0;
    *cp++ = 0;

    /*
     * Skip trailing whitespace after }.
     */
    *bp = cp + strspn(cp, MAC_EXP_WHITESPACE);
    return (payload);
}

/* mac_exp_parse_relational - parse relational expression, advance read ptr */

static int mac_exp_parse_relational(MAC_EXP_CONTEXT *mc, const char **lookup,
                char **bp)
{
    char   *cp = *bp;
    VSTRING *left_op_buf;
    VSTRING *rite_op_buf;
    const char *left_op_strval;
    const char *rite_op_strval;
    char   *op_pos;
    char   *op_strval;
    size_t  op_len;
    int     op_tokval;
    int     op_result;
    size_t  tmp_len;
    char   *type_pos;
    size_t  type_len;
    MAC_EXPAND_RELOP_FN relop_eval;

    /*
     * Left operand. The caller is expected to skip leading whitespace before
     * the {. See MAC_EXP_FIND_LEFT_CURLY().
     */
    if ((left_op_strval = mac_exp_extract_curly_payload(mc, &cp,
            NO_STRIP_SPACE)) == 0)
 return (mc->status);

    /*
     * Operator. Todo: regexp operator.
     */
    op_pos = cp;
    op_len = strspn(cp, "<>!=?+-*/~&|%"); /* for better diagnostics. */
    op_strval = mystrndup(cp, op_len);
    op_tokval = name_code(mac_exp_op_table, NAME_CODE_FLAG_NONE, op_strval);
    myfree(op_strval);
    if (op_tokval == MAC_EXP_OP_TOK_NONE)
 MAC_EXP_ERR_RETURN(mc, "%s expected at: \"...%s}>>>%.20s\"",
      MAC_EXP_OP_STR_ANY, left_op_strval, cp);
    cp += op_len;

    /*
     * Custom operator suffix.
     */
    if (mac_exp_ext_table && ISALNUM(*cp)) {
 type_pos = cp;
 for (type_len = 1; ISALNUM(cp[type_len]); type_len++)
      /* void */ ;
 cp += type_len;
 vstring_sprintf(mac_exp_ext_key, "%.*s",
   (int) (op_len + type_len), op_pos);
 if ((relop_eval = (MAC_EXPAND_RELOP_FN) htable_find(mac_exp_ext_table,
      STR(mac_exp_ext_key))) == 0)
     MAC_EXP_ERR_RETURN(mc, "bad operator suffix at: \"...%.*s>>>%.*s\"",
       (int) op_len, op_pos, (int) type_len, type_pos);
    } else {
 relop_eval = mac_exp_eval;
    }

    /*
     * Right operand. Todo: syntax may depend on operator.
     */
    if (MAC_EXP_FIND_LEFT_CURLY(tmp_len, cp) == 0)
 MAC_EXP_ERR_RETURN(mc, "\"{expression}\" expected at: "
      "\"...{%s} %.*s>>>%.20s\"",
      left_op_strval, (int) op_len, op_pos, cp);
    if ((rite_op_strval = mac_exp_extract_curly_payload(mc, &cp,
            NO_STRIP_SPACE)) == 0)
 return (mc->status);

    /*
     * Evaluate the relational expression. Todo: regexp support.
     */
    mc->status |=
 mac_expand(left_op_buf = vstring_alloc(100), left_op_strval,
     mc->flags, mc->filter, mc->lookup, mc->context);
    mc->status |=
 mac_expand(rite_op_buf = vstring_alloc(100), rite_op_strval,
     mc->flags, mc->filter, mc->lookup, mc->context);
    if ((mc->flags & MAC_EXP_FLAG_SCAN) == 0
 && (op_result = relop_eval(vstring_str(left_op_buf), op_tokval,
    vstring_str(rite_op_buf))) == MAC_EXP_OP_RES_ERROR)
 mc->status |= MAC_PARSE_ERROR;
    vstring_free(left_op_buf);
    vstring_free(rite_op_buf);
    if (mc->status & MAC_PARSE_ERROR)
 return (mc->status);

    /*
     * Here, we fake up a non-empty or empty parameter value lookup result,
     * for compatibility with the historical code that looks named parameter
     * values.
     */
    if (mc->flags & MAC_EXP_FLAG_SCAN) {
 *lookup = 0;
    } else {
 switch (op_result) {
 case MAC_EXP_OP_RES_TRUE:
     *lookup = MAC_EXP_BVAL_TRUE;
     break;
 case MAC_EXP_OP_RES_FALSE:
     *lookup = MAC_EXP_BVAL_FALSE;
     break;
 default:
     msg_panic("mac_expand: unexpected operator result: %d", op_result);
 }
    }
    *bp = cp;
    return (0);
}

/* mac_expand_add_relop - register operator extensions */

void    mac_expand_add_relop(int *tok_list, const char *suffix,
                MAC_EXPAND_RELOP_FN relop_eval)
{
    const char myname[] = "mac_expand_add_relop";
    const char *tok_name;
    int    *tp;

    /*
     * Sanity checks.
     */
    if (!allalnum(suffix))
 msg_panic("%s: bad operator suffix: %s", myname, suffix);

    /*
     * One-time initialization.
     */
    if (mac_exp_ext_table == 0) {
 mac_exp_ext_table = htable_create(10);
 mac_exp_ext_key = vstring_alloc(10);
    }
    for (tp = tok_list; *tp; tp++) {
 if ((tok_name = str_name_code(mac_exp_op_table, *tp)) == 0)
     msg_panic("%s: unknown token code: %d", myname, *tp);
 vstring_sprintf(mac_exp_ext_key, "%s%s", tok_name, suffix);
 if (htable_locate(mac_exp_ext_table, STR(mac_exp_ext_key)) != 0)
     msg_panic("%s: duplicate key: %s", myname, STR(mac_exp_ext_key));
 (void) htable_enter(mac_exp_ext_table,
       STR(mac_exp_ext_key), (void *) relop_eval);
    }
}

/* mac_expand_add_named_fn - register named-function callback */

void    mac_expand_add_named_fn(const char *name, MAC_EXPAND_NAMED_FN action)
{
    struct mac_exp_named_fn_entry *xp;

    /*
     * Sanity checks.
     */
    if (!allalnumus(name))
 msg_panic("%s: bad function name: \"%s\"", __func__, name);

    /*
     * One-time initialization.
     */
    if (mac_exp_named_fn_table == 0)
 mac_exp_named_fn_table = htable_create(10);

    /*
     * The C language spec allows sizeof(void *) < sizeof(function pointer).
     */
    if (htable_locate(mac_exp_named_fn_table, name) != 0)
 msg_panic("%s: duplicate key: %s", __func__, name);
    xp = (struct mac_exp_named_fn_entry *) mymalloc(sizeof(*xp));
    xp->action = action;
    (void) htable_enter(mac_exp_named_fn_table, name, (void *) xp);
}

/* mac_exp_parse_function - interpolate result from caller-defined function */

static int mac_exp_parse_function(char *name_start, char *name_end,
              char *cp, MAC_EXP_CONTEXT *mc)
{
    char   *fn_arg;
    struct mac_exp_named_fn_entry *xp;
    VSTRING *buf = 0;

    /* cp is positioned at the '{', zero or more spaces after name_end. */
    if ((fn_arg = mac_exp_extract_curly_payload(mc, &cp, DO_STRIP_SPACE)) == 0)
 return (mc->status);
    if (*cp != 0)    /* garbage */
 MAC_EXP_ERR_RETURN(mc, "unexpected input at: "
      "\"...%s}>>>%.20s\"", fn_arg, cp);
    *name_end = 0;
    /* Look up the function and evaluate. */
    xp = (struct mac_exp_named_fn_entry *)
 htable_find(mac_exp_named_fn_table, name_start);
    if (xp == 0)
 MAC_EXP_ERR_RETURN(mc, "unknown function \"%s\" at"
   "\"...>>>%s{%s}\"", name_start, name_start, fn_arg);
    if ((mc->flags & MAC_EXP_FLAG_SCAN) == 0)
 buf = vstring_alloc(100);
    mc->status |=
 mac_expand(buf, fn_arg, mc->flags, mc->filter, mc->lookup,
     mc->context);
    if ((mc->flags & MAC_EXP_FLAG_SCAN) == 0) {
 if ((mc->status & MAC_PARSE_ERROR) == 0
     && xp->action(mc->result, vstring_str(buf)) == MAC_PARSE_ERROR)
     mc->status |= MAC_PARSE_ERROR;
 vstring_free(buf);
    }
    return (mc->status);
}

/* mac_expand_callback - callback for mac_parse */

static int mac_expand_callback(int type, VSTRING *buf, void *ptr)
{
    static const char myname[] = "mac_expand_callback";
    MAC_EXP_CONTEXT *mc = (MAC_EXP_CONTEXT *) ptr;
    int     lookup_mode;
    const char *lookup;
    char   *cp;
    int     ch;
    ssize_t res_len;
    ssize_t tmp_len;
    const char *res_iftrue;
    const char *res_iffalse;
    int     dont_parse = false;

    /*
     * Sanity check.
     */
    if (mc->level++ > 100)
 mac_exp_parse_error(mc, "unreasonable macro call nesting: \"%s\"",
       vstring_str(buf));
    if (mc->status & MAC_PARSE_ERROR)
 return (mc->status);

    /*
     * Named parameter, function call, or relational expression. In case of a
     * syntax error, return without doing damage, and issue a warning
     * instead.
     */
    if (type == MAC_PARSE_EXPR) {

 cp = vstring_str(buf);

 /*
  * Relational expression. If recursion is disabled, perform only one
  * level of $name expansion.
 */
 if (MAC_EXP_FIND_LEFT_CURLY(tmp_len, cp)) {
     if (mac_exp_parse_relational(mc, &lookup, &cp) != 0)
  return (mc->status);

     /*
      * Look for the ? or : operator.
     */
     if ((ch = *cp) != 0) {
  if (ch != '?' && ch != ':')
      MAC_EXP_ERR_RETURN(mc, "\"?\" or \":\" expected at: "
           "\"...}>>>%.20s\"", cp);
  cp++;
     }
 }

 /*
  * Named parameter or function call.
 */
 else {
     char   *start;

     /*
      * Collect the name of the parameter or function. Look for the ?
      * or : operator, or the '{' to indicate a function call. In case
      * of a syntax error, return without doing damage, and issue a
      * warning instead.
     */
     start = (cp += strspn(cp, MAC_EXP_WHITESPACE));
     for ( /* void */ ; /* void */ ; cp++) {
  if ((ch = cp[tmp_len = strspn(cp, MAC_EXP_WHITESPACE)]) == 0) {
      *cp = 0;
      lookup_mode = MAC_EXP_MODE_USE;
      break;
  }
  if (ch == '?' || ch == ':') {
      *cp++ = 0;
      cp += tmp_len;
      lookup_mode = MAC_EXP_MODE_TEST;
      break;
  }
  if (ch == '{')
      return (mac_exp_parse_function(start, cp, cp + tmp_len, mc));
  ch = *cp;
  if (!ISALNUM(ch) && ch != '_') {
      MAC_EXP_ERR_RETURN(mc, "attribute name syntax error at: "
           "\"...%.*s>>>%.20s\"",
           (int) (cp - vstring_str(buf)),
           vstring_str(buf), cp);
  }
     }

     /*
      * Look up the named parameter. Todo: allow the lookup function
      * to specify if the result is safe for $name expansion.
     */
     if (mc->dont_parse)
  dont_parse = mc->dont_parse(start, mc->context);
     lookup = mc->lookup(start, lookup_mode, mc->context);
 }

 /*
  * Return the requested result. After parsing the result operand
  * following ?, we fall through to parse the result operand following
  * :. This is necessary with the ternary ?: operator: first, with
  * MAC_EXP_FLAG_SCAN to parse both result operands with mac_parse(),
  * and second, to find garbage after any result operand. Without
  * MAC_EXP_FLAG_SCAN the content of only one of the ?: result
  * operands will be parsed with mac_parse(); syntax errors in the
  * other operand will be missed.
 */
 switch (ch) {
 case '?':
     if (MAC_EXP_FIND_LEFT_CURLY(tmp_len, cp)) {
  if ((res_iftrue = mac_exp_extract_curly_payload(mc, &cp,
            NO_STRIP_SPACE)) == 0)
      return (mc->status);
     } else {
  res_iftrue = cp;
  cp = "";   /* no left-over text */
     }
     if ((lookup != 0 && *lookup != 0) || (mc->flags & MAC_EXP_FLAG_SCAN))
  mc->status |= mac_parse(res_iftrue, mac_expand_callback,
     (void *) mc);
     if (*cp == 0)   /* end of input, OK */
  break;
     if (*cp != ':')   /* garbage */
  MAC_EXP_ERR_RETURN(mc, "\":\" expected at: "
       "\"...%s}>>>%.20s\"", res_iftrue, cp);
     cp += 1;
     /* FALLTHROUGH: do not remove, see comment above. */
 case ':':
     if (MAC_EXP_FIND_LEFT_CURLY(tmp_len, cp)) {
  if ((res_iffalse = mac_exp_extract_curly_payload(mc, &cp,
            NO_STRIP_SPACE)) == 0)
      return (mc->status);
     } else {
  res_iffalse = cp;
  cp = "";   /* no left-over text */
     }
     if (lookup == 0 || *lookup == 0 || (mc->flags & MAC_EXP_FLAG_SCAN))
  mc->status |= mac_parse(res_iffalse, mac_expand_callback,
     (void *) mc);
     if (*cp != 0)   /* garbage */
  MAC_EXP_ERR_RETURN(mc, "unexpected input at: "
       "\"...%s}>>>%.20s\"", res_iffalse, cp);
     break;
 case 0:
     if (lookup == 0) {
  mc->status |= MAC_PARSE_UNDEF;
     } else if (*lookup == 0 || (mc->flags & MAC_EXP_FLAG_SCAN)) {
   /* void */ ;
     } else if ((mc->flags & MAC_EXP_FLAG_RECURSE) && !dont_parse) {
  vstring_strcpy(buf, lookup);
  mc->status |= mac_parse(vstring_str(buf), mac_expand_callback,
     (void *) mc);
     } else {
  res_len = VSTRING_LEN(mc->result);
  vstring_strcat(mc->result, lookup);
  if (mc->flags & MAC_EXP_FLAG_PRINTABLE) {
      printable(vstring_str(mc->result) + res_len, '_');
  } else if (mc->filter) {
      cp = vstring_str(mc->result) + res_len;
      while (*(cp += strspn(cp, mc->filter)))
   *cp++ = '_';
  }
     }
     break;
 default:
     msg_panic("%s: unknown operator code %d", myname, ch);
 }
    }

    /*
     * Literal text.
     */
    else if ((mc->flags & MAC_EXP_FLAG_SCAN) == 0) {
 vstring_strcat(mc->result, vstring_str(buf));
    }
    mc->level--;

    return (mc->status);
}

 /*
  * ABI compatibility wrapper.
  */
#undef mac_expand
int     mac_expand(VSTRING *, const char *, int, const char *,
             MAC_EXP_LOOKUP_FN, void *);

/* mac_expand - expand $name instances */

int     mac_expand(VSTRING *result, const char *pattern, int flags,
             const char *filter,
             MAC_EXP_LOOKUP_FN lookup, void *context)
{
    return (mac_expand7(result, pattern, flags, filter, lookup,
   (MAC_EXP_DONT_PARSE_FN) 0, context));
}

int     mac_expand7(VSTRING *result, const char *pattern, int flags,
              const char *filter,
              MAC_EXP_LOOKUP_FN lookup,
              MAC_EXP_DONT_PARSE_FN dont_parse, void *context)
{

    MAC_EXP_CONTEXT mc;
    int     status;

    /*
     * Bundle up the request and do the substitutions.
     */
    mc.result = result;
    mc.flags = flags;
    mc.filter = filter;
    mc.lookup = lookup;
    mc.dont_parse = dont_parse;
    mc.context = context;
    mc.status = 0;
    mc.level = 0;
    if ((flags & (MAC_EXP_FLAG_APPEND | MAC_EXP_FLAG_SCAN)) == 0)
 VSTRING_RESET(result);
    status = mac_parse(pattern, mac_expand_callback, (void *) &mc);
    if ((flags & MAC_EXP_FLAG_SCAN) == 0)
 VSTRING_TERMINATE(result);

    return (status);
}

#ifdef TEST

 /*
  * This code certainly deserves a stand-alone test program.
  */
#include <stringops.h>
#include <htable.h>
#include <vstream.h>
#include <vstring_vstream.h>

static const char *lookup(const char *name, int unused_mode, void *context)
{
    HTABLE *table = (HTABLE *) context;

    return (htable_find(table, name));
}

static MAC_EXP_OP_RES length_relop_eval(const char *left, int relop,
             const char *rite)
{
    const char myname[] = "length_relop_eval";
    ssize_t delta = strlen(left) - strlen(rite);

    switch (relop) {
    case MAC_EXP_OP_TOK_EQ:
 return (mac_exp_op_res_bool[delta == 0]);
    case MAC_EXP_OP_TOK_NE:
 return (mac_exp_op_res_bool[delta != 0]);
    case MAC_EXP_OP_TOK_LT:
 return (mac_exp_op_res_bool[delta < 0]);
    case MAC_EXP_OP_TOK_LE:
 return (mac_exp_op_res_bool[delta <= 0]);
    case MAC_EXP_OP_TOK_GE:
 return (mac_exp_op_res_bool[delta >= 0]);
    case MAC_EXP_OP_TOK_GT:
 return (mac_exp_op_res_bool[delta > 0]);
    default:
 msg_panic("%s: unknown operator: %d",
    myname, relop);
    }
}

static int named_fn_eval(VSTRING *out, const char *in)
{
    vstring_sprintf_append(out, "-=oO%sOo=-", in);
    return (0);
}

int     main(int unused_argc, char **argv)
{
    VSTRING *buf = vstring_alloc(100);
    VSTRING *result = vstring_alloc(100);
    char   *cp;
    char   *name;
    char   *value;
    HTABLE *table;
    int     stat;
    int     length_relops[] = {
 MAC_EXP_OP_TOK_EQ, MAC_EXP_OP_TOK_NE,
 MAC_EXP_OP_TOK_GT, MAC_EXP_OP_TOK_GE,
 MAC_EXP_OP_TOK_LT, MAC_EXP_OP_TOK_LE,
 0,
    };

    /*
     * Add relops that compare string lengths instead of content.
     */
    mac_expand_add_relop(length_relops, "length", length_relop_eval);

    /*
     * Add a silly named function that decorates its argument.
     */
    mac_expand_add_named_fn("test_named_fn", named_fn_eval);

    /*
     * Loop over the inputs.
     */
    while (!vstream_feof(VSTREAM_IN)) {

 table = htable_create(0);

 /*
  * Read a block of definitions, terminated with an empty line.
 */
 while (vstring_get_nonl(buf, VSTREAM_IN) != VSTREAM_EOF) {
     vstream_printf("<< %s\n", vstring_str(buf));
     vstream_fflush(VSTREAM_OUT);
     if (VSTRING_LEN(buf) == 0)
  break;
     cp = vstring_str(buf);
     name = mystrtok(&cp, CHARS_SPACE "=");
     value = mystrtok(&cp, CHARS_SPACE "=");
     htable_enter(table, name, value ? mystrdup(value) : 0);
 }

 /*
  * Read a block of patterns, terminated with an empty line or EOF.
 */
 while (vstring_get_nonl(buf, VSTREAM_IN) != VSTREAM_EOF) {
     vstream_printf("<< %s\n", vstring_str(buf));
     vstream_fflush(VSTREAM_OUT);
     if (VSTRING_LEN(buf) == 0)
  break;
     cp = vstring_str(buf);
     VSTRING_RESET(result);
     stat = mac_expand(result, vstring_str(buf), MAC_EXP_FLAG_NONE,
         (char *) 0, lookup, (void *) table);
     vstream_printf("stat=%d result=%s\n", stat, vstring_str(result));
     vstream_fflush(VSTREAM_OUT);
 }
 htable_free(table, myfree);
 vstream_printf("\n");
    }

    /*
     * Clean up.
     */
    vstring_free(buf);
    vstring_free(result);
    exit(0);
}

#endif