1 /* 2 * Copyright (c) 1983 Eric P. Allman 3 * Copyright (c) 1988 Regents of the University of California. 4 * All rights reserved. 5 * 6 * %sccs.include.redist.c% 7 */ 8 9 #ifndef lint 10 static char sccsid[] = "@(#)envelope.c 6.15 (Berkeley) 02/26/93"; 11 #endif /* not lint */ 12 13 #include <sys/types.h> 14 #include <sys/time.h> 15 #include <sys/stat.h> 16 #include <pwd.h> 17 #include <fcntl.h> 18 #include "sendmail.h" 19 20 /* 21 ** NEWENVELOPE -- allocate a new envelope 22 ** 23 ** Supports inheritance. 24 ** 25 ** Parameters: 26 ** e -- the new envelope to fill in. 27 ** parent -- the envelope to be the parent of e. 28 ** 29 ** Returns: 30 ** e. 31 ** 32 ** Side Effects: 33 ** none. 34 */ 35 36 ENVELOPE * 37 newenvelope(e, parent) 38 register ENVELOPE *e; 39 register ENVELOPE *parent; 40 { 41 extern putheader(), putbody(); 42 extern ENVELOPE BlankEnvelope; 43 44 if (e == parent && e->e_parent != NULL) 45 parent = e->e_parent; 46 clearenvelope(e, TRUE); 47 if (e == CurEnv) 48 bcopy((char *) &NullAddress, (char *) &e->e_from, sizeof e->e_from); 49 else 50 bcopy((char *) &CurEnv->e_from, (char *) &e->e_from, sizeof e->e_from); 51 e->e_parent = parent; 52 e->e_ctime = curtime(); 53 if (parent != NULL) 54 e->e_msgpriority = parent->e_msgsize; 55 e->e_puthdr = putheader; 56 e->e_putbody = putbody; 57 if (CurEnv->e_xfp != NULL) 58 (void) fflush(CurEnv->e_xfp); 59 60 return (e); 61 } 62 /* 63 ** DROPENVELOPE -- deallocate an envelope. 64 ** 65 ** Parameters: 66 ** e -- the envelope to deallocate. 67 ** 68 ** Returns: 69 ** none. 70 ** 71 ** Side Effects: 72 ** housekeeping necessary to dispose of an envelope. 73 ** Unlocks this queue file. 74 */ 75 76 dropenvelope(e) 77 register ENVELOPE *e; 78 { 79 bool queueit = FALSE; 80 register ADDRESS *q; 81 char *id = e->e_id; 82 83 if (tTd(50, 1)) 84 { 85 printf("dropenvelope %x id=", e); 86 xputs(e->e_id); 87 printf(" flags=%o\n", e->e_flags); 88 } 89 90 if (id == NULL) 91 id = "(none)"; 92 93 #ifdef LOG 94 if (LogLevel > 84) 95 syslog(LOG_DEBUG, "dropenvelope, id=%s, flags=%o, pid=%d", 96 id, e->e_flags, getpid()); 97 #endif /* LOG */ 98 99 /* we must have an id to remove disk files */ 100 if (e->e_id == NULL) 101 return; 102 103 /* 104 ** Extract state information from dregs of send list. 105 */ 106 107 for (q = e->e_sendqueue; q != NULL; q = q->q_next) 108 { 109 if (bitset(QQUEUEUP, q->q_flags)) 110 queueit = TRUE; 111 } 112 113 /* 114 ** Send back return receipts as requested. 115 */ 116 117 if (e->e_receiptto != NULL && bitset(EF_SENDRECEIPT, e->e_flags)) 118 { 119 auto ADDRESS *rlist = NULL; 120 121 (void) sendtolist(e->e_receiptto, (ADDRESS *) NULL, &rlist, e); 122 (void) returntosender("Return receipt", rlist, FALSE, e); 123 } 124 125 /* 126 ** Arrange to send error messages if there are fatal errors. 127 */ 128 129 if (bitset(EF_FATALERRS|EF_TIMEOUT, e->e_flags) && ErrorMode != EM_QUIET) 130 savemail(e); 131 132 /* 133 ** Instantiate or deinstantiate the queue. 134 */ 135 136 if ((!queueit && !bitset(EF_KEEPQUEUE, e->e_flags)) || 137 bitset(EF_CLRQUEUE, e->e_flags)) 138 { 139 if (e->e_df != NULL) 140 xunlink(e->e_df); 141 xunlink(queuename(e, 'q')); 142 } 143 else if (queueit || !bitset(EF_INQUEUE, e->e_flags)) 144 { 145 #ifdef QUEUE 146 queueup(e, FALSE, FALSE); 147 #else /* QUEUE */ 148 syserr("554 dropenvelope: queueup"); 149 #endif /* QUEUE */ 150 } 151 152 /* now unlock the job */ 153 closexscript(e); 154 unlockqueue(e); 155 156 /* make sure that this envelope is marked unused */ 157 e->e_id = e->e_df = NULL; 158 if (e->e_dfp != NULL) 159 (void) fclose(e->e_dfp); 160 e->e_dfp = NULL; 161 162 #ifdef LOG 163 if (LogLevel > 74) 164 syslog(LOG_INFO, "%s: done", id); 165 #endif /* LOG */ 166 } 167 /* 168 ** CLEARENVELOPE -- clear an envelope without unlocking 169 ** 170 ** This is normally used by a child process to get a clean 171 ** envelope without disturbing the parent. 172 ** 173 ** Parameters: 174 ** e -- the envelope to clear. 175 ** fullclear - if set, the current envelope is total 176 ** garbage and should be ignored; otherwise, 177 ** release any resources it may indicate. 178 ** 179 ** Returns: 180 ** none. 181 ** 182 ** Side Effects: 183 ** Closes files associated with the envelope. 184 ** Marks the envelope as unallocated. 185 */ 186 187 clearenvelope(e, fullclear) 188 register ENVELOPE *e; 189 bool fullclear; 190 { 191 register HDR *bh; 192 register HDR **nhp; 193 extern ENVELOPE BlankEnvelope; 194 195 if (!fullclear) 196 { 197 /* clear out any file information */ 198 if (e->e_xfp != NULL) 199 (void) fclose(e->e_xfp); 200 if (e->e_dfp != NULL) 201 (void) fclose(e->e_dfp); 202 } 203 204 /* now clear out the data */ 205 STRUCTCOPY(BlankEnvelope, *e); 206 bh = BlankEnvelope.e_header; 207 nhp = &e->e_header; 208 while (bh != NULL) 209 { 210 *nhp = (HDR *) xalloc(sizeof *bh); 211 bcopy((char *) bh, (char *) *nhp, sizeof *bh); 212 bh = bh->h_link; 213 nhp = &(*nhp)->h_link; 214 } 215 } 216 /* 217 ** INITSYS -- initialize instantiation of system 218 ** 219 ** In Daemon mode, this is done in the child. 220 ** 221 ** Parameters: 222 ** none. 223 ** 224 ** Returns: 225 ** none. 226 ** 227 ** Side Effects: 228 ** Initializes the system macros, some global variables, 229 ** etc. In particular, the current time in various 230 ** forms is set. 231 */ 232 233 initsys(e) 234 register ENVELOPE *e; 235 { 236 static char cbuf[5]; /* holds hop count */ 237 static char pbuf[10]; /* holds pid */ 238 #ifdef TTYNAME 239 static char ybuf[10]; /* holds tty id */ 240 register char *p; 241 #endif /* TTYNAME */ 242 extern char *ttyname(); 243 extern char *macvalue(); 244 extern char Version[]; 245 246 /* 247 ** Give this envelope a reality. 248 ** I.e., an id, a transcript, and a creation time. 249 */ 250 251 openxscript(e); 252 e->e_ctime = curtime(); 253 254 /* 255 ** Set OutChannel to something useful if stdout isn't it. 256 ** This arranges that any extra stuff the mailer produces 257 ** gets sent back to the user on error (because it is 258 ** tucked away in the transcript). 259 */ 260 261 if (OpMode == MD_DAEMON && QueueRun && e->e_xfp != NULL) 262 OutChannel = e->e_xfp; 263 264 /* 265 ** Set up some basic system macros. 266 */ 267 268 /* process id */ 269 (void) sprintf(pbuf, "%d", getpid()); 270 define('p', pbuf, e); 271 272 /* hop count */ 273 (void) sprintf(cbuf, "%d", e->e_hopcount); 274 define('c', cbuf, e); 275 276 /* time as integer, unix time, arpa time */ 277 settime(e); 278 279 #ifdef TTYNAME 280 /* tty name */ 281 if (macvalue('y', e) == NULL) 282 { 283 p = ttyname(2); 284 if (p != NULL) 285 { 286 if (strrchr(p, '/') != NULL) 287 p = strrchr(p, '/') + 1; 288 (void) strcpy(ybuf, p); 289 define('y', ybuf, e); 290 } 291 } 292 #endif /* TTYNAME */ 293 } 294 /* 295 ** SETTIME -- set the current time. 296 ** 297 ** Parameters: 298 ** none. 299 ** 300 ** Returns: 301 ** none. 302 ** 303 ** Side Effects: 304 ** Sets the various time macros -- $a, $b, $d, $t. 305 */ 306 307 settime(e) 308 register ENVELOPE *e; 309 { 310 register char *p; 311 auto time_t now; 312 static char tbuf[20]; /* holds "current" time */ 313 static char dbuf[30]; /* holds ctime(tbuf) */ 314 register struct tm *tm; 315 extern char *arpadate(); 316 extern struct tm *gmtime(); 317 extern char *macvalue(); 318 319 now = curtime(); 320 tm = gmtime(&now); 321 (void) sprintf(tbuf, "%04d%02d%02d%02d%02d", tm->tm_year + 1900, 322 tm->tm_mon+1, tm->tm_mday, tm->tm_hour, tm->tm_min); 323 define('t', tbuf, e); 324 (void) strcpy(dbuf, ctime(&now)); 325 p = strchr(dbuf, '\n'); 326 if (p != NULL) 327 *p = '\0'; 328 define('d', dbuf, e); 329 p = newstr(arpadate(dbuf)); 330 if (macvalue('a', e) == NULL) 331 define('a', p, e); 332 define('b', p, e); 333 } 334 /* 335 ** OPENXSCRIPT -- Open transcript file 336 ** 337 ** Creates a transcript file for possible eventual mailing or 338 ** sending back. 339 ** 340 ** Parameters: 341 ** e -- the envelope to create the transcript in/for. 342 ** 343 ** Returns: 344 ** none 345 ** 346 ** Side Effects: 347 ** Creates the transcript file. 348 */ 349 350 openxscript(e) 351 register ENVELOPE *e; 352 { 353 register char *p; 354 int fd; 355 356 if (e->e_xfp != NULL) 357 return; 358 p = queuename(e, 'x'); 359 fd = open(p, O_WRONLY|O_CREAT, 0644); 360 if (fd < 0) 361 syserr("Can't create %s", p); 362 else 363 e->e_xfp = fdopen(fd, "w"); 364 } 365 /* 366 ** CLOSEXSCRIPT -- close the transcript file. 367 ** 368 ** Parameters: 369 ** e -- the envelope containing the transcript to close. 370 ** 371 ** Returns: 372 ** none. 373 ** 374 ** Side Effects: 375 ** none. 376 */ 377 378 closexscript(e) 379 register ENVELOPE *e; 380 { 381 if (e->e_xfp == NULL) 382 return; 383 (void) fclose(e->e_xfp); 384 e->e_xfp = NULL; 385 } 386 /* 387 ** SETSENDER -- set the person who this message is from 388 ** 389 ** Under certain circumstances allow the user to say who 390 ** s/he is (using -f or -r). These are: 391 ** 1. The user's uid is zero (root). 392 ** 2. The user's login name is in an approved list (typically 393 ** from a network server). 394 ** 3. The address the user is trying to claim has a 395 ** "!" character in it (since #2 doesn't do it for 396 ** us if we are dialing out for UUCP). 397 ** A better check to replace #3 would be if the 398 ** effective uid is "UUCP" -- this would require me 399 ** to rewrite getpwent to "grab" uucp as it went by, 400 ** make getname more nasty, do another passwd file 401 ** scan, or compile the UID of "UUCP" into the code, 402 ** all of which are reprehensible. 403 ** 404 ** Assuming all of these fail, we figure out something 405 ** ourselves. 406 ** 407 ** Parameters: 408 ** from -- the person we would like to believe this message 409 ** is from, as specified on the command line. 410 ** e -- the envelope in which we would like the sender set. 411 ** 412 ** Returns: 413 ** none. 414 ** 415 ** Side Effects: 416 ** sets sendmail's notion of who the from person is. 417 */ 418 419 setsender(from, e) 420 char *from; 421 register ENVELOPE *e; 422 { 423 register char **pvp; 424 char *realname = NULL; 425 register struct passwd *pw; 426 char buf[MAXNAME]; 427 char pvpbuf[PSBUFSIZE]; 428 extern struct passwd *getpwnam(); 429 extern char *macvalue(); 430 extern char **prescan(); 431 extern char *FullName; 432 433 if (tTd(45, 1)) 434 printf("setsender(%s)\n", from == NULL ? "" : from); 435 436 /* 437 ** Figure out the real user executing us. 438 ** Username can return errno != 0 on non-errors. 439 */ 440 441 if (QueueRun || OpMode == MD_SMTP) 442 realname = from; 443 if (realname == NULL || realname[0] == '\0') 444 { 445 extern char *username(); 446 447 realname = username(); 448 } 449 450 /* 451 SuprErrs = TRUE; 452 */ 453 if (from == NULL || parseaddr(from, &e->e_from, 1, '\0', e) == NULL) 454 { 455 /* log garbage addresses for traceback */ 456 # ifdef LOG 457 if (from != NULL && LogLevel > 2) 458 { 459 char *host = RealHostName; 460 461 if (host == NULL) 462 host = MyHostName; 463 syslog(LOG_NOTICE, 464 "from=%s unparseable, received from %s@%s", 465 from, realname, host); 466 } 467 # endif /* LOG */ 468 if (from != NULL) 469 SuprErrs = TRUE; 470 if (from == realname || 471 parseaddr(from = newstr(realname), &e->e_from, 1, '\0', e) == NULL) 472 { 473 SuprErrs = TRUE; 474 if (parseaddr("postmaster", &e->e_from, 1, '\0', e) == NULL) 475 syserr("553 setsender: can't even parse postmaster!"); 476 } 477 } 478 else 479 FromFlag = TRUE; 480 e->e_from.q_flags |= QDONTSEND; 481 if (tTd(45, 5)) 482 { 483 printf("setsender: QDONTSEND "); 484 printaddr(&e->e_from, FALSE); 485 } 486 loweraddr(&e->e_from); 487 SuprErrs = FALSE; 488 489 pvp = NULL; 490 if (e->e_from.q_mailer == LocalMailer) 491 { 492 # ifdef USERDB 493 register char *p; 494 extern char *udbsender(); 495 # endif 496 497 /* if the user has given fullname already, don't redefine */ 498 if (FullName == NULL) 499 FullName = macvalue('x', e); 500 if (FullName != NULL && FullName[0] == '\0') 501 FullName = NULL; 502 503 # ifdef USERDB 504 p = udbsender(from); 505 506 if (p != NULL) 507 { 508 /* 509 ** We have an alternate address for the sender 510 */ 511 512 pvp = prescan(p, '\0', pvpbuf); 513 } 514 # endif /* USERDB */ 515 516 if ((pw = getpwnam(e->e_from.q_user)) != NULL) 517 { 518 /* 519 ** Process passwd file entry. 520 */ 521 522 523 /* extract home directory */ 524 e->e_from.q_home = newstr(pw->pw_dir); 525 define('z', e->e_from.q_home, e); 526 527 /* extract user and group id */ 528 e->e_from.q_uid = pw->pw_uid; 529 e->e_from.q_gid = pw->pw_gid; 530 531 /* extract full name from passwd file */ 532 if (FullName == NULL && pw->pw_gecos != NULL && 533 strcmp(pw->pw_name, e->e_from.q_user) == 0) 534 { 535 buildfname(pw->pw_gecos, e->e_from.q_user, buf); 536 if (buf[0] != '\0') 537 FullName = newstr(buf); 538 } 539 } 540 if (FullName != NULL) 541 define('x', FullName, e); 542 } 543 else 544 { 545 if (e->e_from.q_home == NULL) 546 e->e_from.q_home = getenv("HOME"); 547 e->e_from.q_uid = getuid(); 548 e->e_from.q_gid = getgid(); 549 } 550 551 /* 552 ** Rewrite the from person to dispose of possible implicit 553 ** links in the net. 554 */ 555 556 if (pvp == NULL) 557 pvp = prescan(from, '\0', pvpbuf); 558 if (pvp == NULL) 559 { 560 # ifdef LOG 561 if (LogLevel > 2) 562 syslog(LOG_NOTICE, "cannot prescan from (%s)", from); 563 # endif 564 usrerr("553 cannot prescan from (%s)", from); 565 finis(); 566 } 567 rewrite(pvp, 3); 568 rewrite(pvp, 1); 569 rewrite(pvp, 4); 570 cataddr(pvp, buf, sizeof buf, '\0'); 571 e->e_sender = e->e_returnpath = newstr(buf); 572 573 define('f', e->e_sender, e); 574 575 /* save the domain spec if this mailer wants it */ 576 if (e->e_from.q_mailer != NULL && 577 bitnset(M_CANONICAL, e->e_from.q_mailer->m_flags)) 578 { 579 extern char **copyplist(); 580 581 while (*pvp != NULL && strcmp(*pvp, "@") != 0) 582 pvp++; 583 if (*pvp != NULL) 584 e->e_fromdomain = copyplist(pvp, TRUE); 585 } 586 } 587