contrib/sendmail/src/daemon.c

   1 /*
   2  * Copyright (c) 1998-2007, 2009, 2010 Proofpoint, Inc. and its suppliers.
   3  *      All rights reserved.
   4  * Copyright (c) 1983, 1995-1997 Eric P. Allman.  All rights reserved.
   5  * Copyright (c) 1988, 1993
   6  *      The Regents of the University of California.  All rights reserved.
   7  *
   8  * By using this file, you agree to the terms and conditions set
   9  * forth in the LICENSE file which can be found at the top level of
  10  * the sendmail distribution.
  11  *
  12  */
  13
  14 #include <sendmail.h>
  15 #include "map.h"
  16
  17 SM_RCSID("@(#)$Id: daemon.c,v 8.698 2013-11-22 20:51:55 ca Exp $")
  18
  19 #if defined(SOCK_STREAM) || defined(__GNU_LIBRARY__)
  20 # define USE_SOCK_STREAM        1
  21 #endif /* defined(SOCK_STREAM) || defined(__GNU_LIBRARY__) */
  22
  23 #if defined(USE_SOCK_STREAM)
  24 # if NETINET || NETINET6
  25 #  include <arpa/inet.h>
  26 # endif /* NETINET || NETINET6 */
  27 # if NAMED_BIND
  28 #  ifndef NO_DATA
  29 #   define NO_DATA      NO_ADDRESS
  30 #  endif /* ! NO_DATA */
  31 # endif /* NAMED_BIND */
  32 #endif /* defined(USE_SOCK_STREAM) */
  33
  34 #if STARTTLS
  35 # include <openssl/rand.h>
  36 #endif /* STARTTLS */
  37
  38 #include <sm/time.h>
  39
  40 #if IP_SRCROUTE && NETINET
  41 # include <netinet/in_systm.h>
  42 # include <netinet/ip.h>
  43 # if HAS_IN_H
  44 #  include <netinet/in.h>
  45 #  ifndef IPOPTION
  46 #   define IPOPTION     ip_opts
  47 #   define IP_LIST      ip_opts
  48 #   define IP_DST       ip_dst
  49 #  endif /* ! IPOPTION */
  50 # else /* HAS_IN_H */
  51 #  include <netinet/ip_var.h>
  52 #  ifndef IPOPTION
  53 #   define IPOPTION     ipoption
  54 #   define IP_LIST      ipopt_list
  55 #   define IP_DST       ipopt_dst
  56 #  endif /* ! IPOPTION */
  57 # endif /* HAS_IN_H */
  58 #endif /* IP_SRCROUTE && NETINET */
  59
  60 #include <sm/fdset.h>
  61
  62 #define DAEMON_C 1
  63 #include <daemon.h>
  64
  65 static void             connecttimeout __P((int));
  66 static int              opendaemonsocket __P((DAEMON_T *, bool));
  67 static unsigned short   setupdaemon __P((SOCKADDR *));
  68 static void             getrequests_checkdiskspace __P((ENVELOPE *e));
  69 static void             setsockaddroptions __P((char *, DAEMON_T *));
  70 static void             printdaemonflags __P((DAEMON_T *));
  71 static int              addr_family __P((char *));
  72 static int              addrcmp __P((struct hostent *, char *, SOCKADDR *));
  73 static void             authtimeout __P((int));
  74
  75 /*
  76 **  DAEMON.C -- routines to use when running as a daemon.
  77 **
  78 **      This entire file is highly dependent on the 4.2 BSD
  79 **      interprocess communication primitives.  No attempt has
  80 **      been made to make this file portable to Version 7,
  81 **      Version 6, MPX files, etc.  If you should try such a
  82 **      thing yourself, I recommend chucking the entire file
  83 **      and starting from scratch.  Basic semantics are:
  84 **
  85 **      getrequests(e)
  86 **              Opens a port and initiates a connection.
  87 **              Returns in a child.  Must set InChannel and
  88 **              OutChannel appropriately.
  89 **      clrdaemon()
  90 **              Close any open files associated with getting
  91 **              the connection; this is used when running the queue,
  92 **              etc., to avoid having extra file descriptors during
  93 **              the queue run and to avoid confusing the network
  94 **              code (if it cares).
  95 **      makeconnection(host, port, mci, e, enough)
  96 **              Make a connection to the named host on the given
  97 **              port. Returns zero on success, else an exit status
  98 **              describing the error.
  99 **      host_map_lookup(map, hbuf, avp, pstat)
 100 **              Convert the entry in hbuf into a canonical form.
 101 */
 102
 103 static int      NDaemons = 0;                   /* actual number of daemons */
 104
 105 static time_t   NextDiskSpaceCheck = 0;
 106
 107 /*
 108 **  GETREQUESTS -- open mail IPC port and get requests.
 109 **
 110 **      Parameters:
 111 **              e -- the current envelope.
 112 **
 113 **      Returns:
 114 **              pointer to flags.
 115 **
 116 **      Side Effects:
 117 **              Waits until some interesting activity occurs.  When
 118 **              it does, a child is created to process it, and the
 119 **              parent waits for completion.  Return from this
 120 **              routine is always in the child.  The file pointers
 121 **              "InChannel" and "OutChannel" should be set to point
 122 **              to the communication channel.
 123 **              May restart persistent queue runners if they have ended
 124 **              for some reason.
 125 */
 126
 127 BITMAP256 *
 128 getrequests(e)
 129         ENVELOPE *e;
 130 {
 131         int t;
 132         int idx, curdaemon = -1;
 133         int i, olddaemon = 0;
 134 #if XDEBUG
 135         bool j_has_dot;
 136 #endif /* XDEBUG */
 137         char status[MAXLINE];
 138         SOCKADDR sa;
 139         SOCKADDR_LEN_T len = sizeof(sa);
 140 #if _FFR_QUEUE_RUN_PARANOIA
 141         time_t lastrun;
 142 #endif /* _FFR_QUEUE_RUN_PARANOIA */
 143 # if NETUNIX
 144         extern int ControlSocket;
 145 # endif /* NETUNIX */
 146         extern ENVELOPE BlankEnvelope;
 147
 148
 149         /* initialize data for function that generates queue ids */
 150         init_qid_alg();
 151         for (idx = 0; idx < NDaemons; idx++)
 152         {
 153                 Daemons[idx].d_port = setupdaemon(&(Daemons[idx].d_addr));
 154                 Daemons[idx].d_firsttime = true;
 155                 Daemons[idx].d_refuse_connections_until = (time_t) 0;
 156         }
 157
 158         /*
 159         **  Try to actually open the connection.
 160         */
 161
 162         if (tTd(15, 1))
 163         {
 164                 for (idx = 0; idx < NDaemons; idx++)
 165                 {
 166                         sm_dprintf("getrequests: daemon %s: port %d\n",
 167                                    Daemons[idx].d_name,
 168                                    ntohs(Daemons[idx].d_port));
 169                 }
 170         }
 171
 172         /* get a socket for the SMTP connection */
 173         for (idx = 0; idx < NDaemons; idx++)
 174                 Daemons[idx].d_socksize = opendaemonsocket(&Daemons[idx], true);
 175
 176         if (opencontrolsocket() < 0)
 177                 sm_syslog(LOG_WARNING, NOQID,
 178                           "daemon could not open control socket %s: %s",
 179                           ControlSocketName, sm_errstring(errno));
 180
 181         /* If there are any queue runners released reapchild() co-ord's */
 182         (void) sm_signal(SIGCHLD, reapchild);
 183
 184         /* write the pid to file, command line args to syslog */
 185         log_sendmail_pid(e);
 186
 187 #if XDEBUG
 188         {
 189                 char jbuf[MAXHOSTNAMELEN];
 190
 191                 expand("\201j", jbuf, sizeof(jbuf), e);
 192                 j_has_dot = strchr(jbuf, '.') != NULL;
 193         }
 194 #endif /* XDEBUG */
 195
 196         /* Add parent process as first item */
 197         proc_list_add(CurrentPid, "Sendmail daemon", PROC_DAEMON, 0, -1, NULL);
 198
 199         if (tTd(15, 1))
 200         {
 201                 for (idx = 0; idx < NDaemons; idx++)
 202                         sm_dprintf("getrequests: daemon %s: socket %d\n",
 203                                 Daemons[idx].d_name,
 204                                 Daemons[idx].d_socket);
 205         }
 206
 207         for (;;)
 208         {
 209                 register pid_t pid;
 210                 auto SOCKADDR_LEN_T lotherend;
 211                 bool timedout = false;
 212                 bool control = false;
 213                 int save_errno;
 214                 int pipefd[2];
 215                 time_t now;
 216 #if STARTTLS
 217                 long seed;
 218 #endif /* STARTTLS */
 219
 220                 /* see if we are rejecting connections */
 221                 (void) sm_blocksignal(SIGALRM);
 222                 CHECK_RESTART;
 223
 224                 for (idx = 0; idx < NDaemons; idx++)
 225                 {
 226                         /*
 227                         **  XXX do this call outside the loop?
 228                         **      no: refuse_connections may sleep().
 229                         */
 230
 231                         now = curtime();
 232                         if (now < Daemons[idx].d_refuse_connections_until)
 233                                 continue;
 234                         if (bitnset(D_DISABLE, Daemons[idx].d_flags))
 235                                 continue;
 236                         if (refuseconnections(e, idx, curdaemon == idx))
 237                         {
 238                                 if (Daemons[idx].d_socket >= 0)
 239                                 {
 240                                         /* close socket so peer fails quickly */
 241                                         (void) close(Daemons[idx].d_socket);
 242                                         Daemons[idx].d_socket = -1;
 243                                 }
 244
 245                                 /* refuse connections for next 15 seconds */
 246                                 Daemons[idx].d_refuse_connections_until = now + 15;
 247                         }
 248                         else if (Daemons[idx].d_socket < 0 ||
 249                                  Daemons[idx].d_firsttime)
 250                         {
 251                                 if (!Daemons[idx].d_firsttime && LogLevel > 8)
 252                                         sm_syslog(LOG_INFO, NOQID,
 253                                                 "accepting connections again for daemon %s",
 254                                                 Daemons[idx].d_name);
 255
 256                                 /* arrange to (re)open the socket if needed */
 257                                 (void) opendaemonsocket(&Daemons[idx], false);
 258                                 Daemons[idx].d_firsttime = false;
 259                         }
 260                 }
 261
 262                 /* May have been sleeping above, check again */
 263                 CHECK_RESTART;
 264
 265                 getrequests_checkdiskspace(e);
 266
 267 #if XDEBUG
 268                 /* check for disaster */
 269                 {
 270                         char jbuf[MAXHOSTNAMELEN];
 271
 272                         expand("\201j", jbuf, sizeof(jbuf), e);
 273                         if (!wordinclass(jbuf, 'w'))
 274                         {
 275                                 dumpstate("daemon lost $j");
 276                                 sm_syslog(LOG_ALERT, NOQID,
 277                                           "daemon process doesn't have $j in $=w; see syslog");
 278                                 abort();
 279                         }
 280                         else if (j_has_dot && strchr(jbuf, '.') == NULL)
 281                         {
 282                                 dumpstate("daemon $j lost dot");
 283                                 sm_syslog(LOG_ALERT, NOQID,
 284                                           "daemon process $j lost dot; see syslog");
 285                                 abort();
 286                         }
 287                 }
 288 #endif /* XDEBUG */
 289
 290 #if 0
 291                 /*
 292                 **  Andrew Sun <asun@ieps-sun.ml.com> claims that this will
 293                 **  fix the SVr4 problem.  But it seems to have gone away,
 294                 **  so is it worth doing this?
 295                 */
 296
 297                 if (DaemonSocket >= 0 &&
 298                     SetNonBlocking(DaemonSocket, false) < 0)
 299                         log an error here;
 300 #endif /* 0 */
 301                 (void) sm_releasesignal(SIGALRM);
 302
 303                 for (;;)
 304                 {
 305                         bool setproc = false;
 306                         int highest = -1;
 307                         fd_set readfds;
 308                         struct timeval timeout;
 309
 310                         CHECK_RESTART;
 311                         FD_ZERO(&readfds);
 312                         for (idx = 0; idx < NDaemons; idx++)
 313                         {
 314                                 /* wait for a connection */
 315                                 if (Daemons[idx].d_socket >= 0)
 316                                 {
 317                                         if (!setproc &&
 318                                             !bitnset(D_ETRNONLY,
 319                                                      Daemons[idx].d_flags))
 320                                         {
 321                                                 sm_setproctitle(true, e,
 322                                                                 "accepting connections");
 323                                                 setproc = true;
 324                                         }
 325                                         if (Daemons[idx].d_socket > highest)
 326                                                 highest = Daemons[idx].d_socket;
 327                                         SM_FD_SET(Daemons[idx].d_socket,
 328                                                   &readfds);
 329                                 }
 330                         }
 331
 332 #if NETUNIX
 333                         if (ControlSocket >= 0)
 334                         {
 335                                 if (ControlSocket > highest)
 336                                         highest = ControlSocket;
 337                                 SM_FD_SET(ControlSocket, &readfds);
 338                         }
 339 #endif /* NETUNIX */
 340
 341                         timeout.tv_sec = 5;
 342                         timeout.tv_usec = 0;
 343
 344                         t = select(highest + 1, FDSET_CAST &readfds,
 345                                    NULL, NULL, &timeout);
 346
 347                         /* Did someone signal while waiting? */
 348                         CHECK_RESTART;
 349
 350                         curdaemon = -1;
 351                         if (doqueuerun())
 352                         {
 353                                 (void) runqueue(true, false, false, false);
 354 #if _FFR_QUEUE_RUN_PARANOIA
 355                                 lastrun = now;
 356 #endif /* _FFR_QUEUE_RUN_PARANOIA */
 357                         }
 358 #if _FFR_QUEUE_RUN_PARANOIA
 359                         else if (CheckQueueRunners > 0 && QueueIntvl > 0 &&
 360                                  lastrun + QueueIntvl + CheckQueueRunners < now)
 361                         {
 362
 363                                 /*
 364                                 **  set lastrun unconditionally to avoid
 365                                 **  calling checkqueuerunner() all the time.
 366                                 **  That's also why we currently ignore the
 367                                 **  result of the function call.
 368                                 */
 369
 370                                 (void) checkqueuerunner();
 371                                 lastrun = now;
 372                         }
 373 #endif /* _FFR_QUEUE_RUN_PARANOIA */
 374
 375                         if (t <= 0)
 376                         {
 377                                 timedout = true;
 378                                 break;
 379                         }
 380
 381                         control = false;
 382                         errno = 0;
 383
 384                         /* look "round-robin" for an active socket */
 385                         if ((idx = olddaemon + 1) >= NDaemons)
 386                                 idx = 0;
 387                         for (i = 0; i < NDaemons; i++)
 388                         {
 389                                 if (Daemons[idx].d_socket >= 0 &&
 390                                     SM_FD_ISSET(Daemons[idx].d_socket,
 391                                                 &readfds))
 392                                 {
 393                                         lotherend = Daemons[idx].d_socksize;
 394                                         memset(&RealHostAddr, '\0',
 395                                                sizeof(RealHostAddr));
 396                                         t = accept(Daemons[idx].d_socket,
 397                                                    (struct sockaddr *)&RealHostAddr,
 398                                                    &lotherend);
 399
 400                                         /*
 401                                         **  If remote side closes before
 402                                         **  accept() finishes, sockaddr
 403                                         **  might not be fully filled in.
 404                                         */
 405
 406                                         if (t >= 0 &&
 407                                             (lotherend == 0 ||
 408 # ifdef BSD4_4_SOCKADDR
 409                                              RealHostAddr.sa.sa_len == 0 ||
 410 # endif /* BSD4_4_SOCKADDR */
 411                                              RealHostAddr.sa.sa_family != Daemons[idx].d_addr.sa.sa_family))
 412                                         {
 413                                                 (void) close(t);
 414                                                 t = -1;
 415                                                 errno = EINVAL;
 416                                         }
 417                                         olddaemon = curdaemon = idx;
 418                                         break;
 419                                 }
 420                                 if (++idx >= NDaemons)
 421                                         idx = 0;
 422                         }
 423 #if NETUNIX
 424                         if (curdaemon == -1 && ControlSocket >= 0 &&
 425                             SM_FD_ISSET(ControlSocket, &readfds))
 426                         {
 427                                 struct sockaddr_un sa_un;
 428
 429                                 lotherend = sizeof(sa_un);
 430                                 memset(&sa_un, '\0', sizeof(sa_un));
 431                                 t = accept(ControlSocket,
 432                                            (struct sockaddr *)&sa_un,
 433                                            &lotherend);
 434
 435                                 /*
 436                                 **  If remote side closes before
 437                                 **  accept() finishes, sockaddr
 438                                 **  might not be fully filled in.
 439                                 */
 440
 441                                 if (t >= 0 &&
 442                                     (lotherend == 0 ||
 443 # ifdef BSD4_4_SOCKADDR
 444                                      sa_un.sun_len == 0 ||
 445 # endif /* BSD4_4_SOCKADDR */
 446                                      sa_un.sun_family != AF_UNIX))
 447                                 {
 448                                         (void) close(t);
 449                                         t = -1;
 450                                         errno = EINVAL;
 451                                 }
 452                                 if (t >= 0)
 453                                         control = true;
 454                         }
 455 #else /* NETUNIX */
 456                         if (curdaemon == -1)
 457                         {
 458                                 /* No daemon to service */
 459                                 continue;
 460                         }
 461 #endif /* NETUNIX */
 462                         if (t >= 0 || errno != EINTR)
 463                                 break;
 464                 }
 465                 if (timedout)
 466                 {
 467                         timedout = false;
 468                         continue;
 469                 }
 470                 save_errno = errno;
 471                 (void) sm_blocksignal(SIGALRM);
 472                 if (t < 0)
 473                 {
 474                         errno = save_errno;
 475
 476                         /* let's ignore these temporary errors */
 477                         if (save_errno == EINTR
 478 #ifdef EAGAIN
 479                             || save_errno == EAGAIN
 480 #endif /* EAGAIN */
 481 #ifdef ECONNABORTED
 482                             || save_errno == ECONNABORTED
 483 #endif /* ECONNABORTED */
 484 #ifdef EWOULDBLOCK
 485                             || save_errno == EWOULDBLOCK
 486 #endif /* EWOULDBLOCK */
 487                            )
 488                                 continue;
 489
 490                         syserr("getrequests: accept");
 491
 492                         if (curdaemon >= 0)
 493                         {
 494                                 /* arrange to re-open socket next time around */
 495                                 (void) close(Daemons[curdaemon].d_socket);
 496                                 Daemons[curdaemon].d_socket = -1;
 497 #if SO_REUSEADDR_IS_BROKEN
 498                                 /*
 499                                 **  Give time for bound socket to be released.
 500                                 **  This creates a denial-of-service if you can
 501                                 **  force accept() to fail on affected systems.
 502                                 */
 503
 504                                 Daemons[curdaemon].d_refuse_connections_until =
 505                                         curtime() + 15;
 506 #endif /* SO_REUSEADDR_IS_BROKEN */
 507                         }
 508                         continue;
 509                 }
 510
 511                 if (!control)
 512                 {
 513                         /* set some daemon related macros */
 514                         switch (Daemons[curdaemon].d_addr.sa.sa_family)
 515                         {
 516                           case AF_UNSPEC:
 517                                 macdefine(&BlankEnvelope.e_macro, A_PERM,
 518                                         macid("{daemon_family}"), "unspec");
 519                                 break;
 520 #if NETUNIX
 521                           case AF_UNIX:
 522                                 macdefine(&BlankEnvelope.e_macro, A_PERM,
 523                                         macid("{daemon_family}"), "local");
 524                                 break;
 525 #endif /* NETUNIX */
 526 #if NETINET
 527                           case AF_INET:
 528                                 macdefine(&BlankEnvelope.e_macro, A_PERM,
 529                                         macid("{daemon_family}"), "inet");
 530                                 break;
 531 #endif /* NETINET */
 532 #if NETINET6
 533                           case AF_INET6:
 534                                 macdefine(&BlankEnvelope.e_macro, A_PERM,
 535                                         macid("{daemon_family}"), "inet6");
 536                                 break;
 537 #endif /* NETINET6 */
 538 #if NETISO
 539                           case AF_ISO:
 540                                 macdefine(&BlankEnvelope.e_macro, A_PERM,
 541                                         macid("{daemon_family}"), "iso");
 542                                 break;
 543 #endif /* NETISO */
 544 #if NETNS
 545                           case AF_NS:
 546                                 macdefine(&BlankEnvelope.e_macro, A_PERM,
 547                                         macid("{daemon_family}"), "ns");
 548                                 break;
 549 #endif /* NETNS */
 550 #if NETX25
 551                           case AF_CCITT:
 552                                 macdefine(&BlankEnvelope.e_macro, A_PERM,
 553                                         macid("{daemon_family}"), "x.25");
 554                                 break;
 555 #endif /* NETX25 */
 556                         }
 557                         macdefine(&BlankEnvelope.e_macro, A_PERM,
 558                                 macid("{daemon_name}"),
 559                                 Daemons[curdaemon].d_name);
 560                         if (Daemons[curdaemon].d_mflags != NULL)
 561                                 macdefine(&BlankEnvelope.e_macro, A_PERM,
 562                                         macid("{daemon_flags}"),
 563                                         Daemons[curdaemon].d_mflags);
 564                         else
 565                                 macdefine(&BlankEnvelope.e_macro, A_PERM,
 566                                         macid("{daemon_flags}"), "");
 567                 }
 568
 569                 /*
 570                 **  If connection rate is exceeded here, connection shall be
 571                 **  refused later by a new call after fork() by the
 572                 **  validate_connection() function. Closing the connection
 573                 **  at this point violates RFC 2821.
 574                 **  Do NOT remove this call, its side effects are needed.
 575                 */
 576
 577                 connection_rate_check(&RealHostAddr, NULL);
 578
 579                 /*
 580                 **  Create a subprocess to process the mail.
 581                 */
 582
 583                 if (tTd(15, 2))
 584                         sm_dprintf("getrequests: forking (fd = %d)\n", t);
 585
 586                 /*
 587                 **  Advance state of PRNG.
 588                 **  This is necessary because otherwise all child processes
 589                 **  will produce the same PRN sequence and hence the selection
 590                 **  of a queue directory (and other things, e.g., MX selection)
 591                 **  are not "really" random.
 592                 */
 593 #if STARTTLS
 594                 /* XXX get some better "random" data? */
 595                 seed = get_random();
 596                 RAND_seed((void *) &NextDiskSpaceCheck,
 597                           sizeof(NextDiskSpaceCheck));
 598                 RAND_seed((void *) &now, sizeof(now));
 599                 RAND_seed((void *) &seed, sizeof(seed));
 600 #else /* STARTTLS */
 601                 (void) get_random();
 602 #endif /* STARTTLS */
 603
 604 #if NAMED_BIND
 605                 /*
 606                 **  Update MX records for FallbackMX.
 607                 **  Let's hope this is fast otherwise we screw up the
 608                 **  response time.
 609                 */
 610
 611                 if (FallbackMX != NULL)
 612                         (void) getfallbackmxrr(FallbackMX);
 613 #endif /* NAMED_BIND */
 614
 615                 if (tTd(93, 100))
 616                 {
 617                         /* don't fork, handle connection in this process */
 618                         pid = 0;
 619                         pipefd[0] = pipefd[1] = -1;
 620                 }
 621                 else
 622                 {
 623                         /*
 624                         **  Create a pipe to keep the child from writing to
 625                         **  the socket until after the parent has closed
 626                         **  it.  Otherwise the parent may hang if the child
 627                         **  has closed it first.
 628                         */
 629
 630                         if (pipe(pipefd) < 0)
 631                                 pipefd[0] = pipefd[1] = -1;
 632
 633                         (void) sm_blocksignal(SIGCHLD);
 634                         pid = fork();
 635                         if (pid < 0)
 636                         {
 637                                 syserr("daemon: cannot fork");
 638                                 if (pipefd[0] != -1)
 639                                 {
 640                                         (void) close(pipefd[0]);
 641                                         (void) close(pipefd[1]);
 642                                 }
 643                                 (void) sm_releasesignal(SIGCHLD);
 644                                 (void) sleep(10);
 645                                 (void) close(t);
 646                                 continue;
 647                         }
 648                 }
 649
 650                 if (pid == 0)
 651                 {
 652                         char *p;
 653                         SM_FILE_T *inchannel, *outchannel = NULL;
 654
 655                         /*
 656                         **  CHILD -- return to caller.
 657                         **      Collect verified idea of sending host.
 658                         **      Verify calling user id if possible here.
 659                         */
 660
 661                         /* Reset global flags */
 662                         RestartRequest = NULL;
 663                         RestartWorkGroup = false;
 664                         ShutdownRequest = NULL;
 665                         PendingSignal = 0;
 666                         CurrentPid = getpid();
 667                         close_sendmail_pid();
 668
 669                         (void) sm_releasesignal(SIGALRM);
 670                         (void) sm_releasesignal(SIGCHLD);
 671                         (void) sm_signal(SIGCHLD, SIG_DFL);
 672                         (void) sm_signal(SIGHUP, SIG_DFL);
 673                         (void) sm_signal(SIGTERM, intsig);
 674
 675                         /* turn on profiling */
 676                         /* SM_PROF(0); */
 677
 678                         /*
 679                         **  Initialize exception stack and default exception
 680                         **  handler for child process.
 681                         */
 682
 683                         sm_exc_newthread(fatal_error);
 684
 685                         if (!control)
 686                         {
 687                                 macdefine(&BlankEnvelope.e_macro, A_TEMP,
 688                                         macid("{daemon_addr}"),
 689                                         anynet_ntoa(&Daemons[curdaemon].d_addr));
 690                                 (void) sm_snprintf(status, sizeof(status), "%d",
 691                                                 ntohs(Daemons[curdaemon].d_port));
 692                                 macdefine(&BlankEnvelope.e_macro, A_TEMP,
 693                                         macid("{daemon_port}"), status);
 694                         }
 695
 696                         for (idx = 0; idx < NDaemons; idx++)
 697                         {
 698                                 if (Daemons[idx].d_socket >= 0)
 699                                         (void) close(Daemons[idx].d_socket);
 700                                 Daemons[idx].d_socket = -1;
 701                         }
 702                         clrcontrol();
 703
 704                         /* Avoid SMTP daemon actions if control command */
 705                         if (control)
 706                         {
 707                                 /* Add control socket process */
 708                                 proc_list_add(CurrentPid,
 709                                               "console socket child",
 710                                               PROC_CONTROL_CHILD, 0, -1, NULL);
 711                         }
 712                         else
 713                         {
 714                                 proc_list_clear();
 715
 716                                 /* clean up background delivery children */
 717                                 (void) sm_signal(SIGCHLD, reapchild);
 718
 719                                 /* Add parent process as first child item */
 720                                 proc_list_add(CurrentPid, "daemon child",
 721                                               PROC_DAEMON_CHILD, 0, -1, NULL);
 722                                 /* don't schedule queue runs if ETRN */
 723                                 QueueIntvl = 0;
 724
 725                                 /*
 726                                 **  Hack: override global variables if
 727                                 **      the corresponding DaemonPortOption
 728                                 **      is set.
 729                                 */
 730 #if _FFR_SS_PER_DAEMON
 731                                 if (Daemons[curdaemon].d_supersafe !=
 732                                     DPO_NOTSET)
 733                                         SuperSafe = Daemons[curdaemon].
 734                                                                 d_supersafe;
 735 #endif /* _FFR_SS_PER_DAEMON */
 736                                 if (Daemons[curdaemon].d_dm != DM_NOTSET)
 737                                         set_delivery_mode(
 738                                                 Daemons[curdaemon].d_dm, e);
 739
 740                                 if (Daemons[curdaemon].d_refuseLA !=
 741                                     DPO_NOTSET)
 742                                         RefuseLA = Daemons[curdaemon].
 743                                                                 d_refuseLA;
 744                                 if (Daemons[curdaemon].d_queueLA != DPO_NOTSET)
 745                                         QueueLA = Daemons[curdaemon].d_queueLA;
 746                                 if (Daemons[curdaemon].d_delayLA != DPO_NOTSET)
 747                                         DelayLA = Daemons[curdaemon].d_delayLA;
 748                                 if (Daemons[curdaemon].d_maxchildren !=
 749                                     DPO_NOTSET)
 750                                         MaxChildren = Daemons[curdaemon].
 751                                                                 d_maxchildren;
 752
 753                                 sm_setproctitle(true, e, "startup with %s",
 754                                                 anynet_ntoa(&RealHostAddr));
 755                         }
 756
 757                         if (pipefd[0] != -1)
 758                         {
 759                                 auto char c;
 760
 761                                 /*
 762                                 **  Wait for the parent to close the write end
 763                                 **  of the pipe, which we will see as an EOF.
 764                                 **  This guarantees that we won't write to the
 765                                 **  socket until after the parent has closed
 766                                 **  the pipe.
 767                                 */
 768
 769                                 /* close the write end of the pipe */
 770                                 (void) close(pipefd[1]);
 771
 772                                 /* we shouldn't be interrupted, but ... */
 773                                 while (read(pipefd[0], &c, 1) < 0 &&
 774                                        errno == EINTR)
 775                                         continue;
 776                                 (void) close(pipefd[0]);
 777                         }
 778
 779                         /* control socket processing */
 780                         if (control)
 781                         {
 782                                 control_command(t, e);
 783                                 /* NOTREACHED */
 784                                 exit(EX_SOFTWARE);
 785                         }
 786
 787                         /* determine host name */
 788                         p = hostnamebyanyaddr(&RealHostAddr);
 789                         if (strlen(p) > MAXNAME) /* XXX  - 1 ? */
 790                                 p[MAXNAME] = '\0';
 791                         RealHostName = newstr(p);
 792                         if (RealHostName[0] == '[')
 793                         {
 794                                 macdefine(&BlankEnvelope.e_macro, A_PERM,
 795                                         macid("{client_resolve}"),
 796                                         h_errno == TRY_AGAIN ? "TEMP" : "FAIL");
 797                         }
 798                         else
 799                         {
 800                                 macdefine(&BlankEnvelope.e_macro, A_PERM,
 801                                           macid("{client_resolve}"), "OK");
 802                         }
 803                         sm_setproctitle(true, e, "startup with %s", p);
 804                         markstats(e, NULL, STATS_CONNECT);
 805
 806                         if ((inchannel = sm_io_open(SmFtStdiofd,
 807                                                     SM_TIME_DEFAULT,
 808                                                     (void *) &t,
 809                                                     SM_IO_RDONLY_B,
 810                                                     NULL)) == NULL ||
 811                             (t = dup(t)) < 0 ||
 812                             (outchannel = sm_io_open(SmFtStdiofd,
 813                                                      SM_TIME_DEFAULT,
 814                                                      (void *) &t,
 815                                                      SM_IO_WRONLY_B,
 816                                                      NULL)) == NULL)
 817                         {
 818                                 syserr("cannot open SMTP server channel, fd=%d",
 819                                         t);
 820                                 finis(false, true, EX_OK);
 821                         }
 822                         sm_io_automode(inchannel, outchannel);
 823
 824                         InChannel = inchannel;
 825                         OutChannel = outchannel;
 826                         DisConnected = false;
 827
 828 #if _FFR_XCNCT
 829                         t = xconnect(inchannel);
 830                         if (t <= 0)
 831                         {
 832                                 clrbitn(D_XCNCT, Daemons[curdaemon].d_flags);
 833                                 clrbitn(D_XCNCT_M, Daemons[curdaemon].d_flags);
 834                         }
 835                         else
 836                                 setbitn(t, Daemons[curdaemon].d_flags);
 837
 838 #endif /* _FFR_XCNCT */
 839
 840 #if XLA
 841                         if (!xla_host_ok(RealHostName))
 842                         {
 843                                 message("421 4.4.5 Too many SMTP sessions for this host");
 844                                 finis(false, true, EX_OK);
 845                         }
 846 #endif /* XLA */
 847                         /* find out name for interface of connection */
 848                         if (getsockname(sm_io_getinfo(InChannel, SM_IO_WHAT_FD,
 849                                                       NULL), &sa.sa, &len) == 0)
 850                         {
 851                                 p = hostnamebyanyaddr(&sa);
 852                                 if (tTd(15, 9))
 853                                         sm_dprintf("getreq: got name %s\n", p);
 854                                 macdefine(&BlankEnvelope.e_macro, A_TEMP,
 855                                         macid("{if_name}"), p);
 856
 857                                 /*
 858                                 **  Do this only if it is not the loopback
 859                                 **  interface.
 860                                 */
 861
 862                                 if (!isloopback(sa))
 863                                 {
 864                                         char *addr;
 865                                         char family[5];
 866
 867                                         addr = anynet_ntoa(&sa);
 868                                         (void) sm_snprintf(family,
 869                                                 sizeof(family),
 870                                                 "%d", sa.sa.sa_family);
 871                                         macdefine(&BlankEnvelope.e_macro,
 872                                                 A_TEMP,
 873                                                 macid("{if_addr}"), addr);
 874                                         macdefine(&BlankEnvelope.e_macro,
 875                                                 A_TEMP,
 876                                                 macid("{if_family}"), family);
 877                                         if (tTd(15, 7))
 878                                                 sm_dprintf("getreq: got addr %s and family %s\n",
 879                                                         addr, family);
 880                                 }
 881                                 else
 882                                 {
 883                                         macdefine(&BlankEnvelope.e_macro,
 884                                                 A_PERM,
 885                                                 macid("{if_addr}"), NULL);
 886                                         macdefine(&BlankEnvelope.e_macro,
 887                                                 A_PERM,
 888                                                 macid("{if_family}"), NULL);
 889                                 }
 890                         }
 891                         else
 892                         {
 893                                 if (tTd(15, 7))
 894                                         sm_dprintf("getreq: getsockname failed\n");
 895                                 macdefine(&BlankEnvelope.e_macro, A_PERM,
 896                                         macid("{if_name}"), NULL);
 897                                 macdefine(&BlankEnvelope.e_macro, A_PERM,
 898                                         macid("{if_addr}"), NULL);
 899                                 macdefine(&BlankEnvelope.e_macro, A_PERM,
 900                                         macid("{if_family}"), NULL);
 901                         }
 902                         break;
 903                 }
 904
 905                 /* parent -- keep track of children */
 906                 if (control)
 907                 {
 908                         (void) sm_snprintf(status, sizeof(status),
 909                                            "control socket server child");
 910                         proc_list_add(pid, status, PROC_CONTROL, 0, -1, NULL);
 911                 }
 912                 else
 913                 {
 914                         (void) sm_snprintf(status, sizeof(status),
 915                                            "SMTP server child for %s",
 916                                            anynet_ntoa(&RealHostAddr));
 917                         proc_list_add(pid, status, PROC_DAEMON, 0, -1,
 918                                         &RealHostAddr);
 919                 }
 920                 (void) sm_releasesignal(SIGCHLD);
 921
 922                 /* close the read end of the synchronization pipe */
 923                 if (pipefd[0] != -1)
 924                 {
 925                         (void) close(pipefd[0]);
 926                         pipefd[0] = -1;
 927                 }
 928
 929                 /* close the port so that others will hang (for a while) */
 930                 (void) close(t);
 931
 932                 /* release the child by closing the read end of the sync pipe */
 933                 if (pipefd[1] != -1)
 934                 {
 935                         (void) close(pipefd[1]);
 936                         pipefd[1] = -1;
 937                 }
 938         }
 939         if (tTd(15, 2))
 940                 sm_dprintf("getreq: returning\n");
 941
 942 #if MILTER
 943         /* set the filters for this daemon */
 944         if (Daemons[curdaemon].d_inputfilterlist != NULL)
 945         {
 946                 for (i = 0;
 947                      (i < MAXFILTERS &&
 948                       Daemons[curdaemon].d_inputfilters[i] != NULL);
 949                      i++)
 950                 {
 951                         InputFilters[i] = Daemons[curdaemon].d_inputfilters[i];
 952                 }
 953                 if (i < MAXFILTERS)
 954                         InputFilters[i] = NULL;
 955         }
 956 #endif /* MILTER */
 957         return &Daemons[curdaemon].d_flags;
 958 }
 959
 960 /*
 961 **  GETREQUESTS_CHECKDISKSPACE -- check available diskspace.
 962 **
 963 **      Parameters:
 964 **              e -- envelope.
 965 **
 966 **      Returns:
 967 **              none.
 968 **
 969 **      Side Effects:
 970 **              Modifies Daemon flags (D_ETRNONLY) if not enough disk space.
 971 */
 972
 973 static void
 974 getrequests_checkdiskspace(e)
 975         ENVELOPE *e;
 976 {
 977         bool logged = false;
 978         int idx;
 979         time_t now;
 980
 981         now = curtime();
 982         if (now < NextDiskSpaceCheck)
 983                 return;
 984
 985         /* Check if there is available disk space in all queue groups. */
 986         if (!enoughdiskspace(0, NULL))
 987         {
 988                 for (idx = 0; idx < NDaemons; ++idx)
 989                 {
 990                         if (bitnset(D_ETRNONLY, Daemons[idx].d_flags))
 991                                 continue;
 992
 993                         /* log only if not logged before */
 994                         if (!logged)
 995                         {
 996                                 if (LogLevel > 8)
 997                                         sm_syslog(LOG_INFO, NOQID,
 998                                                   "rejecting new messages: min free: %ld",
 999                                                   MinBlocksFree);
1000                                 sm_setproctitle(true, e,
1001                                                 "rejecting new messages: min free: %ld",
1002                                                 MinBlocksFree);
1003                                 logged = true;
1004                         }
1005                         setbitn(D_ETRNONLY, Daemons[idx].d_flags);
1006                 }
1007         }
1008         else
1009         {
1010                 for (idx = 0; idx < NDaemons; ++idx)
1011                 {
1012                         if (!bitnset(D_ETRNONLY, Daemons[idx].d_flags))
1013                                 continue;
1014
1015                         /* log only if not logged before */
1016                         if (!logged)
1017                         {
1018                                 if (LogLevel > 8)
1019                                         sm_syslog(LOG_INFO, NOQID,
1020                                                   "accepting new messages (again)");
1021                                 logged = true;
1022                         }
1023
1024                         /* title will be set later */
1025                         clrbitn(D_ETRNONLY, Daemons[idx].d_flags);
1026                 }
1027         }
1028
1029         /* only check disk space once a minute */
1030         NextDiskSpaceCheck = now + 60;
1031 }
1032
1033 /*
1034 **  OPENDAEMONSOCKET -- open SMTP socket
1035 **
1036 **      Deals with setting all appropriate options.
1037 **
1038 **      Parameters:
1039 **              d -- the structure for the daemon to open.
1040 **              firsttime -- set if this is the initial open.
1041 **
1042 **      Returns:
1043 **              Size in bytes of the daemon socket addr.
1044 **
1045 **      Side Effects:
1046 **              Leaves DaemonSocket set to the open socket.
1047 **              Exits if the socket cannot be created.
1048 */
1049
1050 #define MAXOPENTRIES    10      /* maximum number of tries to open connection */
1051
1052 static int
1053 opendaemonsocket(d, firsttime)
1054         DAEMON_T *d;
1055         bool firsttime;
1056 {
1057         int on = 1;
1058         int fdflags;
1059         SOCKADDR_LEN_T socksize = 0;
1060         int ntries = 0;
1061         int save_errno;
1062
1063         if (tTd(15, 2))
1064                 sm_dprintf("opendaemonsocket(%s)\n", d->d_name);
1065
1066         do
1067         {
1068                 if (ntries > 0)
1069                         (void) sleep(5);
1070                 if (firsttime || d->d_socket < 0)
1071                 {
1072 #if NETUNIX
1073                         if (d->d_addr.sa.sa_family == AF_UNIX)
1074                         {
1075                                 int rval;
1076                                 long sff = SFF_SAFEDIRPATH|SFF_OPENASROOT|SFF_NOLINK|SFF_ROOTOK|SFF_EXECOK|SFF_CREAT;
1077
1078                                 /* if not safe, don't use it */
1079                                 rval = safefile(d->d_addr.sunix.sun_path,
1080                                                 RunAsUid, RunAsGid,
1081                                                 RunAsUserName, sff,
1082                                                 S_IRUSR|S_IWUSR, NULL);
1083                                 if (rval != 0)
1084                                 {
1085                                         save_errno = errno;
1086                                         syserr("opendaemonsocket: daemon %s: unsafe domain socket %s",
1087                                                d->d_name,
1088                                                d->d_addr.sunix.sun_path);
1089                                         goto fail;
1090                                 }
1091
1092                                 /* Don't try to overtake an existing socket */
1093                                 (void) unlink(d->d_addr.sunix.sun_path);
1094                         }
1095 #endif /* NETUNIX */
1096                         d->d_socket = socket(d->d_addr.sa.sa_family,
1097                                              SOCK_STREAM, 0);
1098                         if (d->d_socket < 0)
1099                         {
1100                                 save_errno = errno;
1101                                 syserr("opendaemonsocket: daemon %s: can't create server SMTP socket",
1102                                        d->d_name);
1103                           fail:
1104                                 if (bitnset(D_OPTIONAL, d->d_flags) &&
1105                                     (!transienterror(save_errno) ||
1106                                      ntries >= MAXOPENTRIES - 1))
1107                                 {
1108                                         syserr("opendaemonsocket: daemon %s: optional socket disabled",
1109                                                d->d_name);
1110                                         setbitn(D_DISABLE, d->d_flags);
1111                                         d->d_socket = -1;
1112                                         return -1;
1113                                 }
1114                           severe:
1115                                 if (LogLevel > 0)
1116                                         sm_syslog(LOG_ALERT, NOQID,
1117                                                   "daemon %s: problem creating SMTP socket",
1118                                                   d->d_name);
1119                                 d->d_socket = -1;
1120                                 continue;
1121                         }
1122
1123                         if (!SM_FD_OK_SELECT(d->d_socket))
1124                         {
1125                                 save_errno = EINVAL;
1126                                 syserr("opendaemonsocket: daemon %s: server SMTP socket (%d) too large",
1127                                        d->d_name, d->d_socket);
1128                                 goto fail;
1129                         }
1130
1131                         /* turn on network debugging? */
1132                         if (tTd(15, 101))
1133                                 (void) setsockopt(d->d_socket, SOL_SOCKET,
1134                                                   SO_DEBUG, (char *)&on,
1135                                                   sizeof(on));
1136
1137                         (void) setsockopt(d->d_socket, SOL_SOCKET,
1138                                           SO_REUSEADDR, (char *)&on, sizeof(on));
1139                         (void) setsockopt(d->d_socket, SOL_SOCKET,
1140                                           SO_KEEPALIVE, (char *)&on, sizeof(on));
1141
1142 #ifdef SO_RCVBUF
1143                         if (d->d_tcprcvbufsize > 0)
1144                         {
1145                                 if (setsockopt(d->d_socket, SOL_SOCKET,
1146                                                SO_RCVBUF,
1147                                                (char *) &d->d_tcprcvbufsize,
1148                                                sizeof(d->d_tcprcvbufsize)) < 0)
1149                                         syserr("opendaemonsocket: daemon %s: setsockopt(SO_RCVBUF)", d->d_name);
1150                         }
1151 #endif /* SO_RCVBUF */
1152 #ifdef SO_SNDBUF
1153                         if (d->d_tcpsndbufsize > 0)
1154                         {
1155                                 if (setsockopt(d->d_socket, SOL_SOCKET,
1156                                                SO_SNDBUF,
1157                                                (char *) &d->d_tcpsndbufsize,
1158                                                sizeof(d->d_tcpsndbufsize)) < 0)
1159                                         syserr("opendaemonsocket: daemon %s: setsockopt(SO_SNDBUF)", d->d_name);
1160                         }
1161 #endif /* SO_SNDBUF */
1162
1163                         if ((fdflags = fcntl(d->d_socket, F_GETFD, 0)) == -1 ||
1164                             fcntl(d->d_socket, F_SETFD,
1165                                   fdflags | FD_CLOEXEC) == -1)
1166                         {
1167                                 save_errno = errno;
1168                                 syserr("opendaemonsocket: daemon %s: failed to %s close-on-exec flag: %s",
1169                                        d->d_name,
1170                                        fdflags == -1 ? "get" : "set",
1171                                        sm_errstring(save_errno));
1172                                 (void) close(d->d_socket);
1173                                 goto severe;
1174                         }
1175
1176                         switch (d->d_addr.sa.sa_family)
1177                         {
1178 #ifdef NETUNIX
1179                           case AF_UNIX:
1180                                 socksize = sizeof(d->d_addr.sunix);
1181                                 break;
1182 #endif /* NETUNIX */
1183 #if NETINET
1184                           case AF_INET:
1185                                 socksize = sizeof(d->d_addr.sin);
1186                                 break;
1187 #endif /* NETINET */
1188
1189 #if NETINET6
1190                           case AF_INET6:
1191                                 socksize = sizeof(d->d_addr.sin6);
1192                                 break;
1193 #endif /* NETINET6 */
1194
1195 #if NETISO
1196                           case AF_ISO:
1197                                 socksize = sizeof(d->d_addr.siso);
1198                                 break;
1199 #endif /* NETISO */
1200
1201                           default:
1202                                 socksize = sizeof(d->d_addr);
1203                                 break;
1204                         }
1205
1206                         if (bind(d->d_socket, &d->d_addr.sa, socksize) < 0)
1207                         {
1208                                 /* probably another daemon already */
1209                                 save_errno = errno;
1210                                 syserr("opendaemonsocket: daemon %s: cannot bind",
1211                                        d->d_name);
1212                                 (void) close(d->d_socket);
1213                                 goto fail;
1214                         }
1215                 }
1216                 if (!firsttime &&
1217                     listen(d->d_socket, d->d_listenqueue) < 0)
1218                 {
1219                         save_errno = errno;
1220                         syserr("opendaemonsocket: daemon %s: cannot listen",
1221                                d->d_name);
1222                         (void) close(d->d_socket);
1223                         goto severe;
1224                 }
1225                 return socksize;
1226         } while (ntries++ < MAXOPENTRIES && transienterror(save_errno));
1227         syserr("!opendaemonsocket: daemon %s: server SMTP socket wedged: exiting",
1228                d->d_name);
1229         /* NOTREACHED */
1230         return -1;  /* avoid compiler warning on IRIX */
1231 }
1232 /*
1233 **  SETUPDAEMON -- setup socket for daemon
1234 **
1235 **      Parameters:
1236 **              daemonaddr -- socket for daemon
1237 **
1238 **      Returns:
1239 **              port number on which daemon should run
1240 **
1241 */
1242
1243 static unsigned short
1244 setupdaemon(daemonaddr)
1245         SOCKADDR *daemonaddr;
1246 {
1247         unsigned short port;
1248
1249         /*
1250         **  Set up the address for the mailer.
1251         */
1252
1253         if (daemonaddr->sa.sa_family == AF_UNSPEC)
1254         {
1255                 memset(daemonaddr, '\0', sizeof(*daemonaddr));
1256 #if NETINET
1257                 daemonaddr->sa.sa_family = AF_INET;
1258 #endif /* NETINET */
1259         }
1260
1261         switch (daemonaddr->sa.sa_family)
1262         {
1263 #if NETINET
1264           case AF_INET:
1265                 if (daemonaddr->sin.sin_addr.s_addr == 0)
1266                         daemonaddr->sin.sin_addr.s_addr =
1267                             LocalDaemon ? htonl(INADDR_LOOPBACK) : INADDR_ANY;
1268                 port = daemonaddr->sin.sin_port;
1269                 break;
1270 #endif /* NETINET */
1271
1272 #if NETINET6
1273           case AF_INET6:
1274                 if (IN6_IS_ADDR_UNSPECIFIED(&daemonaddr->sin6.sin6_addr))
1275                         daemonaddr->sin6.sin6_addr =
1276                             (LocalDaemon && V6LoopbackAddrFound) ?
1277                             in6addr_loopback : in6addr_any;
1278                 port = daemonaddr->sin6.sin6_port;
1279                 break;
1280 #endif /* NETINET6 */
1281
1282           default:
1283                 /* unknown protocol */
1284                 port = 0;
1285                 break;
1286         }
1287         if (port == 0)
1288         {
1289 #ifdef NO_GETSERVBYNAME
1290                 port = htons(25);
1291 #else /* NO_GETSERVBYNAME */
1292                 {
1293                         register struct servent *sp;
1294
1295                         sp = getservbyname("smtp", "tcp");
1296                         if (sp == NULL)
1297                         {
1298                                 syserr("554 5.3.5 service \"smtp\" unknown");
1299                                 port = htons(25);
1300                         }
1301                         else
1302                                 port = sp->s_port;
1303                 }
1304 #endif /* NO_GETSERVBYNAME */
1305         }
1306
1307         switch (daemonaddr->sa.sa_family)
1308         {
1309 #if NETINET
1310           case AF_INET:
1311                 daemonaddr->sin.sin_port = port;
1312                 break;
1313 #endif /* NETINET */
1314
1315 #if NETINET6
1316           case AF_INET6:
1317                 daemonaddr->sin6.sin6_port = port;
1318                 break;
1319 #endif /* NETINET6 */
1320
1321           default:
1322                 /* unknown protocol */
1323                 break;
1324         }
1325         return port;
1326 }
1327 /*
1328 **  CLRDAEMON -- reset the daemon connection
1329 **
1330 **      Parameters:
1331 **              none.
1332 **
1333 **      Returns:
1334 **              none.
1335 **
1336 **      Side Effects:
1337 **              releases any resources used by the passive daemon.
1338 */
1339
1340 void
1341 clrdaemon()
1342 {
1343         int i;
1344
1345         for (i = 0; i < NDaemons; i++)
1346         {
1347                 if (Daemons[i].d_socket >= 0)
1348                         (void) close(Daemons[i].d_socket);
1349                 Daemons[i].d_socket = -1;
1350         }
1351 }
1352
1353 /*
1354 **  GETMODIFIERS -- get modifier flags
1355 **
1356 **      Parameters:
1357 **              v -- the modifiers (input text line).
1358 **              modifiers -- pointer to flag field to represent modifiers.
1359 **
1360 **      Returns:
1361 **              (xallocat()ed) string representation of modifiers.
1362 **
1363 **      Side Effects:
1364 **              fills in modifiers.
1365 */
1366
1367 char *
1368 getmodifiers(v, modifiers)
1369         char *v;
1370         BITMAP256 modifiers;
1371 {
1372         int l;
1373         char *h, *f, *flags;
1374
1375         /* maximum length of flags: upper case Option -> "OO " */
1376         l = 3 * strlen(v) + 3;
1377
1378         /* is someone joking? */
1379         if (l < 0 || l > 256)
1380         {
1381                 if (LogLevel > 2)
1382                         sm_syslog(LOG_ERR, NOQID,
1383                                   "getmodifiers too long, ignored");
1384                 return NULL;
1385         }
1386         flags = xalloc(l);
1387         f = flags;
1388         clrbitmap(modifiers);
1389         for (h = v; *h != '\0'; h++)
1390         {
1391                 if (isascii(*h) && !isspace(*h) && isprint(*h))
1392                 {
1393                         setbitn(*h, modifiers);
1394                         if (flags != f)
1395                                 *flags++ = ' ';
1396                         *flags++ = *h;
1397                         if (isupper(*h))
1398                                 *flags++ = *h;
1399                 }
1400         }
1401         *flags++ = '\0';
1402         return f;
1403 }
1404
1405 /*
1406 **  CHKDAEMONMODIFIERS -- check whether all daemons have set a flag.
1407 **
1408 **      Parameters:
1409 **              flag -- the flag to test.
1410 **
1411 **      Returns:
1412 **              true iff all daemons have set flag.
1413 */
1414
1415 bool
1416 chkdaemonmodifiers(flag)
1417         int flag;
1418 {
1419         int i;
1420
1421         for (i = 0; i < NDaemons; i++)
1422                 if (!bitnset((char) flag, Daemons[i].d_flags))
1423                         return false;
1424         return true;
1425 }
1426
1427 /*
1428 **  SETSOCKADDROPTIONS -- set options for SOCKADDR (daemon or client)
1429 **
1430 **      Parameters:
1431 **              p -- the options line.
1432 **              d -- the daemon structure to fill in.
1433 **
1434 **      Returns:
1435 **              none.
1436 */
1437
1438 static void
1439 setsockaddroptions(p, d)
1440         char *p;
1441         DAEMON_T *d;
1442 {
1443 #if NETISO
1444         short portno;
1445 #endif /* NETISO */
1446         char *port = NULL;
1447         char *addr = NULL;
1448
1449 #if NETINET
1450         if (d->d_addr.sa.sa_family == AF_UNSPEC)
1451                 d->d_addr.sa.sa_family = AF_INET;
1452 #endif /* NETINET */
1453 #if _FFR_SS_PER_DAEMON
1454         d->d_supersafe = DPO_NOTSET;
1455 #endif /* _FFR_SS_PER_DAEMON */
1456         d->d_dm = DM_NOTSET;
1457         d->d_refuseLA = DPO_NOTSET;
1458         d->d_queueLA = DPO_NOTSET;
1459         d->d_delayLA = DPO_NOTSET;
1460         d->d_maxchildren = DPO_NOTSET;
1461
1462         while (p != NULL)
1463         {
1464                 register char *f;
1465                 register char *v;
1466
1467                 while (isascii(*p) && isspace(*p))
1468                         p++;
1469                 if (*p == '\0')
1470                         break;
1471                 f = p;
1472                 p = strchr(p, ',');
1473                 if (p != NULL)
1474                         *p++ = '\0';
1475                 v = strchr(f, '=');
1476                 if (v == NULL)
1477                         continue;
1478                 while (isascii(*++v) && isspace(*v))
1479                         continue;
1480
1481                 switch (*f)
1482                 {
1483                   case 'A':             /* address */
1484 #if !_FFR_DPO_CS
1485                   case 'a':
1486 #endif /* !_FFR_DPO_CS */
1487                         addr = v;
1488                         break;
1489
1490                   case 'c':
1491                         d->d_maxchildren = atoi(v);
1492                         break;
1493
1494                   case 'D':             /* DeliveryMode */
1495                         switch (*v)
1496                         {
1497                           case SM_QUEUE:
1498                           case SM_DEFER:
1499                           case SM_DELIVER:
1500                           case SM_FORK:
1501 #if _FFR_PROXY
1502                           case SM_PROXY_REQ:
1503 #endif /* _FFR_PROXY */
1504                                 d->d_dm = *v;
1505                                 break;
1506                           default:
1507                                 syserr("554 5.3.5 Unknown delivery mode %c",
1508                                         *v);
1509                                 break;
1510                         }
1511                         break;
1512
1513                   case 'd':             /* delayLA */
1514                         d->d_delayLA = atoi(v);
1515                         break;
1516
1517                   case 'F':             /* address family */
1518 #if !_FFR_DPO_CS
1519                   case 'f':
1520 #endif /* !_FFR_DPO_CS */
1521                         if (isascii(*v) && isdigit(*v))
1522                                 d->d_addr.sa.sa_family = atoi(v);
1523 #ifdef NETUNIX
1524                         else if (sm_strcasecmp(v, "unix") == 0 ||
1525                                  sm_strcasecmp(v, "local") == 0)
1526                                 d->d_addr.sa.sa_family = AF_UNIX;
1527 #endif /* NETUNIX */
1528 #if NETINET
1529                         else if (sm_strcasecmp(v, "inet") == 0)
1530                                 d->d_addr.sa.sa_family = AF_INET;
1531 #endif /* NETINET */
1532 #if NETINET6
1533                         else if (sm_strcasecmp(v, "inet6") == 0)
1534                                 d->d_addr.sa.sa_family = AF_INET6;
1535 #endif /* NETINET6 */
1536 #if NETISO
1537                         else if (sm_strcasecmp(v, "iso") == 0)
1538                                 d->d_addr.sa.sa_family = AF_ISO;
1539 #endif /* NETISO */
1540 #if NETNS
1541                         else if (sm_strcasecmp(v, "ns") == 0)
1542                                 d->d_addr.sa.sa_family = AF_NS;
1543 #endif /* NETNS */
1544 #if NETX25
1545                         else if (sm_strcasecmp(v, "x.25") == 0)
1546                                 d->d_addr.sa.sa_family = AF_CCITT;
1547 #endif /* NETX25 */
1548                         else
1549                                 syserr("554 5.3.5 Unknown address family %s in Family=option",
1550                                        v);
1551                         break;
1552
1553 #if MILTER
1554                   case 'I':
1555 # if !_FFR_DPO_CS
1556                   case 'i':
1557 # endif /* !_FFR_DPO_CS */
1558                         d->d_inputfilterlist = v;
1559                         break;
1560 #endif /* MILTER */
1561
1562                   case 'L':             /* listen queue size */
1563 #if !_FFR_DPO_CS
1564                   case 'l':
1565 #endif /* !_FFR_DPO_CS */
1566                         d->d_listenqueue = atoi(v);
1567                         break;
1568
1569                   case 'M':             /* modifiers (flags) */
1570 #if !_FFR_DPO_CS
1571                   case 'm':
1572 #endif /* !_FFR_DPO_CS */
1573                         d->d_mflags = getmodifiers(v, d->d_flags);
1574                         break;
1575
1576                   case 'N':             /* name */
1577 #if !_FFR_DPO_CS
1578                   case 'n':
1579 #endif /* !_FFR_DPO_CS */
1580                         d->d_name = v;
1581                         break;
1582
1583                   case 'P':             /* port */
1584 #if !_FFR_DPO_CS
1585                   case 'p':
1586 #endif /* !_FFR_DPO_CS */
1587                         port = v;
1588                         break;
1589
1590                   case 'q':
1591                         d->d_queueLA = atoi(v);
1592                         break;
1593
1594                   case 'R':             /* receive buffer size */
1595                         d->d_tcprcvbufsize = atoi(v);
1596                         break;
1597
1598                   case 'r':
1599                         d->d_refuseLA = atoi(v);
1600                         break;
1601
1602                   case 'S':             /* send buffer size */
1603 #if !_FFR_DPO_CS
1604                   case 's':
1605 #endif /* !_FFR_DPO_CS */
1606                         d->d_tcpsndbufsize = atoi(v);
1607                         break;
1608
1609 #if _FFR_SS_PER_DAEMON
1610                   case 'T':             /* SuperSafe */
1611                         if (tolower(*v) == 'i')
1612                                 d->d_supersafe = SAFE_INTERACTIVE;
1613                         else if (tolower(*v) == 'p')
1614 # if MILTER
1615                                 d->d_supersafe = SAFE_REALLY_POSTMILTER;
1616 # else /* MILTER */
1617                                 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT,
1618                                         "Warning: SuperSafe=PostMilter requires Milter support (-DMILTER)\n");
1619 # endif /* MILTER */
1620                         else
1621                                 d->d_supersafe = atobool(v) ? SAFE_REALLY
1622                                                         : SAFE_NO;
1623                         break;
1624 #endif /* _FFR_SS_PER_DAEMON */
1625
1626                   default:
1627                         syserr("554 5.3.5 PortOptions parameter \"%s\" unknown",
1628                                f);
1629                 }
1630         }
1631
1632         /* Check addr and port after finding family */
1633         if (addr != NULL)
1634         {
1635                 switch (d->d_addr.sa.sa_family)
1636                 {
1637 #if NETUNIX
1638                   case AF_UNIX:
1639                         if (strlen(addr) >= sizeof(d->d_addr.sunix.sun_path))
1640                         {
1641                                 errno = ENAMETOOLONG;
1642                                 syserr("setsockaddroptions: domain socket name too long: %s > %ld",
1643                                        addr,
1644                                        (long) sizeof(d->d_addr.sunix.sun_path));
1645                                 break;
1646                         }
1647
1648                         /* file safety check done in opendaemonsocket() */
1649                         (void) memset(&d->d_addr.sunix.sun_path, '\0',
1650                                       sizeof(d->d_addr.sunix.sun_path));
1651                         (void) sm_strlcpy((char *)&d->d_addr.sunix.sun_path,
1652                                           addr,
1653                                           sizeof(d->d_addr.sunix.sun_path));
1654                         break;
1655 #endif /* NETUNIX */
1656 #if NETINET
1657                   case AF_INET:
1658                         if (!isascii(*addr) || !isdigit(*addr) ||
1659                             ((d->d_addr.sin.sin_addr.s_addr = inet_addr(addr))
1660                              == INADDR_NONE))
1661                         {
1662                                 register struct hostent *hp;
1663
1664                                 hp = sm_gethostbyname(addr, AF_INET);
1665                                 if (hp == NULL)
1666                                         syserr("554 5.3.0 host \"%s\" unknown",
1667                                                addr);
1668                                 else
1669                                 {
1670                                         while (*(hp->h_addr_list) != NULL &&
1671                                                hp->h_addrtype != AF_INET)
1672                                                 hp->h_addr_list++;
1673                                         if (*(hp->h_addr_list) == NULL)
1674                                                 syserr("554 5.3.0 host \"%s\" unknown",
1675                                                        addr);
1676                                         else
1677                                                 memmove(&d->d_addr.sin.sin_addr,
1678                                                         *(hp->h_addr_list),
1679                                                         INADDRSZ);
1680 # if NETINET6
1681                                         freehostent(hp);
1682                                         hp = NULL;
1683 # endif /* NETINET6 */
1684                                 }
1685                         }
1686                         break;
1687 #endif /* NETINET */
1688
1689 #if NETINET6
1690                   case AF_INET6:
1691                         if (anynet_pton(AF_INET6, addr,
1692                                         &d->d_addr.sin6.sin6_addr) != 1)
1693                         {
1694                                 register struct hostent *hp;
1695
1696                                 hp = sm_gethostbyname(addr, AF_INET6);
1697                                 if (hp == NULL)
1698                                         syserr("554 5.3.0 host \"%s\" unknown",
1699                                                addr);
1700                                 else
1701                                 {
1702                                         while (*(hp->h_addr_list) != NULL &&
1703                                                hp->h_addrtype != AF_INET6)
1704                                                 hp->h_addr_list++;
1705                                         if (*(hp->h_addr_list) == NULL)
1706                                                 syserr("554 5.3.0 host \"%s\" unknown",
1707                                                        addr);
1708                                         else
1709                                                 memmove(&d->d_addr.sin6.sin6_addr,
1710                                                         *(hp->h_addr_list),
1711                                                         IN6ADDRSZ);
1712                                         freehostent(hp);
1713                                         hp = NULL;
1714                                 }
1715                         }
1716                         break;
1717 #endif /* NETINET6 */
1718
1719                   default:
1720                         syserr("554 5.3.5 address= option unsupported for family %d",
1721                                d->d_addr.sa.sa_family);
1722                         break;
1723                 }
1724         }
1725
1726         if (port != NULL)
1727         {
1728                 switch (d->d_addr.sa.sa_family)
1729                 {
1730 #if NETINET
1731                   case AF_INET:
1732                         if (isascii(*port) && isdigit(*port))
1733                                 d->d_addr.sin.sin_port = htons((unsigned short)
1734                                                      atoi((const char *) port));
1735                         else
1736                         {
1737 # ifdef NO_GETSERVBYNAME
1738                                 syserr("554 5.3.5 invalid port number: %s",
1739                                        port);
1740 # else /* NO_GETSERVBYNAME */
1741                                 register struct servent *sp;
1742
1743                                 sp = getservbyname(port, "tcp");
1744                                 if (sp == NULL)
1745                                         syserr("554 5.3.5 service \"%s\" unknown",
1746                                                port);
1747                                 else
1748                                         d->d_addr.sin.sin_port = sp->s_port;
1749 # endif /* NO_GETSERVBYNAME */
1750                         }
1751                         break;
1752 #endif /* NETINET */
1753
1754 #if NETINET6
1755                   case AF_INET6:
1756                         if (isascii(*port) && isdigit(*port))
1757                                 d->d_addr.sin6.sin6_port = htons((unsigned short)
1758                                                                   atoi(port));
1759                         else
1760                         {
1761 # ifdef NO_GETSERVBYNAME
1762                                 syserr("554 5.3.5 invalid port number: %s",
1763                                        port);
1764 # else /* NO_GETSERVBYNAME */
1765                                 register struct servent *sp;
1766
1767                                 sp = getservbyname(port, "tcp");
1768                                 if (sp == NULL)
1769                                         syserr("554 5.3.5 service \"%s\" unknown",
1770                                                port);
1771                                 else
1772                                         d->d_addr.sin6.sin6_port = sp->s_port;
1773 # endif /* NO_GETSERVBYNAME */
1774                         }
1775                         break;
1776 #endif /* NETINET6 */
1777
1778 #if NETISO
1779                   case AF_ISO:
1780                         /* assume two byte transport selector */
1781                         if (isascii(*port) && isdigit(*port))
1782                                 portno = htons((unsigned short) atoi(port));
1783                         else
1784                         {
1785 # ifdef NO_GETSERVBYNAME
1786                                 syserr("554 5.3.5 invalid port number: %s",
1787                                        port);
1788 # else /* NO_GETSERVBYNAME */
1789                                 register struct servent *sp;
1790
1791                                 sp = getservbyname(port, "tcp");
1792                                 if (sp == NULL)
1793                                         syserr("554 5.3.5 service \"%s\" unknown",
1794                                                port);
1795                                 else
1796                                         portno = sp->s_port;
1797 # endif /* NO_GETSERVBYNAME */
1798                         }
1799                         memmove(TSEL(&d->d_addr.siso),
1800                                 (char *) &portno, 2);
1801                         break;
1802 #endif /* NETISO */
1803
1804                   default:
1805                         syserr("554 5.3.5 Port= option unsupported for family %d",
1806                                d->d_addr.sa.sa_family);
1807                         break;
1808                 }
1809         }
1810 }
1811 /*
1812 **  SETDAEMONOPTIONS -- set options for running the MTA daemon
1813 **
1814 **      Parameters:
1815 **              p -- the options line.
1816 **
1817 **      Returns:
1818 **              true if successful, false otherwise.
1819 **
1820 **      Side Effects:
1821 **              increments number of daemons.
1822 */
1823
1824 #define DEF_LISTENQUEUE 10
1825
1826 struct dflags
1827 {
1828         char    *d_name;
1829         int     d_flag;
1830 };
1831
1832 static struct dflags    DaemonFlags[] =
1833 {
1834         { "AUTHREQ",            D_AUTHREQ       },
1835         { "BINDIF",             D_BINDIF        },
1836         { "CANONREQ",           D_CANONREQ      },
1837         { "IFNHELO",            D_IFNHELO       },
1838         { "FQMAIL",             D_FQMAIL        },
1839         { "FQRCPT",             D_FQRCPT        },
1840         { "SMTPS",              D_SMTPS         },
1841         { "UNQUALOK",           D_UNQUALOK      },
1842         { "NOAUTH",             D_NOAUTH        },
1843         { "NOCANON",            D_NOCANON       },
1844         { "NOETRN",             D_NOETRN        },
1845         { "NOTLS",              D_NOTLS         },
1846         { "ETRNONLY",           D_ETRNONLY      },
1847         { "OPTIONAL",           D_OPTIONAL      },
1848         { "DISABLE",            D_DISABLE       },
1849         { "ISSET",              D_ISSET         },
1850         { NULL,                 0               }
1851 };
1852
1853 static void
1854 printdaemonflags(d)
1855         DAEMON_T *d;
1856 {
1857         register struct dflags *df;
1858         bool first = true;
1859
1860         for (df = DaemonFlags; df->d_name != NULL; df++)
1861         {
1862                 if (!bitnset(df->d_flag, d->d_flags))
1863                         continue;
1864                 if (first)
1865                         sm_dprintf("<%s", df->d_name);
1866                 else
1867                         sm_dprintf(",%s", df->d_name);
1868                 first = false;
1869         }
1870         if (!first)
1871                 sm_dprintf(">");
1872 }
1873
1874 bool
1875 setdaemonoptions(p)
1876         register char *p;
1877 {
1878         if (NDaemons >= MAXDAEMONS)
1879                 return false;
1880         Daemons[NDaemons].d_socket = -1;
1881         Daemons[NDaemons].d_listenqueue = DEF_LISTENQUEUE;
1882         clrbitmap(Daemons[NDaemons].d_flags);
1883         setsockaddroptions(p, &Daemons[NDaemons]);
1884
1885 #if MILTER
1886         if (Daemons[NDaemons].d_inputfilterlist != NULL)
1887                 Daemons[NDaemons].d_inputfilterlist = newstr(Daemons[NDaemons].d_inputfilterlist);
1888 #endif /* MILTER */
1889
1890         if (Daemons[NDaemons].d_name != NULL)
1891                 Daemons[NDaemons].d_name = newstr(Daemons[NDaemons].d_name);
1892         else
1893         {
1894                 char num[30];
1895
1896                 (void) sm_snprintf(num, sizeof(num), "Daemon%d", NDaemons);
1897                 Daemons[NDaemons].d_name = newstr(num);
1898         }
1899
1900         if (tTd(37, 1))
1901         {
1902                 sm_dprintf("Daemon %s flags: ", Daemons[NDaemons].d_name);
1903                 printdaemonflags(&Daemons[NDaemons]);
1904                 sm_dprintf("\n");
1905         }
1906         ++NDaemons;
1907         return true;
1908 }
1909 /*
1910 **  INITDAEMON -- initialize daemon if not yet done.
1911 **
1912 **      Parameters:
1913 **              none
1914 **
1915 **      Returns:
1916 **              none
1917 **
1918 **      Side Effects:
1919 **              initializes structure for one daemon.
1920 */
1921
1922 void
1923 initdaemon()
1924 {
1925         if (NDaemons == 0)
1926         {
1927                 Daemons[NDaemons].d_socket = -1;
1928                 Daemons[NDaemons].d_listenqueue = DEF_LISTENQUEUE;
1929                 Daemons[NDaemons].d_name = "Daemon0";
1930                 NDaemons = 1;
1931         }
1932 }
1933 /*
1934 **  SETCLIENTOPTIONS -- set options for running the client
1935 **
1936 **      Parameters:
1937 **              p -- the options line.
1938 **
1939 **      Returns:
1940 **              none.
1941 */
1942
1943 static DAEMON_T ClientSettings[AF_MAX + 1];
1944
1945 void
1946 setclientoptions(p)
1947         register char *p;
1948 {
1949         int family;
1950         DAEMON_T d;
1951
1952         memset(&d, '\0', sizeof(d));
1953         setsockaddroptions(p, &d);
1954
1955         /* grab what we need */
1956         family = d.d_addr.sa.sa_family;
1957         STRUCTCOPY(d, ClientSettings[family]);
1958         setbitn(D_ISSET, ClientSettings[family].d_flags); /* mark as set */
1959         if (d.d_name != NULL)
1960                 ClientSettings[family].d_name = newstr(d.d_name);
1961         else
1962         {
1963                 char num[30];
1964
1965                 (void) sm_snprintf(num, sizeof(num), "Client%d", family);
1966                 ClientSettings[family].d_name = newstr(num);
1967         }
1968 }
1969 /*
1970 **  ADDR_FAMILY -- determine address family from address
1971 **
1972 **      Parameters:
1973 **              addr -- the string representation of the address
1974 **
1975 **      Returns:
1976 **              AF_INET, AF_INET6 or AF_UNSPEC
1977 **
1978 **      Side Effects:
1979 **              none.
1980 */
1981
1982 static int
1983 addr_family(addr)
1984         char *addr;
1985 {
1986 #if NETINET6
1987         SOCKADDR clt_addr;
1988 #endif /* NETINET6 */
1989
1990 #if NETINET
1991         if (inet_addr(addr) != INADDR_NONE)
1992         {
1993                 if (tTd(16, 9))
1994                         sm_dprintf("addr_family(%s): INET\n", addr);
1995                 return AF_INET;
1996         }
1997 #endif /* NETINET */
1998 #if NETINET6
1999         if (anynet_pton(AF_INET6, addr, &clt_addr.sin6.sin6_addr) == 1)
2000         {
2001                 if (tTd(16, 9))
2002                         sm_dprintf("addr_family(%s): INET6\n", addr);
2003                 return AF_INET6;
2004         }
2005 #endif /* NETINET6 */
2006 #if NETUNIX
2007         if (*addr == '/')
2008         {
2009                 if (tTd(16, 9))
2010                         sm_dprintf("addr_family(%s): LOCAL\n", addr);
2011                 return AF_UNIX;
2012         }
2013 #endif /* NETUNIX */
2014         if (tTd(16, 9))
2015                 sm_dprintf("addr_family(%s): UNSPEC\n", addr);
2016         return AF_UNSPEC;
2017 }
2018
2019 /*
2020 **  CHKCLIENTMODIFIERS -- check whether all clients have set a flag.
2021 **
2022 **      Parameters:
2023 **              flag -- the flag to test.
2024 **
2025 **      Returns:
2026 **              true iff all configured clients have set the flag.
2027 */
2028
2029 bool
2030 chkclientmodifiers(flag)
2031         int flag;
2032 {
2033         int i;
2034         bool flagisset;
2035
2036         flagisset = false;
2037         for (i = 0; i < AF_MAX; i++)
2038         {
2039                 if (bitnset(D_ISSET, ClientSettings[i].d_flags))
2040                 {
2041                         if (!bitnset((char) flag, ClientSettings[i].d_flags))
2042                                 return false;
2043                         flagisset = true;
2044                 }
2045         }
2046         return flagisset;
2047 }
2048
2049 #if MILTER
2050 /*
2051 **  SETUP_DAEMON_MILTERS -- Parse per-socket filters
2052 **
2053 **      Parameters:
2054 **              none
2055 **
2056 **      Returns:
2057 **              none
2058 */
2059
2060 void
2061 setup_daemon_milters()
2062 {
2063         int idx;
2064
2065         if (OpMode == MD_SMTP)
2066         {
2067                 /* no need to configure the daemons */
2068                 return;
2069         }
2070
2071         for (idx = 0; idx < NDaemons; idx++)
2072         {
2073                 if (Daemons[idx].d_inputfilterlist != NULL)
2074                 {
2075                         milter_config(Daemons[idx].d_inputfilterlist,
2076                                       Daemons[idx].d_inputfilters,
2077                                       MAXFILTERS);
2078                 }
2079         }
2080 }
2081 #endif /* MILTER */
2082 /*
2083 **  MAKECONNECTION -- make a connection to an SMTP socket on a machine.
2084 **
2085 **      Parameters:
2086 **              host -- the name of the host.
2087 **              port -- the port number to connect to.
2088 **              mci -- a pointer to the mail connection information
2089 **                      structure to be filled in.
2090 **              e -- the current envelope.
2091 **              enough -- time at which to stop further connection attempts.
2092 **                      (0 means no limit)
2093 **
2094 **      Returns:
2095 **              An exit code telling whether the connection could be
2096 **                      made and if not why not.
2097 **
2098 **      Side Effects:
2099 **              none.
2100 */
2101
2102 static jmp_buf  CtxConnectTimeout;
2103
2104 SOCKADDR        CurHostAddr;            /* address of current host */
2105
2106 int
2107 makeconnection(host, port, mci, e, enough)
2108         char *host;
2109         volatile unsigned int port;
2110         register MCI *mci;
2111         ENVELOPE *e;
2112         time_t enough;
2113 {
2114         register volatile int addrno = 0;
2115         volatile int s;
2116         register struct hostent *volatile hp = (struct hostent *) NULL;
2117         SOCKADDR addr;
2118         SOCKADDR clt_addr;
2119         int save_errno = 0;
2120         volatile SOCKADDR_LEN_T addrlen;
2121         volatile bool firstconnect = true;
2122         SM_EVENT *volatile ev = NULL;
2123 #if NETINET6
2124         volatile bool v6found = false;
2125 #endif /* NETINET6 */
2126         volatile int family = InetMode;
2127         SOCKADDR_LEN_T len;
2128         volatile SOCKADDR_LEN_T socksize = 0;
2129         volatile bool clt_bind;
2130         BITMAP256 d_flags;
2131         char *p;
2132         extern ENVELOPE BlankEnvelope;
2133
2134         /* retranslate {daemon_flags} into bitmap */
2135         clrbitmap(d_flags);
2136         if ((p = macvalue(macid("{daemon_flags}"), e)) != NULL)
2137         {
2138                 for (; *p != '\0'; p++)
2139                 {
2140                         if (!(isascii(*p) && isspace(*p)))
2141                                 setbitn(bitidx(*p), d_flags);
2142                 }
2143         }
2144
2145 #if NETINET6
2146  v4retry:
2147 #endif /* NETINET6 */
2148         clt_bind = false;
2149
2150         /* Set up the address for outgoing connection. */
2151         if (bitnset(D_BINDIF, d_flags) &&
2152             (p = macvalue(macid("{if_addr}"), e)) != NULL &&
2153             *p != '\0')
2154         {
2155 #if NETINET6
2156                 char p6[INET6_ADDRSTRLEN];
2157 #endif /* NETINET6 */
2158
2159                 memset(&clt_addr, '\0', sizeof(clt_addr));
2160
2161                 /* infer the address family from the address itself */
2162                 clt_addr.sa.sa_family = addr_family(p);
2163                 switch (clt_addr.sa.sa_family)
2164                 {
2165 #if NETINET
2166                   case AF_INET:
2167                         clt_addr.sin.sin_addr.s_addr = inet_addr(p);
2168                         if (clt_addr.sin.sin_addr.s_addr != INADDR_NONE &&
2169                             clt_addr.sin.sin_addr.s_addr !=
2170                                 htonl(INADDR_LOOPBACK))
2171                         {
2172                                 clt_bind = true;
2173                                 socksize = sizeof(struct sockaddr_in);
2174                         }
2175                         break;
2176 #endif /* NETINET */
2177
2178 #if NETINET6
2179                   case AF_INET6:
2180                         if (inet_addr(p) != INADDR_NONE)
2181                                 (void) sm_snprintf(p6, sizeof(p6),
2182                                                    "IPv6:::ffff:%s", p);
2183                         else
2184                                 (void) sm_strlcpy(p6, p, sizeof(p6));
2185                         if (anynet_pton(AF_INET6, p6,
2186                                         &clt_addr.sin6.sin6_addr) == 1 &&
2187                             !IN6_IS_ADDR_LOOPBACK(&clt_addr.sin6.sin6_addr))
2188                         {
2189                                 clt_bind = true;
2190                                 socksize = sizeof(struct sockaddr_in6);
2191                         }
2192                         break;
2193 #endif /* NETINET6 */
2194
2195 #if 0
2196                   default:
2197                         syserr("554 5.3.5 Address= option unsupported for family %d",
2198                                clt_addr.sa.sa_family);
2199                         break;
2200 #endif /* 0 */
2201                 }
2202                 if (clt_bind)
2203                         family = clt_addr.sa.sa_family;
2204         }
2205
2206         /* D_BINDIF not set or not available, fallback to ClientPortOptions */
2207         if (!clt_bind)
2208         {
2209                 STRUCTCOPY(ClientSettings[family].d_addr, clt_addr);
2210                 switch (clt_addr.sa.sa_family)
2211                 {
2212 #if NETINET
2213                   case AF_INET:
2214                         if (clt_addr.sin.sin_addr.s_addr == 0)
2215                                 clt_addr.sin.sin_addr.s_addr = LocalDaemon ?
2216                                         htonl(INADDR_LOOPBACK) : INADDR_ANY;
2217                         else
2218                                 clt_bind = true;
2219                         if (clt_addr.sin.sin_port != 0)
2220                                 clt_bind = true;
2221                         socksize = sizeof(struct sockaddr_in);
2222                         break;
2223 #endif /* NETINET */
2224 #if NETINET6
2225                   case AF_INET6:
2226                         if (IN6_IS_ADDR_UNSPECIFIED(&clt_addr.sin6.sin6_addr))
2227                                 clt_addr.sin6.sin6_addr =
2228                                         (LocalDaemon && V6LoopbackAddrFound) ?
2229                                         in6addr_loopback : in6addr_any;
2230                         else
2231                                 clt_bind = true;
2232                         socksize = sizeof(struct sockaddr_in6);
2233                         if (clt_addr.sin6.sin6_port != 0)
2234                                 clt_bind = true;
2235                         break;
2236 #endif /* NETINET6 */
2237 #if NETISO
2238                   case AF_ISO:
2239                         socksize = sizeof(clt_addr.siso);
2240                         clt_bind = true;
2241                         break;
2242 #endif /* NETISO */
2243                   default:
2244                         break;
2245                 }
2246         }
2247
2248         /*
2249         **  Set up the address for the mailer.
2250         **      Accept "[a.b.c.d]" syntax for host name.
2251         */
2252
2253         SM_SET_H_ERRNO(0);
2254         errno = 0;
2255         memset(&CurHostAddr, '\0', sizeof(CurHostAddr));
2256         memset(&addr, '\0', sizeof(addr));
2257         SmtpPhase = mci->mci_phase = "initial connection";
2258         CurHostName = host;
2259
2260         if (host[0] == '[')
2261         {
2262                 p = strchr(host, ']');
2263                 if (p != NULL)
2264                 {
2265 #if NETINET
2266                         unsigned long hid = INADDR_NONE;
2267 #endif /* NETINET */
2268 #if NETINET6
2269                         struct sockaddr_in6 hid6;
2270 #endif /* NETINET6 */
2271
2272                         *p = '\0';
2273 #if NETINET6
2274                         memset(&hid6, '\0', sizeof(hid6));
2275 #endif /* NETINET6 */
2276 #if NETINET
2277                         if (family == AF_INET &&
2278                             (hid = inet_addr(&host[1])) != INADDR_NONE)
2279                         {
2280                                 addr.sin.sin_family = AF_INET;
2281                                 addr.sin.sin_addr.s_addr = hid;
2282                         }
2283                         else
2284 #endif /* NETINET */
2285 #if NETINET6
2286                         if (family == AF_INET6 &&
2287                             anynet_pton(AF_INET6, &host[1],
2288                                         &hid6.sin6_addr) == 1)
2289                         {
2290                                 addr.sin6.sin6_family = AF_INET6;
2291                                 addr.sin6.sin6_addr = hid6.sin6_addr;
2292                         }
2293                         else
2294 #endif /* NETINET6 */
2295                         {
2296                                 /* try it as a host name (avoid MX lookup) */
2297                                 hp = sm_gethostbyname(&host[1], family);
2298                                 if (hp == NULL && p[-1] == '.')
2299                                 {
2300 #if NAMED_BIND
2301                                         int oldopts = _res.options;
2302
2303                                         _res.options &= ~(RES_DEFNAMES|RES_DNSRCH);
2304 #endif /* NAMED_BIND */
2305                                         p[-1] = '\0';
2306                                         hp = sm_gethostbyname(&host[1],
2307                                                               family);
2308                                         p[-1] = '.';
2309 #if NAMED_BIND
2310                                         _res.options = oldopts;
2311 #endif /* NAMED_BIND */
2312                                 }
2313                                 *p = ']';
2314                                 goto gothostent;
2315                         }
2316                         *p = ']';
2317                 }
2318                 if (p == NULL)
2319                 {
2320                         extern char MsgBuf[];
2321
2322                         usrerrenh("5.1.2",
2323                                   "553 Invalid numeric domain spec \"%s\"",
2324                                   host);
2325                         mci_setstat(mci, EX_NOHOST, "5.1.2", MsgBuf);
2326                         errno = EINVAL;
2327                         return EX_NOHOST;
2328                 }
2329         }
2330         else
2331         {
2332                 /* contortion to get around SGI cc complaints */
2333                 {
2334                         p = &host[strlen(host) - 1];
2335                         hp = sm_gethostbyname(host, family);
2336                         if (hp == NULL && *p == '.')
2337                         {
2338 #if NAMED_BIND
2339                                 int oldopts = _res.options;
2340
2341                                 _res.options &= ~(RES_DEFNAMES|RES_DNSRCH);
2342 #endif /* NAMED_BIND */
2343                                 *p = '\0';
2344                                 hp = sm_gethostbyname(host, family);
2345                                 *p = '.';
2346 #if NAMED_BIND
2347                                 _res.options = oldopts;
2348 #endif /* NAMED_BIND */
2349                         }
2350                 }
2351 gothostent:
2352                 if (hp == NULL || hp->h_addr == NULL)
2353                 {
2354 #if NAMED_BIND
2355                         /* check for name server timeouts */
2356 # if NETINET6
2357                         if (WorkAroundBrokenAAAA && family == AF_INET6 &&
2358                             (h_errno == TRY_AGAIN || errno == ETIMEDOUT))
2359                         {
2360                                 /*
2361                                 **  An attempt with family AF_INET may
2362                                 **  succeed. By skipping the next section
2363                                 **  of code, we will try AF_INET before
2364                                 **  failing.
2365                                 */
2366
2367                                 if (tTd(16, 10))
2368                                         sm_dprintf("makeconnection: WorkAroundBrokenAAAA: Trying AF_INET lookup (AF_INET6 failed)\n");
2369                         }
2370                         else
2371 # endif /* NETINET6 */
2372                         {
2373                                 if (errno == ETIMEDOUT ||
2374 # if _FFR_GETHBN_ExFILE
2375 #  ifdef EMFILE
2376                                    errno == EMFILE ||
2377 #  endif /* EMFILE */
2378 #  ifdef ENFILE
2379                                    errno == ENFILE ||
2380 #  endif /* ENFILE */
2381 # endif /* _FFR_GETHBN_ExFILE */
2382                                     h_errno == TRY_AGAIN ||
2383                                     (errno == ECONNREFUSED && UseNameServer))
2384                                 {
2385                                         save_errno = errno;
2386                                         mci_setstat(mci, EX_TEMPFAIL,
2387                                                     "4.4.3", NULL);
2388                                         errno = save_errno;
2389                                         return EX_TEMPFAIL;
2390                                 }
2391                         }
2392 #endif /* NAMED_BIND */
2393 #if NETINET6
2394                         /*
2395                         **  Try v6 first, then fall back to v4.
2396                         **  If we found a v6 address, but no v4
2397                         **  addresses, then TEMPFAIL.
2398                         */
2399
2400                         if (family == AF_INET6)
2401                         {
2402                                 family = AF_INET;
2403                                 goto v4retry;
2404                         }
2405                         if (v6found)
2406                                 goto v6tempfail;
2407 #endif /* NETINET6 */
2408                         save_errno = errno;
2409                         mci_setstat(mci, EX_NOHOST, "5.1.2", NULL);
2410                         errno = save_errno;
2411                         return EX_NOHOST;
2412                 }
2413                 addr.sa.sa_family = hp->h_addrtype;
2414                 switch (hp->h_addrtype)
2415                 {
2416 #if NETINET
2417                   case AF_INET:
2418                         memmove(&addr.sin.sin_addr,
2419                                 hp->h_addr,
2420                                 INADDRSZ);
2421                         break;
2422 #endif /* NETINET */
2423
2424 #if NETINET6
2425                   case AF_INET6:
2426                         memmove(&addr.sin6.sin6_addr,
2427                                 hp->h_addr,
2428                                 IN6ADDRSZ);
2429                         break;
2430 #endif /* NETINET6 */
2431
2432                   default:
2433                         if (hp->h_length > sizeof(addr.sa.sa_data))
2434                         {
2435                                 syserr("makeconnection: long sa_data: family %d len %d",
2436                                         hp->h_addrtype, hp->h_length);
2437                                 mci_setstat(mci, EX_NOHOST, "5.1.2", NULL);
2438                                 errno = EINVAL;
2439                                 return EX_NOHOST;
2440                         }
2441                         memmove(addr.sa.sa_data, hp->h_addr, hp->h_length);
2442                         break;
2443                 }
2444                 addrno = 1;
2445         }
2446
2447         /*
2448         **  Determine the port number.
2449         */
2450
2451         if (port == 0)
2452         {
2453 #ifdef NO_GETSERVBYNAME
2454                 port = htons(25);
2455 #else /* NO_GETSERVBYNAME */
2456                 register struct servent *sp = getservbyname("smtp", "tcp");
2457
2458                 if (sp == NULL)
2459                 {
2460                         if (LogLevel > 2)
2461                                 sm_syslog(LOG_ERR, NOQID,
2462                                           "makeconnection: service \"smtp\" unknown");
2463                         port = htons(25);
2464                 }
2465                 else
2466                         port = sp->s_port;
2467 #endif /* NO_GETSERVBYNAME */
2468         }
2469
2470 #if NETINET6
2471         if (addr.sa.sa_family == AF_INET6 &&
2472             IN6_IS_ADDR_V4MAPPED(&addr.sin6.sin6_addr) &&
2473             ClientSettings[AF_INET].d_addr.sa.sa_family != 0)
2474         {
2475                 /*
2476                 **  Ignore mapped IPv4 address since
2477                 **  there is a ClientPortOptions setting
2478                 **  for IPv4.
2479                 */
2480
2481                 goto nextaddr;
2482         }
2483 #endif /* NETINET6 */
2484
2485         switch (addr.sa.sa_family)
2486         {
2487 #if NETINET
2488           case AF_INET:
2489                 addr.sin.sin_port = port;
2490                 addrlen = sizeof(struct sockaddr_in);
2491                 break;
2492 #endif /* NETINET */
2493
2494 #if NETINET6
2495           case AF_INET6:
2496                 addr.sin6.sin6_port = port;
2497                 addrlen = sizeof(struct sockaddr_in6);
2498                 break;
2499 #endif /* NETINET6 */
2500
2501 #if NETISO
2502           case AF_ISO:
2503                 /* assume two byte transport selector */
2504                 memmove(TSEL((struct sockaddr_iso *) &addr), (char *) &port, 2);
2505                 addrlen = sizeof(struct sockaddr_iso);
2506                 break;
2507 #endif /* NETISO */
2508
2509           default:
2510                 syserr("Can't connect to address family %d", addr.sa.sa_family);
2511                 mci_setstat(mci, EX_NOHOST, "5.1.2", NULL);
2512                 errno = EINVAL;
2513 #if NETINET6
2514                 if (hp != NULL)
2515                         freehostent(hp);
2516 #endif /* NETINET6 */
2517                 return EX_NOHOST;
2518         }
2519
2520         /*
2521         **  Try to actually open the connection.
2522         */
2523
2524 #if XLA
2525         /* if too many connections, don't bother trying */
2526         if (!xla_noqueue_ok(host))
2527         {
2528 # if NETINET6
2529                 if (hp != NULL)
2530                         freehostent(hp);
2531 # endif /* NETINET6 */
2532                 return EX_TEMPFAIL;
2533         }
2534 #endif /* XLA */
2535
2536         for (;;)
2537         {
2538                 if (tTd(16, 1))
2539                         sm_dprintf("makeconnection (%s [%s].%d (%d))\n",
2540                                    host, anynet_ntoa(&addr), ntohs(port),
2541                                    (int) addr.sa.sa_family);
2542
2543                 /* save for logging */
2544                 CurHostAddr = addr;
2545
2546 #if HASRRESVPORT
2547                 if (bitnset(M_SECURE_PORT, mci->mci_mailer->m_flags))
2548                 {
2549                         int rport = IPPORT_RESERVED - 1;
2550
2551                         s = rresvport(&rport);
2552                 }
2553                 else
2554 #endif /* HASRRESVPORT */
2555                 {
2556                         s = socket(addr.sa.sa_family, SOCK_STREAM, 0);
2557                 }
2558                 if (s < 0)
2559                 {
2560                         save_errno = errno;
2561                         syserr("makeconnection: cannot create socket");
2562 #if XLA
2563                         xla_host_end(host);
2564 #endif /* XLA */
2565                         mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
2566 #if NETINET6
2567                         if (hp != NULL)
2568                                 freehostent(hp);
2569 #endif /* NETINET6 */
2570                         errno = save_errno;
2571                         return EX_TEMPFAIL;
2572                 }
2573
2574 #ifdef SO_SNDBUF
2575                 if (ClientSettings[family].d_tcpsndbufsize > 0)
2576                 {
2577                         if (setsockopt(s, SOL_SOCKET, SO_SNDBUF,
2578                                        (char *) &ClientSettings[family].d_tcpsndbufsize,
2579                                        sizeof(ClientSettings[family].d_tcpsndbufsize)) < 0)
2580                                 syserr("makeconnection: setsockopt(SO_SNDBUF)");
2581                 }
2582 #endif /* SO_SNDBUF */
2583 #ifdef SO_RCVBUF
2584                 if (ClientSettings[family].d_tcprcvbufsize > 0)
2585                 {
2586                         if (setsockopt(s, SOL_SOCKET, SO_RCVBUF,
2587                                        (char *) &ClientSettings[family].d_tcprcvbufsize,
2588                                        sizeof(ClientSettings[family].d_tcprcvbufsize)) < 0)
2589                                 syserr("makeconnection: setsockopt(SO_RCVBUF)");
2590                 }
2591 #endif /* SO_RCVBUF */
2592
2593                 if (tTd(16, 1))
2594                         sm_dprintf("makeconnection: fd=%d\n", s);
2595
2596                 /* turn on network debugging? */
2597                 if (tTd(16, 101))
2598                 {
2599                         int on = 1;
2600
2601                         (void) setsockopt(s, SOL_SOCKET, SO_DEBUG,
2602                                           (char *)&on, sizeof(on));
2603                 }
2604                 if (e->e_xfp != NULL)   /* for debugging */
2605                         (void) sm_io_flush(e->e_xfp, SM_TIME_DEFAULT);
2606                 errno = 0;              /* for debugging */
2607
2608                 if (clt_bind)
2609                 {
2610                         int on = 1;
2611
2612                         switch (clt_addr.sa.sa_family)
2613                         {
2614 #if NETINET
2615                           case AF_INET:
2616                                 if (clt_addr.sin.sin_port != 0)
2617                                         (void) setsockopt(s, SOL_SOCKET,
2618                                                           SO_REUSEADDR,
2619                                                           (char *) &on,
2620                                                           sizeof(on));
2621                                 break;
2622 #endif /* NETINET */
2623
2624 #if NETINET6
2625                           case AF_INET6:
2626                                 if (clt_addr.sin6.sin6_port != 0)
2627                                         (void) setsockopt(s, SOL_SOCKET,
2628                                                           SO_REUSEADDR,
2629                                                           (char *) &on,
2630                                                           sizeof(on));
2631                                 break;
2632 #endif /* NETINET6 */
2633                         }
2634
2635                         if (bind(s, &clt_addr.sa, socksize) < 0)
2636                         {
2637                                 save_errno = errno;
2638                                 (void) close(s);
2639                                 errno = save_errno;
2640                                 syserr("makeconnection: cannot bind socket [%s]",
2641                                        anynet_ntoa(&clt_addr));
2642 #if NETINET6
2643                                 if (hp != NULL)
2644                                         freehostent(hp);
2645 #endif /* NETINET6 */
2646                                 errno = save_errno;
2647                                 return EX_TEMPFAIL;
2648                         }
2649                 }
2650
2651                 /*
2652                 **  Linux seems to hang in connect for 90 minutes (!!!).
2653                 **  Time out the connect to avoid this problem.
2654                 */
2655
2656                 if (setjmp(CtxConnectTimeout) == 0)
2657                 {
2658                         int i;
2659
2660                         if (e->e_ntries <= 0 && TimeOuts.to_iconnect != 0)
2661                                 ev = sm_setevent(TimeOuts.to_iconnect,
2662                                                  connecttimeout, 0);
2663                         else if (TimeOuts.to_connect != 0)
2664                                 ev = sm_setevent(TimeOuts.to_connect,
2665                                                  connecttimeout, 0);
2666                         else
2667                                 ev = NULL;
2668
2669                         switch (ConnectOnlyTo.sa.sa_family)
2670                         {
2671 #if NETINET
2672                           case AF_INET:
2673                                 addr.sin.sin_addr.s_addr = ConnectOnlyTo.sin.sin_addr.s_addr;
2674                                 addr.sa.sa_family = ConnectOnlyTo.sa.sa_family;
2675                                 break;
2676 #endif /* NETINET */
2677
2678 #if NETINET6
2679                           case AF_INET6:
2680                                 memmove(&addr.sin6.sin6_addr,
2681                                         &ConnectOnlyTo.sin6.sin6_addr,
2682                                         IN6ADDRSZ);
2683                                 break;
2684 #endif /* NETINET6 */
2685                         }
2686                         if (tTd(16, 1))
2687                                 sm_dprintf("Connecting to [%s]...\n", anynet_ntoa(&addr));
2688                         i = connect(s, (struct sockaddr *) &addr, addrlen);
2689                         save_errno = errno;
2690                         if (ev != NULL)
2691                                 sm_clrevent(ev);
2692                         if (i >= 0)
2693                                 break;
2694                 }
2695                 else
2696                         save_errno = errno;
2697
2698                 /* couldn't connect.... figure out why */
2699                 (void) close(s);
2700
2701                 /* if running demand-dialed connection, try again */
2702                 if (DialDelay > 0 && firstconnect &&
2703                     bitnset(M_DIALDELAY, mci->mci_mailer->m_flags))
2704                 {
2705                         if (tTd(16, 1))
2706                                 sm_dprintf("Connect failed (%s); trying again...\n",
2707                                            sm_errstring(save_errno));
2708                         firstconnect = false;
2709                         (void) sleep(DialDelay);
2710                         continue;
2711                 }
2712
2713                 if (LogLevel > 13)
2714                         sm_syslog(LOG_INFO, e->e_id,
2715                                   "makeconnection (%s [%s]) failed: %s",
2716                                   host, anynet_ntoa(&addr),
2717                                   sm_errstring(save_errno));
2718
2719 #if NETINET6
2720 nextaddr:
2721 #endif /* NETINET6 */
2722                 if (hp != NULL && hp->h_addr_list[addrno] != NULL &&
2723                     (enough == 0 || curtime() < enough))
2724                 {
2725                         if (tTd(16, 1))
2726                                 sm_dprintf("Connect failed (%s); trying new address....\n",
2727                                            sm_errstring(save_errno));
2728                         switch (addr.sa.sa_family)
2729                         {
2730 #if NETINET
2731                           case AF_INET:
2732                                 memmove(&addr.sin.sin_addr,
2733                                         hp->h_addr_list[addrno++],
2734                                         INADDRSZ);
2735                                 break;
2736 #endif /* NETINET */
2737
2738 #if NETINET6
2739                           case AF_INET6:
2740                                 memmove(&addr.sin6.sin6_addr,
2741                                         hp->h_addr_list[addrno++],
2742                                         IN6ADDRSZ);
2743                                 break;
2744 #endif /* NETINET6 */
2745
2746                           default:
2747                                 memmove(addr.sa.sa_data,
2748                                         hp->h_addr_list[addrno++],
2749                                         hp->h_length);
2750                                 break;
2751                         }
2752                         continue;
2753                 }
2754                 errno = save_errno;
2755
2756 #if NETINET6
2757                 if (family == AF_INET6)
2758                 {
2759                         if (tTd(16, 1))
2760                                 sm_dprintf("Connect failed (%s); retrying with AF_INET....\n",
2761                                            sm_errstring(save_errno));
2762                         v6found = true;
2763                         family = AF_INET;
2764                         if (hp != NULL)
2765                         {
2766                                 freehostent(hp);
2767                                 hp = NULL;
2768                         }
2769                         goto v4retry;
2770                 }
2771         v6tempfail:
2772 #endif /* NETINET6 */
2773                 /* couldn't open connection */
2774 #if NETINET6
2775                 /* Don't clobber an already saved errno from v4retry */
2776                 if (errno > 0)
2777 #endif /* NETINET6 */
2778                         save_errno = errno;
2779                 if (tTd(16, 1))
2780                         sm_dprintf("Connect failed (%s)\n",
2781                                    sm_errstring(save_errno));
2782 #if XLA
2783                 xla_host_end(host);
2784 #endif /* XLA */
2785                 mci_setstat(mci, EX_TEMPFAIL, "4.4.1", NULL);
2786 #if NETINET6
2787                 if (hp != NULL)
2788                         freehostent(hp);
2789 #endif /* NETINET6 */
2790                 errno = save_errno;
2791                 return EX_TEMPFAIL;
2792         }
2793
2794 #if NETINET6
2795         if (hp != NULL)
2796         {
2797                 freehostent(hp);
2798                 hp = NULL;
2799         }
2800 #endif /* NETINET6 */
2801
2802         /* connection ok, put it into canonical form */
2803         mci->mci_out = NULL;
2804         if ((mci->mci_out = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
2805                                        (void *) &s,
2806                                        SM_IO_WRONLY_B, NULL)) == NULL ||
2807             (s = dup(s)) < 0 ||
2808             (mci->mci_in = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
2809                                       (void *) &s,
2810                                       SM_IO_RDONLY_B, NULL)) == NULL)
2811         {
2812                 save_errno = errno;
2813                 syserr("cannot open SMTP client channel, fd=%d", s);
2814                 mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
2815                 if (mci->mci_out != NULL)
2816                         (void) sm_io_close(mci->mci_out, SM_TIME_DEFAULT);
2817                 (void) close(s);
2818                 errno = save_errno;
2819                 return EX_TEMPFAIL;
2820         }
2821         sm_io_automode(mci->mci_out, mci->mci_in);
2822
2823         /* set {client_flags} */
2824         if (ClientSettings[addr.sa.sa_family].d_mflags != NULL)
2825         {
2826                 macdefine(&mci->mci_macro, A_PERM,
2827                           macid("{client_flags}"),
2828                           ClientSettings[addr.sa.sa_family].d_mflags);
2829         }
2830         else
2831                 macdefine(&mci->mci_macro, A_PERM,
2832                           macid("{client_flags}"), "");
2833
2834         /* "add" {client_flags} to bitmap */
2835         if (bitnset(D_IFNHELO, ClientSettings[addr.sa.sa_family].d_flags))
2836         {
2837                 /* look for just this one flag */
2838                 setbitn(D_IFNHELO, d_flags);
2839         }
2840
2841         /* find out name for Interface through which we connect */
2842         len = sizeof(addr);
2843         if (getsockname(s, &addr.sa, &len) == 0)
2844         {
2845                 char *name;
2846                 char family[5];
2847
2848                 macdefine(&BlankEnvelope.e_macro, A_TEMP,
2849                         macid("{if_addr_out}"), anynet_ntoa(&addr));
2850                 (void) sm_snprintf(family, sizeof(family), "%d",
2851                         addr.sa.sa_family);
2852                 macdefine(&BlankEnvelope.e_macro, A_TEMP,
2853                         macid("{if_family_out}"), family);
2854
2855                 name = hostnamebyanyaddr(&addr);
2856                 macdefine(&BlankEnvelope.e_macro, A_TEMP,
2857                         macid("{if_name_out}"), name);
2858                 if (LogLevel > 11)
2859                 {
2860                         /* log connection information */
2861                         sm_syslog(LOG_INFO, e->e_id,
2862                                   "SMTP outgoing connect on %.40s", name);
2863                 }
2864                 if (bitnset(D_IFNHELO, d_flags))
2865                 {
2866                         if (name[0] != '[' && strchr(name, '.') != NULL)
2867                                 mci->mci_heloname = newstr(name);
2868                 }
2869         }
2870         else
2871         {
2872                 macdefine(&BlankEnvelope.e_macro, A_PERM,
2873                         macid("{if_name_out}"), NULL);
2874                 macdefine(&BlankEnvelope.e_macro, A_PERM,
2875                         macid("{if_addr_out}"), NULL);
2876                 macdefine(&BlankEnvelope.e_macro, A_PERM,
2877                         macid("{if_family_out}"), NULL);
2878         }
2879
2880         /* Use the configured HeloName as appropriate */
2881         if (HeloName != NULL && HeloName[0] != '\0')
2882         {
2883                 SM_FREE_CLR(mci->mci_heloname);
2884                 mci->mci_heloname = newstr(HeloName);
2885         }
2886
2887         mci_setstat(mci, EX_OK, NULL, NULL);
2888         return EX_OK;
2889 }
2890
2891 static void
2892 connecttimeout(ignore)
2893         int ignore;
2894 {
2895         /*
2896         **  NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER.  DO NOT ADD
2897         **      ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
2898         **      DOING.
2899         */
2900
2901         errno = ETIMEDOUT;
2902         longjmp(CtxConnectTimeout, 1);
2903 }
2904 /*
2905 **  MAKECONNECTION_DS -- make a connection to a domain socket.
2906 **
2907 **      Parameters:
2908 **              mux_path -- the path of the socket to connect to.
2909 **              mci -- a pointer to the mail connection information
2910 **                      structure to be filled in.
2911 **
2912 **      Returns:
2913 **              An exit code telling whether the connection could be
2914 **                      made and if not why not.
2915 **
2916 **      Side Effects:
2917 **              none.
2918 */
2919
2920 #if NETUNIX
2921 int
2922 makeconnection_ds(mux_path, mci)
2923         char *mux_path;
2924         register MCI *mci;
2925 {
2926         int sock;
2927         int rval, save_errno;
2928         long sff = SFF_SAFEDIRPATH|SFF_OPENASROOT|SFF_NOLINK|SFF_ROOTOK|SFF_EXECOK;
2929         struct sockaddr_un unix_addr;
2930
2931         /* if not safe, don't connect */
2932         rval = safefile(mux_path, RunAsUid, RunAsGid, RunAsUserName,
2933                         sff, S_IRUSR|S_IWUSR, NULL);
2934
2935         if (rval != 0)
2936         {
2937                 syserr("makeconnection_ds: unsafe domain socket %s",
2938                         mux_path);
2939                 mci_setstat(mci, EX_TEMPFAIL, "4.3.5", NULL);
2940                 errno = rval;
2941                 return EX_TEMPFAIL;
2942         }
2943
2944         /* prepare address structure */
2945         memset(&unix_addr, '\0', sizeof(unix_addr));
2946         unix_addr.sun_family = AF_UNIX;
2947
2948         if (strlen(mux_path) >= sizeof(unix_addr.sun_path))
2949         {
2950                 syserr("makeconnection_ds: domain socket name %s too long",
2951                         mux_path);
2952
2953                 /* XXX why TEMPFAIL but 5.x.y ? */
2954                 mci_setstat(mci, EX_TEMPFAIL, "5.3.5", NULL);
2955                 errno = ENAMETOOLONG;
2956                 return EX_UNAVAILABLE;
2957         }
2958         (void) sm_strlcpy(unix_addr.sun_path, mux_path,
2959                           sizeof(unix_addr.sun_path));
2960
2961         /* initialize domain socket */
2962         sock = socket(AF_UNIX, SOCK_STREAM, 0);
2963         if (sock == -1)
2964         {
2965                 save_errno = errno;
2966                 syserr("makeconnection_ds: could not create domain socket %s",
2967                         mux_path);
2968                 mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
2969                 errno = save_errno;
2970                 return EX_TEMPFAIL;
2971         }
2972
2973         /* connect to server */
2974         if (connect(sock, (struct sockaddr *) &unix_addr,
2975                     sizeof(unix_addr)) == -1)
2976         {
2977                 save_errno = errno;
2978                 syserr("Could not connect to socket %s", mux_path);
2979                 mci_setstat(mci, EX_TEMPFAIL, "4.4.1", NULL);
2980                 (void) close(sock);
2981                 errno = save_errno;
2982                 return EX_TEMPFAIL;
2983         }
2984
2985         /* connection ok, put it into canonical form */
2986         mci->mci_out = NULL;
2987         if ((mci->mci_out = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
2988                                        (void *) &sock, SM_IO_WRONLY_B, NULL))
2989                                         == NULL
2990             || (sock = dup(sock)) < 0 ||
2991             (mci->mci_in = sm_io_open(SmFtStdiofd, SM_TIME_DEFAULT,
2992                                       (void *) &sock, SM_IO_RDONLY_B, NULL))
2993                                         == NULL)
2994         {
2995                 save_errno = errno;
2996                 syserr("cannot open SMTP client channel, fd=%d", sock);
2997                 mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
2998                 if (mci->mci_out != NULL)
2999                         (void) sm_io_close(mci->mci_out, SM_TIME_DEFAULT);
3000                 (void) close(sock);
3001                 errno = save_errno;
3002                 return EX_TEMPFAIL;
3003         }
3004         sm_io_automode(mci->mci_out, mci->mci_in);
3005
3006         mci_setstat(mci, EX_OK, NULL, NULL);
3007         errno = 0;
3008         return EX_OK;
3009 }
3010 #endif /* NETUNIX */
3011 /*
3012 **  SHUTDOWN_DAEMON -- Performs a clean shutdown of the daemon
3013 **
3014 **      Parameters:
3015 **              none.
3016 **
3017 **      Returns:
3018 **              none.
3019 **
3020 **      Side Effects:
3021 **              closes control socket, exits.
3022 */
3023
3024 void
3025 shutdown_daemon()
3026 {
3027         int i;
3028         char *reason;
3029
3030         sm_allsignals(true);
3031
3032         reason = ShutdownRequest;
3033         ShutdownRequest = NULL;
3034         PendingSignal = 0;
3035
3036         if (LogLevel > 9)
3037                 sm_syslog(LOG_INFO, CurEnv->e_id, "stopping daemon, reason=%s",
3038                           reason == NULL ? "implicit call" : reason);
3039
3040         FileName = NULL;
3041         closecontrolsocket(true);
3042 #if XLA
3043         xla_all_end();
3044 #endif /* XLA */
3045
3046         for (i = 0; i < NDaemons; i++)
3047         {
3048                 if (Daemons[i].d_socket >= 0)
3049                 {
3050                         (void) close(Daemons[i].d_socket);
3051                         Daemons[i].d_socket = -1;
3052
3053 #if NETUNIX
3054                         /* Remove named sockets */
3055                         if (Daemons[i].d_addr.sa.sa_family == AF_UNIX)
3056                         {
3057                                 int rval;
3058                                 long sff = SFF_SAFEDIRPATH|SFF_OPENASROOT|SFF_NOLINK|SFF_MUSTOWN|SFF_EXECOK|SFF_CREAT;
3059
3060                                 /* if not safe, don't use it */
3061                                 rval = safefile(Daemons[i].d_addr.sunix.sun_path,
3062                                                 RunAsUid, RunAsGid,
3063                                                 RunAsUserName, sff,
3064                                                 S_IRUSR|S_IWUSR, NULL);
3065                                 if (rval == 0 &&
3066                                     unlink(Daemons[i].d_addr.sunix.sun_path) < 0)
3067                                 {
3068                                         sm_syslog(LOG_WARNING, NOQID,
3069                                                   "Could not remove daemon %s socket: %s: %s",
3070                                                   Daemons[i].d_name,
3071                                                   Daemons[i].d_addr.sunix.sun_path,
3072                                                   sm_errstring(errno));
3073                                 }
3074                         }
3075 #endif /* NETUNIX */
3076                 }
3077         }
3078
3079         finis(false, true, EX_OK);
3080 }
3081 /*
3082 **  RESTART_DAEMON -- Performs a clean restart of the daemon
3083 **
3084 **      Parameters:
3085 **              none.
3086 **
3087 **      Returns:
3088 **              none.
3089 **
3090 **      Side Effects:
3091 **              restarts the daemon or exits if restart fails.
3092 */
3093
3094 /* Make a non-DFL/IGN signal a noop */
3095 #define SM_NOOP_SIGNAL(sig, old)                                \
3096 do                                                              \
3097 {                                                               \
3098         (old) = sm_signal((sig), sm_signal_noop);               \
3099         if ((old) == SIG_IGN || (old) == SIG_DFL)               \
3100                 (void) sm_signal((sig), (old));                 \
3101 } while (0)
3102
3103 void
3104 restart_daemon()
3105 {
3106         bool drop;
3107         int save_errno;
3108         char *reason;
3109         sigfunc_t ignore, oalrm, ousr1;
3110         extern int DtableSize;
3111
3112         /* clear the events to turn off SIGALRMs */
3113         sm_clear_events();
3114         sm_allsignals(true);
3115
3116         reason = RestartRequest;
3117         RestartRequest = NULL;
3118         PendingSignal = 0;
3119
3120         if (SaveArgv[0][0] != '/')
3121         {
3122                 if (LogLevel > 3)
3123                         sm_syslog(LOG_INFO, NOQID,
3124                                   "could not restart: need full path");
3125                 finis(false, true, EX_OSFILE);
3126                 /* NOTREACHED */
3127         }
3128         if (LogLevel > 3)
3129                 sm_syslog(LOG_INFO, NOQID, "restarting %s due to %s",
3130                           SaveArgv[0],
3131                           reason == NULL ? "implicit call" : reason);
3132
3133         closecontrolsocket(true);
3134 #if SM_CONF_SHM
3135         cleanup_shm(DaemonPid == getpid());
3136 #endif /* SM_CONF_SHM */
3137
3138         /* close locked pid file */
3139         close_sendmail_pid();
3140
3141         /*
3142         **  Want to drop to the user who started the process in all cases
3143         **  *but* when running as "smmsp" for the clientmqueue queue run
3144         **  daemon.  In that case, UseMSP will be true, RunAsUid should not
3145         **  be root, and RealUid should be either 0 or RunAsUid.
3146         */
3147
3148         drop = !(UseMSP && RunAsUid != 0 &&
3149                  (RealUid == 0 || RealUid == RunAsUid));
3150
3151         if (drop_privileges(drop) != EX_OK)
3152         {
3153                 if (LogLevel > 0)
3154                         sm_syslog(LOG_ALERT, NOQID,
3155                                   "could not drop privileges: %s",
3156                                   sm_errstring(errno));
3157                 finis(false, true, EX_OSERR);
3158                 /* NOTREACHED */
3159         }
3160
3161         sm_close_on_exec(STDERR_FILENO + 1, DtableSize);
3162
3163         /*
3164         **  Need to allow signals before execve() to make them "harmless".
3165         **  However, the default action can be "terminate", so it isn't
3166         **  really harmless.  Setting signals to IGN will cause them to be
3167         **  ignored in the new process to, so that isn't a good alternative.
3168         */
3169
3170         SM_NOOP_SIGNAL(SIGALRM, oalrm);
3171         SM_NOOP_SIGNAL(SIGCHLD, ignore);
3172         SM_NOOP_SIGNAL(SIGHUP, ignore);
3173         SM_NOOP_SIGNAL(SIGINT, ignore);
3174         SM_NOOP_SIGNAL(SIGPIPE, ignore);
3175         SM_NOOP_SIGNAL(SIGTERM, ignore);
3176 #ifdef SIGUSR1
3177         SM_NOOP_SIGNAL(SIGUSR1, ousr1);
3178 #endif /* SIGUSR1 */
3179
3180         /* Turn back on signals */
3181         sm_allsignals(false);
3182
3183         (void) execve(SaveArgv[0], (ARGV_T) SaveArgv, (ARGV_T) ExternalEnviron);
3184         save_errno = errno;
3185
3186         /* block signals again and restore needed signals */
3187         sm_allsignals(true);
3188
3189         /* For finis() events */
3190         (void) sm_signal(SIGALRM, oalrm);
3191
3192 #ifdef SIGUSR1
3193         /* For debugging finis() */
3194         (void) sm_signal(SIGUSR1, ousr1);
3195 #endif /* SIGUSR1 */
3196
3197         errno = save_errno;
3198         if (LogLevel > 0)
3199                 sm_syslog(LOG_ALERT, NOQID, "could not exec %s: %s",
3200                           SaveArgv[0], sm_errstring(errno));
3201         finis(false, true, EX_OSFILE);
3202         /* NOTREACHED */
3203 }
3204 /*
3205 **  MYHOSTNAME -- return the name of this host.
3206 **
3207 **      Parameters:
3208 **              hostbuf -- a place to return the name of this host.
3209 **              size -- the size of hostbuf.
3210 **
3211 **      Returns:
3212 **              A list of aliases for this host.
3213 **
3214 **      Side Effects:
3215 **              Adds numeric codes to $=w.
3216 */
3217
3218 struct hostent *
3219 myhostname(hostbuf, size)
3220         char hostbuf[];
3221         int size;
3222 {
3223         register struct hostent *hp;
3224
3225         if (gethostname(hostbuf, size) < 0 || hostbuf[0] == '\0')
3226                 (void) sm_strlcpy(hostbuf, "localhost", size);
3227         hp = sm_gethostbyname(hostbuf, InetMode);
3228 #if NETINET && NETINET6
3229         if (hp == NULL && InetMode == AF_INET6)
3230         {
3231                 /*
3232                 **  It's possible that this IPv6 enabled machine doesn't
3233                 **  actually have any IPv6 interfaces and, therefore, no
3234                 **  IPv6 addresses.  Fall back to AF_INET.
3235                 */
3236
3237                 hp = sm_gethostbyname(hostbuf, AF_INET);
3238         }
3239 #endif /* NETINET && NETINET6 */
3240         if (hp == NULL)
3241                 return NULL;
3242         if (strchr(hp->h_name, '.') != NULL || strchr(hostbuf, '.') == NULL)
3243                 (void) cleanstrcpy(hostbuf, hp->h_name, size);
3244
3245 #if NETINFO
3246         if (strchr(hostbuf, '.') == NULL)
3247         {
3248                 char *domainname;
3249
3250                 domainname = ni_propval("/locations", NULL, "resolver",
3251                                         "domain", '\0');
3252                 if (domainname != NULL &&
3253                     strlen(domainname) + strlen(hostbuf) + 1 < size)
3254                         (void) sm_strlcat2(hostbuf, ".", domainname, size);
3255         }
3256 #endif /* NETINFO */
3257
3258         /*
3259         **  If there is still no dot in the name, try looking for a
3260         **  dotted alias.
3261         */
3262
3263         if (strchr(hostbuf, '.') == NULL)
3264         {
3265                 char **ha;
3266
3267                 for (ha = hp->h_aliases; ha != NULL && *ha != NULL; ha++)
3268                 {
3269                         if (strchr(*ha, '.') != NULL)
3270                         {
3271                                 (void) cleanstrcpy(hostbuf, *ha, size - 1);
3272                                 hostbuf[size - 1] = '\0';
3273                                 break;
3274                         }
3275                 }
3276         }
3277
3278         /*
3279         **  If _still_ no dot, wait for a while and try again -- it is
3280         **  possible that some service is starting up.  This can result
3281         **  in excessive delays if the system is badly configured, but
3282         **  there really isn't a way around that, particularly given that
3283         **  the config file hasn't been read at this point.
3284         **  All in all, a bit of a mess.
3285         */
3286
3287         if (strchr(hostbuf, '.') == NULL &&
3288             !getcanonname(hostbuf, size, true, NULL))
3289         {
3290                 sm_syslog(LocalDaemon ? LOG_WARNING : LOG_CRIT, NOQID,
3291                           "My unqualified host name (%s) unknown; sleeping for retry",
3292                           hostbuf);
3293                 message("My unqualified host name (%s) unknown; sleeping for retry",
3294                         hostbuf);
3295                 (void) sleep(60);
3296                 if (!getcanonname(hostbuf, size, true, NULL))
3297                 {
3298                         sm_syslog(LocalDaemon ? LOG_WARNING : LOG_ALERT, NOQID,
3299                                   "unable to qualify my own domain name (%s) -- using short name",
3300                                   hostbuf);
3301                         message("WARNING: unable to qualify my own domain name (%s) -- using short name",
3302                                 hostbuf);
3303                 }
3304         }
3305         return hp;
3306 }
3307 /*
3308 **  ADDRCMP -- compare two host addresses
3309 **
3310 **      Parameters:
3311 **              hp -- hostent structure for the first address
3312 **              ha -- actual first address
3313 **              sa -- second address
3314 **
3315 **      Returns:
3316 **              0 -- if ha and sa match
3317 **              else -- they don't match
3318 */
3319
3320 static int
3321 addrcmp(hp, ha, sa)
3322         struct hostent *hp;
3323         char *ha;
3324         SOCKADDR *sa;
3325 {
3326 #if NETINET6
3327         unsigned char *a;
3328 #endif /* NETINET6 */
3329
3330         switch (sa->sa.sa_family)
3331         {
3332 #if NETINET
3333           case AF_INET:
3334                 if (hp->h_addrtype == AF_INET)
3335                         return memcmp(ha, (char *) &sa->sin.sin_addr, INADDRSZ);
3336                 break;
3337 #endif /* NETINET */
3338
3339 #if NETINET6
3340           case AF_INET6:
3341                 a = (unsigned char *) &sa->sin6.sin6_addr;
3342
3343                 /* Straight binary comparison */
3344                 if (hp->h_addrtype == AF_INET6)
3345                         return memcmp(ha, a, IN6ADDRSZ);
3346
3347                 /* If IPv4-mapped IPv6 address, compare the IPv4 section */
3348                 if (hp->h_addrtype == AF_INET &&
3349                     IN6_IS_ADDR_V4MAPPED(&sa->sin6.sin6_addr))
3350                         return memcmp(a + IN6ADDRSZ - INADDRSZ, ha, INADDRSZ);
3351                 break;
3352 #endif /* NETINET6 */
3353         }
3354         return -1;
3355 }
3356 /*
3357 **  GETAUTHINFO -- get the real host name associated with a file descriptor
3358 **
3359 **      Uses RFC1413 protocol to try to get info from the other end.
3360 **
3361 **      Parameters:
3362 **              fd -- the descriptor
3363 **              may_be_forged -- an outage that is set to true if the
3364 **                      forward lookup of RealHostName does not match
3365 **                      RealHostAddr; set to false if they do match.
3366 **
3367 **      Returns:
3368 **              The user@host information associated with this descriptor.
3369 */
3370
3371 static jmp_buf  CtxAuthTimeout;
3372
3373 static void
3374 authtimeout(ignore)
3375         int ignore;
3376 {
3377         /*
3378         **  NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER.  DO NOT ADD
3379         **      ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
3380         **      DOING.
3381         */
3382
3383         errno = ETIMEDOUT;
3384         longjmp(CtxAuthTimeout, 1);
3385 }
3386
3387 char *
3388 getauthinfo(fd, may_be_forged)
3389         int fd;
3390         bool *may_be_forged;
3391 {
3392         unsigned short SM_NONVOLATILE port = 0;
3393         SOCKADDR_LEN_T falen;
3394         register char *volatile p = NULL;
3395         SOCKADDR la;
3396         SOCKADDR_LEN_T lalen;
3397 #ifndef NO_GETSERVBYNAME
3398         register struct servent *sp;
3399 # if NETINET
3400         static unsigned short port4 = 0;
3401 # endif /* NETINET */
3402 # if NETINET6
3403         static unsigned short port6 = 0;
3404 # endif /* NETINET6 */
3405 #endif /* ! NO_GETSERVBYNAME */
3406         volatile int s;
3407         int i = 0;
3408         size_t len;
3409         SM_EVENT *ev;
3410         int nleft;
3411         struct hostent *hp;
3412         char *ostype = NULL;
3413         char **ha;
3414         char ibuf[MAXNAME + 1];
3415         static char hbuf[MAXNAME + MAXAUTHINFO + 11];
3416
3417         *may_be_forged = true;
3418         falen = sizeof(RealHostAddr);
3419         if (isatty(fd) || (i = getpeername(fd, &RealHostAddr.sa, &falen)) < 0 ||
3420             falen <= 0 || RealHostAddr.sa.sa_family == 0)
3421         {
3422                 if (i < 0)
3423                 {
3424                         /*
3425                         **  ENOTSOCK is OK: bail on anything else, but reset
3426                         **  errno in this case, so a mis-report doesn't
3427                         **  happen later.
3428                         */
3429
3430                         if (errno != ENOTSOCK)
3431                                 return NULL;
3432                         errno = 0;
3433                 }
3434
3435                 *may_be_forged = false;
3436                 (void) sm_strlcpyn(hbuf, sizeof(hbuf), 2, RealUserName,
3437                                    "@localhost");
3438                 if (tTd(9, 1))
3439                         sm_dprintf("getauthinfo: %s\n", hbuf);
3440                 return hbuf;
3441         }
3442
3443         if (RealHostName == NULL)
3444         {
3445                 /* translate that to a host name */
3446                 RealHostName = newstr(hostnamebyanyaddr(&RealHostAddr));
3447                 if (strlen(RealHostName) > MAXNAME)
3448                         RealHostName[MAXNAME] = '\0'; /* XXX - 1 ? */
3449         }
3450
3451         /* cross check RealHostName with forward DNS lookup */
3452         if (anynet_ntoa(&RealHostAddr)[0] == '[' ||
3453             RealHostName[0] == '[')
3454                 *may_be_forged = false;
3455         else
3456         {
3457                 int family;
3458
3459                 family = RealHostAddr.sa.sa_family;
3460 #if NETINET6 && NEEDSGETIPNODE
3461                 /*
3462                 **  If RealHostAddr is an IPv6 connection with an
3463                 **  IPv4-mapped address, we need RealHostName's IPv4
3464                 **  address(es) for addrcmp() to compare against
3465                 **  RealHostAddr.
3466                 **
3467                 **  Actually, we only need to do this for systems
3468                 **  which NEEDSGETIPNODE since the real getipnodebyname()
3469                 **  already does V4MAPPED address via the AI_V4MAPPEDCFG
3470                 **  flag.  A better fix to this problem is to add this
3471                 **  functionality to our stub getipnodebyname().
3472                 */
3473
3474                 if (family == AF_INET6 &&
3475                     IN6_IS_ADDR_V4MAPPED(&RealHostAddr.sin6.sin6_addr))
3476                         family = AF_INET;
3477 #endif /* NETINET6 && NEEDSGETIPNODE */
3478
3479                 /* try to match the reverse against the forward lookup */
3480                 hp = sm_gethostbyname(RealHostName, family);
3481                 if (hp != NULL)
3482                 {
3483                         for (ha = hp->h_addr_list; *ha != NULL; ha++)
3484                         {
3485                                 if (addrcmp(hp, *ha, &RealHostAddr) == 0)
3486                                 {
3487                                         *may_be_forged = false;
3488                                         break;
3489                                 }
3490                         }
3491 #if NETINET6
3492                         freehostent(hp);
3493                         hp = NULL;
3494 #endif /* NETINET6 */
3495                 }
3496         }
3497
3498         if (TimeOuts.to_ident == 0)
3499                 goto noident;
3500
3501         lalen = sizeof(la);
3502         switch (RealHostAddr.sa.sa_family)
3503         {
3504 #if NETINET
3505           case AF_INET:
3506                 if (getsockname(fd, &la.sa, &lalen) < 0 ||
3507                     lalen <= 0 ||
3508                     la.sa.sa_family != AF_INET)
3509                 {
3510                         /* no ident info */
3511                         goto noident;
3512                 }
3513                 port = RealHostAddr.sin.sin_port;
3514
3515                 /* create ident query */
3516                 (void) sm_snprintf(ibuf, sizeof(ibuf), "%d,%d\r\n",
3517                                 ntohs(RealHostAddr.sin.sin_port),
3518                                 ntohs(la.sin.sin_port));
3519
3520                 /* create local address */
3521                 la.sin.sin_port = 0;
3522
3523                 /* create foreign address */
3524 # ifdef NO_GETSERVBYNAME
3525                 RealHostAddr.sin.sin_port = htons(113);
3526 # else /* NO_GETSERVBYNAME */
3527
3528                 /*
3529                 **  getservbyname() consumes about 5% of the time
3530                 **  when receiving a small message (almost all of the time
3531                 **  spent in this routine).
3532                 **  Hence we store the port in a static variable
3533                 **  to save this time.
3534                 **  The portnumber shouldn't change very often...
3535                 **  This code makes the assumption that the port number
3536                 **  is not 0.
3537                 */
3538
3539                 if (port4 == 0)
3540                 {
3541                         sp = getservbyname("auth", "tcp");
3542                         if (sp != NULL)
3543                                 port4 = sp->s_port;
3544                         else
3545                                 port4 = htons(113);
3546                 }
3547                 RealHostAddr.sin.sin_port = port4;
3548                 break;
3549 # endif /* NO_GETSERVBYNAME */
3550 #endif /* NETINET */
3551
3552 #if NETINET6
3553           case AF_INET6:
3554                 if (getsockname(fd, &la.sa, &lalen) < 0 ||
3555                     lalen <= 0 ||
3556                     la.sa.sa_family != AF_INET6)
3557                 {
3558                         /* no ident info */
3559                         goto noident;
3560                 }
3561                 port = RealHostAddr.sin6.sin6_port;
3562
3563                 /* create ident query */
3564                 (void) sm_snprintf(ibuf, sizeof(ibuf), "%d,%d\r\n",
3565                                 ntohs(RealHostAddr.sin6.sin6_port),
3566                                 ntohs(la.sin6.sin6_port));
3567
3568                 /* create local address */
3569                 la.sin6.sin6_port = 0;
3570
3571                 /* create foreign address */
3572 # ifdef NO_GETSERVBYNAME
3573                 RealHostAddr.sin6.sin6_port = htons(113);
3574 # else /* NO_GETSERVBYNAME */
3575                 if (port6 == 0)
3576                 {
3577                         sp = getservbyname("auth", "tcp");
3578                         if (sp != NULL)
3579                                 port6 = sp->s_port;
3580                         else
3581                                 port6 = htons(113);
3582                 }
3583                 RealHostAddr.sin6.sin6_port = port6;
3584                 break;
3585 # endif /* NO_GETSERVBYNAME */
3586 #endif /* NETINET6 */
3587           default:
3588                 /* no ident info */
3589                 goto noident;
3590         }
3591
3592         s = -1;
3593         if (setjmp(CtxAuthTimeout) != 0)
3594         {
3595                 if (s >= 0)
3596                         (void) close(s);
3597                 goto noident;
3598         }
3599
3600         /* put a timeout around the whole thing */
3601         ev = sm_setevent(TimeOuts.to_ident, authtimeout, 0);
3602
3603         /* connect to foreign IDENT server using same address as SMTP socket */
3604         s = socket(la.sa.sa_family, SOCK_STREAM, 0);
3605         if (s < 0)
3606         {
3607                 sm_clrevent(ev);
3608                 goto noident;
3609         }
3610         if (bind(s, &la.sa, lalen) < 0 ||
3611             connect(s, &RealHostAddr.sa, lalen) < 0)
3612                 goto closeident;
3613
3614         if (tTd(9, 10))
3615                 sm_dprintf("getauthinfo: sent %s", ibuf);
3616
3617         /* send query */
3618         if (write(s, ibuf, strlen(ibuf)) < 0)
3619                 goto closeident;
3620
3621         /* get result */
3622         p = &ibuf[0];
3623         nleft = sizeof(ibuf) - 1;
3624         while ((i = read(s, p, nleft)) > 0)
3625         {
3626                 char *s;
3627
3628                 p += i;
3629                 nleft -= i;
3630                 *p = '\0';
3631                 if ((s = strchr(ibuf, '\n')) != NULL)
3632                 {
3633                         if (p > s + 1)
3634                         {
3635                                 p = s + 1;
3636                                 *p = '\0';
3637                         }
3638                         break;
3639                 }
3640                 if (nleft <= 0)
3641                         break;
3642         }
3643         (void) close(s);
3644         sm_clrevent(ev);
3645         if (i < 0 || p == &ibuf[0])
3646                 goto noident;
3647
3648         if (p >= &ibuf[2] && *--p == '\n' && *--p == '\r')
3649                 p--;
3650         *++p = '\0';
3651
3652         if (tTd(9, 3))
3653                 sm_dprintf("getauthinfo:  got %s\n", ibuf);
3654
3655         /* parse result */
3656         p = strchr(ibuf, ':');
3657         if (p == NULL)
3658         {
3659                 /* malformed response */
3660                 goto noident;
3661         }
3662         while (isascii(*++p) && isspace(*p))
3663                 continue;
3664         if (sm_strncasecmp(p, "userid", 6) != 0)
3665         {
3666                 /* presumably an error string */
3667                 goto noident;
3668         }
3669         p += 6;
3670         while (isascii(*p) && isspace(*p))
3671                 p++;
3672         if (*p++ != ':')
3673         {
3674                 /* either useridxx or malformed response */
3675                 goto noident;
3676         }
3677
3678         /* p now points to the OSTYPE field */
3679         while (isascii(*p) && isspace(*p))
3680                 p++;
3681         ostype = p;
3682         p = strchr(p, ':');
3683         if (p == NULL)
3684         {
3685                 /* malformed response */
3686                 goto noident;
3687         }
3688         else
3689         {
3690                 char *charset;
3691
3692                 *p = '\0';
3693                 charset = strchr(ostype, ',');
3694                 if (charset != NULL)
3695                         *charset = '\0';
3696         }
3697
3698         /* 1413 says don't do this -- but it's broken otherwise */
3699         while (isascii(*++p) && isspace(*p))
3700                 continue;
3701
3702         /* p now points to the authenticated name -- copy carefully */
3703         if (sm_strncasecmp(ostype, "other", 5) == 0 &&
3704             (ostype[5] == ' ' || ostype[5] == '\0'))
3705         {
3706                 (void) sm_strlcpy(hbuf, "IDENT:", sizeof(hbuf));
3707                 cleanstrcpy(&hbuf[6], p, MAXAUTHINFO);
3708         }
3709         else
3710                 cleanstrcpy(hbuf, p, MAXAUTHINFO);
3711         len = strlen(hbuf);
3712         (void) sm_strlcpyn(&hbuf[len], sizeof(hbuf) - len, 2, "@",
3713                            RealHostName == NULL ? "localhost" : RealHostName);
3714         goto postident;
3715
3716 closeident:
3717         (void) close(s);
3718         sm_clrevent(ev);
3719
3720 noident:
3721         /* put back the original incoming port */
3722         switch (RealHostAddr.sa.sa_family)
3723         {
3724 #if NETINET
3725           case AF_INET:
3726                 if (port > 0)
3727                         RealHostAddr.sin.sin_port = port;
3728                 break;
3729 #endif /* NETINET */
3730
3731 #if NETINET6
3732           case AF_INET6:
3733                 if (port > 0)
3734                         RealHostAddr.sin6.sin6_port = port;
3735                 break;
3736 #endif /* NETINET6 */
3737         }
3738
3739         if (RealHostName == NULL)
3740         {
3741                 if (tTd(9, 1))
3742                         sm_dprintf("getauthinfo: NULL\n");
3743                 return NULL;
3744         }
3745         (void) sm_strlcpy(hbuf, RealHostName, sizeof(hbuf));
3746
3747 postident:
3748 #if IP_SRCROUTE
3749 # ifndef GET_IPOPT_DST
3750 #  define GET_IPOPT_DST(dst)    (dst)
3751 # endif /* ! GET_IPOPT_DST */
3752         /*
3753         **  Extract IP source routing information.
3754         **
3755         **      Format of output for a connection from site a through b
3756         **      through c to d:
3757         **              loose:      @site-c@site-b:site-a
3758         **              strict:    !@site-c@site-b:site-a
3759         **
3760         **      o - pointer within ipopt_list structure.
3761         **      q - pointer within ls/ss rr route data
3762         **      p - pointer to hbuf
3763         */
3764
3765         if (RealHostAddr.sa.sa_family == AF_INET)
3766         {
3767                 SOCKOPT_LEN_T ipoptlen;
3768                 int j;
3769                 unsigned char *q;
3770                 unsigned char *o;
3771                 int l;
3772                 struct IPOPTION ipopt;
3773
3774                 ipoptlen = sizeof(ipopt);
3775                 if (getsockopt(fd, IPPROTO_IP, IP_OPTIONS,
3776                                (char *) &ipopt, &ipoptlen) < 0)
3777                         goto noipsr;
3778                 if (ipoptlen == 0)
3779                         goto noipsr;
3780                 o = (unsigned char *) ipopt.IP_LIST;
3781                 while (o != NULL && o < (unsigned char *) &ipopt + ipoptlen)
3782                 {
3783                         switch (*o)
3784                         {
3785                           case IPOPT_EOL:
3786                                 o = NULL;
3787                                 break;
3788
3789                           case IPOPT_NOP:
3790                                 o++;
3791                                 break;
3792
3793                           case IPOPT_SSRR:
3794                           case IPOPT_LSRR:
3795                                 /*
3796                                 **  Source routing.
3797                                 **      o[0] is the option type (loose/strict).
3798                                 **      o[1] is the length of this option,
3799                                 **              including option type and
3800                                 **              length.
3801                                 **      o[2] is the pointer into the route
3802                                 **              data.
3803                                 **      o[3] begins the route data.
3804                                 */
3805
3806                                 p = &hbuf[strlen(hbuf)];
3807                                 l = sizeof(hbuf) - (hbuf - p) - 6;
3808                                 (void) sm_snprintf(p, SPACELEFT(hbuf, p),
3809                                         " [%s@%.*s",
3810                                         *o == IPOPT_SSRR ? "!" : "",
3811                                         l > 240 ? 120 : l / 2,
3812                                         inet_ntoa(GET_IPOPT_DST(ipopt.IP_DST)));
3813                                 i = strlen(p);
3814                                 p += i;
3815                                 l -= strlen(p);
3816
3817                                 j = o[1] / sizeof(struct in_addr) - 1;
3818
3819                                 /* q skips length and router pointer to data */
3820                                 q = &o[3];
3821                                 for ( ; j >= 0; j--)
3822                                 {
3823                                         struct in_addr addr;
3824
3825                                         memcpy(&addr, q, sizeof(addr));
3826                                         (void) sm_snprintf(p,
3827                                                 SPACELEFT(hbuf, p),
3828                                                 "%c%.*s",
3829                                                 j != 0 ? '@' : ':',
3830                                                 l > 240 ? 120 :
3831                                                         j == 0 ? l : l / 2,
3832                                                 inet_ntoa(addr));
3833                                         i = strlen(p);
3834                                         p += i;
3835                                         l -= i + 1;
3836                                         q += sizeof(struct in_addr);
3837                                 }
3838                                 o += o[1];
3839                                 break;
3840
3841                           default:
3842                                 /* Skip over option */
3843                                 o += o[1];
3844                                 break;
3845                         }
3846                 }
3847                 (void) sm_snprintf(p, SPACELEFT(hbuf, p), "]");
3848                 goto postipsr;
3849         }
3850
3851 noipsr:
3852 #endif /* IP_SRCROUTE */
3853         if (RealHostName != NULL && RealHostName[0] != '[')
3854         {
3855                 p = &hbuf[strlen(hbuf)];
3856                 (void) sm_snprintf(p, SPACELEFT(hbuf, p), " [%.100s]",
3857                                    anynet_ntoa(&RealHostAddr));
3858         }
3859         if (*may_be_forged)
3860         {
3861                 p = &hbuf[strlen(hbuf)];
3862                 (void) sm_strlcpy(p, " (may be forged)", SPACELEFT(hbuf, p));
3863                 macdefine(&BlankEnvelope.e_macro, A_PERM,
3864                           macid("{client_resolve}"), "FORGED");
3865         }
3866
3867 #if IP_SRCROUTE
3868 postipsr:
3869 #endif /* IP_SRCROUTE */
3870
3871         /* put back the original incoming port */
3872         switch (RealHostAddr.sa.sa_family)
3873         {
3874 #if NETINET
3875           case AF_INET:
3876                 if (port > 0)
3877                         RealHostAddr.sin.sin_port = port;
3878                 break;
3879 #endif /* NETINET */
3880
3881 #if NETINET6
3882           case AF_INET6:
3883                 if (port > 0)
3884                         RealHostAddr.sin6.sin6_port = port;
3885                 break;
3886 #endif /* NETINET6 */
3887         }
3888
3889         if (tTd(9, 1))
3890                 sm_dprintf("getauthinfo: %s\n", hbuf);
3891         return hbuf;
3892 }
3893 /*
3894 **  HOST_MAP_LOOKUP -- turn a hostname into canonical form
3895 **
3896 **      Parameters:
3897 **              map -- a pointer to this map.
3898 **              name -- the (presumably unqualified) hostname.
3899 **              av -- unused -- for compatibility with other mapping
3900 **                      functions.
3901 **              statp -- an exit status (out parameter) -- set to
3902 **                      EX_TEMPFAIL if the name server is unavailable.
3903 **
3904 **      Returns:
3905 **              The mapping, if found.
3906 **              NULL if no mapping found.
3907 **
3908 **      Side Effects:
3909 **              Looks up the host specified in hbuf.  If it is not
3910 **              the canonical name for that host, return the canonical
3911 **              name (unless MF_MATCHONLY is set, which will cause the
3912 **              status only to be returned).
3913 */
3914
3915 char *
3916 host_map_lookup(map, name, av, statp)
3917         MAP *map;
3918         char *name;
3919         char **av;
3920         int *statp;
3921 {
3922         register struct hostent *hp;
3923 #if NETINET
3924         struct in_addr in_addr;
3925 #endif /* NETINET */
3926 #if NETINET6
3927         struct in6_addr in6_addr;
3928 #endif /* NETINET6 */
3929         char *cp, *ans = NULL;
3930         register STAB *s;
3931         time_t now;
3932 #if NAMED_BIND
3933         time_t SM_NONVOLATILE retrans = 0;
3934         int SM_NONVOLATILE retry = 0;
3935 #endif /* NAMED_BIND */
3936         char hbuf[MAXNAME + 1];
3937
3938         /*
3939         **  See if we have already looked up this name.  If so, just
3940         **  return it (unless expired).
3941         */
3942
3943         now = curtime();
3944         s = stab(name, ST_NAMECANON, ST_ENTER);
3945         if (bitset(NCF_VALID, s->s_namecanon.nc_flags) &&
3946             s->s_namecanon.nc_exp >= now)
3947         {
3948                 if (tTd(9, 1))
3949                         sm_dprintf("host_map_lookup(%s) => CACHE %s\n",
3950                                     name,
3951                                     s->s_namecanon.nc_cname == NULL
3952                                         ? "NULL"
3953                                         : s->s_namecanon.nc_cname);
3954                 errno = s->s_namecanon.nc_errno;
3955                 SM_SET_H_ERRNO(s->s_namecanon.nc_herrno);
3956                 *statp = s->s_namecanon.nc_stat;
3957                 if (*statp == EX_TEMPFAIL)
3958                 {
3959                         CurEnv->e_status = "4.4.3";
3960                         message("851 %s: Name server timeout",
3961                                 shortenstring(name, 33));
3962                 }
3963                 if (*statp != EX_OK)
3964                         return NULL;
3965                 if (s->s_namecanon.nc_cname == NULL)
3966                 {
3967                         syserr("host_map_lookup(%s): bogus NULL cache entry, errno=%d, h_errno=%d",
3968                                name,
3969                                s->s_namecanon.nc_errno,
3970                                s->s_namecanon.nc_herrno);
3971                         return NULL;
3972                 }
3973                 if (bitset(MF_MATCHONLY, map->map_mflags))
3974                         cp = map_rewrite(map, name, strlen(name), NULL);
3975                 else
3976                         cp = map_rewrite(map,
3977                                          s->s_namecanon.nc_cname,
3978                                          strlen(s->s_namecanon.nc_cname),
3979                                          av);
3980                 return cp;
3981         }
3982
3983         /*
3984         **  If we are running without a regular network connection (usually
3985         **  dial-on-demand) and we are just queueing, we want to avoid DNS
3986         **  lookups because those could try to connect to a server.
3987         */
3988
3989         if (CurEnv->e_sendmode == SM_DEFER &&
3990             bitset(MF_DEFER, map->map_mflags))
3991         {
3992                 if (tTd(9, 1))
3993                         sm_dprintf("host_map_lookup(%s) => DEFERRED\n", name);
3994                 *statp = EX_TEMPFAIL;
3995                 return NULL;
3996         }
3997
3998         /*
3999         **  If first character is a bracket, then it is an address
4000         **  lookup.  Address is copied into a temporary buffer to
4001         **  strip the brackets and to preserve name if address is
4002         **  unknown.
4003         */
4004
4005         if (tTd(9, 1))
4006                 sm_dprintf("host_map_lookup(%s) => ", name);
4007 #if NAMED_BIND
4008         if (map->map_timeout > 0)
4009         {
4010                 retrans = _res.retrans;
4011                 _res.retrans = map->map_timeout;
4012         }
4013         if (map->map_retry > 0)
4014         {
4015                 retry = _res.retry;
4016                 _res.retry = map->map_retry;
4017         }
4018 #endif /* NAMED_BIND */
4019
4020         /* set default TTL */
4021         s->s_namecanon.nc_exp = now + SM_DEFAULT_TTL;
4022         if (*name != '[')
4023         {
4024                 int ttl;
4025
4026                 (void) sm_strlcpy(hbuf, name, sizeof(hbuf));
4027                 if (getcanonname(hbuf, sizeof(hbuf) - 1, !HasWildcardMX, &ttl))
4028                 {
4029                         ans = hbuf;
4030                         if (ttl > 0)
4031                                 s->s_namecanon.nc_exp = now + SM_MIN(ttl,
4032                                                                 SM_DEFAULT_TTL);
4033                 }
4034         }
4035         else
4036         {
4037                 if ((cp = strchr(name, ']')) == NULL)
4038                 {
4039                         if (tTd(9, 1))
4040                                 sm_dprintf("FAILED\n");
4041                         return NULL;
4042                 }
4043                 *cp = '\0';
4044
4045                 hp = NULL;
4046 #if NETINET
4047                 if ((in_addr.s_addr = inet_addr(&name[1])) != INADDR_NONE)
4048                         hp = sm_gethostbyaddr((char *)&in_addr,
4049                                               INADDRSZ, AF_INET);
4050 #endif /* NETINET */
4051 #if NETINET6
4052                 if (hp == NULL &&
4053                     anynet_pton(AF_INET6, &name[1], &in6_addr) == 1)
4054                         hp = sm_gethostbyaddr((char *)&in6_addr,
4055                                               IN6ADDRSZ, AF_INET6);
4056 #endif /* NETINET6 */
4057                 *cp = ']';
4058
4059                 if (hp != NULL)
4060                 {
4061                         /* found a match -- copy out */
4062                         ans = denlstring((char *) hp->h_name, true, true);
4063 #if NETINET6
4064                         if (ans == hp->h_name)
4065                         {
4066                                 static char n[MAXNAME + 1];
4067
4068                                 /* hp->h_name is about to disappear */
4069                                 (void) sm_strlcpy(n, ans, sizeof(n));
4070                                 ans = n;
4071                         }
4072                         freehostent(hp);
4073                         hp = NULL;
4074 #endif /* NETINET6 */
4075                 }
4076         }
4077 #if NAMED_BIND
4078         if (map->map_timeout > 0)
4079                 _res.retrans = retrans;
4080         if (map->map_retry > 0)
4081                 _res.retry = retry;
4082 #endif /* NAMED_BIND */
4083
4084         s->s_namecanon.nc_flags |= NCF_VALID;   /* will be soon */
4085
4086         /* Found an answer */
4087         if (ans != NULL)
4088         {
4089                 s->s_namecanon.nc_stat = *statp = EX_OK;
4090                 if (s->s_namecanon.nc_cname != NULL)
4091                         sm_free(s->s_namecanon.nc_cname);
4092                 s->s_namecanon.nc_cname = sm_strdup_x(ans);
4093                 if (bitset(MF_MATCHONLY, map->map_mflags))
4094                         cp = map_rewrite(map, name, strlen(name), NULL);
4095                 else
4096                         cp = map_rewrite(map, ans, strlen(ans), av);
4097                 if (tTd(9, 1))
4098                         sm_dprintf("FOUND %s\n", ans);
4099                 return cp;
4100         }
4101
4102
4103         /* No match found */
4104         s->s_namecanon.nc_errno = errno;
4105 #if NAMED_BIND
4106         s->s_namecanon.nc_herrno = h_errno;
4107         if (tTd(9, 1))
4108                 sm_dprintf("FAIL (%d)\n", h_errno);
4109         switch (h_errno)
4110         {
4111           case TRY_AGAIN:
4112                 if (UseNameServer)
4113                 {
4114                         CurEnv->e_status = "4.4.3";
4115                         message("851 %s: Name server timeout",
4116                                 shortenstring(name, 33));
4117                 }
4118                 *statp = EX_TEMPFAIL;
4119                 break;
4120
4121           case HOST_NOT_FOUND:
4122           case NO_DATA:
4123                 *statp = EX_NOHOST;
4124                 break;
4125
4126           case NO_RECOVERY:
4127                 *statp = EX_SOFTWARE;
4128                 break;
4129
4130           default:
4131                 *statp = EX_UNAVAILABLE;
4132                 break;
4133         }
4134 #else /* NAMED_BIND */
4135         if (tTd(9, 1))
4136                 sm_dprintf("FAIL\n");
4137         *statp = EX_NOHOST;
4138 #endif /* NAMED_BIND */
4139         s->s_namecanon.nc_stat = *statp;
4140         return NULL;
4141 }
4142 /*
4143 **  HOST_MAP_INIT -- initialize host class structures
4144 **
4145 **      Parameters:
4146 **              map -- a pointer to this map.
4147 **              args -- argument string.
4148 **
4149 **      Returns:
4150 **              true.
4151 */
4152
4153 bool
4154 host_map_init(map, args)
4155         MAP *map;
4156         char *args;
4157 {
4158         register char *p = args;
4159
4160         for (;;)
4161         {
4162                 while (isascii(*p) && isspace(*p))
4163                         p++;
4164                 if (*p != '-')
4165                         break;
4166                 switch (*++p)
4167                 {
4168                   case 'a':
4169                         map->map_app = ++p;
4170                         break;
4171
4172                   case 'T':
4173                         map->map_tapp = ++p;
4174                         break;
4175
4176                   case 'm':
4177                         map->map_mflags |= MF_MATCHONLY;
4178                         break;
4179
4180                   case 't':
4181                         map->map_mflags |= MF_NODEFER;
4182                         break;
4183
4184                   case 'S':     /* only for consistency */
4185                         map->map_spacesub = *++p;
4186                         break;
4187
4188                   case 'D':
4189                         map->map_mflags |= MF_DEFER;
4190                         break;
4191
4192                   case 'd':
4193                         {
4194                                 char *h;
4195
4196                                 while (isascii(*++p) && isspace(*p))
4197                                         continue;
4198                                 h = strchr(p, ' ');
4199                                 if (h != NULL)
4200                                         *h = '\0';
4201                                 map->map_timeout = convtime(p, 's');
4202                                 if (h != NULL)
4203                                         *h = ' ';
4204                         }
4205                         break;
4206
4207                   case 'r':
4208                         while (isascii(*++p) && isspace(*p))
4209                                 continue;
4210                         map->map_retry = atoi(p);
4211                         break;
4212                 }
4213                 while (*p != '\0' && !(isascii(*p) && isspace(*p)))
4214                         p++;
4215                 if (*p != '\0')
4216                         *p++ = '\0';
4217         }
4218         if (map->map_app != NULL)
4219                 map->map_app = newstr(map->map_app);
4220         if (map->map_tapp != NULL)
4221                 map->map_tapp = newstr(map->map_tapp);
4222         return true;
4223 }
4224
4225 #if NETINET6
4226 /*
4227 **  ANYNET_NTOP -- convert an IPv6 network address to printable form.
4228 **
4229 **      Parameters:
4230 **              s6a -- a pointer to an in6_addr structure.
4231 **              dst -- buffer to store result in
4232 **              dst_len -- size of dst buffer
4233 **
4234 **      Returns:
4235 **              A printable version of that structure.
4236 */
4237
4238 char *
4239 anynet_ntop(s6a, dst, dst_len)
4240         struct in6_addr *s6a;
4241         char *dst;
4242         size_t dst_len;
4243 {
4244         register char *ap;
4245
4246         if (IN6_IS_ADDR_V4MAPPED(s6a))
4247                 ap = (char *) inet_ntop(AF_INET,
4248                                         &s6a->s6_addr[IN6ADDRSZ - INADDRSZ],
4249                                         dst, dst_len);
4250         else
4251         {
4252                 char *d;
4253                 size_t sz;
4254
4255                 /* Save pointer to beginning of string */
4256                 d = dst;
4257
4258                 /* Add IPv6: protocol tag */
4259                 sz = sm_strlcpy(dst, "IPv6:", dst_len);
4260                 if (sz >= dst_len)
4261                         return NULL;
4262                 dst += sz;
4263                 dst_len -= sz;
4264                 if (UseCompressedIPv6Addresses)
4265                         ap = (char *) inet_ntop(AF_INET6, s6a, dst, dst_len);
4266                 else
4267                         ap = sm_inet6_ntop(s6a, dst, dst_len);
4268                 /* Restore pointer to beginning of string */
4269                 if (ap != NULL)
4270                         ap = d;
4271         }
4272         return ap;
4273 }
4274
4275 /*
4276 **  ANYNET_PTON -- convert printed form to network address.
4277 **
4278 **      Wrapper for inet_pton() which handles IPv6: labels.
4279 **
4280 **      Parameters:
4281 **              family -- address family
4282 **              src -- string
4283 **              dst -- destination address structure
4284 **
4285 **      Returns:
4286 **              1 if the address was valid
4287 **              0 if the address wasn't parseable
4288 **              -1 if error
4289 */
4290
4291 int
4292 anynet_pton(family, src, dst)
4293         int family;
4294         const char *src;
4295         void *dst;
4296 {
4297         if (family == AF_INET6 && sm_strncasecmp(src, "IPv6:", 5) == 0)
4298                 src += 5;
4299         return inet_pton(family, src, dst);
4300 }
4301 #endif /* NETINET6 */
4302 /*
4303 **  ANYNET_NTOA -- convert a network address to printable form.
4304 **
4305 **      Parameters:
4306 **              sap -- a pointer to a sockaddr structure.
4307 **
4308 **      Returns:
4309 **              A printable version of that sockaddr.
4310 */
4311
4312 #ifdef USE_SOCK_STREAM
4313
4314 # if NETLINK
4315 #  include <net/if_dl.h>
4316 # endif /* NETLINK */
4317
4318 char *
4319 anynet_ntoa(sap)
4320         register SOCKADDR *sap;
4321 {
4322         register char *bp;
4323         register char *ap;
4324         int l;
4325         static char buf[100];
4326
4327         /* check for null/zero family */
4328         if (sap == NULL)
4329                 return "NULLADDR";
4330         if (sap->sa.sa_family == 0)
4331                 return "0";
4332
4333         switch (sap->sa.sa_family)
4334         {
4335 # if NETUNIX
4336           case AF_UNIX:
4337                 if (sap->sunix.sun_path[0] != '\0')
4338                         (void) sm_snprintf(buf, sizeof(buf), "[UNIX: %.64s]",
4339                                            sap->sunix.sun_path);
4340                 else
4341                         (void) sm_strlcpy(buf, "[UNIX: localhost]", sizeof(buf));
4342                 return buf;
4343 # endif /* NETUNIX */
4344
4345 # if NETINET
4346           case AF_INET:
4347                 return (char *) inet_ntoa(sap->sin.sin_addr);
4348 # endif /* NETINET */
4349
4350 # if NETINET6
4351           case AF_INET6:
4352                 ap = anynet_ntop(&sap->sin6.sin6_addr, buf, sizeof(buf));
4353                 if (ap != NULL)
4354                         return ap;
4355                 break;
4356 # endif /* NETINET6 */
4357
4358 # if NETLINK
4359           case AF_LINK:
4360                 (void) sm_snprintf(buf, sizeof(buf), "[LINK: %s]",
4361                                    link_ntoa((struct sockaddr_dl *) &sap->sa));
4362                 return buf;
4363 # endif /* NETLINK */
4364           default:
4365                 /* this case is needed when nothing is #defined */
4366                 /* in order to keep the switch syntactically correct */
4367                 break;
4368         }
4369
4370         /* unknown family -- just dump bytes */
4371         (void) sm_snprintf(buf, sizeof(buf), "Family %d: ", sap->sa.sa_family);
4372         bp = &buf[strlen(buf)];
4373         ap = sap->sa.sa_data;
4374         for (l = sizeof(sap->sa.sa_data); --l >= 0; )
4375         {
4376                 (void) sm_snprintf(bp, SPACELEFT(buf, bp), "%02x:",
4377                                    *ap++ & 0377);
4378                 bp += 3;
4379         }
4380         *--bp = '\0';
4381         return buf;
4382 }
4383 /*
4384 **  HOSTNAMEBYANYADDR -- return name of host based on address
4385 **
4386 **      Parameters:
4387 **              sap -- SOCKADDR pointer
4388 **
4389 **      Returns:
4390 **              text representation of host name.
4391 **
4392 **      Side Effects:
4393 **              none.
4394 */
4395
4396 char *
4397 hostnamebyanyaddr(sap)
4398         register SOCKADDR *sap;
4399 {
4400         register struct hostent *hp;
4401 # if NAMED_BIND
4402         int saveretry;
4403 # endif /* NAMED_BIND */
4404 # if NETINET6
4405         struct in6_addr in6_addr;
4406 # endif /* NETINET6 */
4407
4408 # if NAMED_BIND
4409         /* shorten name server timeout to avoid higher level timeouts */
4410         saveretry = _res.retry;
4411         if (_res.retry * _res.retrans > 20)
4412                 _res.retry = 20 / _res.retrans;
4413         if (_res.retry == 0)
4414                 _res.retry = 1;
4415 # endif /* NAMED_BIND */
4416
4417         switch (sap->sa.sa_family)
4418         {
4419 # if NETINET
4420           case AF_INET:
4421                 hp = sm_gethostbyaddr((char *) &sap->sin.sin_addr,
4422                                       INADDRSZ, AF_INET);
4423                 break;
4424 # endif /* NETINET */
4425
4426 # if NETINET6
4427           case AF_INET6:
4428                 hp = sm_gethostbyaddr((char *) &sap->sin6.sin6_addr,
4429                                       IN6ADDRSZ, AF_INET6);
4430                 break;
4431 # endif /* NETINET6 */
4432
4433 # if NETISO
4434           case AF_ISO:
4435                 hp = sm_gethostbyaddr((char *) &sap->siso.siso_addr,
4436                                       sizeof(sap->siso.siso_addr), AF_ISO);
4437                 break;
4438 # endif /* NETISO */
4439
4440 # if NETUNIX
4441           case AF_UNIX:
4442                 hp = NULL;
4443                 break;
4444 # endif /* NETUNIX */
4445
4446           default:
4447                 hp = sm_gethostbyaddr(sap->sa.sa_data, sizeof(sap->sa.sa_data),
4448                                       sap->sa.sa_family);
4449                 break;
4450         }
4451
4452 # if NAMED_BIND
4453         _res.retry = saveretry;
4454 # endif /* NAMED_BIND */
4455
4456 # if NETINET || NETINET6
4457         if (hp != NULL && hp->h_name[0] != '['
4458 #  if NETINET6
4459             && inet_pton(AF_INET6, hp->h_name, &in6_addr) != 1
4460 #  endif /* NETINET6 */
4461 #  if NETINET
4462             && inet_addr(hp->h_name) == INADDR_NONE
4463 #  endif /* NETINET */
4464             )
4465         {
4466                 char *name;
4467
4468                 name = denlstring((char *) hp->h_name, true, true);
4469 #  if NETINET6
4470                 if (name == hp->h_name)
4471                 {
4472                         static char n[MAXNAME + 1];
4473
4474                         /* Copy the string, hp->h_name is about to disappear */
4475                         (void) sm_strlcpy(n, name, sizeof(n));
4476                         name = n;
4477                 }
4478                 freehostent(hp);
4479 #  endif /* NETINET6 */
4480                 return name;
4481         }
4482 # endif /* NETINET || NETINET6 */
4483
4484 # if NETINET6
4485         if (hp != NULL)
4486         {
4487                 freehostent(hp);
4488                 hp = NULL;
4489         }
4490 # endif /* NETINET6 */
4491
4492 # if NETUNIX
4493         if (sap->sa.sa_family == AF_UNIX && sap->sunix.sun_path[0] == '\0')
4494                 return "localhost";
4495 # endif /* NETUNIX */
4496         {
4497                 static char buf[203];
4498
4499                 (void) sm_snprintf(buf, sizeof(buf), "[%.200s]",
4500                                    anynet_ntoa(sap));
4501                 return buf;
4502         }
4503 }
4504 #endif /* USE_SOCK_STREAM */