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