1 /* 2 * Copyright (c) 1998-2003 Sendmail, Inc. and its suppliers. 3 * All rights reserved. 4 * Copyright (c) 1995-1997 Eric P. Allman. All rights reserved. 5 * Copyright (c) 1988, 1993 6 * The Regents of the University of California. All rights reserved. 7 * 8 * By using this file, you agree to the terms and conditions set 9 * forth in the LICENSE file which can be found at the top level of 10 * the sendmail distribution. 11 * 12 */ 13 14 #include <sendmail.h> 15 16 SM_RCSID("@(#)$Id: mci.c,v 8.212 2004/08/04 21:11:31 ca Exp $") 17 18 #if NETINET || NETINET6 19 # include <arpa/inet.h> 20 #endif /* NETINET || NETINET6 */ 21 22 #include <dirent.h> 23 24 static int mci_generate_persistent_path __P((const char *, char *, 25 int, bool)); 26 static bool mci_load_persistent __P((MCI *)); 27 static void mci_uncache __P((MCI **, bool)); 28 static int mci_lock_host_statfile __P((MCI *)); 29 static int mci_read_persistent __P((SM_FILE_T *, MCI *)); 30 31 /* 32 ** Mail Connection Information (MCI) Caching Module. 33 ** 34 ** There are actually two separate things cached. The first is 35 ** the set of all open connections -- these are stored in a 36 ** (small) list. The second is stored in the symbol table; it 37 ** has the overall status for all hosts, whether or not there 38 ** is a connection open currently. 39 ** 40 ** There should never be too many connections open (since this 41 ** could flood the socket table), nor should a connection be 42 ** allowed to sit idly for too long. 43 ** 44 ** MaxMciCache is the maximum number of open connections that 45 ** will be supported. 46 ** 47 ** MciCacheTimeout is the time (in seconds) that a connection 48 ** is permitted to survive without activity. 49 ** 50 ** We actually try any cached connections by sending a NOOP 51 ** before we use them; if the NOOP fails we close down the 52 ** connection and reopen it. Note that this means that a 53 ** server SMTP that doesn't support NOOP will hose the 54 ** algorithm -- but that doesn't seem too likely. 55 ** 56 ** The persistent MCI code is donated by Mark Lovell and Paul 57 ** Vixie. It is based on the long term host status code in KJS 58 ** written by Paul but has been adapted by Mark to fit into the 59 ** MCI structure. 60 */ 61 62 static MCI **MciCache; /* the open connection cache */ 63 64 /* 65 ** MCI_CACHE -- enter a connection structure into the open connection cache 66 ** 67 ** This may cause something else to be flushed. 68 ** 69 ** Parameters: 70 ** mci -- the connection to cache. 71 ** 72 ** Returns: 73 ** none. 74 */ 75 76 void 77 mci_cache(mci) 78 register MCI *mci; 79 { 80 register MCI **mcislot; 81 82 /* 83 ** Find the best slot. This may cause expired connections 84 ** to be closed. 85 */ 86 87 mcislot = mci_scan(mci); 88 if (mcislot == NULL) 89 { 90 /* we don't support caching */ 91 return; 92 } 93 94 if (mci->mci_host == NULL) 95 return; 96 97 /* if this is already cached, we are done */ 98 if (bitset(MCIF_CACHED, mci->mci_flags)) 99 return; 100 101 /* otherwise we may have to clear the slot */ 102 if (*mcislot != NULL) 103 mci_uncache(mcislot, true); 104 105 if (tTd(42, 5)) 106 sm_dprintf("mci_cache: caching %p (%s) in slot %d\n", 107 mci, mci->mci_host, (int) (mcislot - MciCache)); 108 if (tTd(91, 100)) 109 sm_syslog(LOG_DEBUG, CurEnv->e_id, 110 "mci_cache: caching %lx (%.100s) in slot %d", 111 (unsigned long) mci, mci->mci_host, 112 (int) (mcislot - MciCache)); 113 114 *mcislot = mci; 115 mci->mci_flags |= MCIF_CACHED; 116 } 117 /* 118 ** MCI_SCAN -- scan the cache, flush junk, and return best slot 119 ** 120 ** Parameters: 121 ** savemci -- never flush this one. Can be null. 122 ** 123 ** Returns: 124 ** The LRU (or empty) slot. 125 */ 126 127 MCI ** 128 mci_scan(savemci) 129 MCI *savemci; 130 { 131 time_t now; 132 register MCI **bestmci; 133 register MCI *mci; 134 register int i; 135 136 if (MaxMciCache <= 0) 137 { 138 /* we don't support caching */ 139 return NULL; 140 } 141 142 if (MciCache == NULL) 143 { 144 /* first call */ 145 MciCache = (MCI **) sm_pmalloc_x(MaxMciCache * sizeof *MciCache); 146 memset((char *) MciCache, '\0', MaxMciCache * sizeof *MciCache); 147 return &MciCache[0]; 148 } 149 150 now = curtime(); 151 bestmci = &MciCache[0]; 152 for (i = 0; i < MaxMciCache; i++) 153 { 154 mci = MciCache[i]; 155 if (mci == NULL || mci->mci_state == MCIS_CLOSED) 156 { 157 bestmci = &MciCache[i]; 158 continue; 159 } 160 if ((mci->mci_lastuse + MciCacheTimeout <= now || 161 (mci->mci_mailer != NULL && 162 mci->mci_mailer->m_maxdeliveries > 0 && 163 mci->mci_deliveries + 1 >= mci->mci_mailer->m_maxdeliveries))&& 164 mci != savemci) 165 { 166 /* connection idle too long or too many deliveries */ 167 bestmci = &MciCache[i]; 168 169 /* close it */ 170 mci_uncache(bestmci, true); 171 continue; 172 } 173 if (*bestmci == NULL) 174 continue; 175 if (mci->mci_lastuse < (*bestmci)->mci_lastuse) 176 bestmci = &MciCache[i]; 177 } 178 return bestmci; 179 } 180 /* 181 ** MCI_UNCACHE -- remove a connection from a slot. 182 ** 183 ** May close a connection. 184 ** 185 ** Parameters: 186 ** mcislot -- the slot to empty. 187 ** doquit -- if true, send QUIT protocol on this connection. 188 ** if false, we are assumed to be in a forked child; 189 ** all we want to do is close the file(s). 190 ** 191 ** Returns: 192 ** none. 193 */ 194 195 static void 196 mci_uncache(mcislot, doquit) 197 register MCI **mcislot; 198 bool doquit; 199 { 200 register MCI *mci; 201 extern ENVELOPE BlankEnvelope; 202 203 mci = *mcislot; 204 if (mci == NULL) 205 return; 206 *mcislot = NULL; 207 if (mci->mci_host == NULL) 208 return; 209 210 mci_unlock_host(mci); 211 212 if (tTd(42, 5)) 213 sm_dprintf("mci_uncache: uncaching %p (%s) from slot %d (%d)\n", 214 mci, mci->mci_host, (int) (mcislot - MciCache), 215 doquit); 216 if (tTd(91, 100)) 217 sm_syslog(LOG_DEBUG, CurEnv->e_id, 218 "mci_uncache: uncaching %lx (%.100s) from slot %d (%d)", 219 (unsigned long) mci, mci->mci_host, 220 (int) (mcislot - MciCache), doquit); 221 222 mci->mci_deliveries = 0; 223 if (doquit) 224 { 225 message("Closing connection to %s", mci->mci_host); 226 227 mci->mci_flags &= ~MCIF_CACHED; 228 229 /* only uses the envelope to flush the transcript file */ 230 if (mci->mci_state != MCIS_CLOSED) 231 smtpquit(mci->mci_mailer, mci, &BlankEnvelope); 232 #if XLA 233 xla_host_end(mci->mci_host); 234 #endif /* XLA */ 235 } 236 else 237 { 238 if (mci->mci_in != NULL) 239 (void) sm_io_close(mci->mci_in, SM_TIME_DEFAULT); 240 if (mci->mci_out != NULL) 241 (void) sm_io_close(mci->mci_out, SM_TIME_DEFAULT); 242 mci->mci_in = mci->mci_out = NULL; 243 mci->mci_state = MCIS_CLOSED; 244 mci->mci_exitstat = EX_OK; 245 mci->mci_errno = 0; 246 mci->mci_flags = 0; 247 248 mci->mci_retryrcpt = false; 249 mci->mci_tolist = NULL; 250 #if PIPELINING 251 mci->mci_okrcpts = 0; 252 #endif /* PIPELINING */ 253 } 254 255 SM_FREE_CLR(mci->mci_status); 256 SM_FREE_CLR(mci->mci_rstatus); 257 SM_FREE_CLR(mci->mci_heloname); 258 if (mci->mci_rpool != NULL) 259 { 260 sm_rpool_free(mci->mci_rpool); 261 mci->mci_macro.mac_rpool = NULL; 262 mci->mci_rpool = NULL; 263 } 264 } 265 /* 266 ** MCI_FLUSH -- flush the entire cache 267 ** 268 ** Parameters: 269 ** doquit -- if true, send QUIT protocol. 270 ** if false, just close the connection. 271 ** allbut -- but leave this one open. 272 ** 273 ** Returns: 274 ** none. 275 */ 276 277 void 278 mci_flush(doquit, allbut) 279 bool doquit; 280 MCI *allbut; 281 { 282 register int i; 283 284 if (MciCache == NULL) 285 return; 286 287 for (i = 0; i < MaxMciCache; i++) 288 { 289 if (allbut != MciCache[i]) 290 mci_uncache(&MciCache[i], doquit); 291 } 292 } 293 /* 294 ** MCI_GET -- get information about a particular host 295 ** 296 ** Parameters: 297 ** host -- host to look for. 298 ** m -- mailer. 299 ** 300 ** Returns: 301 ** mci for this host (might be new). 302 */ 303 304 MCI * 305 mci_get(host, m) 306 char *host; 307 MAILER *m; 308 { 309 register MCI *mci; 310 register STAB *s; 311 extern SOCKADDR CurHostAddr; 312 313 /* clear CurHostAddr so we don't get a bogus address with this name */ 314 memset(&CurHostAddr, '\0', sizeof CurHostAddr); 315 316 /* clear out any expired connections */ 317 (void) mci_scan(NULL); 318 319 if (m->m_mno < 0) 320 syserr("!negative mno %d (%s)", m->m_mno, m->m_name); 321 322 s = stab(host, ST_MCI + m->m_mno, ST_ENTER); 323 mci = &s->s_mci; 324 325 /* initialize per-message data */ 326 mci->mci_retryrcpt = false; 327 mci->mci_tolist = NULL; 328 #if PIPELINING 329 mci->mci_okrcpts = 0; 330 #endif /* PIPELINING */ 331 332 if (mci->mci_rpool == NULL) 333 mci->mci_rpool = sm_rpool_new_x(NULL); 334 335 if (mci->mci_macro.mac_rpool == NULL) 336 mci->mci_macro.mac_rpool = mci->mci_rpool; 337 338 /* 339 ** We don't need to load the persistent data if we have data 340 ** already loaded in the cache. 341 */ 342 343 if (mci->mci_host == NULL && 344 (mci->mci_host = s->s_name) != NULL && 345 !mci_load_persistent(mci)) 346 { 347 if (tTd(42, 2)) 348 sm_dprintf("mci_get(%s %s): lock failed\n", 349 host, m->m_name); 350 mci->mci_exitstat = EX_TEMPFAIL; 351 mci->mci_state = MCIS_CLOSED; 352 mci->mci_statfile = NULL; 353 return mci; 354 } 355 356 if (tTd(42, 2)) 357 { 358 sm_dprintf("mci_get(%s %s): mci_state=%d, _flags=%lx, _exitstat=%d, _errno=%d\n", 359 host, m->m_name, mci->mci_state, mci->mci_flags, 360 mci->mci_exitstat, mci->mci_errno); 361 } 362 363 if (mci->mci_state == MCIS_OPEN) 364 { 365 /* poke the connection to see if it's still alive */ 366 (void) smtpprobe(mci); 367 368 /* reset the stored state in the event of a timeout */ 369 if (mci->mci_state != MCIS_OPEN) 370 { 371 mci->mci_errno = 0; 372 mci->mci_exitstat = EX_OK; 373 mci->mci_state = MCIS_CLOSED; 374 } 375 else 376 { 377 /* get peer host address */ 378 /* (this should really be in the mci struct) */ 379 SOCKADDR_LEN_T socklen = sizeof CurHostAddr; 380 381 (void) getpeername(sm_io_getinfo(mci->mci_in, 382 SM_IO_WHAT_FD, NULL), 383 (struct sockaddr *) &CurHostAddr, &socklen); 384 } 385 } 386 if (mci->mci_state == MCIS_CLOSED) 387 { 388 time_t now = curtime(); 389 390 /* if this info is stale, ignore it */ 391 if (mci->mci_lastuse + MciInfoTimeout <= now) 392 { 393 mci->mci_lastuse = now; 394 mci->mci_errno = 0; 395 mci->mci_exitstat = EX_OK; 396 } 397 } 398 399 return mci; 400 } 401 402 /* 403 ** MCI_CLOSE -- (forcefully) close files used for a connection. 404 ** Note: this is a last resort, usually smtpquit() or endmailer() 405 ** should be used to close a connection. 406 ** 407 ** Parameters: 408 ** mci -- the connection to close. 409 ** where -- where has this been called? 410 ** 411 ** Returns: 412 ** none. 413 */ 414 415 void 416 mci_close(mci, where) 417 MCI *mci; 418 char *where; 419 { 420 bool dumped; 421 422 if (mci == NULL) 423 return; 424 dumped = false; 425 if (mci->mci_out != NULL) 426 { 427 if (tTd(56, 1)) 428 { 429 sm_dprintf("mci_close: mci_out!=NULL, where=%s\n", 430 where); 431 mci_dump(sm_debug_file(), mci, false); 432 dumped = true; 433 } 434 (void) sm_io_close(mci->mci_out, SM_TIME_DEFAULT); 435 mci->mci_out = NULL; 436 } 437 if (mci->mci_in != NULL) 438 { 439 if (tTd(56, 1)) 440 { 441 sm_dprintf("mci_close: mci_in!=NULL, where=%s\n", 442 where); 443 if (!dumped) 444 mci_dump(sm_debug_file(), mci, false); 445 } 446 (void) sm_io_close(mci->mci_in, SM_TIME_DEFAULT); 447 mci->mci_in = NULL; 448 } 449 mci->mci_state = MCIS_CLOSED; 450 } 451 452 /* 453 ** MCI_NEW -- allocate new MCI structure 454 ** 455 ** Parameters: 456 ** rpool -- if non-NULL: allocate from that rpool. 457 ** 458 ** Returns: 459 ** mci (new). 460 */ 461 462 MCI * 463 mci_new(rpool) 464 SM_RPOOL_T *rpool; 465 { 466 register MCI *mci; 467 468 if (rpool == NULL) 469 mci = (MCI *) sm_malloc_x(sizeof *mci); 470 else 471 mci = (MCI *) sm_rpool_malloc_x(rpool, sizeof *mci); 472 memset((char *) mci, '\0', sizeof *mci); 473 mci->mci_rpool = sm_rpool_new_x(NULL); 474 mci->mci_macro.mac_rpool = mci->mci_rpool; 475 return mci; 476 } 477 /* 478 ** MCI_MATCH -- check connection cache for a particular host 479 ** 480 ** Parameters: 481 ** host -- host to look for. 482 ** m -- mailer. 483 ** 484 ** Returns: 485 ** true iff open connection exists. 486 */ 487 488 bool 489 mci_match(host, m) 490 char *host; 491 MAILER *m; 492 { 493 register MCI *mci; 494 register STAB *s; 495 496 if (m->m_mno < 0 || m->m_mno > MAXMAILERS) 497 return false; 498 s = stab(host, ST_MCI + m->m_mno, ST_FIND); 499 if (s == NULL) 500 return false; 501 502 mci = &s->s_mci; 503 return mci->mci_state == MCIS_OPEN; 504 } 505 /* 506 ** MCI_SETSTAT -- set status codes in MCI structure. 507 ** 508 ** Parameters: 509 ** mci -- the MCI structure to set. 510 ** xstat -- the exit status code. 511 ** dstat -- the DSN status code. 512 ** rstat -- the SMTP status code. 513 ** 514 ** Returns: 515 ** none. 516 */ 517 518 void 519 mci_setstat(mci, xstat, dstat, rstat) 520 MCI *mci; 521 int xstat; 522 char *dstat; 523 char *rstat; 524 { 525 /* protocol errors should never be interpreted as sticky */ 526 if (xstat != EX_NOTSTICKY && xstat != EX_PROTOCOL) 527 mci->mci_exitstat = xstat; 528 529 SM_FREE_CLR(mci->mci_status); 530 if (dstat != NULL) 531 mci->mci_status = sm_strdup_x(dstat); 532 533 SM_FREE_CLR(mci->mci_rstatus); 534 if (rstat != NULL) 535 mci->mci_rstatus = sm_strdup_x(rstat); 536 } 537 /* 538 ** MCI_DUMP -- dump the contents of an MCI structure. 539 ** 540 ** Parameters: 541 ** fp -- output file pointer 542 ** mci -- the MCI structure to dump. 543 ** 544 ** Returns: 545 ** none. 546 ** 547 ** Side Effects: 548 ** none. 549 */ 550 551 struct mcifbits 552 { 553 int mcif_bit; /* flag bit */ 554 char *mcif_name; /* flag name */ 555 }; 556 static struct mcifbits MciFlags[] = 557 { 558 { MCIF_VALID, "VALID" }, 559 { MCIF_CACHED, "CACHED" }, 560 { MCIF_ESMTP, "ESMTP" }, 561 { MCIF_EXPN, "EXPN" }, 562 { MCIF_SIZE, "SIZE" }, 563 { MCIF_8BITMIME, "8BITMIME" }, 564 { MCIF_7BIT, "7BIT" }, 565 { MCIF_INHEADER, "INHEADER" }, 566 { MCIF_CVT8TO7, "CVT8TO7" }, 567 { MCIF_DSN, "DSN" }, 568 { MCIF_8BITOK, "8BITOK" }, 569 { MCIF_CVT7TO8, "CVT7TO8" }, 570 { MCIF_INMIME, "INMIME" }, 571 { MCIF_AUTH, "AUTH" }, 572 { MCIF_AUTHACT, "AUTHACT" }, 573 { MCIF_ENHSTAT, "ENHSTAT" }, 574 { MCIF_PIPELINED, "PIPELINED" }, 575 #if STARTTLS 576 { MCIF_TLS, "TLS" }, 577 { MCIF_TLSACT, "TLSACT" }, 578 #endif /* STARTTLS */ 579 { MCIF_DLVR_BY, "DLVR_BY" }, 580 { 0, NULL } 581 }; 582 583 void 584 mci_dump(fp, mci, logit) 585 SM_FILE_T *fp; 586 register MCI *mci; 587 bool logit; 588 { 589 register char *p; 590 char *sep; 591 char buf[4000]; 592 593 sep = logit ? " " : "\n\t"; 594 p = buf; 595 (void) sm_snprintf(p, SPACELEFT(buf, p), "MCI@%p: ", mci); 596 p += strlen(p); 597 if (mci == NULL) 598 { 599 (void) sm_snprintf(p, SPACELEFT(buf, p), "NULL"); 600 goto printit; 601 } 602 (void) sm_snprintf(p, SPACELEFT(buf, p), "flags=%lx", mci->mci_flags); 603 p += strlen(p); 604 605 /* 606 ** The following check is just for paranoia. It protects the 607 ** assignment in the if() clause. If there's not some minimum 608 ** amount of space we can stop right now. The check will not 609 ** trigger as long as sizeof(buf)=4000. 610 */ 611 612 if (p >= buf + sizeof(buf) - 4) 613 goto printit; 614 if (mci->mci_flags != 0) 615 { 616 struct mcifbits *f; 617 618 *p++ = '<'; /* protected above */ 619 for (f = MciFlags; f->mcif_bit != 0; f++) 620 { 621 if (!bitset(f->mcif_bit, mci->mci_flags)) 622 continue; 623 (void) sm_strlcpyn(p, SPACELEFT(buf, p), 2, 624 f->mcif_name, ","); 625 p += strlen(p); 626 } 627 p[-1] = '>'; 628 } 629 630 /* Note: sm_snprintf() takes care of NULL arguments for %s */ 631 (void) sm_snprintf(p, SPACELEFT(buf, p), 632 ",%serrno=%d, herrno=%d, exitstat=%d, state=%d, pid=%d,%s", 633 sep, mci->mci_errno, mci->mci_herrno, 634 mci->mci_exitstat, mci->mci_state, (int) mci->mci_pid, sep); 635 p += strlen(p); 636 (void) sm_snprintf(p, SPACELEFT(buf, p), 637 "maxsize=%ld, phase=%s, mailer=%s,%s", 638 mci->mci_maxsize, mci->mci_phase, 639 mci->mci_mailer == NULL ? "NULL" : mci->mci_mailer->m_name, 640 sep); 641 p += strlen(p); 642 (void) sm_snprintf(p, SPACELEFT(buf, p), 643 "status=%s, rstatus=%s,%s", 644 mci->mci_status, mci->mci_rstatus, sep); 645 p += strlen(p); 646 (void) sm_snprintf(p, SPACELEFT(buf, p), 647 "host=%s, lastuse=%s", 648 mci->mci_host, ctime(&mci->mci_lastuse)); 649 printit: 650 if (logit) 651 sm_syslog(LOG_DEBUG, CurEnv->e_id, "%.1000s", buf); 652 else 653 (void) sm_io_fprintf(fp, SM_TIME_DEFAULT, "%s\n", buf); 654 } 655 /* 656 ** MCI_DUMP_ALL -- print the entire MCI cache 657 ** 658 ** Parameters: 659 ** fp -- output file pointer 660 ** logit -- if set, log the result instead of printing 661 ** to stdout. 662 ** 663 ** Returns: 664 ** none. 665 */ 666 667 void 668 mci_dump_all(fp, logit) 669 SM_FILE_T *fp; 670 bool logit; 671 { 672 register int i; 673 674 if (MciCache == NULL) 675 return; 676 677 for (i = 0; i < MaxMciCache; i++) 678 mci_dump(fp, MciCache[i], logit); 679 } 680 /* 681 ** MCI_LOCK_HOST -- Lock host while sending. 682 ** 683 ** If we are contacting a host, we'll need to 684 ** update the status information in the host status 685 ** file, and if we want to do that, we ought to have 686 ** locked it. This has the (according to some) 687 ** desirable effect of serializing connectivity with 688 ** remote hosts -- i.e.: one connection to a given 689 ** host at a time. 690 ** 691 ** Parameters: 692 ** mci -- containing the host we want to lock. 693 ** 694 ** Returns: 695 ** EX_OK -- got the lock. 696 ** EX_TEMPFAIL -- didn't get the lock. 697 */ 698 699 int 700 mci_lock_host(mci) 701 MCI *mci; 702 { 703 if (mci == NULL) 704 { 705 if (tTd(56, 1)) 706 sm_dprintf("mci_lock_host: NULL mci\n"); 707 return EX_OK; 708 } 709 710 if (!SingleThreadDelivery) 711 return EX_OK; 712 713 return mci_lock_host_statfile(mci); 714 } 715 716 static int 717 mci_lock_host_statfile(mci) 718 MCI *mci; 719 { 720 int save_errno = errno; 721 int retVal = EX_OK; 722 char fname[MAXPATHLEN]; 723 724 if (HostStatDir == NULL || mci->mci_host == NULL) 725 return EX_OK; 726 727 if (tTd(56, 2)) 728 sm_dprintf("mci_lock_host: attempting to lock %s\n", 729 mci->mci_host); 730 731 if (mci_generate_persistent_path(mci->mci_host, fname, sizeof fname, 732 true) < 0) 733 { 734 /* of course this should never happen */ 735 if (tTd(56, 2)) 736 sm_dprintf("mci_lock_host: Failed to generate host path for %s\n", 737 mci->mci_host); 738 739 retVal = EX_TEMPFAIL; 740 goto cleanup; 741 } 742 743 mci->mci_statfile = safefopen(fname, O_RDWR, FileMode, 744 SFF_NOLOCK|SFF_NOLINK|SFF_OPENASROOT|SFF_REGONLY|SFF_SAFEDIRPATH|SFF_CREAT); 745 746 if (mci->mci_statfile == NULL) 747 { 748 syserr("mci_lock_host: cannot create host lock file %s", fname); 749 goto cleanup; 750 } 751 752 if (!lockfile(sm_io_getinfo(mci->mci_statfile, SM_IO_WHAT_FD, NULL), 753 fname, "", LOCK_EX|LOCK_NB)) 754 { 755 if (tTd(56, 2)) 756 sm_dprintf("mci_lock_host: couldn't get lock on %s\n", 757 fname); 758 (void) sm_io_close(mci->mci_statfile, SM_TIME_DEFAULT); 759 mci->mci_statfile = NULL; 760 retVal = EX_TEMPFAIL; 761 goto cleanup; 762 } 763 764 if (tTd(56, 12) && mci->mci_statfile != NULL) 765 sm_dprintf("mci_lock_host: Sanity check -- lock is good\n"); 766 767 cleanup: 768 errno = save_errno; 769 return retVal; 770 } 771 /* 772 ** MCI_UNLOCK_HOST -- unlock host 773 ** 774 ** Clean up the lock on a host, close the file, let 775 ** someone else use it. 776 ** 777 ** Parameters: 778 ** mci -- us. 779 ** 780 ** Returns: 781 ** nothing. 782 */ 783 784 void 785 mci_unlock_host(mci) 786 MCI *mci; 787 { 788 int save_errno = errno; 789 790 if (mci == NULL) 791 { 792 if (tTd(56, 1)) 793 sm_dprintf("mci_unlock_host: NULL mci\n"); 794 return; 795 } 796 797 if (HostStatDir == NULL || mci->mci_host == NULL) 798 return; 799 800 if (!SingleThreadDelivery && mci_lock_host_statfile(mci) == EX_TEMPFAIL) 801 { 802 if (tTd(56, 1)) 803 sm_dprintf("mci_unlock_host: stat file already locked\n"); 804 } 805 else 806 { 807 if (tTd(56, 2)) 808 sm_dprintf("mci_unlock_host: store prior to unlock\n"); 809 mci_store_persistent(mci); 810 } 811 812 if (mci->mci_statfile != NULL) 813 { 814 (void) sm_io_close(mci->mci_statfile, SM_TIME_DEFAULT); 815 mci->mci_statfile = NULL; 816 } 817 818 errno = save_errno; 819 } 820 /* 821 ** MCI_LOAD_PERSISTENT -- load persistent host info 822 ** 823 ** Load information about host that is kept 824 ** in common for all running sendmails. 825 ** 826 ** Parameters: 827 ** mci -- the host/connection to load persistent info for. 828 ** 829 ** Returns: 830 ** true -- lock was successful 831 ** false -- lock failed 832 */ 833 834 static bool 835 mci_load_persistent(mci) 836 MCI *mci; 837 { 838 int save_errno = errno; 839 bool locked = true; 840 SM_FILE_T *fp; 841 char fname[MAXPATHLEN]; 842 843 if (mci == NULL) 844 { 845 if (tTd(56, 1)) 846 sm_dprintf("mci_load_persistent: NULL mci\n"); 847 return true; 848 } 849 850 if (IgnoreHostStatus || HostStatDir == NULL || mci->mci_host == NULL) 851 return true; 852 853 /* Already have the persistent information in memory */ 854 if (SingleThreadDelivery && mci->mci_statfile != NULL) 855 return true; 856 857 if (tTd(56, 1)) 858 sm_dprintf("mci_load_persistent: Attempting to load persistent information for %s\n", 859 mci->mci_host); 860 861 if (mci_generate_persistent_path(mci->mci_host, fname, sizeof fname, 862 false) < 0) 863 { 864 /* Not much we can do if the file isn't there... */ 865 if (tTd(56, 1)) 866 sm_dprintf("mci_load_persistent: Couldn't generate host path\n"); 867 goto cleanup; 868 } 869 870 fp = safefopen(fname, O_RDONLY, FileMode, 871 SFF_NOLOCK|SFF_NOLINK|SFF_OPENASROOT|SFF_REGONLY|SFF_SAFEDIRPATH); 872 if (fp == NULL) 873 { 874 /* I can't think of any reason this should ever happen */ 875 if (tTd(56, 1)) 876 sm_dprintf("mci_load_persistent: open(%s): %s\n", 877 fname, sm_errstring(errno)); 878 goto cleanup; 879 } 880 881 FileName = fname; 882 locked = lockfile(sm_io_getinfo(fp, SM_IO_WHAT_FD, NULL), fname, "", 883 LOCK_SH|LOCK_NB); 884 if (locked) 885 { 886 (void) mci_read_persistent(fp, mci); 887 (void) lockfile(sm_io_getinfo(fp, SM_IO_WHAT_FD, NULL), fname, 888 "", LOCK_UN); 889 } 890 FileName = NULL; 891 (void) sm_io_close(fp, SM_TIME_DEFAULT); 892 893 cleanup: 894 errno = save_errno; 895 return locked; 896 } 897 /* 898 ** MCI_READ_PERSISTENT -- read persistent host status file 899 ** 900 ** Parameters: 901 ** fp -- the file pointer to read. 902 ** mci -- the pointer to fill in. 903 ** 904 ** Returns: 905 ** -1 -- if the file was corrupt. 906 ** 0 -- otherwise. 907 ** 908 ** Warning: 909 ** This code makes the assumption that this data 910 ** will be read in an atomic fashion, and that the data 911 ** was written in an atomic fashion. Any other functioning 912 ** may lead to some form of insanity. This should be 913 ** perfectly safe due to underlying stdio buffering. 914 */ 915 916 static int 917 mci_read_persistent(fp, mci) 918 SM_FILE_T *fp; 919 register MCI *mci; 920 { 921 int ver; 922 register char *p; 923 int saveLineNumber = LineNumber; 924 char buf[MAXLINE]; 925 926 if (fp == NULL) 927 syserr("mci_read_persistent: NULL fp"); 928 if (mci == NULL) 929 syserr("mci_read_persistent: NULL mci"); 930 if (tTd(56, 93)) 931 { 932 sm_dprintf("mci_read_persistent: fp=%lx, mci=", 933 (unsigned long) fp); 934 } 935 936 SM_FREE_CLR(mci->mci_status); 937 SM_FREE_CLR(mci->mci_rstatus); 938 939 sm_io_rewind(fp, SM_TIME_DEFAULT); 940 ver = -1; 941 LineNumber = 0; 942 while (sm_io_fgets(fp, SM_TIME_DEFAULT, buf, sizeof buf) != NULL) 943 { 944 LineNumber++; 945 p = strchr(buf, '\n'); 946 if (p != NULL) 947 *p = '\0'; 948 switch (buf[0]) 949 { 950 case 'V': /* version stamp */ 951 ver = atoi(&buf[1]); 952 if (ver < 0 || ver > 0) 953 syserr("Unknown host status version %d: %d max", 954 ver, 0); 955 break; 956 957 case 'E': /* UNIX error number */ 958 mci->mci_errno = atoi(&buf[1]); 959 break; 960 961 case 'H': /* DNS error number */ 962 mci->mci_herrno = atoi(&buf[1]); 963 break; 964 965 case 'S': /* UNIX exit status */ 966 mci->mci_exitstat = atoi(&buf[1]); 967 break; 968 969 case 'D': /* DSN status */ 970 mci->mci_status = newstr(&buf[1]); 971 break; 972 973 case 'R': /* SMTP status */ 974 mci->mci_rstatus = newstr(&buf[1]); 975 break; 976 977 case 'U': /* last usage time */ 978 mci->mci_lastuse = atol(&buf[1]); 979 break; 980 981 case '.': /* end of file */ 982 if (tTd(56, 93)) 983 mci_dump(sm_debug_file(), mci, false); 984 return 0; 985 986 default: 987 sm_syslog(LOG_CRIT, NOQID, 988 "%s: line %d: Unknown host status line \"%s\"", 989 FileName == NULL ? mci->mci_host : FileName, 990 LineNumber, buf); 991 LineNumber = saveLineNumber; 992 return -1; 993 } 994 } 995 LineNumber = saveLineNumber; 996 if (tTd(56, 93)) 997 sm_dprintf("incomplete (missing dot for EOF)\n"); 998 if (ver < 0) 999 return -1; 1000 return 0; 1001 } 1002 /* 1003 ** MCI_STORE_PERSISTENT -- Store persistent MCI information 1004 ** 1005 ** Store information about host that is kept 1006 ** in common for all running sendmails. 1007 ** 1008 ** Parameters: 1009 ** mci -- the host/connection to store persistent info for. 1010 ** 1011 ** Returns: 1012 ** none. 1013 */ 1014 1015 void 1016 mci_store_persistent(mci) 1017 MCI *mci; 1018 { 1019 int save_errno = errno; 1020 1021 if (mci == NULL) 1022 { 1023 if (tTd(56, 1)) 1024 sm_dprintf("mci_store_persistent: NULL mci\n"); 1025 return; 1026 } 1027 1028 if (HostStatDir == NULL || mci->mci_host == NULL) 1029 return; 1030 1031 if (tTd(56, 1)) 1032 sm_dprintf("mci_store_persistent: Storing information for %s\n", 1033 mci->mci_host); 1034 1035 if (mci->mci_statfile == NULL) 1036 { 1037 if (tTd(56, 1)) 1038 sm_dprintf("mci_store_persistent: no statfile\n"); 1039 return; 1040 } 1041 1042 sm_io_rewind(mci->mci_statfile, SM_TIME_DEFAULT); 1043 #if !NOFTRUNCATE 1044 (void) ftruncate(sm_io_getinfo(mci->mci_statfile, SM_IO_WHAT_FD, NULL), 1045 (off_t) 0); 1046 #endif /* !NOFTRUNCATE */ 1047 1048 (void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT, "V0\n"); 1049 (void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT, "E%d\n", 1050 mci->mci_errno); 1051 (void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT, "H%d\n", 1052 mci->mci_herrno); 1053 (void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT, "S%d\n", 1054 mci->mci_exitstat); 1055 if (mci->mci_status != NULL) 1056 (void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT, 1057 "D%.80s\n", 1058 denlstring(mci->mci_status, true, false)); 1059 if (mci->mci_rstatus != NULL) 1060 (void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT, 1061 "R%.80s\n", 1062 denlstring(mci->mci_rstatus, true, false)); 1063 (void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT, "U%ld\n", 1064 (long)(mci->mci_lastuse)); 1065 (void) sm_io_fprintf(mci->mci_statfile, SM_TIME_DEFAULT, ".\n"); 1066 1067 (void) sm_io_flush(mci->mci_statfile, SM_TIME_DEFAULT); 1068 1069 errno = save_errno; 1070 return; 1071 } 1072 /* 1073 ** MCI_TRAVERSE_PERSISTENT -- walk persistent status tree 1074 ** 1075 ** Recursively find all the mci host files in `pathname'. Default to 1076 ** main host status directory if no path is provided. 1077 ** Call (*action)(pathname, host) for each file found. 1078 ** 1079 ** Note: all information is collected in a list before it is processed. 1080 ** This may not be the best way to do it, but it seems safest, since 1081 ** the file system would be touched while we are attempting to traverse 1082 ** the directory tree otherwise (during purges). 1083 ** 1084 ** Parameters: 1085 ** action -- function to call on each node. If returns < 0, 1086 ** return immediately. 1087 ** pathname -- root of tree. If null, use main host status 1088 ** directory. 1089 ** 1090 ** Returns: 1091 ** < 0 -- if any action routine returns a negative value, that 1092 ** value is returned. 1093 ** 0 -- if we successfully went to completion. 1094 ** > 0 -- return status from action() 1095 */ 1096 1097 int 1098 mci_traverse_persistent(action, pathname) 1099 int (*action)__P((char *, char *)); 1100 char *pathname; 1101 { 1102 struct stat statbuf; 1103 DIR *d; 1104 int ret; 1105 1106 if (pathname == NULL) 1107 pathname = HostStatDir; 1108 if (pathname == NULL) 1109 return -1; 1110 1111 if (tTd(56, 1)) 1112 sm_dprintf("mci_traverse: pathname is %s\n", pathname); 1113 1114 ret = stat(pathname, &statbuf); 1115 if (ret < 0) 1116 { 1117 if (tTd(56, 2)) 1118 sm_dprintf("mci_traverse: Failed to stat %s: %s\n", 1119 pathname, sm_errstring(errno)); 1120 return ret; 1121 } 1122 if (S_ISDIR(statbuf.st_mode)) 1123 { 1124 bool leftone, removedone; 1125 size_t len; 1126 char *newptr; 1127 struct dirent *e; 1128 char newpath[MAXPATHLEN]; 1129 1130 if ((d = opendir(pathname)) == NULL) 1131 { 1132 if (tTd(56, 2)) 1133 sm_dprintf("mci_traverse: opendir %s: %s\n", 1134 pathname, sm_errstring(errno)); 1135 return -1; 1136 } 1137 len = sizeof(newpath) - MAXNAMLEN - 3; 1138 if (sm_strlcpy(newpath, pathname, len) >= len) 1139 { 1140 if (tTd(56, 2)) 1141 sm_dprintf("mci_traverse: path \"%s\" too long", 1142 pathname); 1143 return -1; 1144 } 1145 newptr = newpath + strlen(newpath); 1146 *newptr++ = '/'; 1147 1148 /* 1149 ** repeat until no file has been removed 1150 ** this may become ugly when several files "expire" 1151 ** during these loops, but it's better than doing 1152 ** a rewinddir() inside the inner loop 1153 */ 1154 1155 do 1156 { 1157 leftone = removedone = false; 1158 while ((e = readdir(d)) != NULL) 1159 { 1160 if (e->d_name[0] == '.') 1161 continue; 1162 1163 (void) sm_strlcpy(newptr, e->d_name, 1164 sizeof newpath - 1165 (newptr - newpath)); 1166 1167 if (StopRequest) 1168 stop_sendmail(); 1169 ret = mci_traverse_persistent(action, newpath); 1170 if (ret < 0) 1171 break; 1172 if (ret == 1) 1173 leftone = true; 1174 if (!removedone && ret == 0 && 1175 action == mci_purge_persistent) 1176 removedone = true; 1177 } 1178 if (ret < 0) 1179 break; 1180 1181 /* 1182 ** The following appears to be 1183 ** necessary during purges, since 1184 ** we modify the directory structure 1185 */ 1186 1187 if (removedone) 1188 rewinddir(d); 1189 if (tTd(56, 40)) 1190 sm_dprintf("mci_traverse: path %s: ret %d removed %d left %d\n", 1191 pathname, ret, removedone, leftone); 1192 } while (removedone); 1193 1194 /* purge (or whatever) the directory proper */ 1195 if (!leftone) 1196 { 1197 *--newptr = '\0'; 1198 ret = (*action)(newpath, NULL); 1199 } 1200 (void) closedir(d); 1201 } 1202 else if (S_ISREG(statbuf.st_mode)) 1203 { 1204 char *end = pathname + strlen(pathname) - 1; 1205 char *start; 1206 char *scan; 1207 char host[MAXHOSTNAMELEN]; 1208 char *hostptr = host; 1209 1210 /* 1211 ** Reconstruct the host name from the path to the 1212 ** persistent information. 1213 */ 1214 1215 do 1216 { 1217 if (hostptr != host) 1218 *(hostptr++) = '.'; 1219 start = end; 1220 while (start > pathname && *(start - 1) != '/') 1221 start--; 1222 1223 if (*end == '.') 1224 end--; 1225 1226 for (scan = start; scan <= end; scan++) 1227 *(hostptr++) = *scan; 1228 1229 end = start - 2; 1230 } while (end > pathname && *end == '.'); 1231 1232 *hostptr = '\0'; 1233 1234 /* 1235 ** Do something with the file containing the persistent 1236 ** information. 1237 */ 1238 1239 ret = (*action)(pathname, host); 1240 } 1241 1242 return ret; 1243 } 1244 /* 1245 ** MCI_PRINT_PERSISTENT -- print persistent info 1246 ** 1247 ** Dump the persistent information in the file 'pathname' 1248 ** 1249 ** Parameters: 1250 ** pathname -- the pathname to the status file. 1251 ** hostname -- the corresponding host name. 1252 ** 1253 ** Returns: 1254 ** 0 1255 */ 1256 1257 int 1258 mci_print_persistent(pathname, hostname) 1259 char *pathname; 1260 char *hostname; 1261 { 1262 static bool initflag = false; 1263 SM_FILE_T *fp; 1264 int width = Verbose ? 78 : 25; 1265 bool locked; 1266 MCI mcib; 1267 1268 /* skip directories */ 1269 if (hostname == NULL) 1270 return 0; 1271 1272 if (StopRequest) 1273 stop_sendmail(); 1274 1275 if (!initflag) 1276 { 1277 initflag = true; 1278 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 1279 " -------------- Hostname --------------- How long ago ---------Results---------\n"); 1280 } 1281 1282 fp = safefopen(pathname, O_RDONLY, FileMode, 1283 SFF_NOLOCK|SFF_NOLINK|SFF_OPENASROOT|SFF_REGONLY|SFF_SAFEDIRPATH); 1284 1285 if (fp == NULL) 1286 { 1287 if (tTd(56, 1)) 1288 sm_dprintf("mci_print_persistent: cannot open %s: %s\n", 1289 pathname, sm_errstring(errno)); 1290 return 0; 1291 } 1292 1293 FileName = pathname; 1294 memset(&mcib, '\0', sizeof mcib); 1295 if (mci_read_persistent(fp, &mcib) < 0) 1296 { 1297 syserr("%s: could not read status file", pathname); 1298 (void) sm_io_close(fp, SM_TIME_DEFAULT); 1299 FileName = NULL; 1300 return 0; 1301 } 1302 1303 locked = !lockfile(sm_io_getinfo(fp, SM_IO_WHAT_FD, NULL), pathname, 1304 "", LOCK_SH|LOCK_NB); 1305 (void) sm_io_close(fp, SM_TIME_DEFAULT); 1306 FileName = NULL; 1307 1308 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%c%-39s %12s ", 1309 locked ? '*' : ' ', hostname, 1310 pintvl(curtime() - mcib.mci_lastuse, true)); 1311 if (mcib.mci_rstatus != NULL) 1312 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%.*s\n", width, 1313 mcib.mci_rstatus); 1314 else if (mcib.mci_exitstat == EX_TEMPFAIL && mcib.mci_errno != 0) 1315 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 1316 "Deferred: %.*s\n", width - 10, 1317 sm_errstring(mcib.mci_errno)); 1318 else if (mcib.mci_exitstat != 0) 1319 { 1320 char *exmsg = sm_sysexmsg(mcib.mci_exitstat); 1321 1322 if (exmsg == NULL) 1323 { 1324 char buf[80]; 1325 1326 (void) sm_snprintf(buf, sizeof buf, 1327 "Unknown mailer error %d", 1328 mcib.mci_exitstat); 1329 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%.*s\n", 1330 width, buf); 1331 } 1332 else 1333 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "%.*s\n", 1334 width, &exmsg[5]); 1335 } 1336 else if (mcib.mci_errno == 0) 1337 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "OK\n"); 1338 else 1339 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, "OK: %.*s\n", 1340 width - 4, sm_errstring(mcib.mci_errno)); 1341 1342 return 0; 1343 } 1344 /* 1345 ** MCI_PURGE_PERSISTENT -- Remove a persistence status file. 1346 ** 1347 ** Parameters: 1348 ** pathname -- path to the status file. 1349 ** hostname -- name of host corresponding to that file. 1350 ** NULL if this is a directory (domain). 1351 ** 1352 ** Returns: 1353 ** 0 -- ok 1354 ** 1 -- file not deleted (too young, incorrect format) 1355 ** < 0 -- some error occurred 1356 */ 1357 1358 int 1359 mci_purge_persistent(pathname, hostname) 1360 char *pathname; 1361 char *hostname; 1362 { 1363 struct stat statbuf; 1364 char *end = pathname + strlen(pathname) - 1; 1365 int ret; 1366 1367 if (tTd(56, 1)) 1368 sm_dprintf("mci_purge_persistent: purging %s\n", pathname); 1369 1370 ret = stat(pathname, &statbuf); 1371 if (ret < 0) 1372 { 1373 if (tTd(56, 2)) 1374 sm_dprintf("mci_purge_persistent: Failed to stat %s: %s\n", 1375 pathname, sm_errstring(errno)); 1376 return ret; 1377 } 1378 if (curtime() - statbuf.st_mtime <= MciInfoTimeout) 1379 return 1; 1380 if (hostname != NULL) 1381 { 1382 /* remove the file */ 1383 ret = unlink(pathname); 1384 if (ret < 0) 1385 { 1386 if (LogLevel > 8) 1387 sm_syslog(LOG_ERR, NOQID, 1388 "mci_purge_persistent: failed to unlink %s: %s", 1389 pathname, sm_errstring(errno)); 1390 if (tTd(56, 2)) 1391 sm_dprintf("mci_purge_persistent: failed to unlink %s: %s\n", 1392 pathname, sm_errstring(errno)); 1393 return ret; 1394 } 1395 } 1396 else 1397 { 1398 /* remove the directory */ 1399 if (*end != '.') 1400 return 1; 1401 1402 if (tTd(56, 1)) 1403 sm_dprintf("mci_purge_persistent: dpurge %s\n", pathname); 1404 1405 ret = rmdir(pathname); 1406 if (ret < 0) 1407 { 1408 if (tTd(56, 2)) 1409 sm_dprintf("mci_purge_persistent: rmdir %s: %s\n", 1410 pathname, sm_errstring(errno)); 1411 return ret; 1412 } 1413 } 1414 1415 return 0; 1416 } 1417 /* 1418 ** MCI_GENERATE_PERSISTENT_PATH -- generate path from hostname 1419 ** 1420 ** Given `host', convert from a.b.c to $HostStatDir/c./b./a, 1421 ** putting the result into `path'. if `createflag' is set, intervening 1422 ** directories will be created as needed. 1423 ** 1424 ** Parameters: 1425 ** host -- host name to convert from. 1426 ** path -- place to store result. 1427 ** pathlen -- length of path buffer. 1428 ** createflag -- if set, create intervening directories as 1429 ** needed. 1430 ** 1431 ** Returns: 1432 ** 0 -- success 1433 ** -1 -- failure 1434 */ 1435 1436 static int 1437 mci_generate_persistent_path(host, path, pathlen, createflag) 1438 const char *host; 1439 char *path; 1440 int pathlen; 1441 bool createflag; 1442 { 1443 char *elem, *p, *x, ch; 1444 int ret = 0; 1445 int len; 1446 char t_host[MAXHOSTNAMELEN]; 1447 #if NETINET6 1448 struct in6_addr in6_addr; 1449 #endif /* NETINET6 */ 1450 1451 /* 1452 ** Rationality check the arguments. 1453 */ 1454 1455 if (host == NULL) 1456 { 1457 syserr("mci_generate_persistent_path: null host"); 1458 return -1; 1459 } 1460 if (path == NULL) 1461 { 1462 syserr("mci_generate_persistent_path: null path"); 1463 return -1; 1464 } 1465 1466 if (tTd(56, 80)) 1467 sm_dprintf("mci_generate_persistent_path(%s): ", host); 1468 1469 if (*host == '\0' || *host == '.') 1470 return -1; 1471 1472 /* make certain this is not a bracketed host number */ 1473 if (strlen(host) > sizeof t_host - 1) 1474 return -1; 1475 if (host[0] == '[') 1476 (void) sm_strlcpy(t_host, host + 1, sizeof t_host); 1477 else 1478 (void) sm_strlcpy(t_host, host, sizeof t_host); 1479 1480 /* 1481 ** Delete any trailing dots from the hostname. 1482 ** Leave 'elem' pointing at the \0. 1483 */ 1484 1485 elem = t_host + strlen(t_host); 1486 while (elem > t_host && 1487 (elem[-1] == '.' || (host[0] == '[' && elem[-1] == ']'))) 1488 *--elem = '\0'; 1489 1490 /* check for bogus bracketed address */ 1491 if (host[0] == '[') 1492 { 1493 bool good = false; 1494 # if NETINET6 1495 if (anynet_pton(AF_INET6, t_host, &in6_addr) == 1) 1496 good = true; 1497 # endif /* NETINET6 */ 1498 # if NETINET 1499 if (inet_addr(t_host) != INADDR_NONE) 1500 good = true; 1501 # endif /* NETINET */ 1502 if (!good) 1503 return -1; 1504 } 1505 1506 /* check for what will be the final length of the path */ 1507 len = strlen(HostStatDir) + 2; 1508 for (p = (char *) t_host; *p != '\0'; p++) 1509 { 1510 if (*p == '.') 1511 len++; 1512 len++; 1513 if (p[0] == '.' && p[1] == '.') 1514 return -1; 1515 } 1516 if (len > pathlen || len < 1) 1517 return -1; 1518 (void) sm_strlcpy(path, HostStatDir, pathlen); 1519 p = path + strlen(path); 1520 while (elem > t_host) 1521 { 1522 if (!path_is_dir(path, createflag)) 1523 { 1524 ret = -1; 1525 break; 1526 } 1527 elem--; 1528 while (elem >= t_host && *elem != '.') 1529 elem--; 1530 *p++ = '/'; 1531 x = elem + 1; 1532 while ((ch = *x++) != '\0' && ch != '.') 1533 { 1534 if (isascii(ch) && isupper(ch)) 1535 ch = tolower(ch); 1536 if (ch == '/') 1537 ch = ':'; /* / -> : */ 1538 *p++ = ch; 1539 } 1540 if (elem >= t_host) 1541 *p++ = '.'; 1542 *p = '\0'; 1543 } 1544 if (tTd(56, 80)) 1545 { 1546 if (ret < 0) 1547 sm_dprintf("FAILURE %d\n", ret); 1548 else 1549 sm_dprintf("SUCCESS %s\n", path); 1550 } 1551 return ret; 1552 } 1553