1 /* 2 * Copyright (c) 1998-2001, 2003, 2006, 2007 Sendmail, Inc. and its suppliers. 3 * All rights reserved. 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. 7 * 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. 11 * 12 */ 13 14 #include <sendmail.h> 15 16 SM_RCSID("@(#)$Id: macro.c,v 8.107 2007/08/06 22:29:02 ca Exp $") 17 18 #include <sm/sendmail.h> 19 #if MAXMACROID != (BITMAPBITS - 1) 20 ERROR Read the comment in conf.h 21 #endif /* MAXMACROID != (BITMAPBITS - 1) */ 22 23 static char *MacroName[MAXMACROID + 1]; /* macro id to name table */ 24 25 /* 26 ** Codes for long named macros. 27 ** See also macname(): 28 * if not ASCII printable, look up the name * 29 if (n <= 0x20 || n > 0x7f) 30 ** First use 1 to NEXTMACROID_L, then use NEXTMACROID_H to MAXMACROID. 31 */ 32 33 #define NEXTMACROID_L 037 34 #define NEXTMACROID_H 0240 35 36 #if _FFR_MORE_MACROS 37 /* table for next id in non-printable ASCII range: disallow some value */ 38 static int NextMIdTable[] = 39 { 40 /* 0 nul */ 1, 41 /* 1 soh */ 2, 42 /* 2 stx */ 3, 43 /* 3 etx */ 4, 44 /* 4 eot */ 5, 45 /* 5 enq */ 6, 46 /* 6 ack */ 7, 47 /* 7 bel */ 8, 48 /* 8 bs */ 14, 49 /* 9 ht */ -1, 50 /* 10 nl */ -1, 51 /* 11 vt */ -1, 52 /* 12 np */ -1, 53 /* 13 cr */ -1, 54 /* 14 so */ 15, 55 /* 15 si */ 16, 56 /* 16 dle */ 17, 57 /* 17 dc1 */ 18, 58 /* 18 dc2 */ 19, 59 /* 19 dc3 */ 20, 60 /* 20 dc4 */ 21, 61 /* 21 nak */ 22, 62 /* 22 syn */ 23, 63 /* 23 etb */ 24, 64 /* 24 can */ 25, 65 /* 25 em */ 26, 66 /* 26 sub */ 27, 67 /* 27 esc */ 28, 68 /* 28 fs */ 29, 69 /* 29 gs */ 30, 70 /* 30 rs */ 31, 71 /* 31 us */ 32, 72 /* 32 sp */ -1, 73 }; 74 75 #define NEXTMACROID(mid) ( \ 76 (mid < NEXTMACROID_L) ? (NextMIdTable[mid]) : \ 77 ((mid < NEXTMACROID_H) ? NEXTMACROID_H : (mid + 1))) 78 79 int NextMacroId = 1; /* codes for long named macros */ 80 /* see sendmail.h: Special characters in rewriting rules. */ 81 #else /* _FFR_MORE_MACROS */ 82 int NextMacroId = 0240; /* codes for long named macros */ 83 #define NEXTMACROID(mid) ((mid) + 1) 84 #endif /* _FFR_MORE_MACROS */ 85 86 87 /* 88 ** INITMACROS -- initialize the macro system 89 ** 90 ** This just involves defining some macros that are actually 91 ** used internally as metasymbols to be themselves. 92 ** 93 ** Parameters: 94 ** none. 95 ** 96 ** Returns: 97 ** none. 98 ** 99 ** Side Effects: 100 ** initializes several macros to be themselves. 101 */ 102 103 struct metamac MetaMacros[] = 104 { 105 /* LHS pattern matching characters */ 106 { '*', MATCHZANY }, { '+', MATCHANY }, { '-', MATCHONE }, 107 { '=', MATCHCLASS }, { '~', MATCHNCLASS }, 108 109 /* these are RHS metasymbols */ 110 { '#', CANONNET }, { '@', CANONHOST }, { ':', CANONUSER }, 111 { '>', CALLSUBR }, 112 113 /* the conditional operations */ 114 { '?', CONDIF }, { '|', CONDELSE }, { '.', CONDFI }, 115 116 /* the hostname lookup characters */ 117 { '[', HOSTBEGIN }, { ']', HOSTEND }, 118 { '(', LOOKUPBEGIN }, { ')', LOOKUPEND }, 119 120 /* miscellaneous control characters */ 121 { '&', MACRODEXPAND }, 122 123 { '\0', '\0' } 124 }; 125 126 #define MACBINDING(name, mid) \ 127 stab(name, ST_MACRO, ST_ENTER)->s_macro = mid; \ 128 MacroName[mid] = name; 129 130 void 131 initmacros(e) 132 ENVELOPE *e; 133 { 134 struct metamac *m; 135 int c; 136 char buf[5]; 137 138 for (m = MetaMacros; m->metaname != '\0'; m++) 139 { 140 buf[0] = m->metaval; 141 buf[1] = '\0'; 142 macdefine(&e->e_macro, A_TEMP, m->metaname, buf); 143 } 144 buf[0] = MATCHREPL; 145 buf[2] = '\0'; 146 for (c = '0'; c <= '9'; c++) 147 { 148 buf[1] = c; 149 macdefine(&e->e_macro, A_TEMP, c, buf); 150 } 151 152 /* set defaults for some macros sendmail will use later */ 153 macdefine(&e->e_macro, A_PERM, 'n', "MAILER-DAEMON"); 154 155 /* set up external names for some internal macros */ 156 MACBINDING("opMode", MID_OPMODE); 157 /*XXX should probably add equivalents for all short macros here XXX*/ 158 } 159 160 /* 161 ** EXPAND/DOEXPAND -- macro expand a string using $x escapes. 162 ** 163 ** After expansion, the expansion will be in external form (that is, 164 ** there will be no sendmail metacharacters and METAQUOTEs will have 165 ** been stripped out). 166 ** 167 ** Parameters: 168 ** s -- the string to expand. 169 ** buf -- the place to put the expansion. 170 ** bufsize -- the size of the buffer. 171 ** explevel -- the depth of expansion (doexpand only) 172 ** e -- envelope in which to work. 173 ** 174 ** Returns: 175 ** none. 176 ** 177 ** Side Effects: 178 ** none. 179 */ 180 181 static void doexpand __P(( char *, char *, size_t, int, ENVELOPE *)); 182 183 static void 184 doexpand(s, buf, bufsize, explevel, e) 185 char *s; 186 char *buf; 187 size_t bufsize; 188 int explevel; 189 ENVELOPE *e; 190 { 191 char *xp; 192 char *q; 193 bool skipping; /* set if conditionally skipping output */ 194 bool recurse; /* set if recursion required */ 195 size_t i; 196 int skiplev; /* skipping nesting level */ 197 int iflev; /* if nesting level */ 198 bool quotenext; /* quote the following character */ 199 char xbuf[MACBUFSIZE]; 200 201 if (tTd(35, 24)) 202 { 203 sm_dprintf("expand("); 204 xputs(sm_debug_file(), s); 205 sm_dprintf(")\n"); 206 } 207 208 recurse = false; 209 skipping = false; 210 skiplev = 0; 211 iflev = 0; 212 quotenext = false; 213 if (s == NULL) 214 s = ""; 215 for (xp = xbuf; *s != '\0'; s++) 216 { 217 int c; 218 219 /* 220 ** Check for non-ordinary (special?) character. 221 ** 'q' will be the interpolated quantity. 222 */ 223 224 q = NULL; 225 c = *s & 0377; 226 227 if (quotenext) 228 { 229 quotenext = false; 230 goto simpleinterpolate; 231 } 232 233 switch (c) 234 { 235 case CONDIF: /* see if var set */ 236 iflev++; 237 c = *++s & 0377; 238 if (skipping) 239 skiplev++; 240 else 241 { 242 char *mv; 243 244 mv = macvalue(c, e); 245 skipping = (mv == NULL || *mv == '\0'); 246 } 247 continue; 248 249 case CONDELSE: /* change state of skipping */ 250 if (iflev == 0) 251 break; /* XXX: error */ 252 if (skiplev == 0) 253 skipping = !skipping; 254 continue; 255 256 case CONDFI: /* stop skipping */ 257 if (iflev == 0) 258 break; /* XXX: error */ 259 iflev--; 260 if (skiplev == 0) 261 skipping = false; 262 if (skipping) 263 skiplev--; 264 continue; 265 266 case MACROEXPAND: /* macro interpolation */ 267 c = bitidx(*++s); 268 if (c != '\0') 269 q = macvalue(c, e); 270 else 271 { 272 s--; 273 q = NULL; 274 } 275 if (q == NULL) 276 continue; 277 break; 278 279 case METAQUOTE: 280 /* next octet completely quoted */ 281 quotenext = true; 282 break; 283 } 284 285 /* 286 ** Interpolate q or output one character 287 */ 288 289 simpleinterpolate: 290 if (skipping || xp >= &xbuf[sizeof(xbuf) - 1]) 291 continue; 292 if (q == NULL) 293 *xp++ = c; 294 else 295 { 296 /* copy to end of q or max space remaining in buf */ 297 bool hiderecurse = false; 298 299 while ((c = *q++) != '\0' && 300 xp < &xbuf[sizeof(xbuf) - 1]) 301 { 302 /* check for any sendmail metacharacters */ 303 if (!hiderecurse && (c & 0340) == 0200) 304 recurse = true; 305 *xp++ = c; 306 307 /* give quoted characters a free ride */ 308 hiderecurse = (c & 0377) == METAQUOTE; 309 } 310 } 311 } 312 *xp = '\0'; 313 314 if (tTd(35, 28)) 315 { 316 sm_dprintf("expand(%d) ==> ", explevel); 317 xputs(sm_debug_file(), xbuf); 318 sm_dprintf("\n"); 319 } 320 321 /* recurse as appropriate */ 322 if (recurse) 323 { 324 if (explevel < MaxMacroRecursion) 325 { 326 doexpand(xbuf, buf, bufsize, explevel + 1, e); 327 return; 328 } 329 syserr("expand: recursion too deep (%d max)", 330 MaxMacroRecursion); 331 } 332 333 /* copy results out */ 334 if (explevel == 0) 335 (void) sm_strlcpy(buf, xbuf, bufsize); 336 else 337 { 338 /* leave in internal form */ 339 i = xp - xbuf; 340 if (i >= bufsize) 341 i = bufsize - 1; 342 memmove(buf, xbuf, i); 343 buf[i] = '\0'; 344 } 345 346 if (tTd(35, 24)) 347 { 348 sm_dprintf("expand ==> "); 349 xputs(sm_debug_file(), buf); 350 sm_dprintf("\n"); 351 } 352 } 353 354 void 355 expand(s, buf, bufsize, e) 356 char *s; 357 char *buf; 358 size_t bufsize; 359 ENVELOPE *e; 360 { 361 doexpand(s, buf, bufsize, 0, e); 362 } 363 364 /* 365 ** MACDEFINE -- bind a macro name to a value 366 ** 367 ** Set a macro to a value, with fancy storage management. 368 ** macdefine will make a copy of the value, if required, 369 ** and will ensure that the storage for the previous value 370 ** is not leaked. 371 ** 372 ** Parameters: 373 ** mac -- Macro table. 374 ** vclass -- storage class of 'value', ignored if value==NULL. 375 ** A_HEAP means that the value was allocated by 376 ** malloc, and that macdefine owns the storage. 377 ** A_TEMP means that value points to temporary storage, 378 ** and thus macdefine needs to make a copy. 379 ** A_PERM means that value points to storage that 380 ** will remain allocated and unchanged for 381 ** at least the lifetime of mac. Use A_PERM if: 382 ** -- value == NULL, 383 ** -- value points to a string literal, 384 ** -- value was allocated from mac->mac_rpool 385 ** or (in the case of an envelope macro) 386 ** from e->e_rpool, 387 ** -- in the case of an envelope macro, 388 ** value is a string member of the envelope 389 ** such as e->e_sender. 390 ** id -- Macro id. This is a single character macro name 391 ** such as 'g', or a value returned by macid(). 392 ** value -- Macro value: either NULL, or a string. 393 */ 394 395 void 396 #if SM_HEAP_CHECK 397 macdefine_tagged(mac, vclass, id, value, file, line, grp) 398 #else /* SM_HEAP_CHECK */ 399 macdefine(mac, vclass, id, value) 400 #endif /* SM_HEAP_CHECK */ 401 MACROS_T *mac; 402 ARGCLASS_T vclass; 403 int id; 404 char *value; 405 #if SM_HEAP_CHECK 406 char *file; 407 int line; 408 int grp; 409 #endif /* SM_HEAP_CHECK */ 410 { 411 char *newvalue; 412 413 if (id < 0 || id > MAXMACROID) 414 return; 415 416 if (tTd(35, 9)) 417 { 418 sm_dprintf("%sdefine(%s as ", 419 mac->mac_table[id] == NULL ? "" : "re", macname(id)); 420 xputs(sm_debug_file(), value); 421 sm_dprintf(")\n"); 422 } 423 424 if (mac->mac_rpool == NULL) 425 { 426 char *freeit = NULL; 427 428 if (mac->mac_table[id] != NULL && 429 bitnset(id, mac->mac_allocated)) 430 freeit = mac->mac_table[id]; 431 432 if (value == NULL || vclass == A_HEAP) 433 { 434 sm_heap_checkptr_tagged(value, file, line); 435 newvalue = value; 436 clrbitn(id, mac->mac_allocated); 437 } 438 else 439 { 440 #if SM_HEAP_CHECK 441 newvalue = sm_strdup_tagged_x(value, file, line, 0); 442 #else /* SM_HEAP_CHECK */ 443 newvalue = sm_strdup_x(value); 444 #endif /* SM_HEAP_CHECK */ 445 setbitn(id, mac->mac_allocated); 446 } 447 mac->mac_table[id] = newvalue; 448 if (freeit != NULL) 449 sm_free(freeit); 450 } 451 else 452 { 453 if (value == NULL || vclass == A_PERM) 454 newvalue = value; 455 else 456 newvalue = sm_rpool_strdup_x(mac->mac_rpool, value); 457 mac->mac_table[id] = newvalue; 458 if (vclass == A_HEAP) 459 sm_free(value); 460 } 461 462 #if _FFR_RESET_MACRO_GLOBALS 463 switch (id) 464 { 465 case 'j': 466 PSTRSET(MyHostName, value); 467 break; 468 } 469 #endif /* _FFR_RESET_MACRO_GLOBALS */ 470 } 471 472 /* 473 ** MACSET -- set a named macro to a value (low level) 474 ** 475 ** No fancy storage management; the caller takes full responsibility. 476 ** Often used with macget; see also macdefine. 477 ** 478 ** Parameters: 479 ** mac -- Macro table. 480 ** i -- Macro name, specified as an integer offset. 481 ** value -- Macro value: either NULL, or a string. 482 */ 483 484 void 485 macset(mac, i, value) 486 MACROS_T *mac; 487 int i; 488 char *value; 489 { 490 if (i < 0 || i > MAXMACROID) 491 return; 492 493 if (tTd(35, 9)) 494 { 495 sm_dprintf("macset(%s as ", macname(i)); 496 xputs(sm_debug_file(), value); 497 sm_dprintf(")\n"); 498 } 499 mac->mac_table[i] = value; 500 } 501 502 /* 503 ** MACVALUE -- return uninterpreted value of a macro. 504 ** 505 ** Does fancy path searching. 506 ** The low level counterpart is macget. 507 ** 508 ** Parameters: 509 ** n -- the name of the macro. 510 ** e -- envelope in which to start looking for the macro. 511 ** 512 ** Returns: 513 ** The value of n. 514 ** 515 ** Side Effects: 516 ** none. 517 */ 518 519 char * 520 macvalue(n, e) 521 int n; 522 ENVELOPE *e; 523 { 524 n = bitidx(n); 525 if (e != NULL && e->e_mci != NULL) 526 { 527 char *p = e->e_mci->mci_macro.mac_table[n]; 528 529 if (p != NULL) 530 return p; 531 } 532 while (e != NULL) 533 { 534 char *p = e->e_macro.mac_table[n]; 535 536 if (p != NULL) 537 return p; 538 if (e == e->e_parent) 539 break; 540 e = e->e_parent; 541 } 542 return GlobalMacros.mac_table[n]; 543 } 544 545 /* 546 ** MACNAME -- return the name of a macro given its internal id 547 ** 548 ** Parameter: 549 ** n -- the id of the macro 550 ** 551 ** Returns: 552 ** The name of n. 553 ** 554 ** Side Effects: 555 ** none. 556 ** 557 ** WARNING: 558 ** Not thread-safe. 559 */ 560 561 char * 562 macname(n) 563 int n; 564 { 565 static char mbuf[2]; 566 567 n = (int)(unsigned char)n; 568 if (n > MAXMACROID) 569 return "***OUT OF RANGE MACRO***"; 570 571 /* if not ASCII printable, look up the name */ 572 if (n <= 0x20 || n > 0x7f) 573 { 574 char *p = MacroName[n]; 575 576 if (p != NULL) 577 return p; 578 return "***UNDEFINED MACRO***"; 579 } 580 581 /* if in the ASCII graphic range, just return the id directly */ 582 mbuf[0] = n; 583 mbuf[1] = '\0'; 584 return mbuf; 585 } 586 587 /* 588 ** MACID_PARSE -- return id of macro identified by its name 589 ** 590 ** Parameters: 591 ** p -- pointer to name string -- either a single 592 ** character or {name}. 593 ** ep -- filled in with the pointer to the byte 594 ** after the name. 595 ** 596 ** Returns: 597 ** 0 -- An error was detected. 598 ** 1..MAXMACROID -- The internal id code for this macro. 599 ** 600 ** Side Effects: 601 ** If this is a new macro name, a new id is allocated. 602 ** On error, syserr is called. 603 */ 604 605 int 606 macid_parse(p, ep) 607 char *p; 608 char **ep; 609 { 610 int mid; 611 char *bp; 612 char mbuf[MAXMACNAMELEN + 1]; 613 614 if (tTd(35, 14)) 615 { 616 sm_dprintf("macid("); 617 xputs(sm_debug_file(), p); 618 sm_dprintf(") => "); 619 } 620 621 if (*p == '\0' || (p[0] == '{' && p[1] == '}')) 622 { 623 syserr("Name required for macro/class"); 624 if (ep != NULL) 625 *ep = p; 626 if (tTd(35, 14)) 627 sm_dprintf("NULL\n"); 628 return 0; 629 } 630 if (*p != '{') 631 { 632 /* the macro is its own code */ 633 if (ep != NULL) 634 *ep = p + 1; 635 if (tTd(35, 14)) 636 { 637 char buf[2]; 638 639 buf[0] = *p; 640 buf[1] = '\0'; 641 xputs(sm_debug_file(), buf); 642 sm_dprintf("\n"); 643 } 644 return bitidx(*p); 645 } 646 bp = mbuf; 647 while (*++p != '\0' && *p != '}' && bp < &mbuf[sizeof(mbuf) - 1]) 648 { 649 if (isascii(*p) && (isalnum(*p) || *p == '_')) 650 *bp++ = *p; 651 else 652 syserr("Invalid macro/class character %c", *p); 653 } 654 *bp = '\0'; 655 mid = -1; 656 if (*p == '\0') 657 { 658 syserr("Unbalanced { on %s", mbuf); /* missing } */ 659 } 660 else if (*p != '}') 661 { 662 syserr("Macro/class name ({%s}) too long (%d chars max)", 663 mbuf, (int) (sizeof(mbuf) - 1)); 664 } 665 else if (mbuf[1] == '\0' && mbuf[0] >= 0x20) 666 { 667 /* ${x} == $x */ 668 mid = bitidx(mbuf[0]); 669 p++; 670 } 671 else 672 { 673 STAB *s; 674 675 s = stab(mbuf, ST_MACRO, ST_ENTER); 676 if (s->s_macro != 0) 677 mid = s->s_macro; 678 else 679 { 680 if (NextMacroId > MAXMACROID) 681 { 682 syserr("Macro/class {%s}: too many long names", 683 mbuf); 684 s->s_macro = -1; 685 } 686 else 687 { 688 MacroName[NextMacroId] = s->s_name; 689 s->s_macro = mid = NextMacroId; 690 NextMacroId = NEXTMACROID(NextMacroId); 691 } 692 } 693 p++; 694 } 695 if (ep != NULL) 696 *ep = p; 697 if (mid < 0 || mid > MAXMACROID) 698 { 699 syserr("Unable to assign macro/class ID (mid = 0x%x)", mid); 700 if (tTd(35, 14)) 701 sm_dprintf("NULL\n"); 702 return 0; 703 } 704 if (tTd(35, 14)) 705 sm_dprintf("0x%x\n", mid); 706 return mid; 707 } 708 709 /* 710 ** WORDINCLASS -- tell if a word is in a specific class 711 ** 712 ** Parameters: 713 ** str -- the name of the word to look up. 714 ** cl -- the class name. 715 ** 716 ** Returns: 717 ** true if str can be found in cl. 718 ** false otherwise. 719 */ 720 721 bool 722 wordinclass(str, cl) 723 char *str; 724 int cl; 725 { 726 STAB *s; 727 728 s = stab(str, ST_CLASS, ST_FIND); 729 return s != NULL && bitnset(bitidx(cl), s->s_class); 730 } 731