1 /* 2 * Copyright (c) 1998-2007, 2009, 2010 Proofpoint, Inc. and its suppliers. 3 * All rights reserved. 4 * Copyright (c) 1983, 1995-1997 Eric P. Allman. All rights reserved. 5 * Copyright (c) 1988, 1993 6 * The Regents of the University of California. All rights reserved. 7 * 8 * By using this file, you agree to the terms and conditions set 9 * forth in the LICENSE file which can be found at the top level of 10 * the sendmail distribution. 11 * 12 */ 13 14 #include <sendmail.h> 15 #include "map.h" 16 17 SM_RCSID("@(#)$Id: daemon.c,v 8.698 2013-11-22 20:51:55 ca Exp $") 18 19 #if defined(SOCK_STREAM) || defined(__GNU_LIBRARY__) 20 # define USE_SOCK_STREAM 1 21 #endif 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 85 static void connecttimeout __P((int)); 86 static int opendaemonsocket __P((DAEMON_T *, bool)); 87 static unsigned short setupdaemon __P((SOCKADDR *)); 88 static void getrequests_checkdiskspace __P((ENVELOPE *e)); 89 static void setsockaddroptions __P((char *, DAEMON_T *)); 90 static void printdaemonflags __P((DAEMON_T *)); 91 static int addr_family __P((char *)); 92 static int addrcmp __P((struct hostent *, char *, SOCKADDR *)); 93 static 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 123 static int NDaemons = 0; /* actual number of daemons */ 124 125 static 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 147 BITMAP256 * 148 getrequests(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 993 static void 994 getrequests_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 1072 static int 1073 opendaemonsocket(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 1263 static unsigned short 1264 setupdaemon(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 1360 void 1361 clrdaemon() 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 1387 char * 1388 getmodifiers(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 1435 bool 1436 chkdaemonmodifiers(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 1458 static void 1459 setsockaddroptions(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 1842 struct dflags 1843 { 1844 char *d_name; 1845 int d_flag; 1846 }; 1847 1848 static 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 1869 static void 1870 printdaemonflags(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 1890 bool 1891 setdaemonoptions(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 1938 void 1939 initdaemon() 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 1959 static DAEMON_T ClientSettings[AF_MAX + 1]; 1960 1961 void 1962 setclientoptions(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 1998 static int 1999 addr_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 2045 bool 2046 chkclientmodifiers(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 2076 void 2077 setup_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 2118 static jmp_buf CtxConnectTimeout; 2119 2120 SOCKADDR CurHostAddr; /* address of current host */ 2121 2122 int 2123 makeconnection(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 } 2435 gothostent: 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 2848 nextaddr: 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 3019 static void 3020 connecttimeout(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 3049 int 3050 makeconnection_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 3152 void 3153 shutdown_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) \ 3224 do \ 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 3231 void 3232 restart_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 3346 struct hostent * 3347 myhostname(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 3448 static int 3449 addrcmp(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 3499 static jmp_buf CtxAuthTimeout; 3500 3501 static void 3502 authtimeout(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 3515 char * 3516 getauthinfo(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 3841 closeident: 3842 (void) close(s); 3843 sm_clrevent(ev); 3844 3845 noident: 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 3872 postident: 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 3976 noipsr: 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 3993 postipsr: 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 4040 char * 4041 host_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 4297 bool 4298 host_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 4382 char * 4383 anynet_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 4435 int 4436 anynet_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 4462 char * 4463 anynet_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 4540 char * 4541 hostnamebyanyaddr(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