2 * Copyright (c) 1998-2001 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.86 2001/09/11 04:05:14 gshapiro 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(");
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 ==> ");
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));
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);
328 newvalue = sm_strdup_tagged_x(value, file, line, 0);
329 setbitn(id, mac->mac_allocated);
331 mac->mac_table[id] = newvalue;
337 if (value == NULL || vclass == A_PERM)
340 newvalue = sm_rpool_strdup_x(mac->mac_rpool, value);
341 mac->mac_table[id] = newvalue;
342 if (vclass == A_HEAP)
346 #if _FFR_RESET_MACRO_GLOBALS
350 PSTRSET(MyHostName, value);
353 #endif /* _FFR_RESET_MACRO_GLOBALS */
357 ** MACSET -- set a named macro to a value (low level)
359 ** No fancy storage management; the caller takes full responsibility.
360 ** Often used with macget; see also macdefine.
363 ** mac -- Macro table.
364 ** i -- Macro name, specified as an integer offset.
365 ** value -- Macro value: either NULL, or a string.
369 macset(mac, i, value)
374 if (i < 0 || i > MAXMACROID)
379 sm_dprintf("macset(%s as ", macname(i));
383 mac->mac_table[i] = value;
387 ** MACVALUE -- return uninterpreted value of a macro.
389 ** Does fancy path searching.
390 ** The low level counterpart is macget.
393 ** n -- the name of the macro.
394 ** e -- envelope in which to start looking for the macro.
406 register ENVELOPE *e;
409 if (e != NULL && e->e_mci != NULL)
411 register char *p = e->e_mci->mci_macro.mac_table[n];
418 register char *p = e->e_macro.mac_table[n];
422 if (e == e->e_parent)
426 return GlobalMacros.mac_table[n];
429 ** MACNAME -- return the name of a macro given its internal id
432 ** n -- the id of the macro
450 char *p = MacroName[n];
454 return "***UNDEFINED MACRO***";
461 ** MACID_PARSE -- return id of macro identified by its name
464 ** p -- pointer to name string -- either a single
465 ** character or {name}.
466 ** ep -- filled in with the pointer to the byte
470 ** 0 -- An error was detected.
471 ** 1..255 -- The internal id code for this macro.
474 ** If this is a new macro name, a new id is allocated.
475 ** On error, syserr is called.
485 char mbuf[MAXMACNAMELEN + 1];
489 sm_dprintf("macid(");
494 if (*p == '\0' || (p[0] == '{' && p[1] == '}'))
496 syserr("Name required for macro/class");
500 sm_dprintf("NULL\n");
505 /* the macro is its own code */
509 sm_dprintf("%c\n", bitidx(*p));
513 while (*++p != '\0' && *p != '}' && bp < &mbuf[sizeof mbuf - 1])
515 if (isascii(*p) && (isalnum(*p) || *p == '_'))
518 syserr("Invalid macro/class character %c", *p);
524 syserr("Unbalanced { on %s", mbuf); /* missing } */
528 syserr("Macro/class name ({%s}) too long (%d chars max)",
529 mbuf, (int) (sizeof mbuf - 1));
531 else if (mbuf[1] == '\0')
534 mid = bitidx(mbuf[0]);
541 s = stab(mbuf, ST_MACRO, ST_ENTER);
546 if (NextMacroId > MAXMACROID)
548 syserr("Macro/class {%s}: too many long names",
554 MacroName[NextMacroId] = s->s_name;
555 s->s_macro = mid = NextMacroId++;
562 if (mid < 0 || mid > MAXMACROID)
564 syserr("Unable to assign macro/class ID (mid = 0x%x)", mid);
566 sm_dprintf("NULL\n");
570 sm_dprintf("0x%x\n", mid);
574 ** WORDINCLASS -- tell if a word is in a specific class
577 ** str -- the name of the word to look up.
578 ** cl -- the class name.
581 ** true if str can be found in cl.
592 s = stab(str, ST_CLASS, ST_FIND);
593 return s != NULL && bitnset(bitidx(cl), s->s_class);