parseaddr.c revision 285303
1/* 2 * Copyright (c) 1998-2006 Proofpoint, 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 16SM_RCSID("@(#)$Id: parseaddr.c,v 8.407 2013-11-22 20:51:56 ca Exp $") 17 18#include <sm/sendmail.h> 19#include "map.h" 20 21static void allocaddr __P((ADDRESS *, int, char *, ENVELOPE *)); 22static int callsubr __P((char**, int, ENVELOPE *)); 23static char *map_lookup __P((STAB *, char *, char **, int *, ENVELOPE *)); 24static ADDRESS *buildaddr __P((char **, ADDRESS *, int, ENVELOPE *)); 25static bool hasctrlchar __P((register char *, bool, bool)); 26 27/* replacement for illegal characters in addresses */ 28#define BAD_CHAR_REPLACEMENT '?' 29 30/* 31** PARSEADDR -- Parse an address 32** 33** Parses an address and breaks it up into three parts: a 34** net to transmit the message on, the host to transmit it 35** to, and a user on that host. These are loaded into an 36** ADDRESS header with the values squirreled away if necessary. 37** The "user" part may not be a real user; the process may 38** just reoccur on that machine. For example, on a machine 39** with an arpanet connection, the address 40** csvax.bill@berkeley 41** will break up to a "user" of 'csvax.bill' and a host 42** of 'berkeley' -- to be transmitted over the arpanet. 43** 44** Parameters: 45** addr -- the address to parse. 46** a -- a pointer to the address descriptor buffer. 47** If NULL, an address will be created. 48** flags -- describe detail for parsing. See RF_ definitions 49** in sendmail.h. 50** delim -- the character to terminate the address, passed 51** to prescan. 52** delimptr -- if non-NULL, set to the location of the 53** delim character that was found. 54** e -- the envelope that will contain this address. 55** isrcpt -- true if the address denotes a recipient; false 56** indicates a sender. 57** 58** Returns: 59** A pointer to the address descriptor header (`a' if 60** `a' is non-NULL). 61** NULL on error. 62** 63** Side Effects: 64** e->e_to = addr 65*/ 66 67/* following delimiters are inherent to the internal algorithms */ 68#define DELIMCHARS "()<>,;\r\n" /* default word delimiters */ 69 70ADDRESS * 71parseaddr(addr, a, flags, delim, delimptr, e, isrcpt) 72 char *addr; 73 register ADDRESS *a; 74 int flags; 75 int delim; 76 char **delimptr; 77 register ENVELOPE *e; 78 bool isrcpt; 79{ 80 char **pvp; 81 auto char *delimptrbuf; 82 bool qup; 83 char pvpbuf[PSBUFSIZE]; 84 85 /* 86 ** Initialize and prescan address. 87 */ 88 89 e->e_to = addr; 90 if (tTd(20, 1)) 91 sm_dprintf("\n--parseaddr(%s)\n", addr); 92 93 if (delimptr == NULL) 94 delimptr = &delimptrbuf; 95 96 pvp = prescan(addr, delim, pvpbuf, sizeof(pvpbuf), delimptr, 97 ExtTokenTab, false); 98 if (pvp == NULL) 99 { 100 if (tTd(20, 1)) 101 sm_dprintf("parseaddr-->NULL\n"); 102 return NULL; 103 } 104 105 if (invalidaddr(addr, delim == '\0' ? NULL : *delimptr, isrcpt)) 106 { 107 if (tTd(20, 1)) 108 sm_dprintf("parseaddr-->bad address\n"); 109 return NULL; 110 } 111 112 /* 113 ** Save addr if we are going to have to. 114 ** 115 ** We have to do this early because there is a chance that 116 ** the map lookups in the rewriting rules could clobber 117 ** static memory somewhere. 118 */ 119 120 if (bitset(RF_COPYPADDR, flags) && addr != NULL) 121 { 122 char savec = **delimptr; 123 124 if (savec != '\0') 125 **delimptr = '\0'; 126 e->e_to = addr = sm_rpool_strdup_x(e->e_rpool, addr); 127 if (savec != '\0') 128 **delimptr = savec; 129 } 130 131 /* 132 ** Apply rewriting rules. 133 ** Ruleset 0 does basic parsing. It must resolve. 134 */ 135 136 qup = false; 137 if (REWRITE(pvp, 3, e) == EX_TEMPFAIL) 138 qup = true; 139 if (REWRITE(pvp, 0, e) == EX_TEMPFAIL) 140 qup = true; 141 142 /* 143 ** Build canonical address from pvp. 144 */ 145 146 a = buildaddr(pvp, a, flags, e); 147 148 if (hasctrlchar(a->q_user, isrcpt, true)) 149 { 150 if (tTd(20, 1)) 151 sm_dprintf("parseaddr-->bad q_user\n"); 152 153 /* 154 ** Just mark the address as bad so DSNs work. 155 ** hasctrlchar() has to make sure that the address 156 ** has been sanitized, e.g., shortened. 157 */ 158 159 a->q_state = QS_BADADDR; 160 } 161 162 /* 163 ** Make local copies of the host & user and then 164 ** transport them out. 165 */ 166 167 allocaddr(a, flags, addr, e); 168 if (QS_IS_BADADDR(a->q_state)) 169 { 170 /* weed out bad characters in the printable address too */ 171 (void) hasctrlchar(a->q_paddr, isrcpt, false); 172 return a; 173 } 174 175 /* 176 ** Select a queue directory for recipient addresses. 177 ** This is done here and in split_across_queue_groups(), 178 ** but the latter applies to addresses after aliasing, 179 ** and only if splitting is done. 180 */ 181 182 if ((a->q_qgrp == NOAQGRP || a->q_qgrp == ENVQGRP) && 183 !bitset(RF_SENDERADDR|RF_HEADERADDR|RF_RM_ADDR, flags) && 184 OpMode != MD_INITALIAS) 185 { 186 int r; 187 188 /* call ruleset which should return a queue group name */ 189 r = rscap(RS_QUEUEGROUP, a->q_user, NULL, e, &pvp, pvpbuf, 190 sizeof(pvpbuf)); 191 if (r == EX_OK && 192 pvp != NULL && pvp[0] != NULL && 193 (pvp[0][0] & 0377) == CANONNET && 194 pvp[1] != NULL && pvp[1][0] != '\0') 195 { 196 r = name2qid(pvp[1]); 197 if (r == NOQGRP && LogLevel > 10) 198 sm_syslog(LOG_INFO, NOQID, 199 "can't find queue group name %s, selection ignored", 200 pvp[1]); 201 if (tTd(20, 4) && r != NOQGRP) 202 sm_syslog(LOG_INFO, NOQID, 203 "queue group name %s -> %d", 204 pvp[1], r); 205 a->q_qgrp = r == NOQGRP ? ENVQGRP : r; 206 } 207 } 208 209 /* 210 ** If there was a parsing failure, mark it for queueing. 211 */ 212 213 if (qup && OpMode != MD_INITALIAS) 214 { 215 char *msg = "Transient parse error -- message queued for future delivery"; 216 217 if (e->e_sendmode == SM_DEFER) 218 msg = "Deferring message until queue run"; 219 if (tTd(20, 1)) 220 sm_dprintf("parseaddr: queueing message\n"); 221 message(msg); 222 if (e->e_message == NULL && e->e_sendmode != SM_DEFER) 223 e->e_message = sm_rpool_strdup_x(e->e_rpool, msg); 224 a->q_state = QS_QUEUEUP; 225 a->q_status = "4.4.3"; 226 } 227 228 /* 229 ** Compute return value. 230 */ 231 232 if (tTd(20, 1)) 233 { 234 sm_dprintf("parseaddr-->"); 235 printaddr(sm_debug_file(), a, false); 236 } 237 238 return a; 239} 240/* 241** INVALIDADDR -- check for address containing characters used for macros 242** 243** Parameters: 244** addr -- the address to check. 245** note: this is the complete address (including display part) 246** delimptr -- if non-NULL: end of address to check, i.e., 247** a pointer in the address string. 248** isrcpt -- true iff the address is for a recipient. 249** 250** Returns: 251** true -- if the address has characters that are reservered 252** for macros or is too long. 253** false -- otherwise. 254*/ 255 256bool 257invalidaddr(addr, delimptr, isrcpt) 258 register char *addr; 259 char *delimptr; 260 bool isrcpt; 261{ 262 bool result = false; 263 char savedelim = '\0'; 264 char *b = addr; 265 int len = 0; 266 267 if (delimptr != NULL) 268 { 269 /* delimptr points to the end of the address to test */ 270 savedelim = *delimptr; 271 if (savedelim != '\0') /* if that isn't '\0' already: */ 272 *delimptr = '\0'; /* set it */ 273 } 274 for (; *addr != '\0'; addr++) 275 { 276 if (!EightBitAddrOK && (*addr & 0340) == 0200) 277 { 278 setstat(EX_USAGE); 279 result = true; 280 *addr = BAD_CHAR_REPLACEMENT; 281 } 282 if (++len > MAXNAME - 1) 283 { 284 char saved = *addr; 285 286 *addr = '\0'; 287 usrerr("553 5.1.0 Address \"%s\" too long (%d bytes max)", 288 b, MAXNAME - 1); 289 *addr = saved; 290 result = true; 291 goto delim; 292 } 293 } 294 if (result) 295 { 296 if (isrcpt) 297 usrerr("501 5.1.3 8-bit character in mailbox address \"%s\"", 298 b); 299 else 300 usrerr("501 5.1.7 8-bit character in mailbox address \"%s\"", 301 b); 302 } 303delim: 304 if (delimptr != NULL && savedelim != '\0') 305 *delimptr = savedelim; /* restore old character at delimptr */ 306 return result; 307} 308/* 309** HASCTRLCHAR -- check for address containing meta-characters 310** 311** Checks that the address contains no meta-characters, and contains 312** no "non-printable" characters unless they are quoted or escaped. 313** Quoted or escaped characters are literals. 314** 315** Parameters: 316** addr -- the address to check. 317** isrcpt -- true if the address is for a recipient; false 318** indicates a from. 319** complain -- true if an error should issued if the address 320** is invalid and should be "repaired". 321** 322** Returns: 323** true -- if the address has any "weird" characters or 324** non-printable characters or if a quote is unbalanced. 325** false -- otherwise. 326*/ 327 328static bool 329hasctrlchar(addr, isrcpt, complain) 330 register char *addr; 331 bool isrcpt, complain; 332{ 333 bool quoted = false; 334 int len = 0; 335 char *result = NULL; 336 char *b = addr; 337 338 if (addr == NULL) 339 return false; 340 for (; *addr != '\0'; addr++) 341 { 342 if (++len > MAXNAME - 1) 343 { 344 if (complain) 345 { 346 (void) shorten_rfc822_string(b, MAXNAME - 1); 347 usrerr("553 5.1.0 Address \"%s\" too long (%d bytes max)", 348 b, MAXNAME - 1); 349 return true; 350 } 351 result = "too long"; 352 } 353 if (!EightBitAddrOK && !quoted && (*addr < 32 || *addr == 127)) 354 { 355 result = "non-printable character"; 356 *addr = BAD_CHAR_REPLACEMENT; 357 continue; 358 } 359 if (*addr == '"') 360 quoted = !quoted; 361 else if (*addr == '\\') 362 { 363 /* XXX Generic problem: no '\0' in strings. */ 364 if (*++addr == '\0') 365 { 366 result = "trailing \\ character"; 367 *--addr = BAD_CHAR_REPLACEMENT; 368 break; 369 } 370 } 371 if (!EightBitAddrOK && (*addr & 0340) == 0200) 372 { 373 setstat(EX_USAGE); 374 result = "8-bit character"; 375 *addr = BAD_CHAR_REPLACEMENT; 376 continue; 377 } 378 } 379 if (quoted) 380 result = "unbalanced quote"; /* unbalanced quote */ 381 if (result != NULL && complain) 382 { 383 if (isrcpt) 384 usrerr("501 5.1.3 Syntax error in mailbox address \"%s\" (%s)", 385 b, result); 386 else 387 usrerr("501 5.1.7 Syntax error in mailbox address \"%s\" (%s)", 388 b, result); 389 } 390 return result != NULL; 391} 392/* 393** ALLOCADDR -- do local allocations of address on demand. 394** 395** Also lowercases the host name if requested. 396** 397** Parameters: 398** a -- the address to reallocate. 399** flags -- the copy flag (see RF_ definitions in sendmail.h 400** for a description). 401** paddr -- the printname of the address. 402** e -- envelope 403** 404** Returns: 405** none. 406** 407** Side Effects: 408** Copies portions of a into local buffers as requested. 409*/ 410 411static void 412allocaddr(a, flags, paddr, e) 413 register ADDRESS *a; 414 int flags; 415 char *paddr; 416 ENVELOPE *e; 417{ 418 if (tTd(24, 4)) 419 sm_dprintf("allocaddr(flags=%x, paddr=%s)\n", flags, paddr); 420 421 a->q_paddr = paddr; 422 423 if (a->q_user == NULL) 424 a->q_user = ""; 425 if (a->q_host == NULL) 426 a->q_host = ""; 427 428 if (bitset(RF_COPYPARSE, flags)) 429 { 430 a->q_host = sm_rpool_strdup_x(e->e_rpool, a->q_host); 431 if (a->q_user != a->q_paddr) 432 a->q_user = sm_rpool_strdup_x(e->e_rpool, a->q_user); 433 } 434 435 if (a->q_paddr == NULL) 436 a->q_paddr = sm_rpool_strdup_x(e->e_rpool, a->q_user); 437 a->q_qgrp = NOAQGRP; 438} 439 440/* 441** PRESCAN -- Prescan name and make it canonical 442** 443** Scans a name and turns it into a set of tokens. This process 444** deletes blanks and comments (in parentheses) (if the token type 445** for left paren is SPC). 446** 447** This routine knows about quoted strings and angle brackets. 448** 449** There are certain subtleties to this routine. The one that 450** comes to mind now is that backslashes on the ends of names 451** are silently stripped off; this is intentional. The problem 452** is that some versions of sndmsg (like at LBL) set the kill 453** character to something other than @ when reading addresses; 454** so people type "csvax.eric\@berkeley" -- which screws up the 455** berknet mailer. 456** 457** Parameters: 458** addr -- the name to chomp. 459** delim -- the delimiter for the address, normally 460** '\0' or ','; \0 is accepted in any case. 461** If '\t' then we are reading the .cf file. 462** pvpbuf -- place to put the saved text -- note that 463** the pointers are static. 464** pvpbsize -- size of pvpbuf. 465** delimptr -- if non-NULL, set to the location of the 466** terminating delimiter. 467** toktab -- if set, a token table to use for parsing. 468** If NULL, use the default table. 469** ignore -- if true, ignore unbalanced addresses 470** 471** Returns: 472** A pointer to a vector of tokens. 473** NULL on error. 474*/ 475 476/* states and character types */ 477#define OPR 0 /* operator */ 478#define ATM 1 /* atom */ 479#define QST 2 /* in quoted string */ 480#define SPC 3 /* chewing up spaces */ 481#define ONE 4 /* pick up one character */ 482#define ILL 5 /* illegal character */ 483 484#define NSTATES 6 /* number of states */ 485#define TYPE 017 /* mask to select state type */ 486 487/* meta bits for table */ 488#define M 020 /* meta character; don't pass through */ 489#define B 040 /* cause a break */ 490#define MB M|B /* meta-break */ 491 492static short StateTab[NSTATES][NSTATES] = 493{ 494 /* oldst chtype> OPR ATM QST SPC ONE ILL */ 495 /*OPR*/ { OPR|B, ATM|B, QST|B, SPC|MB, ONE|B, ILL|MB }, 496 /*ATM*/ { OPR|B, ATM, QST|B, SPC|MB, ONE|B, ILL|MB }, 497 /*QST*/ { QST, QST, OPR, QST, QST, QST }, 498 /*SPC*/ { OPR, ATM, QST, SPC|M, ONE, ILL|MB }, 499 /*ONE*/ { OPR, OPR, OPR, OPR, OPR, ILL|MB }, 500 /*ILL*/ { OPR|B, ATM|B, QST|B, SPC|MB, ONE|B, ILL|M } 501}; 502 503/* these all get modified with the OperatorChars */ 504 505/* token type table for external strings */ 506unsigned char ExtTokenTab[256] = 507{ 508 /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */ 509 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,SPC,SPC,SPC,SPC,SPC,ATM,ATM, 510 /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us */ 511 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 512 /* sp ! " # $ % & ' ( ) * + , - . / */ 513 SPC,ATM,QST,ATM,ATM,ATM,ATM,ATM, SPC,SPC,ATM,ATM,ATM,ATM,ATM,ATM, 514 /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */ 515 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 516 /* @ A B C D E F G H I J K L M N O */ 517 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 518 /* P Q R S T U V W X Y Z [ \ ] ^ _ */ 519 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 520 /* ` a b c d e f g h i j k l m n o */ 521 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 522 /* p q r s t u v w x y z { | } ~ del */ 523 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 524 525 /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */ 526 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 527 /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us */ 528 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 529 /* sp ! " # $ % & ' ( ) * + , - . / */ 530 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 531 /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */ 532 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 533 /* @ A B C D E F G H I J K L M N O */ 534 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 535 /* P Q R S T U V W X Y Z [ \ ] ^ _ */ 536 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 537 /* ` a b c d e f g h i j k l m n o */ 538 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 539 /* p q r s t u v w x y z { | } ~ del */ 540 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM 541}; 542 543/* token type table for internal strings */ 544unsigned char IntTokenTab[256] = 545{ 546 /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */ 547 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,SPC,SPC,SPC,SPC,SPC,ATM,ATM, 548 /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us */ 549 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 550 /* sp ! " # $ % & ' ( ) * + , - . / */ 551 SPC,ATM,QST,ATM,ATM,ATM,ATM,ATM, SPC,SPC,ATM,ATM,ATM,ATM,ATM,ATM, 552 /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */ 553 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 554 /* @ A B C D E F G H I J K L M N O */ 555 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 556 /* P Q R S T U V W X Y Z [ \ ] ^ _ */ 557 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 558 /* ` a b c d e f g h i j k l m n o */ 559 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 560 /* p q r s t u v w x y z { | } ~ del */ 561 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 562 563 /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */ 564 OPR,OPR,ONE,OPR,OPR,OPR,OPR,OPR, OPR,OPR,OPR,OPR,OPR,OPR,OPR,OPR, 565 /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us */ 566 OPR,OPR,OPR,ONE,ONE,ONE,OPR,OPR, OPR,OPR,OPR,OPR,OPR,OPR,OPR,OPR, 567 /* sp ! " # $ % & ' ( ) * + , - . / */ 568 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 569 /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */ 570 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 571 /* @ A B C D E F G H I J K L M N O */ 572 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 573 /* P Q R S T U V W X Y Z [ \ ] ^ _ */ 574 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 575 /* ` a b c d e f g h i j k l m n o */ 576 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 577 /* p q r s t u v w x y z { | } ~ del */ 578 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ONE 579}; 580 581/* token type table for MIME parsing */ 582unsigned char MimeTokenTab[256] = 583{ 584 /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */ 585 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,SPC,SPC,SPC,SPC,SPC,ILL,ILL, 586 /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us */ 587 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, 588 /* sp ! " # $ % & ' ( ) * + , - . / */ 589 SPC,ATM,QST,ATM,ATM,ATM,ATM,ATM, SPC,SPC,ATM,ATM,OPR,ATM,ATM,OPR, 590 /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */ 591 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,OPR,OPR,OPR,OPR,OPR,OPR, 592 /* @ A B C D E F G H I J K L M N O */ 593 OPR,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 594 /* P Q R S T U V W X Y Z [ \ ] ^ _ */ 595 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,OPR,OPR,OPR,ATM,ATM, 596 /* ` a b c d e f g h i j k l m n o */ 597 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 598 /* p q r s t u v w x y z { | } ~ del */ 599 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 600 601 /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */ 602 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, 603 /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us */ 604 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, 605 /* sp ! " # $ % & ' ( ) * + , - . / */ 606 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, 607 /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */ 608 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, 609 /* @ A B C D E F G H I J K L M N O */ 610 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, 611 /* P Q R S T U V W X Y Z [ \ ] ^ _ */ 612 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, 613 /* ` a b c d e f g h i j k l m n o */ 614 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, 615 /* p q r s t u v w x y z { | } ~ del */ 616 ILL,ILL,ILL,ILL,ILL,ILL,ILL,ILL, ILL,ILL,ILL,ILL,ILL,ILL,ILL,ONE 617}; 618 619/* token type table: don't strip comments */ 620unsigned char TokTypeNoC[256] = 621{ 622 /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */ 623 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,SPC,SPC,SPC,SPC,SPC,ATM,ATM, 624 /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us */ 625 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 626 /* sp ! " # $ % & ' ( ) * + , - . / */ 627 SPC,ATM,QST,ATM,ATM,ATM,ATM,ATM, OPR,OPR,ATM,ATM,ATM,ATM,ATM,ATM, 628 /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */ 629 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 630 /* @ A B C D E F G H I J K L M N O */ 631 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 632 /* P Q R S T U V W X Y Z [ \ ] ^ _ */ 633 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 634 /* ` a b c d e f g h i j k l m n o */ 635 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 636 /* p q r s t u v w x y z { | } ~ del */ 637 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 638 639 /* nul soh stx etx eot enq ack bel bs ht nl vt np cr so si */ 640 OPR,OPR,ONE,OPR,OPR,OPR,OPR,OPR, OPR,OPR,OPR,OPR,OPR,OPR,OPR,OPR, 641 /* dle dc1 dc2 dc3 dc4 nak syn etb can em sub esc fs gs rs us */ 642 OPR,OPR,OPR,ONE,ONE,ONE,OPR,OPR, OPR,OPR,OPR,OPR,OPR,OPR,OPR,OPR, 643 /* sp ! " # $ % & ' ( ) * + , - . / */ 644 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 645 /* 0 1 2 3 4 5 6 7 8 9 : ; < = > ? */ 646 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 647 /* @ A B C D E F G H I J K L M N O */ 648 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 649 /* P Q R S T U V W X Y Z [ \ ] ^ _ */ 650 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 651 /* ` a b c d e f g h i j k l m n o */ 652 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, 653 /* p q r s t u v w x y z { | } ~ del */ 654 ATM,ATM,ATM,ATM,ATM,ATM,ATM,ATM, ATM,ATM,ATM,ATM,ATM,ATM,ATM,ONE 655}; 656 657 658#define NOCHAR (-1) /* signal nothing in lookahead token */ 659 660char ** 661prescan(addr, delim, pvpbuf, pvpbsize, delimptr, toktab, ignore) 662 char *addr; 663 int delim; 664 char pvpbuf[]; 665 int pvpbsize; 666 char **delimptr; 667 unsigned char *toktab; 668 bool ignore; 669{ 670 register char *p; 671 register char *q; 672 register int c; 673 char **avp; 674 bool bslashmode; 675 bool route_syntax; 676 int cmntcnt; 677 int anglecnt; 678 char *tok; 679 int state; 680 int newstate; 681 char *saveto = CurEnv->e_to; 682 static char *av[MAXATOM + 1]; 683 static bool firsttime = true; 684 685 if (firsttime) 686 { 687 /* initialize the token type table */ 688 char obuf[50]; 689 690 firsttime = false; 691 if (OperatorChars == NULL) 692 { 693 if (ConfigLevel < 7) 694 OperatorChars = macvalue('o', CurEnv); 695 if (OperatorChars == NULL) 696 OperatorChars = ".:@[]"; 697 } 698 expand(OperatorChars, obuf, sizeof(obuf) - sizeof(DELIMCHARS), 699 CurEnv); 700 (void) sm_strlcat(obuf, DELIMCHARS, sizeof(obuf)); 701 for (p = obuf; *p != '\0'; p++) 702 { 703 if (IntTokenTab[*p & 0xff] == ATM) 704 IntTokenTab[*p & 0xff] = OPR; 705 if (ExtTokenTab[*p & 0xff] == ATM) 706 ExtTokenTab[*p & 0xff] = OPR; 707 if (TokTypeNoC[*p & 0xff] == ATM) 708 TokTypeNoC[*p & 0xff] = OPR; 709 } 710 } 711 if (toktab == NULL) 712 toktab = ExtTokenTab; 713 714 /* make sure error messages don't have garbage on them */ 715 errno = 0; 716 717 q = pvpbuf; 718 bslashmode = false; 719 route_syntax = false; 720 cmntcnt = 0; 721 anglecnt = 0; 722 avp = av; 723 state = ATM; 724 c = NOCHAR; 725 p = addr; 726 CurEnv->e_to = p; 727 if (tTd(22, 11)) 728 { 729 sm_dprintf("prescan: "); 730 xputs(sm_debug_file(), p); 731 sm_dprintf("\n"); 732 } 733 734 do 735 { 736 /* read a token */ 737 tok = q; 738 for (;;) 739 { 740 /* store away any old lookahead character */ 741 if (c != NOCHAR && !bslashmode) 742 { 743 /* see if there is room */ 744 if (q >= &pvpbuf[pvpbsize - 5]) 745 { 746 addrtoolong: 747 usrerr("553 5.1.1 Address too long"); 748 if (strlen(addr) > MAXNAME) 749 addr[MAXNAME] = '\0'; 750 returnnull: 751 if (delimptr != NULL) 752 { 753 if (p > addr) 754 --p; 755 *delimptr = p; 756 } 757 CurEnv->e_to = saveto; 758 return NULL; 759 } 760 761 /* squirrel it away */ 762#if !ALLOW_255 763 if ((char) c == (char) -1 && !tTd(82, 101) && 764 !EightBitAddrOK) 765 c &= 0x7f; 766#endif /* !ALLOW_255 */ 767 *q++ = c; 768 } 769 770 /* read a new input character */ 771 c = (*p++) & 0x00ff; 772 if (c == '\0') 773 { 774 /* diagnose and patch up bad syntax */ 775 if (ignore) 776 break; 777 else if (state == QST) 778 { 779 usrerr("553 Unbalanced '\"'"); 780 c = '"'; 781 } 782 else if (cmntcnt > 0) 783 { 784 usrerr("553 Unbalanced '('"); 785 c = ')'; 786 } 787 else if (anglecnt > 0) 788 { 789 c = '>'; 790 usrerr("553 Unbalanced '<'"); 791 } 792 else 793 break; 794 795 p--; 796 } 797 else if (c == delim && cmntcnt <= 0 && state != QST) 798 { 799 if (anglecnt <= 0) 800 break; 801 802 /* special case for better error management */ 803 if (delim == ',' && !route_syntax && !ignore) 804 { 805 usrerr("553 Unbalanced '<'"); 806 c = '>'; 807 p--; 808 } 809 } 810 811 if (tTd(22, 101)) 812 sm_dprintf("c=%c, s=%d; ", c, state); 813 814 /* chew up special characters */ 815 *q = '\0'; 816 if (bslashmode) 817 { 818 bslashmode = false; 819 820 /* kludge \! for naive users */ 821 if (cmntcnt > 0) 822 { 823 c = NOCHAR; 824 continue; 825 } 826 else if (c != '!' || state == QST) 827 { 828 /* see if there is room */ 829 if (q >= &pvpbuf[pvpbsize - 5]) 830 goto addrtoolong; 831 *q++ = '\\'; 832 continue; 833 } 834 } 835 836 if (c == '\\') 837 { 838 bslashmode = true; 839 } 840 else if (state == QST) 841 { 842 /* EMPTY */ 843 /* do nothing, just avoid next clauses */ 844 } 845 else if (c == '(' && toktab['('] == SPC) 846 { 847 cmntcnt++; 848 c = NOCHAR; 849 } 850 else if (c == ')' && toktab['('] == SPC) 851 { 852 if (cmntcnt <= 0) 853 { 854 if (!ignore) 855 { 856 usrerr("553 Unbalanced ')'"); 857 c = NOCHAR; 858 } 859 } 860 else 861 cmntcnt--; 862 } 863 else if (cmntcnt > 0) 864 { 865 c = NOCHAR; 866 } 867 else if (c == '<') 868 { 869 char *ptr = p; 870 871 anglecnt++; 872 while (isascii(*ptr) && isspace(*ptr)) 873 ptr++; 874 if (*ptr == '@') 875 route_syntax = true; 876 } 877 else if (c == '>') 878 { 879 if (anglecnt <= 0) 880 { 881 if (!ignore) 882 { 883 usrerr("553 Unbalanced '>'"); 884 c = NOCHAR; 885 } 886 } 887 else 888 anglecnt--; 889 route_syntax = false; 890 } 891 else if (delim == ' ' && isascii(c) && isspace(c)) 892 c = ' '; 893 894 if (c == NOCHAR) 895 continue; 896 897 /* see if this is end of input */ 898 if (c == delim && anglecnt <= 0 && state != QST) 899 break; 900 901 newstate = StateTab[state][toktab[c & 0xff]]; 902 if (tTd(22, 101)) 903 sm_dprintf("ns=%02o\n", newstate); 904 state = newstate & TYPE; 905 if (state == ILL) 906 { 907 if (isascii(c) && isprint(c)) 908 usrerr("553 Illegal character %c", c); 909 else 910 usrerr("553 Illegal character 0x%02x", 911 c & 0x0ff); 912 } 913 if (bitset(M, newstate)) 914 c = NOCHAR; 915 if (bitset(B, newstate)) 916 break; 917 } 918 919 /* new token */ 920 if (tok != q) 921 { 922 /* see if there is room */ 923 if (q >= &pvpbuf[pvpbsize - 5]) 924 goto addrtoolong; 925 *q++ = '\0'; 926 if (tTd(22, 36)) 927 { 928 sm_dprintf("tok="); 929 xputs(sm_debug_file(), tok); 930 sm_dprintf("\n"); 931 } 932 if (avp >= &av[MAXATOM]) 933 { 934 usrerr("553 5.1.0 prescan: too many tokens"); 935 goto returnnull; 936 } 937 if (q - tok > MAXNAME) 938 { 939 usrerr("553 5.1.0 prescan: token too long"); 940 goto returnnull; 941 } 942 *avp++ = tok; 943 } 944 } while (c != '\0' && (c != delim || anglecnt > 0)); 945 *avp = NULL; 946 if (delimptr != NULL) 947 { 948 if (p > addr) 949 p--; 950 *delimptr = p; 951 } 952 if (tTd(22, 12)) 953 { 954 sm_dprintf("prescan==>"); 955 printav(sm_debug_file(), av); 956 } 957 CurEnv->e_to = saveto; 958 if (av[0] == NULL) 959 { 960 if (tTd(22, 1)) 961 sm_dprintf("prescan: null leading token\n"); 962 return NULL; 963 } 964 return av; 965} 966/* 967** REWRITE -- apply rewrite rules to token vector. 968** 969** This routine is an ordered production system. Each rewrite 970** rule has a LHS (called the pattern) and a RHS (called the 971** rewrite); 'rwr' points the the current rewrite rule. 972** 973** For each rewrite rule, 'avp' points the address vector we 974** are trying to match against, and 'pvp' points to the pattern. 975** If pvp points to a special match value (MATCHZANY, MATCHANY, 976** MATCHONE, MATCHCLASS, MATCHNCLASS) then the address in avp 977** matched is saved away in the match vector (pointed to by 'mvp'). 978** 979** When a match between avp & pvp does not match, we try to 980** back out. If we back up over MATCHONE, MATCHCLASS, or MATCHNCLASS 981** we must also back out the match in mvp. If we reach a 982** MATCHANY or MATCHZANY we just extend the match and start 983** over again. 984** 985** When we finally match, we rewrite the address vector 986** and try over again. 987** 988** Parameters: 989** pvp -- pointer to token vector. 990** ruleset -- the ruleset to use for rewriting. 991** reclevel -- recursion level (to catch loops). 992** e -- the current envelope. 993** maxatom -- maximum length of buffer (usually MAXATOM) 994** 995** Returns: 996** A status code. If EX_TEMPFAIL, higher level code should 997** attempt recovery. 998** 999** Side Effects: 1000** pvp is modified. 1001*/ 1002 1003struct match 1004{ 1005 char **match_first; /* first token matched */ 1006 char **match_last; /* last token matched */ 1007 char **match_pattern; /* pointer to pattern */ 1008}; 1009 1010int 1011rewrite(pvp, ruleset, reclevel, e, maxatom) 1012 char **pvp; 1013 int ruleset; 1014 int reclevel; 1015 register ENVELOPE *e; 1016 int maxatom; 1017{ 1018 register char *ap; /* address pointer */ 1019 register char *rp; /* rewrite pointer */ 1020 register char *rulename; /* ruleset name */ 1021 register char *prefix; 1022 register char **avp; /* address vector pointer */ 1023 register char **rvp; /* rewrite vector pointer */ 1024 register struct match *mlp; /* cur ptr into mlist */ 1025 register struct rewrite *rwr; /* pointer to current rewrite rule */ 1026 int ruleno; /* current rule number */ 1027 int rstat = EX_OK; /* return status */ 1028 int loopcount; 1029 struct match mlist[MAXMATCH]; /* stores match on LHS */ 1030 char *npvp[MAXATOM + 1]; /* temporary space for rebuild */ 1031 char buf[MAXLINE]; 1032 char name[6]; 1033 1034 /* 1035 ** mlp will not exceed mlist[] because readcf enforces 1036 ** the upper limit of entries when reading rulesets. 1037 */ 1038 1039 if (ruleset < 0 || ruleset >= MAXRWSETS) 1040 { 1041 syserr("554 5.3.5 rewrite: illegal ruleset number %d", ruleset); 1042 return EX_CONFIG; 1043 } 1044 rulename = RuleSetNames[ruleset]; 1045 if (rulename == NULL) 1046 { 1047 (void) sm_snprintf(name, sizeof(name), "%d", ruleset); 1048 rulename = name; 1049 } 1050 if (OpMode == MD_TEST) 1051 prefix = ""; 1052 else 1053 prefix = "rewrite: ruleset "; 1054 if (OpMode == MD_TEST) 1055 { 1056 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 1057 "%s%-16.16s input:", prefix, rulename); 1058 printav(smioout, pvp); 1059 } 1060 else if (tTd(21, 1)) 1061 { 1062 sm_dprintf("%s%-16.16s input:", prefix, rulename); 1063 printav(sm_debug_file(), pvp); 1064 } 1065 if (reclevel++ > MaxRuleRecursion) 1066 { 1067 syserr("rewrite: excessive recursion (max %d), ruleset %s", 1068 MaxRuleRecursion, rulename); 1069 return EX_CONFIG; 1070 } 1071 if (pvp == NULL) 1072 return EX_USAGE; 1073 if (maxatom <= 0) 1074 return EX_USAGE; 1075 1076 /* 1077 ** Run through the list of rewrite rules, applying 1078 ** any that match. 1079 */ 1080 1081 ruleno = 1; 1082 loopcount = 0; 1083 for (rwr = RewriteRules[ruleset]; rwr != NULL; ) 1084 { 1085 int status; 1086 1087 /* if already canonical, quit now */ 1088 if (pvp[0] != NULL && (pvp[0][0] & 0377) == CANONNET) 1089 break; 1090 1091 if (tTd(21, 12)) 1092 { 1093 if (tTd(21, 15)) 1094 sm_dprintf("-----trying rule (line %d):", 1095 rwr->r_line); 1096 else 1097 sm_dprintf("-----trying rule:"); 1098 printav(sm_debug_file(), rwr->r_lhs); 1099 } 1100 1101 /* try to match on this rule */ 1102 mlp = mlist; 1103 rvp = rwr->r_lhs; 1104 avp = pvp; 1105 if (++loopcount > 100) 1106 { 1107 syserr("554 5.3.5 Infinite loop in ruleset %s, rule %d", 1108 rulename, ruleno); 1109 if (tTd(21, 1)) 1110 { 1111 sm_dprintf("workspace: "); 1112 printav(sm_debug_file(), pvp); 1113 } 1114 break; 1115 } 1116 1117 while ((ap = *avp) != NULL || *rvp != NULL) 1118 { 1119 rp = *rvp; 1120 if (tTd(21, 35)) 1121 { 1122 sm_dprintf("ADVANCE rp="); 1123 xputs(sm_debug_file(), rp); 1124 sm_dprintf(", ap="); 1125 xputs(sm_debug_file(), ap); 1126 sm_dprintf("\n"); 1127 } 1128 if (rp == NULL) 1129 { 1130 /* end-of-pattern before end-of-address */ 1131 goto backup; 1132 } 1133 if (ap == NULL && 1134 (rp[0] & 0377) != MATCHZANY && 1135 (rp[0] & 0377) != MATCHZERO) 1136 { 1137 /* end-of-input with patterns left */ 1138 goto backup; 1139 } 1140 1141 switch (rp[0] & 0377) 1142 { 1143 case MATCHCLASS: 1144 /* match any phrase in a class */ 1145 mlp->match_pattern = rvp; 1146 mlp->match_first = avp; 1147 extendclass: 1148 ap = *avp; 1149 if (ap == NULL) 1150 goto backup; 1151 mlp->match_last = avp++; 1152 cataddr(mlp->match_first, mlp->match_last, 1153 buf, sizeof(buf), '\0', true); 1154 if (!wordinclass(buf, rp[1])) 1155 { 1156 if (tTd(21, 36)) 1157 { 1158 sm_dprintf("EXTEND rp="); 1159 xputs(sm_debug_file(), rp); 1160 sm_dprintf(", ap="); 1161 xputs(sm_debug_file(), ap); 1162 sm_dprintf("\n"); 1163 } 1164 goto extendclass; 1165 } 1166 if (tTd(21, 36)) 1167 sm_dprintf("CLMATCH\n"); 1168 mlp++; 1169 break; 1170 1171 case MATCHNCLASS: 1172 /* match any token not in a class */ 1173 if (wordinclass(ap, rp[1])) 1174 goto backup; 1175 1176 /* FALLTHROUGH */ 1177 1178 case MATCHONE: 1179 case MATCHANY: 1180 /* match exactly one token */ 1181 mlp->match_pattern = rvp; 1182 mlp->match_first = avp; 1183 mlp->match_last = avp++; 1184 mlp++; 1185 break; 1186 1187 case MATCHZANY: 1188 /* match zero or more tokens */ 1189 mlp->match_pattern = rvp; 1190 mlp->match_first = avp; 1191 mlp->match_last = avp - 1; 1192 mlp++; 1193 break; 1194 1195 case MATCHZERO: 1196 /* match zero tokens */ 1197 break; 1198 1199 case MACRODEXPAND: 1200 /* 1201 ** Match against run-time macro. 1202 ** This algorithm is broken for the 1203 ** general case (no recursive macros, 1204 ** improper tokenization) but should 1205 ** work for the usual cases. 1206 */ 1207 1208 ap = macvalue(rp[1], e); 1209 mlp->match_first = avp; 1210 if (tTd(21, 2)) 1211 sm_dprintf("rewrite: LHS $&{%s} => \"%s\"\n", 1212 macname(rp[1]), 1213 ap == NULL ? "(NULL)" : ap); 1214 1215 if (ap == NULL) 1216 break; 1217 while (*ap != '\0') 1218 { 1219 if (*avp == NULL || 1220 sm_strncasecmp(ap, *avp, 1221 strlen(*avp)) != 0) 1222 { 1223 /* no match */ 1224 avp = mlp->match_first; 1225 goto backup; 1226 } 1227 ap += strlen(*avp++); 1228 } 1229 1230 /* match */ 1231 break; 1232 1233 default: 1234 /* must have exact match */ 1235 if (sm_strcasecmp(rp, ap)) 1236 goto backup; 1237 avp++; 1238 break; 1239 } 1240 1241 /* successful match on this token */ 1242 rvp++; 1243 continue; 1244 1245 backup: 1246 /* match failed -- back up */ 1247 while (--mlp >= mlist) 1248 { 1249 rvp = mlp->match_pattern; 1250 rp = *rvp; 1251 avp = mlp->match_last + 1; 1252 ap = *avp; 1253 1254 if (tTd(21, 36)) 1255 { 1256 sm_dprintf("BACKUP rp="); 1257 xputs(sm_debug_file(), rp); 1258 sm_dprintf(", ap="); 1259 xputs(sm_debug_file(), ap); 1260 sm_dprintf("\n"); 1261 } 1262 1263 if (ap == NULL) 1264 { 1265 /* run off the end -- back up again */ 1266 continue; 1267 } 1268 1269 if ((rp[0] & 0377) == MATCHANY || 1270 (rp[0] & 0377) == MATCHZANY) 1271 { 1272 /* extend binding and continue */ 1273 mlp->match_last = avp++; 1274 rvp++; 1275 mlp++; 1276 break; 1277 } 1278 if ((rp[0] & 0377) == MATCHCLASS) 1279 { 1280 /* extend binding and try again */ 1281 mlp->match_last = avp; 1282 goto extendclass; 1283 } 1284 } 1285 1286 if (mlp < mlist) 1287 { 1288 /* total failure to match */ 1289 break; 1290 } 1291 } 1292 1293 /* 1294 ** See if we successfully matched 1295 */ 1296 1297 if (mlp < mlist || *rvp != NULL) 1298 { 1299 if (tTd(21, 10)) 1300 sm_dprintf("----- rule fails\n"); 1301 rwr = rwr->r_next; 1302 ruleno++; 1303 loopcount = 0; 1304 continue; 1305 } 1306 1307 rvp = rwr->r_rhs; 1308 if (tTd(21, 12)) 1309 { 1310 sm_dprintf("-----rule matches:"); 1311 printav(sm_debug_file(), rvp); 1312 } 1313 1314 rp = *rvp; 1315 if (rp != NULL) 1316 { 1317 if ((rp[0] & 0377) == CANONUSER) 1318 { 1319 rvp++; 1320 rwr = rwr->r_next; 1321 ruleno++; 1322 loopcount = 0; 1323 } 1324 else if ((rp[0] & 0377) == CANONHOST) 1325 { 1326 rvp++; 1327 rwr = NULL; 1328 } 1329 } 1330 1331 /* substitute */ 1332 for (avp = npvp; *rvp != NULL; rvp++) 1333 { 1334 register struct match *m; 1335 register char **pp; 1336 1337 rp = *rvp; 1338 if ((rp[0] & 0377) == MATCHREPL) 1339 { 1340 /* substitute from LHS */ 1341 m = &mlist[rp[1] - '1']; 1342 if (m < mlist || m >= mlp) 1343 { 1344 syserr("554 5.3.5 rewrite: ruleset %s: replacement $%c out of bounds", 1345 rulename, rp[1]); 1346 return EX_CONFIG; 1347 } 1348 if (tTd(21, 15)) 1349 { 1350 sm_dprintf("$%c:", rp[1]); 1351 pp = m->match_first; 1352 while (pp <= m->match_last) 1353 { 1354 sm_dprintf(" %p=\"", *pp); 1355 sm_dflush(); 1356 sm_dprintf("%s\"", *pp++); 1357 } 1358 sm_dprintf("\n"); 1359 } 1360 pp = m->match_first; 1361 while (pp <= m->match_last) 1362 { 1363 if (avp >= &npvp[maxatom]) 1364 goto toolong; 1365 *avp++ = *pp++; 1366 } 1367 } 1368 else 1369 { 1370 /* some sort of replacement */ 1371 if (avp >= &npvp[maxatom]) 1372 { 1373 toolong: 1374 syserr("554 5.3.0 rewrite: expansion too long"); 1375 if (LogLevel > 9) 1376 sm_syslog(LOG_ERR, e->e_id, 1377 "rewrite: expansion too long, ruleset=%s, ruleno=%d", 1378 rulename, ruleno); 1379 return EX_DATAERR; 1380 } 1381 if ((rp[0] & 0377) != MACRODEXPAND) 1382 { 1383 /* vanilla replacement from RHS */ 1384 *avp++ = rp; 1385 } 1386 else 1387 { 1388 /* $&{x} replacement */ 1389 char *mval = macvalue(rp[1], e); 1390 char **xpvp; 1391 size_t trsize = 0; 1392 static size_t pvpb1_size = 0; 1393 static char **pvpb1 = NULL; 1394 char pvpbuf[PSBUFSIZE]; 1395 1396 if (tTd(21, 2)) 1397 sm_dprintf("rewrite: RHS $&{%s} => \"%s\"\n", 1398 macname(rp[1]), 1399 mval == NULL ? "(NULL)" : mval); 1400 if (mval == NULL || *mval == '\0') 1401 continue; 1402 1403 /* save the remainder of the input */ 1404 for (xpvp = pvp; *xpvp != NULL; xpvp++) 1405 trsize += sizeof(*xpvp); 1406 if (trsize > pvpb1_size) 1407 { 1408 if (pvpb1 != NULL) 1409 sm_free(pvpb1); 1410 pvpb1 = (char **) 1411 sm_pmalloc_x(trsize); 1412 pvpb1_size = trsize; 1413 } 1414 1415 memmove((char *) pvpb1, 1416 (char *) pvp, 1417 trsize); 1418 1419 /* scan the new replacement */ 1420 xpvp = prescan(mval, '\0', pvpbuf, 1421 sizeof(pvpbuf), NULL, 1422 NULL, false); 1423 if (xpvp == NULL) 1424 { 1425 /* prescan pre-printed error */ 1426 return EX_DATAERR; 1427 } 1428 1429 /* insert it into the output stream */ 1430 while (*xpvp != NULL) 1431 { 1432 if (tTd(21, 19)) 1433 sm_dprintf(" ... %s\n", 1434 *xpvp); 1435 *avp++ = sm_rpool_strdup_x( 1436 e->e_rpool, *xpvp); 1437 if (avp >= &npvp[maxatom]) 1438 goto toolong; 1439 xpvp++; 1440 } 1441 if (tTd(21, 19)) 1442 sm_dprintf(" ... DONE\n"); 1443 1444 /* restore the old trailing input */ 1445 memmove((char *) pvp, 1446 (char *) pvpb1, 1447 trsize); 1448 } 1449 } 1450 } 1451 *avp++ = NULL; 1452 1453 /* 1454 ** Check for any hostname/keyword lookups. 1455 */ 1456 1457 for (rvp = npvp; *rvp != NULL; rvp++) 1458 { 1459 char **hbrvp; 1460 char **xpvp; 1461 size_t trsize; 1462 char *replac; 1463 int endtoken; 1464 bool external; 1465 STAB *map; 1466 char *mapname; 1467 char **key_rvp; 1468 char **arg_rvp; 1469 char **default_rvp; 1470 char cbuf[MAXKEY]; 1471 char *pvpb1[MAXATOM + 1]; 1472 char *argvect[MAX_MAP_ARGS]; 1473 char pvpbuf[PSBUFSIZE]; 1474 char *nullpvp[1]; 1475 1476 hbrvp = rvp; 1477 if ((rvp[0][0] & 0377) == HOSTBEGIN) 1478 { 1479 endtoken = HOSTEND; 1480 mapname = "host"; 1481 } 1482 else if ((rvp[0][0] & 0377) == LOOKUPBEGIN) 1483 { 1484 endtoken = LOOKUPEND; 1485 mapname = *++rvp; 1486 if (mapname == NULL) 1487 { 1488 syserr("554 5.3.0 rewrite: missing mapname"); 1489 /* NOTREACHED */ 1490 SM_ASSERT(0); 1491 } 1492 } 1493 else 1494 continue; 1495 1496 /* 1497 ** Got a hostname/keyword lookup. 1498 ** 1499 ** This could be optimized fairly easily. 1500 */ 1501 1502 map = stab(mapname, ST_MAP, ST_FIND); 1503 if (map == NULL) 1504 syserr("554 5.3.0 rewrite: map %s not found", 1505 mapname); 1506 1507 /* extract the match part */ 1508 key_rvp = ++rvp; 1509 if (key_rvp == NULL) 1510 { 1511 syserr("554 5.3.0 rewrite: missing key for map %s", 1512 mapname); 1513 /* NOTREACHED */ 1514 SM_ASSERT(0); 1515 } 1516 default_rvp = NULL; 1517 arg_rvp = argvect; 1518 xpvp = NULL; 1519 replac = pvpbuf; 1520 while (*rvp != NULL && ((rvp[0][0] & 0377) != endtoken)) 1521 { 1522 int nodetype = rvp[0][0] & 0377; 1523 1524 if (nodetype != CANONHOST && 1525 nodetype != CANONUSER) 1526 { 1527 rvp++; 1528 continue; 1529 } 1530 1531 *rvp++ = NULL; 1532 1533 if (xpvp != NULL) 1534 { 1535 cataddr(xpvp, NULL, replac, 1536 &pvpbuf[sizeof(pvpbuf)] - replac, 1537 '\0', false); 1538 if (arg_rvp < 1539 &argvect[MAX_MAP_ARGS - 1]) 1540 *++arg_rvp = replac; 1541 replac += strlen(replac) + 1; 1542 xpvp = NULL; 1543 } 1544 switch (nodetype) 1545 { 1546 case CANONHOST: 1547 xpvp = rvp; 1548 break; 1549 1550 case CANONUSER: 1551 default_rvp = rvp; 1552 break; 1553 } 1554 } 1555 if (*rvp != NULL) 1556 *rvp++ = NULL; 1557 if (xpvp != NULL) 1558 { 1559 cataddr(xpvp, NULL, replac, 1560 &pvpbuf[sizeof(pvpbuf)] - replac, 1561 '\0', false); 1562 if (arg_rvp < &argvect[MAX_MAP_ARGS - 1]) 1563 *++arg_rvp = replac; 1564 } 1565 if (arg_rvp >= &argvect[MAX_MAP_ARGS - 1]) 1566 argvect[MAX_MAP_ARGS - 1] = NULL; 1567 else 1568 *++arg_rvp = NULL; 1569 1570 /* save the remainder of the input string */ 1571 trsize = (avp - rvp + 1) * sizeof(*rvp); 1572 memmove((char *) pvpb1, (char *) rvp, trsize); 1573 1574 /* look it up */ 1575 cataddr(key_rvp, NULL, cbuf, sizeof(cbuf), 1576 map == NULL ? '\0' : map->s_map.map_spacesub, 1577 true); 1578 argvect[0] = cbuf; 1579 replac = map_lookup(map, cbuf, argvect, &rstat, e); 1580 external = replac != NULL; 1581 1582 /* if no replacement, use default */ 1583 if (replac == NULL && default_rvp != NULL) 1584 { 1585 /* create the default */ 1586 cataddr(default_rvp, NULL, cbuf, sizeof(cbuf), 1587 '\0', false); 1588 replac = cbuf; 1589 } 1590 1591 if (replac == NULL) 1592 { 1593 xpvp = key_rvp; 1594 } 1595 else if (*replac == '\0') 1596 { 1597 /* null replacement */ 1598 nullpvp[0] = NULL; 1599 xpvp = nullpvp; 1600 } 1601 else 1602 { 1603 /* scan the new replacement */ 1604 xpvp = prescan(replac, '\0', pvpbuf, 1605 sizeof(pvpbuf), NULL, 1606 external ? NULL : IntTokenTab, 1607 false); 1608 if (xpvp == NULL) 1609 { 1610 /* prescan already printed error */ 1611 return EX_DATAERR; 1612 } 1613 } 1614 1615 /* append it to the token list */ 1616 for (avp = hbrvp; *xpvp != NULL; xpvp++) 1617 { 1618 *avp++ = sm_rpool_strdup_x(e->e_rpool, *xpvp); 1619 if (avp >= &npvp[maxatom]) 1620 goto toolong; 1621 } 1622 1623 /* restore the old trailing information */ 1624 rvp = avp - 1; 1625 for (xpvp = pvpb1; (*avp++ = *xpvp++) != NULL; ) 1626 if (avp >= &npvp[maxatom]) 1627 goto toolong; 1628 } 1629 1630 /* 1631 ** Check for subroutine calls. 1632 */ 1633 1634 status = callsubr(npvp, reclevel, e); 1635 if (rstat == EX_OK || status == EX_TEMPFAIL) 1636 rstat = status; 1637 1638 /* copy vector back into original space. */ 1639 for (avp = npvp; *avp++ != NULL;) 1640 continue; 1641 memmove((char *) pvp, (char *) npvp, 1642 (int) (avp - npvp) * sizeof(*avp)); 1643 1644 if (tTd(21, 4)) 1645 { 1646 sm_dprintf("rewritten as:"); 1647 printav(sm_debug_file(), pvp); 1648 } 1649 } 1650 1651 if (OpMode == MD_TEST) 1652 { 1653 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 1654 "%s%-16.16s returns:", prefix, rulename); 1655 printav(smioout, pvp); 1656 } 1657 else if (tTd(21, 1)) 1658 { 1659 sm_dprintf("%s%-16.16s returns:", prefix, rulename); 1660 printav(sm_debug_file(), pvp); 1661 } 1662 return rstat; 1663} 1664/* 1665** CALLSUBR -- call subroutines in rewrite vector 1666** 1667** Parameters: 1668** pvp -- pointer to token vector. 1669** reclevel -- the current recursion level. 1670** e -- the current envelope. 1671** 1672** Returns: 1673** The status from the subroutine call. 1674** 1675** Side Effects: 1676** pvp is modified. 1677*/ 1678 1679static int 1680callsubr(pvp, reclevel, e) 1681 char **pvp; 1682 int reclevel; 1683 ENVELOPE *e; 1684{ 1685 char **avp; 1686 register int i; 1687 int subr, j; 1688 int nsubr; 1689 int status; 1690 int rstat = EX_OK; 1691#define MAX_SUBR 16 1692 int subrnumber[MAX_SUBR]; 1693 int subrindex[MAX_SUBR]; 1694 1695 nsubr = 0; 1696 1697 /* 1698 ** Look for subroutine calls in pvp, collect them into subr*[] 1699 ** We will perform the calls in the next loop, because we will 1700 ** call the "last" subroutine first to avoid recursive calls 1701 ** and too much copying. 1702 */ 1703 1704 for (avp = pvp, j = 0; *avp != NULL; avp++, j++) 1705 { 1706 if ((avp[0][0] & 0377) == CALLSUBR && avp[1] != NULL) 1707 { 1708 stripquotes(avp[1]); 1709 subr = strtorwset(avp[1], NULL, ST_FIND); 1710 if (subr < 0) 1711 { 1712 syserr("554 5.3.5 Unknown ruleset %s", avp[1]); 1713 return EX_CONFIG; 1714 } 1715 1716 /* 1717 ** XXX instead of doing this we could optimize 1718 ** the rules after reading them: just remove 1719 ** calls to empty rulesets 1720 */ 1721 1722 /* subroutine is an empty ruleset? don't call it */ 1723 if (RewriteRules[subr] == NULL) 1724 { 1725 if (tTd(21, 3)) 1726 sm_dprintf("-----skip subr %s (%d)\n", 1727 avp[1], subr); 1728 for (i = 2; avp[i] != NULL; i++) 1729 avp[i - 2] = avp[i]; 1730 avp[i - 2] = NULL; 1731 continue; 1732 } 1733 if (++nsubr >= MAX_SUBR) 1734 { 1735 syserr("554 5.3.0 Too many subroutine calls (%d max)", 1736 MAX_SUBR); 1737 return EX_CONFIG; 1738 } 1739 subrnumber[nsubr] = subr; 1740 subrindex[nsubr] = j; 1741 } 1742 } 1743 1744 /* 1745 ** Perform the actual subroutines calls, "last" one first, i.e., 1746 ** go from the right to the left through all calls, 1747 ** do the rewriting in place. 1748 */ 1749 1750 for (; nsubr > 0; nsubr--) 1751 { 1752 subr = subrnumber[nsubr]; 1753 avp = pvp + subrindex[nsubr]; 1754 1755 /* remove the subroutine call and name */ 1756 for (i = 2; avp[i] != NULL; i++) 1757 avp[i - 2] = avp[i]; 1758 avp[i - 2] = NULL; 1759 1760 /* 1761 ** Now we need to call the ruleset specified for 1762 ** the subroutine. We can do this in place since 1763 ** we call the "last" subroutine first. 1764 */ 1765 1766 status = rewrite(avp, subr, reclevel, e, 1767 MAXATOM - subrindex[nsubr]); 1768 if (status != EX_OK && status != EX_TEMPFAIL) 1769 return status; 1770 if (rstat == EX_OK || status == EX_TEMPFAIL) 1771 rstat = status; 1772 } 1773 return rstat; 1774} 1775/* 1776** MAP_LOOKUP -- do lookup in map 1777** 1778** Parameters: 1779** smap -- the map to use for the lookup. 1780** key -- the key to look up. 1781** argvect -- arguments to pass to the map lookup. 1782** pstat -- a pointer to an integer in which to store the 1783** status from the lookup. 1784** e -- the current envelope. 1785** 1786** Returns: 1787** The result of the lookup. 1788** NULL -- if there was no data for the given key. 1789*/ 1790 1791static char * 1792map_lookup(smap, key, argvect, pstat, e) 1793 STAB *smap; 1794 char key[]; 1795 char **argvect; 1796 int *pstat; 1797 ENVELOPE *e; 1798{ 1799 auto int status = EX_OK; 1800 MAP *map; 1801 char *replac; 1802 1803 if (smap == NULL) 1804 return NULL; 1805 1806 map = &smap->s_map; 1807 DYNOPENMAP(map); 1808 1809 if (e->e_sendmode == SM_DEFER && 1810 bitset(MF_DEFER, map->map_mflags)) 1811 { 1812 /* don't do any map lookups */ 1813 if (tTd(60, 1)) 1814 sm_dprintf("map_lookup(%s, %s) => DEFERRED\n", 1815 smap->s_name, key); 1816 *pstat = EX_TEMPFAIL; 1817 return NULL; 1818 } 1819 1820 if (!bitset(MF_KEEPQUOTES, map->map_mflags)) 1821 stripquotes(key); 1822 1823 if (tTd(60, 1)) 1824 { 1825 sm_dprintf("map_lookup(%s, ", smap->s_name); 1826 xputs(sm_debug_file(), key); 1827 if (tTd(60, 5)) 1828 { 1829 int i; 1830 1831 for (i = 0; argvect[i] != NULL; i++) 1832 sm_dprintf(", %%%d=%s", i, argvect[i]); 1833 } 1834 sm_dprintf(") => "); 1835 } 1836 replac = (*map->map_class->map_lookup)(map, key, argvect, &status); 1837 if (tTd(60, 1)) 1838 sm_dprintf("%s (%d)\n", 1839 replac != NULL ? replac : "NOT FOUND", 1840 status); 1841 1842 /* should recover if status == EX_TEMPFAIL */ 1843 if (status == EX_TEMPFAIL && !bitset(MF_NODEFER, map->map_mflags)) 1844 { 1845 *pstat = EX_TEMPFAIL; 1846 if (tTd(60, 1)) 1847 sm_dprintf("map_lookup(%s, %s) tempfail: errno=%d\n", 1848 smap->s_name, key, errno); 1849 if (e->e_message == NULL) 1850 { 1851 char mbuf[320]; 1852 1853 (void) sm_snprintf(mbuf, sizeof(mbuf), 1854 "%.80s map: lookup (%s): deferred", 1855 smap->s_name, 1856 shortenstring(key, MAXSHORTSTR)); 1857 e->e_message = sm_rpool_strdup_x(e->e_rpool, mbuf); 1858 } 1859 } 1860 if (status == EX_TEMPFAIL && map->map_tapp != NULL) 1861 { 1862 size_t i = strlen(key) + strlen(map->map_tapp) + 1; 1863 static char *rwbuf = NULL; 1864 static size_t rwbuflen = 0; 1865 1866 if (i > rwbuflen) 1867 { 1868 if (rwbuf != NULL) 1869 sm_free(rwbuf); 1870 rwbuflen = i; 1871 rwbuf = (char *) sm_pmalloc_x(rwbuflen); 1872 } 1873 (void) sm_strlcpyn(rwbuf, rwbuflen, 2, key, map->map_tapp); 1874 if (tTd(60, 4)) 1875 sm_dprintf("map_lookup tempfail: returning \"%s\"\n", 1876 rwbuf); 1877 return rwbuf; 1878 } 1879 return replac; 1880} 1881/* 1882** INITERRMAILERS -- initialize error and discard mailers 1883** 1884** Parameters: 1885** none. 1886** 1887** Returns: 1888** none. 1889** 1890** Side Effects: 1891** initializes error and discard mailers. 1892*/ 1893 1894static MAILER discardmailer; 1895static MAILER errormailer; 1896static char *discardargv[] = { "DISCARD", NULL }; 1897static char *errorargv[] = { "ERROR", NULL }; 1898 1899void 1900initerrmailers() 1901{ 1902 if (discardmailer.m_name == NULL) 1903 { 1904 /* initialize the discard mailer */ 1905 discardmailer.m_name = "*discard*"; 1906 discardmailer.m_mailer = "DISCARD"; 1907 discardmailer.m_argv = discardargv; 1908 } 1909 if (errormailer.m_name == NULL) 1910 { 1911 /* initialize the bogus mailer */ 1912 errormailer.m_name = "*error*"; 1913 errormailer.m_mailer = "ERROR"; 1914 errormailer.m_argv = errorargv; 1915 } 1916} 1917/* 1918** BUILDADDR -- build address from token vector. 1919** 1920** Parameters: 1921** tv -- token vector. 1922** a -- pointer to address descriptor to fill. 1923** If NULL, one will be allocated. 1924** flags -- info regarding whether this is a sender or 1925** a recipient. 1926** e -- the current envelope. 1927** 1928** Returns: 1929** NULL if there was an error. 1930** 'a' otherwise. 1931** 1932** Side Effects: 1933** fills in 'a' 1934*/ 1935 1936static struct errcodes 1937{ 1938 char *ec_name; /* name of error code */ 1939 int ec_code; /* numeric code */ 1940} ErrorCodes[] = 1941{ 1942 { "usage", EX_USAGE }, 1943 { "nouser", EX_NOUSER }, 1944 { "nohost", EX_NOHOST }, 1945 { "unavailable", EX_UNAVAILABLE }, 1946 { "software", EX_SOFTWARE }, 1947 { "tempfail", EX_TEMPFAIL }, 1948 { "protocol", EX_PROTOCOL }, 1949 { "config", EX_CONFIG }, 1950 { NULL, EX_UNAVAILABLE } 1951}; 1952 1953static ADDRESS * 1954buildaddr(tv, a, flags, e) 1955 register char **tv; 1956 register ADDRESS *a; 1957 int flags; 1958 register ENVELOPE *e; 1959{ 1960 bool tempfail = false; 1961 int maxatom; 1962 struct mailer **mp; 1963 register struct mailer *m; 1964 register char *p; 1965 char *mname; 1966 char **hostp; 1967 char hbuf[MAXNAME + 1]; 1968 static char ubuf[MAXNAME + 2]; 1969 1970 if (tTd(24, 5)) 1971 { 1972 sm_dprintf("buildaddr, flags=%x, tv=", flags); 1973 printav(sm_debug_file(), tv); 1974 } 1975 1976 maxatom = MAXATOM; 1977 if (a == NULL) 1978 a = (ADDRESS *) sm_rpool_malloc_x(e->e_rpool, sizeof(*a)); 1979 memset((char *) a, '\0', sizeof(*a)); 1980 hbuf[0] = '\0'; 1981 1982 /* set up default error return flags */ 1983 a->q_flags |= DefaultNotify; 1984 1985 /* figure out what net/mailer to use */ 1986 if (*tv == NULL || (**tv & 0377) != CANONNET) 1987 { 1988 syserr("554 5.3.5 buildaddr: no mailer in parsed address"); 1989badaddr: 1990 /* 1991 ** ExitStat may have been set by an earlier map open 1992 ** failure (to a permanent error (EX_OSERR) in syserr()) 1993 ** so we also need to check if this particular $#error 1994 ** return wanted a 4XX failure. 1995 ** 1996 ** XXX the real fix is probably to set ExitStat correctly, 1997 ** i.e., to EX_TEMPFAIL if the map open is just a temporary 1998 ** error. 1999 */ 2000 2001 if (ExitStat == EX_TEMPFAIL || tempfail) 2002 a->q_state = QS_QUEUEUP; 2003 else 2004 { 2005 a->q_state = QS_BADADDR; 2006 a->q_mailer = &errormailer; 2007 } 2008 return a; 2009 } 2010 mname = *++tv; 2011 --maxatom; 2012 2013 /* extract host and user portions */ 2014 if (*++tv != NULL && (**tv & 0377) == CANONHOST) 2015 { 2016 hostp = ++tv; 2017 --maxatom; 2018 } 2019 else 2020 hostp = NULL; 2021 --maxatom; 2022 while (*tv != NULL && (**tv & 0377) != CANONUSER) 2023 { 2024 tv++; 2025 --maxatom; 2026 } 2027 if (*tv == NULL) 2028 { 2029 syserr("554 5.3.5 buildaddr: no user"); 2030 goto badaddr; 2031 } 2032 if (tv == hostp) 2033 hostp = NULL; 2034 else if (hostp != NULL) 2035 cataddr(hostp, tv - 1, hbuf, sizeof(hbuf), '\0', false); 2036 cataddr(++tv, NULL, ubuf, sizeof(ubuf), ' ', false); 2037 --maxatom; 2038 2039 /* save away the host name */ 2040 if (sm_strcasecmp(mname, "error") == 0) 2041 { 2042 /* Set up triplet for use by -bv */ 2043 a->q_mailer = &errormailer; 2044 a->q_user = sm_rpool_strdup_x(e->e_rpool, ubuf); 2045 /* XXX wrong place? */ 2046 2047 if (hostp != NULL) 2048 { 2049 register struct errcodes *ep; 2050 2051 a->q_host = sm_rpool_strdup_x(e->e_rpool, hbuf); 2052 if (strchr(hbuf, '.') != NULL) 2053 { 2054 a->q_status = sm_rpool_strdup_x(e->e_rpool, 2055 hbuf); 2056 setstat(dsntoexitstat(hbuf)); 2057 } 2058 else if (isascii(hbuf[0]) && isdigit(hbuf[0])) 2059 { 2060 setstat(atoi(hbuf)); 2061 } 2062 else 2063 { 2064 for (ep = ErrorCodes; ep->ec_name != NULL; ep++) 2065 if (sm_strcasecmp(ep->ec_name, hbuf) == 0) 2066 break; 2067 setstat(ep->ec_code); 2068 } 2069 } 2070 else 2071 { 2072 a->q_host = NULL; 2073 setstat(EX_UNAVAILABLE); 2074 } 2075 stripquotes(ubuf); 2076 if (ISSMTPCODE(ubuf) && ubuf[3] == ' ') 2077 { 2078 char fmt[16]; 2079 int off; 2080 2081 if ((off = isenhsc(ubuf + 4, ' ')) > 0) 2082 { 2083 ubuf[off + 4] = '\0'; 2084 off += 5; 2085 } 2086 else 2087 { 2088 off = 4; 2089 ubuf[3] = '\0'; 2090 } 2091 (void) sm_strlcpyn(fmt, sizeof(fmt), 2, ubuf, " %s"); 2092 if (off > 4) 2093 usrerr(fmt, ubuf + off); 2094 else if (isenhsc(hbuf, '\0') > 0) 2095 usrerrenh(hbuf, fmt, ubuf + off); 2096 else 2097 usrerr(fmt, ubuf + off); 2098 /* XXX ubuf[off - 1] = ' '; */ 2099 if (ubuf[0] == '4') 2100 tempfail = true; 2101 } 2102 else 2103 { 2104 usrerr("553 5.3.0 %s", ubuf); 2105 } 2106 goto badaddr; 2107 } 2108 2109 for (mp = Mailer; (m = *mp++) != NULL; ) 2110 { 2111 if (sm_strcasecmp(m->m_name, mname) == 0) 2112 break; 2113 } 2114 if (m == NULL) 2115 { 2116 syserr("554 5.3.5 buildaddr: unknown mailer %s", mname); 2117 goto badaddr; 2118 } 2119 a->q_mailer = m; 2120 2121 /* figure out what host (if any) */ 2122 if (hostp == NULL) 2123 { 2124 if (!bitnset(M_LOCALMAILER, m->m_flags)) 2125 { 2126 syserr("554 5.3.5 buildaddr: no host"); 2127 goto badaddr; 2128 } 2129 a->q_host = NULL; 2130 } 2131 else 2132 a->q_host = sm_rpool_strdup_x(e->e_rpool, hbuf); 2133 2134 /* figure out the user */ 2135 p = ubuf; 2136 if (bitnset(M_CHECKUDB, m->m_flags) && *p == '@') 2137 { 2138 p++; 2139 tv++; 2140 --maxatom; 2141 a->q_flags |= QNOTREMOTE; 2142 } 2143 2144 /* do special mapping for local mailer */ 2145 if (*p == '"') 2146 p++; 2147 if (*p == '|' && bitnset(M_CHECKPROG, m->m_flags)) 2148 a->q_mailer = m = ProgMailer; 2149 else if (*p == '/' && bitnset(M_CHECKFILE, m->m_flags)) 2150 a->q_mailer = m = FileMailer; 2151 else if (*p == ':' && bitnset(M_CHECKINCLUDE, m->m_flags)) 2152 { 2153 /* may be :include: */ 2154 stripquotes(ubuf); 2155 if (sm_strncasecmp(ubuf, ":include:", 9) == 0) 2156 { 2157 /* if :include:, don't need further rewriting */ 2158 a->q_mailer = m = InclMailer; 2159 a->q_user = sm_rpool_strdup_x(e->e_rpool, &ubuf[9]); 2160 return a; 2161 } 2162 } 2163 2164 /* rewrite according recipient mailer rewriting rules */ 2165 macdefine(&e->e_macro, A_PERM, 'h', a->q_host); 2166 2167 if (ConfigLevel >= 10 || 2168 !bitset(RF_SENDERADDR|RF_HEADERADDR, flags)) 2169 { 2170 /* sender addresses done later */ 2171 (void) rewrite(tv, 2, 0, e, maxatom); 2172 if (m->m_re_rwset > 0) 2173 (void) rewrite(tv, m->m_re_rwset, 0, e, maxatom); 2174 } 2175 (void) rewrite(tv, 4, 0, e, maxatom); 2176 2177 /* save the result for the command line/RCPT argument */ 2178 cataddr(tv, NULL, ubuf, sizeof(ubuf), '\0', true); 2179 a->q_user = sm_rpool_strdup_x(e->e_rpool, ubuf); 2180 2181 /* 2182 ** Do mapping to lower case as requested by mailer 2183 */ 2184 2185 if (a->q_host != NULL && !bitnset(M_HST_UPPER, m->m_flags)) 2186 makelower(a->q_host); 2187 if (!bitnset(M_USR_UPPER, m->m_flags)) 2188 makelower(a->q_user); 2189 2190 if (tTd(24, 6)) 2191 { 2192 sm_dprintf("buildaddr => "); 2193 printaddr(sm_debug_file(), a, false); 2194 } 2195 return a; 2196} 2197 2198/* 2199** CATADDR -- concatenate pieces of addresses (putting in <LWSP> subs) 2200** 2201** Parameters: 2202** pvp -- parameter vector to rebuild. 2203** evp -- last parameter to include. Can be NULL to 2204** use entire pvp. 2205** buf -- buffer to build the string into. 2206** sz -- size of buf. 2207** spacesub -- the space separator character; 2208** '\0': SpaceSub. 2209** NOSPACESEP: no separator 2210** external -- convert to external form? 2211** (no metacharacters; METAQUOTEs removed, see below) 2212** 2213** Returns: 2214** none. 2215** 2216** Side Effects: 2217** Destroys buf. 2218** 2219** Notes: 2220** There are two formats for strings: internal and external. 2221** The external format is just an eight-bit clean string (no 2222** null bytes, everything else OK). The internal format can 2223** include sendmail metacharacters. The special character 2224** METAQUOTE essentially quotes the character following, stripping 2225** it of all special semantics. 2226** 2227** The cataddr routine needs to be aware of whether it is producing 2228** an internal or external form as output (it only takes internal 2229** form as input). 2230** 2231** The parseaddr routine has a similar issue on input, but that 2232** is flagged on the basis of which token table is passed in. 2233*/ 2234 2235void 2236cataddr(pvp, evp, buf, sz, spacesub, external) 2237 char **pvp; 2238 char **evp; 2239 char *buf; 2240 register int sz; 2241 int spacesub; 2242 bool external; 2243{ 2244 bool oatomtok, natomtok; 2245 char *p; 2246 2247 oatomtok = natomtok = false; 2248 if (tTd(59, 14)) 2249 { 2250 sm_dprintf("cataddr(%d) <==", external); 2251 printav(sm_debug_file(), pvp); 2252 } 2253 2254 if (sz <= 0) 2255 return; 2256 2257 if (spacesub == '\0') 2258 spacesub = SpaceSub; 2259 2260 if (pvp == NULL) 2261 { 2262 *buf = '\0'; 2263 return; 2264 } 2265 p = buf; 2266 sz -= 2; 2267 while (*pvp != NULL && sz > 0) 2268 { 2269 char *q; 2270 2271 natomtok = (IntTokenTab[**pvp & 0xff] == ATM); 2272 if (oatomtok && natomtok && spacesub != NOSPACESEP) 2273 { 2274 *p++ = spacesub; 2275 if (--sz <= 0) 2276 break; 2277 } 2278 for (q = *pvp; *q != '\0'; ) 2279 { 2280 int c; 2281 2282 if (--sz <= 0) 2283 break; 2284 *p++ = c = *q++; 2285 2286 /* 2287 ** If the current character (c) is METAQUOTE and we 2288 ** want the "external" form and the next character 2289 ** is not NUL, then overwrite METAQUOTE with that 2290 ** character (i.e., METAQUOTE ch is changed to 2291 ** ch). p[-1] is used because p is advanced (above). 2292 */ 2293 2294 if ((c & 0377) == METAQUOTE && external && *q != '\0') 2295 p[-1] = *q++; 2296 } 2297 if (sz <= 0) 2298 break; 2299 oatomtok = natomtok; 2300 if (pvp++ == evp) 2301 break; 2302 } 2303 2304#if 0 2305 /* 2306 ** Silently truncate long strings: even though this doesn't 2307 ** seem like a good idea it is necessary because header checks 2308 ** send the whole header value to rscheck() and hence rewrite(). 2309 ** The latter however sometimes uses a "short" buffer (e.g., 2310 ** cbuf[MAXNAME + 1]) to call cataddr() which then triggers this 2311 ** error function. One possible fix to the problem is to pass 2312 ** flags to rscheck() and rewrite() to distinguish the various 2313 ** calls and only trigger the error if necessary. For now just 2314 ** undo the change from 8.13.0. 2315 */ 2316 2317 if (sz <= 0) 2318 usrerr("cataddr: string too long"); 2319#endif 2320 *p = '\0'; 2321 2322 if (tTd(59, 14)) 2323 sm_dprintf(" cataddr => %s\n", str2prt(buf)); 2324} 2325 2326/* 2327** SAMEADDR -- Determine if two addresses are the same 2328** 2329** This is not just a straight comparison -- if the mailer doesn't 2330** care about the host we just ignore it, etc. 2331** 2332** Parameters: 2333** a, b -- pointers to the internal forms to compare. 2334** 2335** Returns: 2336** true -- they represent the same mailbox. 2337** false -- they don't. 2338** 2339** Side Effects: 2340** none. 2341*/ 2342 2343bool 2344sameaddr(a, b) 2345 register ADDRESS *a; 2346 register ADDRESS *b; 2347{ 2348 register ADDRESS *ca, *cb; 2349 2350 /* if they don't have the same mailer, forget it */ 2351 if (a->q_mailer != b->q_mailer) 2352 return false; 2353 2354 /* 2355 ** Addresses resolving to error mailer 2356 ** should not be considered identical 2357 */ 2358 2359 if (a->q_mailer == &errormailer) 2360 return false; 2361 2362 /* if the user isn't the same, we can drop out */ 2363 if (strcmp(a->q_user, b->q_user) != 0) 2364 return false; 2365 2366 /* do the required flags match? */ 2367 if (!ADDR_FLAGS_MATCH(a, b)) 2368 return false; 2369 2370 /* if we have good uids for both but they differ, these are different */ 2371 if (a->q_mailer == ProgMailer) 2372 { 2373 ca = getctladdr(a); 2374 cb = getctladdr(b); 2375 if (ca != NULL && cb != NULL && 2376 bitset(QGOODUID, ca->q_flags & cb->q_flags) && 2377 ca->q_uid != cb->q_uid) 2378 return false; 2379 } 2380 2381 /* otherwise compare hosts (but be careful for NULL ptrs) */ 2382 if (a->q_host == b->q_host) 2383 { 2384 /* probably both null pointers */ 2385 return true; 2386 } 2387 if (a->q_host == NULL || b->q_host == NULL) 2388 { 2389 /* only one is a null pointer */ 2390 return false; 2391 } 2392 if (strcmp(a->q_host, b->q_host) != 0) 2393 return false; 2394 2395 return true; 2396} 2397/* 2398** PRINTADDR -- print address (for debugging) 2399** 2400** Parameters: 2401** a -- the address to print 2402** follow -- follow the q_next chain. 2403** 2404** Returns: 2405** none. 2406** 2407** Side Effects: 2408** none. 2409*/ 2410 2411struct qflags 2412{ 2413 char *qf_name; 2414 unsigned long qf_bit; 2415}; 2416 2417/* :'a,.s;^#define \(Q[A-Z]*\) .*; { "\1", \1 },; */ 2418static struct qflags AddressFlags[] = 2419{ 2420 { "QGOODUID", QGOODUID }, 2421 { "QPRIMARY", QPRIMARY }, 2422 { "QNOTREMOTE", QNOTREMOTE }, 2423 { "QSELFREF", QSELFREF }, 2424 { "QBOGUSSHELL", QBOGUSSHELL }, 2425 { "QUNSAFEADDR", QUNSAFEADDR }, 2426 { "QPINGONSUCCESS", QPINGONSUCCESS }, 2427 { "QPINGONFAILURE", QPINGONFAILURE }, 2428 { "QPINGONDELAY", QPINGONDELAY }, 2429 { "QHASNOTIFY", QHASNOTIFY }, 2430 { "QRELAYED", QRELAYED }, 2431 { "QEXPANDED", QEXPANDED }, 2432 { "QDELIVERED", QDELIVERED }, 2433 { "QDELAYED", QDELAYED }, 2434 { "QTHISPASS", QTHISPASS }, 2435 { "QALIAS", QALIAS }, 2436 { "QBYTRACE", QBYTRACE }, 2437 { "QBYNDELAY", QBYNDELAY }, 2438 { "QBYNRELAY", QBYNRELAY }, 2439 { "QINTBCC", QINTBCC }, 2440 { "QDYNMAILER", QDYNMAILER }, 2441 { "QRCPTOK", QRCPTOK }, 2442 { NULL, 0 } 2443}; 2444 2445void 2446printaddr(fp, a, follow) 2447 SM_FILE_T *fp; 2448 register ADDRESS *a; 2449 bool follow; 2450{ 2451 register MAILER *m; 2452 MAILER pseudomailer; 2453 register struct qflags *qfp; 2454 bool firstone; 2455 2456 if (a == NULL) 2457 { 2458 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "[NULL]\n"); 2459 return; 2460 } 2461 2462 while (a != NULL) 2463 { 2464 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%p=", a); 2465 (void) sm_io_flush(fp, SM_TIME_DEFAULT); 2466 2467 /* find the mailer -- carefully */ 2468 m = a->q_mailer; 2469 if (m == NULL) 2470 { 2471 m = &pseudomailer; 2472 m->m_mno = -1; 2473 m->m_name = "NULL"; 2474 } 2475 2476 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2477 "%s:\n\tmailer %d (%s), host `%s'\n", 2478 a->q_paddr == NULL ? "<null>" : a->q_paddr, 2479 m->m_mno, m->m_name, 2480 a->q_host == NULL ? "<null>" : a->q_host); 2481 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2482 "\tuser `%s', ruser `%s'\n", 2483 a->q_user, 2484 a->q_ruser == NULL ? "<null>" : a->q_ruser); 2485 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "\tstate="); 2486 switch (a->q_state) 2487 { 2488 case QS_OK: 2489 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "OK"); 2490 break; 2491 2492 case QS_DONTSEND: 2493 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2494 "DONTSEND"); 2495 break; 2496 2497 case QS_BADADDR: 2498 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2499 "BADADDR"); 2500 break; 2501 2502 case QS_QUEUEUP: 2503 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2504 "QUEUEUP"); 2505 break; 2506 2507 case QS_RETRY: 2508 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "RETRY"); 2509 break; 2510 2511 case QS_SENT: 2512 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "SENT"); 2513 break; 2514 2515 case QS_VERIFIED: 2516 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2517 "VERIFIED"); 2518 break; 2519 2520 case QS_EXPANDED: 2521 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2522 "EXPANDED"); 2523 break; 2524 2525 case QS_SENDER: 2526 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2527 "SENDER"); 2528 break; 2529 2530 case QS_CLONED: 2531 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2532 "CLONED"); 2533 break; 2534 2535 case QS_DISCARDED: 2536 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2537 "DISCARDED"); 2538 break; 2539 2540 case QS_REPLACED: 2541 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2542 "REPLACED"); 2543 break; 2544 2545 case QS_REMOVED: 2546 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2547 "REMOVED"); 2548 break; 2549 2550 case QS_DUPLICATE: 2551 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2552 "DUPLICATE"); 2553 break; 2554 2555 case QS_INCLUDED: 2556 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2557 "INCLUDED"); 2558 break; 2559 2560 default: 2561 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2562 "%d", a->q_state); 2563 break; 2564 } 2565 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2566 ", next=%p, alias %p, uid %d, gid %d\n", 2567 a->q_next, a->q_alias, 2568 (int) a->q_uid, (int) a->q_gid); 2569 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "\tflags=%lx<", 2570 a->q_flags); 2571 firstone = true; 2572 for (qfp = AddressFlags; qfp->qf_name != NULL; qfp++) 2573 { 2574 if (!bitset(qfp->qf_bit, a->q_flags)) 2575 continue; 2576 if (!firstone) 2577 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2578 ","); 2579 firstone = false; 2580 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s", 2581 qfp->qf_name); 2582 } 2583 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, ">\n"); 2584 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2585 "\towner=%s, home=\"%s\", fullname=\"%s\"\n", 2586 a->q_owner == NULL ? "(none)" : a->q_owner, 2587 a->q_home == NULL ? "(none)" : a->q_home, 2588 a->q_fullname == NULL ? "(none)" : a->q_fullname); 2589 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2590 "\torcpt=\"%s\", statmta=%s, status=%s\n", 2591 a->q_orcpt == NULL ? "(none)" : a->q_orcpt, 2592 a->q_statmta == NULL ? "(none)" : a->q_statmta, 2593 a->q_status == NULL ? "(none)" : a->q_status); 2594 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2595 "\tfinalrcpt=\"%s\"\n", 2596 a->q_finalrcpt == NULL ? "(none)" : a->q_finalrcpt); 2597 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2598 "\trstatus=\"%s\"\n", 2599 a->q_rstatus == NULL ? "(none)" : a->q_rstatus); 2600 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, 2601 "\tstatdate=%s\n", 2602 a->q_statdate == 0 ? "(none)" : ctime(&a->q_statdate)); 2603 2604 if (!follow) 2605 return; 2606 a = a->q_next; 2607 } 2608} 2609/* 2610** EMPTYADDR -- return true if this address is empty (``<>'') 2611** 2612** Parameters: 2613** a -- pointer to the address 2614** 2615** Returns: 2616** true -- if this address is "empty" (i.e., no one should 2617** ever generate replies to it. 2618** false -- if it is a "regular" (read: replyable) address. 2619*/ 2620 2621bool 2622emptyaddr(a) 2623 register ADDRESS *a; 2624{ 2625 return a->q_paddr == NULL || strcmp(a->q_paddr, "<>") == 0 || 2626 a->q_user == NULL || strcmp(a->q_user, "<>") == 0; 2627} 2628/* 2629** REMOTENAME -- return the name relative to the current mailer 2630** 2631** Parameters: 2632** name -- the name to translate. 2633** m -- the mailer that we want to do rewriting relative to. 2634** flags -- fine tune operations. 2635** pstat -- pointer to status word. 2636** e -- the current envelope. 2637** 2638** Returns: 2639** the text string representing this address relative to 2640** the receiving mailer. 2641** 2642** Side Effects: 2643** none. 2644** 2645** Warnings: 2646** The text string returned is tucked away locally; 2647** copy it if you intend to save it. 2648*/ 2649 2650char * 2651remotename(name, m, flags, pstat, e) 2652 char *name; 2653 struct mailer *m; 2654 int flags; 2655 int *pstat; 2656 register ENVELOPE *e; 2657{ 2658 register char **pvp; 2659 char *SM_NONVOLATILE fancy; 2660 char *oldg; 2661 int rwset; 2662 static char buf[MAXNAME + 1]; 2663 char lbuf[MAXNAME + 1]; 2664 char pvpbuf[PSBUFSIZE]; 2665 char addrtype[4]; 2666 2667 if (tTd(12, 1)) 2668 { 2669 sm_dprintf("remotename("); 2670 xputs(sm_debug_file(), name); 2671 sm_dprintf(")\n"); 2672 } 2673 2674 /* don't do anything if we are tagging it as special */ 2675 if (bitset(RF_SENDERADDR, flags)) 2676 { 2677 rwset = bitset(RF_HEADERADDR, flags) ? m->m_sh_rwset 2678 : m->m_se_rwset; 2679 addrtype[2] = 's'; 2680 } 2681 else 2682 { 2683 rwset = bitset(RF_HEADERADDR, flags) ? m->m_rh_rwset 2684 : m->m_re_rwset; 2685 addrtype[2] = 'r'; 2686 } 2687 if (rwset < 0) 2688 return name; 2689 addrtype[1] = ' '; 2690 addrtype[3] = '\0'; 2691 addrtype[0] = bitset(RF_HEADERADDR, flags) ? 'h' : 'e'; 2692 macdefine(&e->e_macro, A_TEMP, macid("{addr_type}"), addrtype); 2693 2694 /* 2695 ** Do a heuristic crack of this name to extract any comment info. 2696 ** This will leave the name as a comment and a $g macro. 2697 */ 2698 2699 if (bitset(RF_CANONICAL, flags) || bitnset(M_NOCOMMENT, m->m_flags)) 2700 fancy = "\201g"; 2701 else 2702 fancy = crackaddr(name, e); 2703 2704 /* 2705 ** Turn the name into canonical form. 2706 ** Normally this will be RFC 822 style, i.e., "user@domain". 2707 ** If this only resolves to "user", and the "C" flag is 2708 ** specified in the sending mailer, then the sender's 2709 ** domain will be appended. 2710 */ 2711 2712 pvp = prescan(name, '\0', pvpbuf, sizeof(pvpbuf), NULL, NULL, false); 2713 if (pvp == NULL) 2714 return name; 2715 if (REWRITE(pvp, 3, e) == EX_TEMPFAIL) 2716 *pstat = EX_TEMPFAIL; 2717 if (bitset(RF_ADDDOMAIN, flags) && e->e_fromdomain != NULL) 2718 { 2719 /* append from domain to this address */ 2720 register char **pxp = pvp; 2721 int l = MAXATOM; /* size of buffer for pvp */ 2722 2723 /* see if there is an "@domain" in the current name */ 2724 while (*pxp != NULL && strcmp(*pxp, "@") != 0) 2725 { 2726 pxp++; 2727 --l; 2728 } 2729 if (*pxp == NULL) 2730 { 2731 /* no.... append the "@domain" from the sender */ 2732 register char **qxq = e->e_fromdomain; 2733 2734 while ((*pxp++ = *qxq++) != NULL) 2735 { 2736 if (--l <= 0) 2737 { 2738 *--pxp = NULL; 2739 usrerr("553 5.1.0 remotename: too many tokens"); 2740 *pstat = EX_UNAVAILABLE; 2741 break; 2742 } 2743 } 2744 if (REWRITE(pvp, 3, e) == EX_TEMPFAIL) 2745 *pstat = EX_TEMPFAIL; 2746 } 2747 } 2748 2749 /* 2750 ** Do more specific rewriting. 2751 ** Rewrite using ruleset 1 or 2 depending on whether this is 2752 ** a sender address or not. 2753 ** Then run it through any receiving-mailer-specific rulesets. 2754 */ 2755 2756 if (bitset(RF_SENDERADDR, flags)) 2757 { 2758 if (REWRITE(pvp, 1, e) == EX_TEMPFAIL) 2759 *pstat = EX_TEMPFAIL; 2760 } 2761 else 2762 { 2763 if (REWRITE(pvp, 2, e) == EX_TEMPFAIL) 2764 *pstat = EX_TEMPFAIL; 2765 } 2766 if (rwset > 0) 2767 { 2768 if (REWRITE(pvp, rwset, e) == EX_TEMPFAIL) 2769 *pstat = EX_TEMPFAIL; 2770 } 2771 2772 /* 2773 ** Do any final sanitation the address may require. 2774 ** This will normally be used to turn internal forms 2775 ** (e.g., user@host.LOCAL) into external form. This 2776 ** may be used as a default to the above rules. 2777 */ 2778 2779 if (REWRITE(pvp, 4, e) == EX_TEMPFAIL) 2780 *pstat = EX_TEMPFAIL; 2781 2782 /* 2783 ** Now restore the comment information we had at the beginning. 2784 */ 2785 2786 cataddr(pvp, NULL, lbuf, sizeof(lbuf), '\0', false); 2787 oldg = macget(&e->e_macro, 'g'); 2788 macset(&e->e_macro, 'g', lbuf); 2789 2790 SM_TRY 2791 /* need to make sure route-addrs have <angle brackets> */ 2792 if (bitset(RF_CANONICAL, flags) && lbuf[0] == '@') 2793 expand("<\201g>", buf, sizeof(buf), e); 2794 else 2795 expand(fancy, buf, sizeof(buf), e); 2796 SM_FINALLY 2797 macset(&e->e_macro, 'g', oldg); 2798 SM_END_TRY 2799 2800 if (tTd(12, 1)) 2801 { 2802 sm_dprintf("remotename => `"); 2803 xputs(sm_debug_file(), buf); 2804 sm_dprintf("', stat=%d\n", *pstat); 2805 } 2806 return buf; 2807} 2808/* 2809** MAPLOCALUSER -- run local username through ruleset 5 for final redirection 2810** 2811** Parameters: 2812** a -- the address to map (but just the user name part). 2813** sendq -- the sendq in which to install any replacement 2814** addresses. 2815** aliaslevel -- the alias nesting depth. 2816** e -- the envelope. 2817** 2818** Returns: 2819** none. 2820*/ 2821 2822#define Q_COPYFLAGS (QPRIMARY|QBOGUSSHELL|QUNSAFEADDR|\ 2823 Q_PINGFLAGS|QHASNOTIFY|\ 2824 QRELAYED|QEXPANDED|QDELIVERED|QDELAYED|\ 2825 QBYTRACE|QBYNDELAY|QBYNRELAY) 2826 2827void 2828maplocaluser(a, sendq, aliaslevel, e) 2829 register ADDRESS *a; 2830 ADDRESS **sendq; 2831 int aliaslevel; 2832 ENVELOPE *e; 2833{ 2834 register char **pvp; 2835 register ADDRESS *SM_NONVOLATILE a1 = NULL; 2836 char pvpbuf[PSBUFSIZE]; 2837 2838 if (tTd(29, 1)) 2839 { 2840 sm_dprintf("maplocaluser: "); 2841 printaddr(sm_debug_file(), a, false); 2842 } 2843 pvp = prescan(a->q_user, '\0', pvpbuf, sizeof(pvpbuf), NULL, NULL, 2844 false); 2845 if (pvp == NULL) 2846 { 2847 if (tTd(29, 9)) 2848 sm_dprintf("maplocaluser: cannot prescan %s\n", 2849 a->q_user); 2850 return; 2851 } 2852 2853 macdefine(&e->e_macro, A_PERM, 'h', a->q_host); 2854 macdefine(&e->e_macro, A_PERM, 'u', a->q_user); 2855 macdefine(&e->e_macro, A_PERM, 'z', a->q_home); 2856 2857 macdefine(&e->e_macro, A_PERM, macid("{addr_type}"), "e r"); 2858 if (REWRITE(pvp, 5, e) == EX_TEMPFAIL) 2859 { 2860 if (tTd(29, 9)) 2861 sm_dprintf("maplocaluser: rewrite tempfail\n"); 2862 a->q_state = QS_QUEUEUP; 2863 a->q_status = "4.4.3"; 2864 return; 2865 } 2866 if (pvp[0] == NULL || (pvp[0][0] & 0377) != CANONNET) 2867 { 2868 if (tTd(29, 9)) 2869 sm_dprintf("maplocaluser: doesn't resolve\n"); 2870 return; 2871 } 2872 2873 SM_TRY 2874 a1 = buildaddr(pvp, NULL, 0, e); 2875 SM_EXCEPT(exc, "E:mta.quickabort") 2876 2877 /* 2878 ** mark address as bad, S5 returned an error 2879 ** and we gave that back to the SMTP client. 2880 */ 2881 2882 a->q_state = QS_DONTSEND; 2883 sm_exc_raisenew_x(&EtypeQuickAbort, 2); 2884 SM_END_TRY 2885 2886 /* if non-null, mailer destination specified -- has it changed? */ 2887 if (a1 == NULL || sameaddr(a, a1)) 2888 { 2889 if (tTd(29, 9)) 2890 sm_dprintf("maplocaluser: address unchanged\n"); 2891 return; 2892 } 2893 2894 /* make new address take on flags and print attributes of old */ 2895 a1->q_flags &= ~Q_COPYFLAGS; 2896 a1->q_flags |= a->q_flags & Q_COPYFLAGS; 2897 a1->q_paddr = sm_rpool_strdup_x(e->e_rpool, a->q_paddr); 2898 a1->q_finalrcpt = a->q_finalrcpt; 2899 a1->q_orcpt = a->q_orcpt; 2900 2901 /* mark old address as dead; insert new address */ 2902 a->q_state = QS_REPLACED; 2903 if (tTd(29, 5)) 2904 { 2905 sm_dprintf("maplocaluser: QS_REPLACED "); 2906 printaddr(sm_debug_file(), a, false); 2907 } 2908 a1->q_alias = a; 2909 allocaddr(a1, RF_COPYALL, sm_rpool_strdup_x(e->e_rpool, a->q_paddr), e); 2910 (void) recipient(a1, sendq, aliaslevel, e); 2911} 2912/* 2913** DEQUOTE_INIT -- initialize dequote map 2914** 2915** Parameters: 2916** map -- the internal map structure. 2917** args -- arguments. 2918** 2919** Returns: 2920** true. 2921*/ 2922 2923bool 2924dequote_init(map, args) 2925 MAP *map; 2926 char *args; 2927{ 2928 register char *p = args; 2929 2930 /* there is no check whether there is really an argument */ 2931 map->map_mflags |= MF_KEEPQUOTES; 2932 for (;;) 2933 { 2934 while (isascii(*p) && isspace(*p)) 2935 p++; 2936 if (*p != '-') 2937 break; 2938 switch (*++p) 2939 { 2940 case 'a': 2941 map->map_app = ++p; 2942 break; 2943 2944 case 'D': 2945 map->map_mflags |= MF_DEFER; 2946 break; 2947 2948 case 'S': 2949 case 's': 2950 map->map_spacesub = *++p; 2951 break; 2952 } 2953 while (*p != '\0' && !(isascii(*p) && isspace(*p))) 2954 p++; 2955 if (*p != '\0') 2956 *p = '\0'; 2957 } 2958 if (map->map_app != NULL) 2959 map->map_app = newstr(map->map_app); 2960 2961 return true; 2962} 2963/* 2964** DEQUOTE_MAP -- unquote an address 2965** 2966** Parameters: 2967** map -- the internal map structure (ignored). 2968** name -- the name to dequote. 2969** av -- arguments (ignored). 2970** statp -- pointer to status out-parameter. 2971** 2972** Returns: 2973** NULL -- if there were no quotes, or if the resulting 2974** unquoted buffer would not be acceptable to prescan. 2975** else -- The dequoted buffer. 2976*/ 2977 2978/* ARGSUSED2 */ 2979char * 2980dequote_map(map, name, av, statp) 2981 MAP *map; 2982 char *name; 2983 char **av; 2984 int *statp; 2985{ 2986 register char *p; 2987 register char *q; 2988 register char c; 2989 int anglecnt = 0; 2990 int cmntcnt = 0; 2991 int quotecnt = 0; 2992 int spacecnt = 0; 2993 bool quotemode = false; 2994 bool bslashmode = false; 2995 char spacesub = map->map_spacesub; 2996 2997 for (p = q = name; (c = *p++) != '\0'; ) 2998 { 2999 if (bslashmode) 3000 { 3001 bslashmode = false; 3002 *q++ = c; 3003 continue; 3004 } 3005 3006 if (c == ' ' && spacesub != '\0') 3007 c = spacesub; 3008 3009 switch (c) 3010 { 3011 case '\\': 3012 bslashmode = true; 3013 break; 3014 3015 case '(': 3016 cmntcnt++; 3017 break; 3018 3019 case ')': 3020 if (cmntcnt-- <= 0) 3021 return NULL; 3022 break; 3023 3024 case ' ': 3025 case '\t': 3026 spacecnt++; 3027 break; 3028 } 3029 3030 if (cmntcnt > 0) 3031 { 3032 *q++ = c; 3033 continue; 3034 } 3035 3036 switch (c) 3037 { 3038 case '"': 3039 quotemode = !quotemode; 3040 quotecnt++; 3041 continue; 3042 3043 case '<': 3044 anglecnt++; 3045 break; 3046 3047 case '>': 3048 if (anglecnt-- <= 0) 3049 return NULL; 3050 break; 3051 } 3052 *q++ = c; 3053 } 3054 3055 if (anglecnt != 0 || cmntcnt != 0 || bslashmode || 3056 quotemode || quotecnt <= 0 || spacecnt != 0) 3057 return NULL; 3058 *q++ = '\0'; 3059 return map_rewrite(map, name, strlen(name), NULL); 3060} 3061/* 3062** RSCHECK -- check string(s) for validity using rewriting sets 3063** 3064** Parameters: 3065** rwset -- the rewriting set to use. 3066** p1 -- the first string to check. 3067** p2 -- the second string to check -- may be null. 3068** e -- the current envelope. 3069** flags -- control some behavior, see RSF_ in sendmail.h 3070** logl -- logging level. 3071** host -- NULL or relay host. 3072** logid -- id for sm_syslog. 3073** addr -- if not NULL and ruleset returns $#error: 3074** store mailer triple here. 3075** addrstr -- if not NULL and ruleset does not return $#: 3076** address string 3077** 3078** Returns: 3079** EX_OK -- if the rwset doesn't resolve to $#error 3080** else -- the failure status (message printed) 3081*/ 3082 3083int 3084rscheck(rwset, p1, p2, e, flags, logl, host, logid, addr, addrstr) 3085 char *rwset; 3086 char *p1; 3087 char *p2; 3088 ENVELOPE *e; 3089 int flags; 3090 int logl; 3091 char *host; 3092 char *logid; 3093 ADDRESS *addr; 3094 char **addrstr; 3095{ 3096 char *volatile buf; 3097 size_t bufsize; 3098 int saveexitstat; 3099 int volatile rstat = EX_OK; 3100 char **pvp; 3101 int rsno; 3102 bool volatile discard = false; 3103 bool saveQuickAbort = QuickAbort; 3104 bool saveSuprErrs = SuprErrs; 3105 bool quarantine = false; 3106 char ubuf[BUFSIZ * 2]; 3107 char buf0[MAXLINE]; 3108 char pvpbuf[PSBUFSIZE]; 3109 extern char MsgBuf[]; 3110 3111 if (tTd(48, 2)) 3112 sm_dprintf("rscheck(%s, %s, %s)\n", rwset, p1, 3113 p2 == NULL ? "(NULL)" : p2); 3114 3115 rsno = strtorwset(rwset, NULL, ST_FIND); 3116 if (rsno < 0) 3117 return EX_OK; 3118 3119 if (p2 != NULL) 3120 { 3121 bufsize = strlen(p1) + strlen(p2) + 2; 3122 if (bufsize > sizeof(buf0)) 3123 buf = sm_malloc_x(bufsize); 3124 else 3125 { 3126 buf = buf0; 3127 bufsize = sizeof(buf0); 3128 } 3129 (void) sm_snprintf(buf, bufsize, "%s%c%s", p1, CONDELSE, p2); 3130 } 3131 else 3132 { 3133 bufsize = strlen(p1) + 1; 3134 if (bufsize > sizeof(buf0)) 3135 buf = sm_malloc_x(bufsize); 3136 else 3137 { 3138 buf = buf0; 3139 bufsize = sizeof(buf0); 3140 } 3141 (void) sm_strlcpy(buf, p1, bufsize); 3142 } 3143 SM_TRY 3144 { 3145 SuprErrs = true; 3146 QuickAbort = false; 3147 pvp = prescan(buf, '\0', pvpbuf, sizeof(pvpbuf), NULL, 3148 bitset(RSF_RMCOMM, flags) ? 3149 IntTokenTab : TokTypeNoC, 3150 bitset(RSF_RMCOMM, flags) ? false : true); 3151 SuprErrs = saveSuprErrs; 3152 if (pvp == NULL) 3153 { 3154 if (tTd(48, 2)) 3155 sm_dprintf("rscheck: cannot prescan input\n"); 3156 /* 3157 syserr("rscheck: cannot prescan input: \"%s\"", 3158 shortenstring(buf, MAXSHORTSTR)); 3159 rstat = EX_DATAERR; 3160 */ 3161 goto finis; 3162 } 3163 if (bitset(RSF_UNSTRUCTURED, flags)) 3164 SuprErrs = true; 3165 (void) REWRITE(pvp, rsno, e); 3166 if (bitset(RSF_UNSTRUCTURED, flags)) 3167 SuprErrs = saveSuprErrs; 3168 3169 if (pvp[0] != NULL && (pvp[0][0] & 0377) != CANONNET && 3170 bitset(RSF_ADDR, flags) && addrstr != NULL) 3171 { 3172 cataddr(&(pvp[0]), NULL, ubuf, sizeof(ubuf), 3173 bitset(RSF_STRING, flags) ? NOSPACESEP : ' ', 3174 true); 3175 *addrstr = sm_rpool_strdup_x(e->e_rpool, ubuf); 3176 goto finis; 3177 } 3178 3179 if (pvp[0] == NULL || (pvp[0][0] & 0377) != CANONNET || 3180 pvp[1] == NULL || (strcmp(pvp[1], "error") != 0 && 3181 strcmp(pvp[1], "discard") != 0)) 3182 { 3183 goto finis; 3184 } 3185 3186 if (strcmp(pvp[1], "discard") == 0) 3187 { 3188 if (tTd(48, 2)) 3189 sm_dprintf("rscheck: discard mailer selected\n"); 3190 e->e_flags |= EF_DISCARD; 3191 discard = true; 3192 } 3193 else if (strcmp(pvp[1], "error") == 0 && 3194 pvp[2] != NULL && (pvp[2][0] & 0377) == CANONHOST && 3195 pvp[3] != NULL && strcmp(pvp[3], "quarantine") == 0) 3196 { 3197 if (pvp[4] == NULL || 3198 (pvp[4][0] & 0377) != CANONUSER || 3199 pvp[5] == NULL) 3200 e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool, 3201 rwset); 3202 else 3203 { 3204 cataddr(&(pvp[5]), NULL, ubuf, 3205 sizeof(ubuf), ' ', true); 3206 e->e_quarmsg = sm_rpool_strdup_x(e->e_rpool, 3207 ubuf); 3208 } 3209 macdefine(&e->e_macro, A_PERM, 3210 macid("{quarantine}"), e->e_quarmsg); 3211 quarantine = true; 3212 } 3213 else 3214 { 3215 auto ADDRESS a1; 3216 int savelogusrerrs = LogUsrErrs; 3217 static bool logged = false; 3218 3219 /* got an error -- process it */ 3220 saveexitstat = ExitStat; 3221 LogUsrErrs = false; 3222 (void) buildaddr(pvp, &a1, 0, e); 3223 if (addr != NULL) 3224 { 3225 addr->q_mailer = a1.q_mailer; 3226 addr->q_user = a1.q_user; 3227 addr->q_host = a1.q_host; 3228 } 3229 LogUsrErrs = savelogusrerrs; 3230 rstat = ExitStat; 3231 ExitStat = saveexitstat; 3232 if (!logged) 3233 { 3234 if (bitset(RSF_COUNT, flags)) 3235 markstats(e, &a1, STATS_REJECT); 3236 logged = true; 3237 } 3238 } 3239 3240 if (LogLevel > logl) 3241 { 3242 char *relay; 3243 char *p; 3244 char lbuf[MAXLINE]; 3245 3246 p = lbuf; 3247 if (p2 != NULL) 3248 { 3249 (void) sm_snprintf(p, SPACELEFT(lbuf, p), 3250 ", arg2=%s", 3251 p2); 3252 p += strlen(p); 3253 } 3254 3255 if (host != NULL) 3256 relay = host; 3257 else 3258 relay = macvalue('_', e); 3259 if (relay != NULL) 3260 { 3261 (void) sm_snprintf(p, SPACELEFT(lbuf, p), 3262 ", relay=%s", relay); 3263 p += strlen(p); 3264 } 3265 *p = '\0'; 3266 if (discard) 3267 sm_syslog(LOG_NOTICE, logid, 3268 "ruleset=%s, arg1=%s%s, discard", 3269 rwset, p1, lbuf); 3270 else if (quarantine) 3271 sm_syslog(LOG_NOTICE, logid, 3272 "ruleset=%s, arg1=%s%s, quarantine=%s", 3273 rwset, p1, lbuf, ubuf); 3274 else 3275 sm_syslog(LOG_NOTICE, logid, 3276 "ruleset=%s, arg1=%s%s, reject=%s", 3277 rwset, p1, lbuf, MsgBuf); 3278 } 3279 3280 finis: ; 3281 } 3282 SM_FINALLY 3283 { 3284 /* clean up */ 3285 if (buf != buf0) 3286 sm_free(buf); 3287 QuickAbort = saveQuickAbort; 3288 } 3289 SM_END_TRY 3290 3291 setstat(rstat); 3292 3293 /* rulesets don't set errno */ 3294 errno = 0; 3295 if (rstat != EX_OK && QuickAbort) 3296 sm_exc_raisenew_x(&EtypeQuickAbort, 2); 3297 return rstat; 3298} 3299/* 3300** RSCAP -- call rewriting set to return capabilities 3301** 3302** Parameters: 3303** rwset -- the rewriting set to use. 3304** p1 -- the first string to check. 3305** p2 -- the second string to check -- may be null. 3306** e -- the current envelope. 3307** pvp -- pointer to token vector. 3308** pvpbuf -- buffer space. 3309** size -- size of buffer space. 3310** 3311** Returns: 3312** EX_UNAVAILABLE -- ruleset doesn't exist. 3313** EX_DATAERR -- prescan() failed. 3314** EX_OK -- rewrite() was successful. 3315** else -- return status from rewrite(). 3316*/ 3317 3318int 3319rscap(rwset, p1, p2, e, pvp, pvpbuf, size) 3320 char *rwset; 3321 char *p1; 3322 char *p2; 3323 ENVELOPE *e; 3324 char ***pvp; 3325 char *pvpbuf; 3326 int size; 3327{ 3328 char *volatile buf; 3329 size_t bufsize; 3330 int volatile rstat = EX_OK; 3331 int rsno; 3332 bool saveQuickAbort = QuickAbort; 3333 bool saveSuprErrs = SuprErrs; 3334 char buf0[MAXLINE]; 3335 extern char MsgBuf[]; 3336 3337 if (tTd(48, 2)) 3338 sm_dprintf("rscap(%s, %s, %s)\n", rwset, p1, 3339 p2 == NULL ? "(NULL)" : p2); 3340 3341 SM_REQUIRE(pvp != NULL); 3342 rsno = strtorwset(rwset, NULL, ST_FIND); 3343 if (rsno < 0) 3344 return EX_UNAVAILABLE; 3345 3346 if (p2 != NULL) 3347 { 3348 bufsize = strlen(p1) + strlen(p2) + 2; 3349 if (bufsize > sizeof(buf0)) 3350 buf = sm_malloc_x(bufsize); 3351 else 3352 { 3353 buf = buf0; 3354 bufsize = sizeof(buf0); 3355 } 3356 (void) sm_snprintf(buf, bufsize, "%s%c%s", p1, CONDELSE, p2); 3357 } 3358 else 3359 { 3360 bufsize = strlen(p1) + 1; 3361 if (bufsize > sizeof(buf0)) 3362 buf = sm_malloc_x(bufsize); 3363 else 3364 { 3365 buf = buf0; 3366 bufsize = sizeof(buf0); 3367 } 3368 (void) sm_strlcpy(buf, p1, bufsize); 3369 } 3370 SM_TRY 3371 { 3372 SuprErrs = true; 3373 QuickAbort = false; 3374 *pvp = prescan(buf, '\0', pvpbuf, size, NULL, IntTokenTab, 3375 false); 3376 if (*pvp != NULL) 3377 rstat = rewrite(*pvp, rsno, 0, e, size); 3378 else 3379 { 3380 if (tTd(48, 2)) 3381 sm_dprintf("rscap: cannot prescan input\n"); 3382 rstat = EX_DATAERR; 3383 } 3384 } 3385 SM_FINALLY 3386 { 3387 /* clean up */ 3388 if (buf != buf0) 3389 sm_free(buf); 3390 SuprErrs = saveSuprErrs; 3391 QuickAbort = saveQuickAbort; 3392 3393 /* prevent information leak, this may contain rewrite error */ 3394 MsgBuf[0] = '\0'; 3395 } 3396 SM_END_TRY 3397 return rstat; 3398} 3399