contrib/sendmail/src/mci.c

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