2 * Copyright (c) 1998-2001, 2003 Sendmail, Inc. and its suppliers.
4 * Copyright (c) 1983, 1995-1997 Eric P. Allman. All rights reserved.
5 * Copyright (c) 1988, 1993
6 * The Regents of the University of California. All rights reserved.
8 * By using this file, you agree to the terms and conditions set
9 * forth in the LICENSE file which can be found at the top level of
10 * the sendmail distribution.
16 SM_RCSID("@(#)$Id: macro.c,v 8.88 2003/09/05 23:11:18 ca Exp $")
18 #if MAXMACROID != (BITMAPBITS - 1)
19 ERROR Read the comment in conf.h
20 #endif /* MAXMACROID != (BITMAPBITS - 1) */
22 static char *MacroName[MAXMACROID + 1]; /* macro id to name table */
23 int NextMacroId = 0240; /* codes for long named macros */
26 ** INITMACROS -- initialize the macro system
28 ** This just involves defining some macros that are actually
29 ** used internally as metasymbols to be themselves.
38 ** initializes several macros to be themselves.
41 struct metamac MetaMacros[] =
43 /* LHS pattern matching characters */
44 { '*', MATCHZANY }, { '+', MATCHANY }, { '-', MATCHONE },
45 { '=', MATCHCLASS }, { '~', MATCHNCLASS },
47 /* these are RHS metasymbols */
48 { '#', CANONNET }, { '@', CANONHOST }, { ':', CANONUSER },
51 /* the conditional operations */
52 { '?', CONDIF }, { '|', CONDELSE }, { '.', CONDFI },
54 /* the hostname lookup characters */
55 { '[', HOSTBEGIN }, { ']', HOSTEND },
56 { '(', LOOKUPBEGIN }, { ')', LOOKUPEND },
58 /* miscellaneous control characters */
59 { '&', MACRODEXPAND },
64 #define MACBINDING(name, mid) \
65 stab(name, ST_MACRO, ST_ENTER)->s_macro = mid; \
66 MacroName[mid] = name;
72 register struct metamac *m;
76 for (m = MetaMacros; m->metaname != '\0'; m++)
80 macdefine(&e->e_macro, A_TEMP, m->metaname, buf);
84 for (c = '0'; c <= '9'; c++)
87 macdefine(&e->e_macro, A_TEMP, c, buf);
90 /* set defaults for some macros sendmail will use later */
91 macdefine(&e->e_macro, A_PERM, 'n', "MAILER-DAEMON");
93 /* set up external names for some internal macros */
94 MACBINDING("opMode", MID_OPMODE);
95 /*XXX should probably add equivalents for all short macros here XXX*/
98 ** EXPAND -- macro expand a string using $x escapes.
101 ** s -- the string to expand.
102 ** buf -- the place to put the expansion.
103 ** bufsize -- the size of the buffer.
104 ** e -- envelope in which to work.
114 expand(s, buf, bufsize, e)
118 register ENVELOPE *e;
122 bool skipping; /* set if conditionally skipping output */
123 bool recurse; /* set if recursion required */
125 int skiplev; /* skipping nesting level */
126 int iflev; /* if nesting level */
127 char xbuf[MACBUFSIZE];
128 static int explevel = 0;
132 sm_dprintf("expand(");
133 xputs(sm_debug_file(), s);
143 for (xp = xbuf; *s != '\0'; s++)
148 ** Check for non-ordinary (special?) character.
149 ** 'q' will be the interpolated quantity.
156 case CONDIF: /* see if var set */
166 skipping = (mv == NULL || *mv == '\0');
170 case CONDELSE: /* change state of skipping */
172 break; /* XXX: error */
174 skipping = !skipping;
177 case CONDFI: /* stop skipping */
179 break; /* XXX: error */
187 case MACROEXPAND: /* macro interpolation */
202 ** Interpolate q or output one character
205 if (skipping || xp >= &xbuf[sizeof xbuf - 1])
211 /* copy to end of q or max space remaining in buf */
212 while ((c = *q++) != '\0' && xp < &xbuf[sizeof xbuf - 1])
214 /* check for any sendmail metacharacters */
215 if ((c & 0340) == 0200)
225 sm_dprintf("expand ==> ");
226 xputs(sm_debug_file(), xbuf);
230 /* recurse as appropriate */
233 if (explevel < MaxMacroRecursion)
236 expand(xbuf, buf, bufsize, e);
240 syserr("expand: recursion too deep (%d max)",
244 /* copy results out */
248 memmove(buf, xbuf, i);
253 ** MACDEFINE -- bind a macro name to a value
255 ** Set a macro to a value, with fancy storage management.
256 ** macdefine will make a copy of the value, if required,
257 ** and will ensure that the storage for the previous value
261 ** mac -- Macro table.
262 ** vclass -- storage class of 'value', ignored if value==NULL.
263 ** A_HEAP means that the value was allocated by
264 ** malloc, and that macdefine owns the storage.
265 ** A_TEMP means that value points to temporary storage,
266 ** and thus macdefine needs to make a copy.
267 ** A_PERM means that value points to storage that
268 ** will remain allocated and unchanged for
269 ** at least the lifetime of mac. Use A_PERM if:
271 ** -- value points to a string literal,
272 ** -- value was allocated from mac->mac_rpool
273 ** or (in the case of an envelope macro)
275 ** -- in the case of an envelope macro,
276 ** value is a string member of the envelope
277 ** such as e->e_sender.
278 ** id -- Macro id. This is a single character macro name
279 ** such as 'g', or a value returned by macid().
280 ** value -- Macro value: either NULL, or a string.
285 macdefine_tagged(mac, vclass, id, value, file, line, grp)
286 #else /* SM_HEAP_CHECK */
287 macdefine(mac, vclass, id, value)
288 #endif /* SM_HEAP_CHECK */
297 #endif /* SM_HEAP_CHECK */
301 if (id < 0 || id > MAXMACROID)
306 sm_dprintf("%sdefine(%s as ",
307 mac->mac_table[id] == NULL ? "" : "re", macname(id));
308 xputs(sm_debug_file(), value);
312 if (mac->mac_rpool == NULL)
316 if (mac->mac_table[id] != NULL &&
317 bitnset(id, mac->mac_allocated))
318 freeit = mac->mac_table[id];
320 if (value == NULL || vclass == A_HEAP)
322 sm_heap_checkptr_tagged(value, file, line);
324 clrbitn(id, mac->mac_allocated);
329 newvalue = sm_strdup_tagged_x(value, file, line, 0);
330 #else /* SM_HEAP_CHECK */
331 newvalue = sm_strdup_x(value);
332 #endif /* SM_HEAP_CHECK */
333 setbitn(id, mac->mac_allocated);
335 mac->mac_table[id] = newvalue;
341 if (value == NULL || vclass == A_PERM)
344 newvalue = sm_rpool_strdup_x(mac->mac_rpool, value);
345 mac->mac_table[id] = newvalue;
346 if (vclass == A_HEAP)
350 #if _FFR_RESET_MACRO_GLOBALS
354 PSTRSET(MyHostName, value);
357 #endif /* _FFR_RESET_MACRO_GLOBALS */
361 ** MACSET -- set a named macro to a value (low level)
363 ** No fancy storage management; the caller takes full responsibility.
364 ** Often used with macget; see also macdefine.
367 ** mac -- Macro table.
368 ** i -- Macro name, specified as an integer offset.
369 ** value -- Macro value: either NULL, or a string.
373 macset(mac, i, value)
378 if (i < 0 || i > MAXMACROID)
383 sm_dprintf("macset(%s as ", macname(i));
384 xputs(sm_debug_file(), value);
387 mac->mac_table[i] = value;
391 ** MACVALUE -- return uninterpreted value of a macro.
393 ** Does fancy path searching.
394 ** The low level counterpart is macget.
397 ** n -- the name of the macro.
398 ** e -- envelope in which to start looking for the macro.
410 register ENVELOPE *e;
413 if (e != NULL && e->e_mci != NULL)
415 register char *p = e->e_mci->mci_macro.mac_table[n];
422 register char *p = e->e_macro.mac_table[n];
426 if (e == e->e_parent)
430 return GlobalMacros.mac_table[n];
433 ** MACNAME -- return the name of a macro given its internal id
436 ** n -- the id of the macro
454 char *p = MacroName[n];
458 return "***UNDEFINED MACRO***";
465 ** MACID_PARSE -- return id of macro identified by its name
468 ** p -- pointer to name string -- either a single
469 ** character or {name}.
470 ** ep -- filled in with the pointer to the byte
474 ** 0 -- An error was detected.
475 ** 1..255 -- The internal id code for this macro.
478 ** If this is a new macro name, a new id is allocated.
479 ** On error, syserr is called.
489 char mbuf[MAXMACNAMELEN + 1];
493 sm_dprintf("macid(");
494 xputs(sm_debug_file(), p);
498 if (*p == '\0' || (p[0] == '{' && p[1] == '}'))
500 syserr("Name required for macro/class");
504 sm_dprintf("NULL\n");
509 /* the macro is its own code */
513 sm_dprintf("%c\n", bitidx(*p));
517 while (*++p != '\0' && *p != '}' && bp < &mbuf[sizeof mbuf - 1])
519 if (isascii(*p) && (isalnum(*p) || *p == '_'))
522 syserr("Invalid macro/class character %c", *p);
528 syserr("Unbalanced { on %s", mbuf); /* missing } */
532 syserr("Macro/class name ({%s}) too long (%d chars max)",
533 mbuf, (int) (sizeof mbuf - 1));
535 else if (mbuf[1] == '\0')
538 mid = bitidx(mbuf[0]);
545 s = stab(mbuf, ST_MACRO, ST_ENTER);
550 if (NextMacroId > MAXMACROID)
552 syserr("Macro/class {%s}: too many long names",
558 MacroName[NextMacroId] = s->s_name;
559 s->s_macro = mid = NextMacroId++;
566 if (mid < 0 || mid > MAXMACROID)
568 syserr("Unable to assign macro/class ID (mid = 0x%x)", mid);
570 sm_dprintf("NULL\n");
574 sm_dprintf("0x%x\n", mid);
578 ** WORDINCLASS -- tell if a word is in a specific class
581 ** str -- the name of the word to look up.
582 ** cl -- the class name.
585 ** true if str can be found in cl.
596 s = stab(str, ST_CLASS, ST_FIND);
597 return s != NULL && bitnset(bitidx(cl), s->s_class);