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