开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Email客户端 > 查看源码
daemon.c
资源名称：sendmail.8.10.0.Beta10.tar.Z　[点击查看]
上传用户：xu_441
上传日期：2007-01-04
资源大小：1640k
文件大小：72k
源码类别：

Email客户端

开发平台：

Unix_Linux

daemon.c：源码内容
  1. /*
  2.  * Copyright (c) 1998, 1999 Sendmail, 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.  */
  14. #include <sendmail.h>
  16. #ifndef lint
  17. # ifdef DAEMON
  18. static char id[] = "@(#)$Id: daemon.c,v 8.387 1999/12/03 03:40:28 gshapiro Exp $ (with daemon mode)";
  19. # else /* DAEMON */
  20. static char id[] = "@(#)$Id: daemon.c,v 8.387 1999/12/03 03:40:28 gshapiro Exp $ (without daemon mode)";
  21. # endif /* DAEMON */
  22. #endif /* ! lint */
  24. #if defined(SOCK_STREAM) || defined(__GNU_LIBRARY__)
  25. # define USE_SOCK_STREAM 1
  26. #endif /* defined(SOCK_STREAM) || defined(__GNU_LIBRARY__) */
  28. #if DAEMON || defined(USE_SOCK_STREAM)
  29. # if NETINET || NETINET6
  30. #  include <arpa/inet.h>
  31. # endif /* NETINET || NETINET6 */
  32. # if NAMED_BIND
  33. #  ifndef NO_DATA
  34. #   define NO_DATA NO_ADDRESS
  35. #  endif /* ! NO_DATA */
  36. # endif /* NAMED_BIND */
  37. #endif /* DAEMON || defined(USE_SOCK_STREAM) */
  39. #if DAEMON
  41. # include <sys/time.h>
  43. # if IP_SRCROUTE && NETINET
  44. #  include <netinet/in_systm.h>
  45. #  include <netinet/ip.h>
  46. #  if HAS_IN_H
  47. #   include <netinet/in.h>
  48. #   ifndef IPOPTION
  49. #    define IPOPTION ip_opts
  50. #    define IP_LIST ip_opts
  51. #    define IP_DST ip_dst
  52. #   endif /* ! IPOPTION */
  53. #  else /* HAS_IN_H */
  54. #   include <netinet/ip_var.h>
  55. #   ifndef IPOPTION
  56. #    define IPOPTION ipoption
  57. #    define IP_LIST ipopt_list
  58. #    define IP_DST ipopt_dst
  59. #   endif /* ! IPOPTION */
  60. #  endif /* HAS_IN_H */
  61. # endif /* IP_SRCROUTE && NETINET */
  63. /* structure to describe a daemon */
  64. struct daemon
  65. {
  66. int d_socket; /* fd for socket */
  67. SOCKADDR d_addr; /* socket for incoming */
  68. u_short d_port; /* port number */
  69. int d_listenqueue; /* size of listen queue */
  70. int d_tcprcvbufsize; /* size of TCP receive buffer */
  71. int d_tcpsndbufsize; /* size of TCP send buffer */
  72. time_t d_refuse_connections_until;
  73. bool d_firsttime;
  74. int d_socksize;
  75. BITMAP256 d_flags; /* flags; see sendmail.h */
  76. char * d_mflags; /* flags for use in macro */
  77. char * d_name; /* user-supplied name */
  78. };
  80. typedef struct daemon DAEMON_T;
  82. static void connecttimeout __P((void));
  83. static int opendaemonsocket __P((struct daemon *, bool));
  84. static u_short setupdaemon __P((SOCKADDR *));
  86. /*
  87. **  DAEMON.C -- routines to use when running as a daemon.
  88. **
  89. ** This entire file is highly dependent on the 4.2 BSD
  90. ** interprocess communication primitives.  No attempt has
  91. ** been made to make this file portable to Version 7,
  92. ** Version 6, MPX files, etc.  If you should try such a
  93. ** thing yourself, I recommend chucking the entire file
  94. ** and starting from scratch.  Basic semantics are:
  95. **
  96. ** getrequests(e)
  97. ** Opens a port and initiates a connection.
  98. ** Returns in a child.  Must set InChannel and
  99. ** OutChannel appropriately.
  100. ** clrdaemon()
  101. ** Close any open files associated with getting
  102. ** the connection; this is used when running the queue,
  103. ** etc., to avoid having extra file descriptors during
  104. ** the queue run and to avoid confusing the network
  105. ** code (if it cares).
  106. ** makeconnection(host, port, outfile, infile, e)
  107. ** Make a connection to the named host on the given
  108. ** port.  Set *outfile and *infile to the files
  109. ** appropriate for communication.  Returns zero on
  110. ** success, else an exit status describing the
  111. ** error.
  112. ** host_map_lookup(map, hbuf, avp, pstat)
  113. ** Convert the entry in hbuf into a canonical form.
  114. */
  116. static DAEMON_T Daemons[MAXDAEMONS];
  117. static int ndaemons = 0; /* actual number of daemons */
  119. /* options for client */
  120. static int TcpRcvBufferSize = 0; /* size of TCP receive buffer */
  121. static int TcpSndBufferSize = 0; /* size of TCP send buffer */
  123. /*
  124. **  GETREQUESTS -- open mail IPC port and get requests.
  125. **
  126. ** Parameters:
  127. ** e -- the current envelope.
  128. **
  129. ** Returns:
  130. ** pointer to flags.
  131. **
  132. ** Side Effects:
  133. ** Waits until some interesting activity occurs.  When
  134. ** it does, a child is created to process it, and the
  135. ** parent waits for completion.  Return from this
  136. ** routine is always in the child.  The file pointers
  137. ** "InChannel" and "OutChannel" should be set to point
  138. ** to the communication channel.
  139. */
  141. BITMAP256 *
  142. getrequests(e)
  143. ENVELOPE *e;
  144. {
  145. int t;
  146. time_t last_disk_space_check = 0;
  147. int idx, curdaemon = -1;
  148. # if XDEBUG
  149. bool j_has_dot;
  150. # endif /* XDEBUG */
  151. char status[MAXLINE];
  152. SOCKADDR sa;
  153. SOCKADDR_LEN_T len = sizeof sa;
  154. # if NETUNIX
  155. extern int ControlSocket;
  156. # endif /* NETUNIX */
  157. extern ENVELOPE BlankEnvelope;
  159. #define D(x,idx) x[idx]
  161. for (idx = 0; idx < ndaemons; idx++)
  162. {
  163. Daemons[idx].d_port = setupdaemon(&(Daemons[idx].d_addr));
  164. Daemons[idx].d_firsttime = TRUE;
  165. Daemons[idx].d_refuse_connections_until = (time_t) 0;
  166. }
  167. /*
  168. **  Try to actually open the connection.
  169. */
  171. if (tTd(15, 1))
  172. {
  173. for (idx = 0; idx < ndaemons; idx++)
  174. dprintf("getrequests: daemon %s: port %dn",
  175. Daemons[idx].d_name,
  176. ntohs(Daemons[idx].d_port));
  177. }
  179. /* get a socket for the SMTP connection */
  180. for (idx = 0; idx < ndaemons; idx++)
  181. Daemons[idx].d_socksize = opendaemonsocket(&Daemons[idx], TRUE);
  183. if (opencontrolsocket() < 0)
  184. sm_syslog(LOG_WARNING, NOQID,
  185.   "daemon could not open control socket %s: %s",
  186.   ControlSocketName, errstring(errno));
  188. (void) setsignal(SIGCHLD, reapchild);
  190. /* write the pid to file */
  191. log_sendmail_pid(e);
  193. # if XDEBUG
  194. {
  195. char jbuf[MAXHOSTNAMELEN];
  197. expand("201j", jbuf, sizeof jbuf, e);
  198. j_has_dot = strchr(jbuf, '.') != NULL;
  199. }
  200. # endif /* XDEBUG */
  202. /* Add parent process as first item */
  203. proc_list_add(getpid(), "Sendmail daemon", PROC_DAEMON);
  205. if (tTd(15, 1))
  206. {
  207. for (idx = 0; idx < ndaemons; idx++)
  208. dprintf("getrequests: daemon %s: %dn",
  209. Daemons[idx].d_name,
  210. Daemons[idx].d_socket);
  211. }
  213. for (;;)
  214. {
  215. register pid_t pid;
  216. auto SOCKADDR_LEN_T lotherend;
  217. bool timedout = FALSE;
  218. bool control = FALSE;
  219. int save_errno;
  220. int pipefd[2];
  222. /* see if we are rejecting connections */
  223. (void) blocksignal(SIGALRM);
  225. for (idx = 0; idx < ndaemons; idx++)
  226. {
  227. if (curtime() < Daemons[idx].d_refuse_connections_until)
  228. continue;
  229. if (refuseconnections(Daemons[idx].d_name, e, idx))
  230. {
  231. if (Daemons[idx].d_socket >= 0)
  232. {
  233.        /* close socket so peer fails quickly */
  234.        (void) close(Daemons[idx].d_socket);
  235.        Daemons[idx].d_socket = -1;
  236. }
  238. /* refuse connections for next 15 seconds */
  239. Daemons[idx].d_refuse_connections_until = curtime() + 15;
  240. }
  241. else if (Daemons[idx].d_socket < 0 ||
  242.  Daemons[idx].d_firsttime)
  243. {
  244.       if (!Daemons[idx].d_firsttime && LogLevel >= 9)
  245. sm_syslog(LOG_INFO, NOQID,
  246.   "accepting connections again for daemon %s",
  247.   Daemons[idx].d_name);
  248.       /* arrange to (re)open the socket if needed */
  249.       (void) opendaemonsocket(&Daemons[idx], FALSE);
  250.       Daemons[idx].d_firsttime = FALSE;
  251. }
  252. }
  253. if (curtime() >= last_disk_space_check)
  254. {
  255. if (!enoughdiskspace(MinBlocksFree + 1, FALSE))
  256. {
  257. if (!bitnset(D_ETRNONLY, Daemons[idx].d_flags))
  258. {
  259. /* log only if not logged before */
  260. if (LogLevel >= 9)
  261. sm_syslog(LOG_INFO, NOQID,
  262.   "rejecting new messages: min free: %d",
  263.   MinBlocksFree);
  264. sm_setproctitle(TRUE, e,
  265. "rejecting new messages: min free: %d",
  266.  MinBlocksFree);
  267. setbitn(D_ETRNONLY, Daemons[idx].d_flags);
  268. }
  269. }
  270. else if (bitnset(D_ETRNONLY, Daemons[idx].d_flags))
  271. {
  272. /* log only if not logged before */
  273. if (LogLevel >= 9)
  274. sm_syslog(LOG_INFO, NOQID,
  275.   "accepting new messages (again)");
  276. /* title will be set below */
  277. clrbitn(D_ETRNONLY, Daemons[idx].d_flags);
  278. }
  279. /* only check disk space once a minute */
  280. last_disk_space_check = curtime() + 60;
  281. }
  283. # if XDEBUG
  284. /* check for disaster */
  285. {
  286. char jbuf[MAXHOSTNAMELEN];
  288. expand("201j", jbuf, sizeof jbuf, e);
  289. if (!wordinclass(jbuf, 'w'))
  290. {
  291. dumpstate("daemon lost $j");
  292. sm_syslog(LOG_ALERT, NOQID,
  293.   "daemon process doesn't have $j in $=w; see syslog");
  294. abort();
  295. }
  296. else if (j_has_dot && strchr(jbuf, '.') == NULL)
  297. {
  298. dumpstate("daemon $j lost dot");
  299. sm_syslog(LOG_ALERT, NOQID,
  300.   "daemon process $j lost dot; see syslog");
  301. abort();
  302. }
  303. }
  304. # endif /* XDEBUG */
  306. # if 0
  307. /*
  308. **  Andrew Sun <asun@ieps-sun.ml.com> claims that this will
  309. **  fix the SVr4 problem.  But it seems to have gone away,
  310. **  so is it worth doing this?
  311. */
  313. if (DaemonSocket >= 0 &&
  314.     SetNonBlocking(DaemonSocket, FALSE) < 0)
  315. log an error here;
  316. # endif /* 0 */
  317. (void) releasesignal(SIGALRM);
  319. for (;;)
  320. {
  321. int highest = -1;
  322. fd_set readfds;
  323. struct timeval timeout;
  325. FD_ZERO(&readfds);
  327. for (idx = 0; idx < ndaemons; idx++)
  328. {
  329. /* wait for a connection */
  330. if (Daemons[idx].d_socket >= 0)
  331. {
  332. if (!bitnset(D_ETRNONLY, Daemons[idx].d_flags))
  333. {
  334. sm_setproctitle(TRUE, e,
  335. "accepting connections");
  336. }
  337. if (Daemons[idx].d_socket > highest)
  338. highest = Daemons[idx].d_socket;
  339. FD_SET(Daemons[idx].d_socket, &readfds);
  340. }
  341. }
  343. # if NETUNIX
  344. if (ControlSocket >= 0)
  345. {
  346. if (ControlSocket > highest)
  347. highest = ControlSocket;
  348. FD_SET(ControlSocket, &readfds);
  349. }
  350. # endif /* NETUNIX */
  352. /*
  353. **  if one socket is closed, set the timeout
  354. **  to 5 seconds (so it might get reopened soon),
  355. **  otherwise (all sockets open) 60.
  356. */
  357. idx = 0;
  358. while (idx < ndaemons && Daemons[idx].d_socket >= 0)
  359. idx++;
  360. if (idx < ndaemons)
  361. timeout.tv_sec = 5;
  362. else
  363. timeout.tv_sec = 60;
  364. timeout.tv_usec = 0;
  366. t = select(highest + 1, FDSET_CAST &readfds,
  367.    NULL, NULL, &timeout);
  369. if (DoQueueRun)
  370. (void) runqueue(TRUE, FALSE);
  371. if (t <= 0)
  372. {
  373. timedout = TRUE;
  374. break;
  375. }
  377. control = FALSE;
  378. errno = 0;
  379. curdaemon = -1;
  380. for (idx = 0; idx < ndaemons; idx++)
  381. {
  382. if (Daemons[idx].d_socket >= 0 &&
  383.     FD_ISSET(Daemons[idx].d_socket, &readfds))
  384. {
  385. lotherend = Daemons[idx].d_socksize;
  386. t = accept(Daemons[idx].d_socket,
  387.    (struct sockaddr *)&RealHostAddr,
  388.    &lotherend);
  389. curdaemon = idx;
  390. }
  391. }
  392. # if NETUNIX
  393. if (curdaemon == -1 && ControlSocket >= 0 &&
  394.  FD_ISSET(ControlSocket, &readfds))
  395. {
  396. struct sockaddr_un sa_un;
  398. lotherend = sizeof sa_un;
  399. t = accept(ControlSocket,
  400.    (struct sockaddr *)&sa_un,
  401.    &lotherend);
  402. control = TRUE;
  403. }
  404. # endif /* NETUNIX */
  405. if (t >= 0 || errno != EINTR)
  406. break;
  407. }
  408. if (timedout)
  409. {
  410. timedout = FALSE;
  411. continue;
  412. }
  413. save_errno = errno;
  414. (void) blocksignal(SIGALRM);
  415. if (t < 0)
  416. {
  417. errno = save_errno;
  418. syserr("getrequests: accept");
  420. /* arrange to re-open the socket next time around */
  421. (void) close(Daemons[curdaemon].d_socket);
  422. Daemons[curdaemon].d_socket = -1;
  423. continue;
  424. }
  426. if (!control)
  427. {
  428. /* set some daemon related macros */
  429. switch (Daemons[curdaemon].d_addr.sa.sa_family)
  430. {
  431.   case AF_UNSPEC:
  432. define(macid("{daemon_family}", NULL),
  433.        "unspec", &BlankEnvelope);
  434. break;
  435. # if NETINET
  436.   case AF_INET:
  437. define(macid("{daemon_family}", NULL),
  438.        "inet", &BlankEnvelope);
  439. break;
  440. # endif /* NETINET */
  441. # if NETINET6
  442.   case AF_INET6:
  443. define(macid("{daemon_family}", NULL),
  444.        "inet6", &BlankEnvelope);
  445. break;
  446. # endif /* NETINET6 */
  447. # if NETISO
  448.   case AF_ISO:
  449. define(macid("{daemon_family}", NULL),
  450.        "iso", &BlankEnvelope);
  451. break;
  452. # endif /* NETISO */
  453. # if NETNS
  454.   case AF_NS:
  455. define(macid("{daemon_family}", NULL),
  456.        "ns", &BlankEnvelope);
  457. break;
  458. # endif /* NETNS */
  459. # if NETX25
  460.   case AF_CCITT:
  461. define(macid("{daemon_family}", NULL),
  462.        "x.25", &BlankEnvelope);
  463. break;
  464. # endif /* NETX25 */
  465. }
  466. define(macid("{daemon_name}", NULL),
  467.        Daemons[curdaemon].d_name, &BlankEnvelope);
  468. define(macid("{daemon_addr}", NULL),
  469.        newstr(anynet_ntoa(&Daemons[curdaemon].d_addr)),
  470.        &BlankEnvelope);
  471. (void) snprintf(status, sizeof status, "%d",
  472. ntohs(Daemons[curdaemon].d_port));
  473. define(macid("{daemon_port}", NULL), newstr(status),
  474.        &BlankEnvelope);
  475. if (Daemons[curdaemon].d_mflags != NULL)
  476. define(macid("{daemon_flags}", NULL),
  477.        newstr(Daemons[curdaemon].d_mflags),
  478.        &BlankEnvelope);
  479. else
  480. define(macid("{daemon_flags}", NULL),
  481.        "", &BlankEnvelope);
  482. }
  484. /*
  485. **  Create a subprocess to process the mail.
  486. */
  488. if (tTd(15, 2))
  489. dprintf("getrequests: forking (fd = %d)n", t);
  491. /*
  492. **  Create a pipe to keep the child from writing to the
  493. **  socket until after the parent has closed it.  Otherwise
  494. **  the parent may hang if the child has closed it first.
  495. */
  497. if (pipe(pipefd) < 0)
  498. pipefd[0] = pipefd[1] = -1;
  500. (void) blocksignal(SIGCHLD);
  501. pid = fork();
  502. if (pid < 0)
  503. {
  504. syserr("daemon: cannot fork");
  505. if (pipefd[0] != -1)
  506. {
  507. (void) close(pipefd[0]);
  508. (void) close(pipefd[1]);
  509. }
  510. (void) releasesignal(SIGCHLD);
  511. (void) sleep(10);
  512. (void) close(t);
  513. continue;
  514. }
  516. if (pid == 0)
  517. {
  518. char *p;
  519. FILE *inchannel, *outchannel = NULL;
  521. /*
  522. **  CHILD -- return to caller.
  523. ** Collect verified idea of sending host.
  524. ** Verify calling user id if possible here.
  525. */
  527. (void) releasesignal(SIGALRM);
  528. (void) releasesignal(SIGCHLD);
  529. (void) setsignal(SIGCHLD, SIG_DFL);
  530. (void) setsignal(SIGHUP, intsig);
  531. for (idx = 0; idx < ndaemons; idx++)
  532. {
  533. if (Daemons[idx].d_socket >= 0)
  534. (void) close(Daemons[idx].d_socket);
  535. }
  536. clrcontrol();
  538. /* Avoid SMTP daemon actions if control command */
  539. if (control)
  540. {
  541. /* Add control socket process */
  542. proc_list_add(getpid(), "console socket child",
  543.       PROC_CONTROL_CHILD);
  544. }
  545. else
  546. {
  547. proc_list_clear();
  549. /* Add parent process as first child item */
  550. proc_list_add(getpid(), "daemon child",
  551.       PROC_DAEMON_CHILD);
  553. /* don't schedule queue runs if ETRN */
  554. QueueIntvl = 0;
  556. sm_setproctitle(TRUE, e, "startup with %s",
  557. anynet_ntoa(&RealHostAddr));
  558. }
  560. if (pipefd[0] != -1)
  561. {
  562. auto char c;
  564. /*
  565. **  Wait for the parent to close the write end
  566. **  of the pipe, which we will see as an EOF.
  567. **  This guarantees that we won't write to the
  568. **  socket until after the parent has closed
  569. **  the pipe.
  570. */
  572. /* close the write end of the pipe */
  573. (void) close(pipefd[1]);
  575. /* we shouldn't be interrupted, but ... */
  576. while (read(pipefd[0], &c, 1) < 0 &&
  577.        errno == EINTR)
  578. continue;
  579. (void) close(pipefd[0]);
  580. }
  582. /* control socket processing */
  583. if (control)
  584. {
  585. control_command(t, e);
  586. /* NOTREACHED */
  587. exit(EX_SOFTWARE);
  588. }
  590. /* determine host name */
  591. p = hostnamebyanyaddr(&RealHostAddr);
  592. if (strlen(p) > (SIZE_T) MAXNAME)
  593. p[MAXNAME] = '';
  594. RealHostName = newstr(p);
  595. if (RealHostName[0] == '[')
  596. {
  597. /* TEMP, FAIL: which one? */
  598. define(macid("{client_resolve}", NULL),
  599.        (h_errno == TRY_AGAIN) ? "TEMP" : "FAIL",
  600.        &BlankEnvelope);
  601. }
  602. else
  603. define(macid("{client_resolve}", NULL), "OK",
  604.        &BlankEnvelope);
  605. sm_setproctitle(TRUE, e, "startup with %s", p);
  607. if ((inchannel = fdopen(t, "r")) == NULL ||
  608.     (t = dup(t)) < 0 ||
  609.     (outchannel = fdopen(t, "w")) == NULL)
  610. {
  611. syserr("cannot open SMTP server channel, fd=%d", t);
  612. finis(FALSE, EX_OK);
  613. }
  615. InChannel = inchannel;
  616. OutChannel = outchannel;
  617. DisConnected = FALSE;
  619. # ifdef XLA
  620. if (!xla_host_ok(RealHostName))
  621. {
  622. message("421 4.4.5 Too many SMTP sessions for this host");
  623. finis(FALSE, EX_OK);
  624. }
  625. # endif /* XLA */
  626. /* find out name for interface of connection */
  627. if (getsockname(fileno(InChannel), &sa.sa,
  628. &len) == 0)
  629. {
  630. p = hostnamebyanyaddr(&sa);
  631. if (tTd(15, 9))
  632. dprintf("getreq: got name %sn", p);
  633. define(macid("{if_name}", NULL),
  634.        newstr(p), &BlankEnvelope);
  636. /* do this only if it is not the loopback */
  637. /* interface: how to figure out? XXX */
  638. if (!isloopback(sa))
  639. {
  640. define(macid("{if_addr}", NULL),
  641.        newstr(anynet_ntoa(&sa)),
  642.        &BlankEnvelope);
  643. if (tTd(15, 7))
  644. dprintf("getreq: got addr %sn",
  645. macvalue(macid("{if_addr}", NULL),
  646.  &BlankEnvelope));
  647. p = xalloc(5);
  648. snprintf(p, 4, "%d", sa.sa.sa_family);
  649. define(macid("{if_family}", NULL), p,
  650.        &BlankEnvelope);
  651. }
  652. else
  653. {
  654. define(macid("{if_addr}", NULL), NULL,
  655.        &BlankEnvelope);
  656. define(macid("{if_family}", NULL), NULL,
  657.        &BlankEnvelope);
  658. }
  659. }
  660. else
  661. {
  662. if (tTd(15, 7))
  663. dprintf("getreq: getsockname failedn");
  664. define(macid("{if_name}", NULL), NULL,
  665.        &BlankEnvelope);
  666. define(macid("{if_addr}", NULL), NULL,
  667.        &BlankEnvelope);
  668. define(macid("{if_family}", NULL), NULL,
  669.        &BlankEnvelope);
  670. }
  671. break;
  672. }
  674. /* parent -- keep track of children */
  675. if (control)
  676. {
  677. snprintf(status, sizeof status,
  678.  "control socket server child");
  679. proc_list_add(pid, status, PROC_CONTROL);
  680. }
  681. else
  682. {
  683. snprintf(status, sizeof status,
  684.  "SMTP server child for %s",
  685.  anynet_ntoa(&RealHostAddr));
  686. proc_list_add(pid, status, PROC_DAEMON);
  687. }
  688. (void) releasesignal(SIGCHLD);
  690. /* close the read end of the synchronization pipe */
  691. if (pipefd[0] != -1)
  692. (void) close(pipefd[0]);
  694. /* close the port so that others will hang (for a while) */
  695. (void) close(t);
  697. /* release the child by closing the read end of the sync pipe */
  698. if (pipefd[1] != -1)
  699. (void) close(pipefd[1]);
  700. }
  701. if (tTd(15, 2))
  702. dprintf("getreq: returningn");
  703. return &Daemons[curdaemon].d_flags;
  704. }
  705. /*
  706. **  OPENDAEMONSOCKET -- open SMTP socket
  707. **
  708. ** Deals with setting all appropriate options.
  709. **
  710. ** Parameters:
  711. ** d -- the structure for the daemon to open.
  712. ** firsttime -- set if this is the initial open.
  713. **
  714. ** Returns:
  715. ** Size in bytes of the daemon socket addr.
  716. **
  717. ** Side Effects:
  718. ** Leaves DaemonSocket set to the open socket.
  719. ** Exits if the socket cannot be created.
  720. */
  722. # define MAXOPENTRIES 10 /* maximum number of tries to open connection */
  724. static int
  725. opendaemonsocket(d, firsttime)
  726. struct daemon *d;
  727. bool firsttime;
  728. {
  729. int on = 1;
  730. int fdflags;
  731. SOCKADDR_LEN_T socksize = 0;
  732. int ntries = 0;
  733. int save_errno;
  735. if (tTd(15, 2))
  736. dprintf("opendaemonsocket(%s)n", d->d_name);
  738. do
  739. {
  740. if (ntries > 0)
  741. (void) sleep(5);
  742. if (firsttime || d->d_socket < 0)
  743. {
  744. d->d_socket = socket(d->d_addr.sa.sa_family,
  745.      SOCK_STREAM, 0);
  746. if (d->d_socket < 0)
  747. {
  748. save_errno = errno;
  749. syserr("opendaemonsocket: daemon %s: can't create server SMTP socket", d->d_name);
  750.   severe:
  751. if (LogLevel > 0)
  752. sm_syslog(LOG_ALERT, NOQID,
  753.   "daemon %s: problem creating SMTP socket", d->d_name);
  754. d->d_socket = -1;
  755. continue;
  756. }
  758. /* turn on network debugging? */
  759. if (tTd(15, 101))
  760. (void) setsockopt(d->d_socket, SOL_SOCKET,
  761.   SO_DEBUG, (char *)&on,
  762.   sizeof on);
  764. (void) setsockopt(d->d_socket, SOL_SOCKET,
  765.   SO_REUSEADDR, (char *)&on, sizeof on);
  766. (void) setsockopt(d->d_socket, SOL_SOCKET,
  767.   SO_KEEPALIVE, (char *)&on, sizeof on);
  769. # ifdef SO_RCVBUF
  770. if (d->d_tcprcvbufsize > 0)
  771. {
  772. if (setsockopt(d->d_socket, SOL_SOCKET,
  773.        SO_RCVBUF,
  774.        (char *) &d->d_tcprcvbufsize,
  775.        sizeof(d->d_tcprcvbufsize)) < 0)
  776. syserr("opendaemonsocket: daemon %s: setsockopt(SO_RCVBUF)", d->d_name);
  777. }
  778. # endif /* SO_RCVBUF */
  779. # ifdef SO_SNDBUF
  780. if (d->d_tcpsndbufsize > 0)
  781. {
  782. if (setsockopt(d->d_socket, SOL_SOCKET,
  783.        SO_SNDBUF,
  784.        (char *) &d->d_tcpsndbufsize,
  785.        sizeof(d->d_tcpsndbufsize)) < 0)
  786. syserr("opendaemonsocket: daemon %s: setsockopt(SO_SNDBUF)", d->d_name);
  787. }
  788. # endif /* SO_SNDBUF */
  790. if ((fdflags = fcntl(d->d_socket, F_GETFD, 0)) == -1 ||
  791.     fcntl(d->d_socket, F_SETFD,
  792.   fdflags | FD_CLOEXEC) == -1)
  793. {
  794. save_errno = errno;
  795. syserr("opendaemonsocket: daemon %s: failed to %s close-on-exec flag: %s",
  796.        d->d_name,
  797.        fdflags == -1 ? "get" : "set",
  798.        strerror(save_errno));
  799. (void) close(d->d_socket);
  800. goto severe;
  801. }
  803. switch (d->d_addr.sa.sa_family)
  804. {
  805. # if NETINET
  806.   case AF_INET:
  807. socksize = sizeof d->d_addr.sin;
  808. break;
  809. # endif /* NETINET */
  811. # if NETINET6
  812.   case AF_INET6:
  813. socksize = sizeof d->d_addr.sin6;
  814. break;
  815. # endif /* NETINET6 */
  817. # if NETISO
  818.   case AF_ISO:
  819. socksize = sizeof d->d_addr.siso;
  820. break;
  821. # endif /* NETISO */
  823.   default:
  824. socksize = sizeof d->d_addr;
  825. break;
  826. }
  828. if (bind(d->d_socket, &d->d_addr.sa, socksize) < 0)
  829. {
  830. /* probably another daemon already */
  831. save_errno = errno;
  832. syserr("opendaemonsocket: daemon %s: cannot bind",
  833.        d->d_name);
  834. (void) close(d->d_socket);
  835. goto severe;
  836. }
  837. }
  838. if (!firsttime &&
  839.     listen(d->d_socket, d->d_listenqueue) < 0)
  840. {
  841. save_errno = errno;
  842. syserr("opendaemonsocket: daemon %s: cannot listen",
  843.        d->d_name);
  844. (void) close(d->d_socket);
  845. goto severe;
  846. }
  847. return socksize;
  848. } while (ntries++ < MAXOPENTRIES && transienterror(save_errno));
  849. syserr("!opendaemonsocket: daemon %s: server SMTP socket wedged: exiting",
  850.        d->d_name);
  851. /* NOTREACHED */
  852. return -1;  /* avoid compiler warning on IRIX */
  853. }
  854. /*
  855. **  SETUPDAEMON -- setup socket for daemon
  856. **
  857. ** Parameters:
  858. ** daemonaddr -- socket for daemon
  859. ** daemon -- number of daemon
  860. **
  861. ** Returns:
  862. ** port number on which daemon should run
  863. **
  864. */
  865. static u_short
  866. setupdaemon(daemonaddr)
  867. SOCKADDR *daemonaddr;
  868. {
  869. u_short port;
  871. /*
  872. **  Set up the address for the mailer.
  873. */
  875. if (daemonaddr->sa.sa_family == AF_UNSPEC)
  876. {
  877. memset(daemonaddr, '', sizeof *daemonaddr);
  878. daemonaddr->sa.sa_family = InetMode;
  879. }
  881. switch (daemonaddr->sa.sa_family)
  882. {
  883. # if NETINET
  884.   case AF_INET:
  885. if (daemonaddr->sin.sin_addr.s_addr == 0)
  886. daemonaddr->sin.sin_addr.s_addr = INADDR_ANY;
  887. port = daemonaddr->sin.sin_port;
  888. break;
  889. # endif /* NETINET */
  891. # if NETINET6
  892.   case AF_INET6:
  893. if (IN6_IS_ADDR_UNSPECIFIED(&daemonaddr->sin6.sin6_addr))
  894. daemonaddr->sin6.sin6_addr = in6addr_any;
  895. port = daemonaddr->sin6.sin6_port;
  896. break;
  897. # endif /* NETINET6 */
  899.   default:
  900. /* unknown protocol */
  901. port = 0;
  902. break;
  903. }
  904. if (port == 0)
  905. {
  906. # ifdef NO_GETSERVBYNAME
  907. port = htons(25);
  908. # else /* NO_GETSERVBYNAME */
  909. {
  910. register struct servent *sp;
  912. sp = getservbyname("smtp", "tcp");
  913. if (sp == NULL)
  914. {
  915. syserr("554 5.3.5 service "smtp" unknown");
  916. port = htons(25);
  917. }
  918. else
  919. port = sp->s_port;
  920. }
  921. # endif /* NO_GETSERVBYNAME */
  922. }
  924. switch (daemonaddr->sa.sa_family)
  925. {
  926. # if NETINET
  927.   case AF_INET:
  928. daemonaddr->sin.sin_port = port;
  929. break;
  930. # endif /* NETINET */
  932. # if NETINET6
  933.   case AF_INET6:
  934. daemonaddr->sin6.sin6_port = port;
  935. break;
  936. # endif /* NETINET6 */
  938.   default:
  939. /* unknown protocol */
  940. break;
  941. }
  942. return(port);
  943. }
  944. /*
  945. **  CLRDAEMON -- reset the daemon connection
  946. **
  947. ** Parameters:
  948. ** none.
  949. **
  950. ** Returns:
  951. ** none.
  952. **
  953. ** Side Effects:
  954. ** releases any resources used by the passive daemon.
  955. */
  957. void
  958. clrdaemon()
  959. {
  960. int i;
  962. for (i = 0; i < ndaemons; i++)
  963. {
  964. if (Daemons[i].d_socket >= 0)
  965. (void) close(Daemons[i].d_socket);
  966. Daemons[i].d_socket = -1;
  967. }
  968. }
  969. /*
  970. **  SETSOCKADDROPTIONS -- set options for SOCKADDR (daemon or client)
  971. **
  972. ** Parameters:
  973. ** p -- the options line.
  974. ** d -- the daemon structure to fill in.
  975. **
  976. ** Returns:
  977. ** none.
  978. */
  980. static void
  981. setsockaddroptions(p, d)
  982. register char *p;
  983. struct daemon *d;
  984. {
  985. # if NETISO
  986. short port;
  987. # endif /* NETISO */
  988. int l;
  989. char *h, *flags;
  991. if (d->d_addr.sa.sa_family == AF_UNSPEC)
  992. d->d_addr.sa.sa_family = InetMode;
  994. while (p != NULL)
  995. {
  996. register char *f;
  997. register char *v;
  999. while (isascii(*p) && isspace(*p))
  1000. p++;
  1001. if (*p == '')
  1002. break;
  1003. f = p;
  1004. p = strchr(p, ',');
  1005. if (p != NULL)
  1006. *p++ = '';
  1007. v = strchr(f, '=');
  1008. if (v == NULL)
  1009. continue;
  1010. while (isascii(*++v) && isspace(*v))
  1011. continue;
  1012. if (isascii(*f) && islower(*f))
  1013. *f = toupper(*f);
  1015. switch (*f)
  1016. {
  1017.   case 'F': /* address family */
  1018. if (isascii(*v) && isdigit(*v))
  1019. d->d_addr.sa.sa_family = atoi(v);
  1020. # if NETINET
  1021. else if (strcasecmp(v, "inet") == 0)
  1022. d->d_addr.sa.sa_family = AF_INET;
  1023. # endif /* NETINET */
  1024. # if NETINET6
  1025. else if (strcasecmp(v, "inet6") == 0)
  1026. d->d_addr.sa.sa_family = AF_INET6;
  1027. # endif /* NETINET6 */
  1028. # if NETISO
  1029. else if (strcasecmp(v, "iso") == 0)
  1030. d->d_addr.sa.sa_family = AF_ISO;
  1031. # endif /* NETISO */
  1032. # if NETNS
  1033. else if (strcasecmp(v, "ns") == 0)
  1034. d->d_addr.sa.sa_family = AF_NS;
  1035. # endif /* NETNS */
  1036. # if NETX25
  1037. else if (strcasecmp(v, "x.25") == 0)
  1038. d->d_addr.sa.sa_family = AF_CCITT;
  1039. # endif /* NETX25 */
  1040. else
  1041. syserr("554 5.3.5 Unknown address family %s in Family=option",
  1042.        v);
  1043. break;
  1045.   case 'A': /* address */
  1046. switch (d->d_addr.sa.sa_family)
  1047. {
  1048. # if NETINET
  1049.   case AF_INET:
  1050. if (!isascii(*v) || !isdigit(*v) ||
  1051.     ((d->d_addr.sin.sin_addr.s_addr = inet_addr(v)) == INADDR_NONE))
  1052. {
  1053. register struct hostent *hp;
  1055. hp = sm_gethostbyname(v, AF_INET);
  1056. if (hp == NULL)
  1057. syserr("554 5.3.0 host "%s" unknown",
  1058.        v);
  1059. else
  1060. {
  1061. while (*(hp->h_addr_list) &&
  1062.        hp->h_addrtype != AF_INET)
  1063. hp->h_addr_list++;
  1064. if (*(hp->h_addr_list) == NULL)
  1065. syserr("554 5.3.0 host "%s" unknown",
  1066.        v);
  1067. else
  1068. memmove(&d->d_addr.sin.sin_addr,
  1069. *(hp->h_addr_list),
  1070. INADDRSZ);
  1071. }
  1072. }
  1073. break;
  1074. # endif /* NETINET */
  1076. # if NETINET6
  1077.   case AF_INET6:
  1078. if (!isascii(*v) || !isxdigit(*v) ||
  1079.     inet_pton(AF_INET6, v,
  1080.       &d->d_addr.sin6.sin6_addr) != 1)
  1081. {
  1082. register struct hostent *hp;
  1084. hp = sm_gethostbyname(v, AF_INET6);
  1085. if (hp == NULL)
  1086. syserr("554 5.3.0 host "%s" unknown",
  1087.        v);
  1088. else
  1089. {
  1090. while (*(hp->h_addr_list) &&
  1091.        hp->h_addrtype != AF_INET6)
  1092. hp->h_addr_list++;
  1093. if (*(hp->h_addr_list) == NULL)
  1094. syserr("554 5.3.0 host "%s" unknown",
  1095.        v);
  1096. else
  1097. memmove(&d->d_addr.sin6.sin6_addr,
  1098. *(hp->h_addr_list),
  1099. IN6ADDRSZ);
  1100. }
  1101. }
  1102. break;
  1103. # endif /* NETINET6 */
  1105.   default:
  1106. syserr("554 5.3.5 address= option unsupported for family %d",
  1107.        d->d_addr.sa.sa_family);
  1108. break;
  1109. }
  1110. break;
  1112.   case 'P': /* port */
  1113. switch (d->d_addr.sa.sa_family)
  1114. {
  1115. # if NETINET
  1116.   case AF_INET:
  1117. if (isascii(*v) && isdigit(*v))
  1118. d->d_addr.sin.sin_port = htons(atoi(v));
  1119. else
  1120. {
  1121. #  ifdef NO_GETSERVBYNAME
  1122. syserr("554 5.3.5 invalid port number: %s",
  1123.        v);
  1124. #  else /* NO_GETSERVBYNAME */
  1125. register struct servent *sp;
  1127. sp = getservbyname(v, "tcp");
  1128. if (sp == NULL)
  1129. syserr("554 5.3.5 service "%s" unknown",
  1130.        v);
  1131. else
  1132. d->d_addr.sin.sin_port = sp->s_port;
  1133. #  endif /* NO_GETSERVBYNAME */
  1134. }
  1135. break;
  1136. # endif /* NETINET */
  1138. # if NETINET6
  1139.   case AF_INET6:
  1140. if (isascii(*v) && isdigit(*v))
  1141. d->d_addr.sin6.sin6_port = htons(atoi(v));
  1142. else
  1143. {
  1144. #  ifdef NO_GETSERVBYNAME
  1145. syserr("554 5.3.5 invalid port number: %s",
  1146.        v);
  1147. #  else /* NO_GETSERVBYNAME */
  1148. register struct servent *sp;
  1150. sp = getservbyname(v, "tcp");
  1151. if (sp == NULL)
  1152. syserr("554 5.3.5 service "%s" unknown",
  1153.        v);
  1154. else
  1155. d->d_addr.sin6.sin6_port = sp->s_port;
  1156. #  endif /* NO_GETSERVBYNAME */
  1157. }
  1158. break;
  1159. # endif /* NETINET6 */
  1161. # if NETISO
  1162.   case AF_ISO:
  1163. /* assume two byte transport selector */
  1164. if (isascii(*v) && isdigit(*v))
  1165. port = htons(atoi(v));
  1166. else
  1167. {
  1168. #  ifdef NO_GETSERVBYNAME
  1169. syserr("554 5.3.5 invalid port number: %s",
  1170.        v);
  1171. #  else /* NO_GETSERVBYNAME */
  1172. register struct servent *sp;
  1174. sp = getservbyname(v, "tcp");
  1175. if (sp == NULL)
  1176. syserr("554 5.3.5 service "%s" unknown",
  1177.        v);
  1178. else
  1179. port = sp->s_port;
  1180. #  endif /* NO_GETSERVBYNAME */
  1181. }
  1182. memmove(TSEL(&d->d_addr.siso),
  1183. (char *) &port, 2);
  1184. break;
  1185. # endif /* NETISO */
  1187.   default:
  1188. syserr("554 5.3.5 Port= option unsupported for family %d",
  1189.        d->d_addr.sa.sa_family);
  1190. break;
  1191. }
  1192. break;
  1194.   case 'L': /* listen queue size */
  1195. d->d_listenqueue = atoi(v);
  1196. break;
  1198.   case 'M': /* modifiers (flags) */
  1199. l = 3 * strlen(v) + 3;
  1200. h = v;
  1201. flags = xalloc(l);
  1202. d->d_mflags = flags;
  1203. for (; *h != ''; h++)
  1204. {
  1205. if (!(isascii(*h) && isspace(*h)))
  1206. {
  1207. if (flags != d->d_mflags)
  1208. *f++ = ' ';
  1209. *flags++ = *h;
  1210. if (isupper(*h))
  1211. *flags++ = *h;
  1212. }
  1213. }
  1214. *flags++ = '';
  1215. for (; *v != ''; v++)
  1216. if (!(isascii(*v) && isspace(*v)))
  1217. setbitn(*v, d->d_flags);
  1218. break;
  1220.   case 'S': /* send buffer size */
  1221. d->d_tcpsndbufsize = atoi(v);
  1222. break;
  1224.   case 'R': /* receive buffer size */
  1225. d->d_tcprcvbufsize = atoi(v);
  1226. break;
  1228.   case 'N': /* name */
  1229. d->d_name = v;
  1230. break;
  1232.   default:
  1233. syserr("554 5.3.5 PortOptions parameter "%s" unknown",
  1234.        f);
  1235. }
  1236. }
  1237. }
  1238. /*
  1239. **  SETDAEMONOPTIONS -- set options for running the MTA daemon
  1240. **
  1241. ** Parameters:
  1242. ** p -- the options line.
  1243. **
  1244. ** Returns:
  1245. ** TRUE if successful, FALSE otherwise.
  1246. */
  1248. bool
  1249. setdaemonoptions(p)
  1250. register char *p;
  1251. {
  1252. if (ndaemons >= MAXDAEMONS)
  1253. return FALSE;
  1254. Daemons[ndaemons].d_socket = -1;
  1255. Daemons[ndaemons].d_listenqueue = 10;
  1256. clrbitmap(Daemons[ndaemons].d_flags);
  1257. setsockaddroptions(p, &Daemons[ndaemons]);
  1259. if (Daemons[ndaemons].d_name != NULL)
  1260. Daemons[ndaemons].d_name = newstr(Daemons[ndaemons].d_name);
  1261. else
  1262. {
  1263. char num[30];
  1265. snprintf(num, sizeof num, "Daemon%d", ndaemons);
  1266. Daemons[ndaemons].d_name = newstr(num);
  1267. }
  1269. if (tTd(37, 1))
  1270. {
  1271. dprintf("Daemon %s flags: ", Daemons[ndaemons].d_name);
  1272. if (bitnset(D_ETRNONLY, Daemons[ndaemons].d_flags))
  1273. dprintf("ETRNONLY ");
  1274. if (bitnset(D_NOETRN, Daemons[ndaemons].d_flags))
  1275. dprintf("NOETRN ");
  1276. dprintf("n");
  1277. }
  1278. ++ndaemons;
  1279. return TRUE;
  1280. }
  1281. /*
  1282. **  INITDAEMON -- initialize daemon if not yet done.
  1283. **
  1284. ** Parameters:
  1285. ** none
  1286. **
  1287. ** Returns:
  1288. ** none
  1289. **
  1290. ** Side Effects:
  1291. ** initializes structure for one daemon.
  1292. */
  1293. void
  1294. initdaemon()
  1295. {
  1296. if (ndaemons == 0)
  1297. {
  1298. Daemons[ndaemons].d_socket = -1;
  1299. Daemons[ndaemons].d_listenqueue = 10;
  1300. Daemons[ndaemons].d_name = "Daemon0";
  1301. ndaemons = 1;
  1302. }
  1303. }
  1304. /*
  1305. **  SETCLIENTOPTIONS -- set options for running the client
  1306. **
  1307. ** Parameters:
  1308. ** p -- the options line.
  1309. **
  1310. ** Returns:
  1311. ** none.
  1312. */
  1314. static SOCKADDR ClientAddr; /* address for client */
  1316. void
  1317. setclientoptions(p)
  1318. register char *p;
  1319. {
  1320. struct daemon d;
  1321. extern ENVELOPE BlankEnvelope;
  1323. memset(&d, '', sizeof d);
  1324. setsockaddroptions(p, &d);
  1326. /* grab what we need */
  1327. memcpy(&ClientAddr, &d.d_addr, sizeof ClientAddr);
  1328. TcpSndBufferSize = d.d_tcpsndbufsize;
  1329. TcpRcvBufferSize = d.d_tcprcvbufsize;
  1330. if (d.d_mflags != NULL)
  1331. define(macid("{client_flags}", NULL), d.d_mflags,
  1332.        &BlankEnvelope);
  1333. else
  1334. define(macid("{client_flags}", NULL), "", &BlankEnvelope);
  1335. }
  1336. /*
  1337. **  MAKECONNECTION -- make a connection to an SMTP socket on a machine.
  1338. **
  1339. ** Parameters:
  1340. ** host -- the name of the host.
  1341. ** port -- the port number to connect to.
  1342. ** mci -- a pointer to the mail connection information
  1343. ** structure to be filled in.
  1344. ** e -- the current envelope.
  1345. **
  1346. ** Returns:
  1347. ** An exit code telling whether the connection could be
  1348. ** made and if not why not.
  1349. **
  1350. ** Side Effects:
  1351. ** none.
  1352. */
  1354. static jmp_buf CtxConnectTimeout;
  1356. SOCKADDR CurHostAddr; /* address of current host */
  1358. int
  1359. makeconnection(host, port, mci, e)
  1360. char *host;
  1361. volatile u_int port;
  1362. register MCI *mci;
  1363. ENVELOPE *e;
  1364. {
  1365. register volatile int addrno = 0;
  1366. register volatile int s;
  1367. register struct hostent *volatile hp = (struct hostent *)NULL;
  1368. SOCKADDR addr;
  1369. SOCKADDR clt_addr;
  1370. int save_errno = 0;
  1371. volatile SOCKADDR_LEN_T addrlen;
  1372. volatile bool firstconnect;
  1373. EVENT *volatile ev = NULL;
  1374. # if NETINET6
  1375. volatile int family = AF_INET6;
  1376. bool v6found = FALSE;
  1377. # else /* NETINET6 */
  1378. int family = AF_INET;
  1379. # endif /* NETINET6 */
  1380. SOCKADDR_LEN_T len;
  1381. volatile SOCKADDR_LEN_T socksize = 0;
  1382. volatile bool clt_bind = FALSE;
  1383. BITMAP256 d_flags;
  1384. char *p;
  1385. extern ENVELOPE BlankEnvelope;
  1387. /* retranslate ${daemon_flags} into bitmap */
  1388. clrbitmap(d_flags);
  1389. if ((p = macvalue(macid("{daemon_flags}", NULL), e)) != NULL)
  1390. {
  1391. for (; *p != ''; p++)
  1392. if (!(isascii(*p) && isspace(*p)))
  1393. setbitn(*p, d_flags);
  1394. }
  1396. /* "add" ${client_flags} to bitmap */
  1397. if ((p = macvalue(macid("{client_flags}", NULL), e)) != NULL)
  1398. {
  1399. for (; *p != ''; p++)
  1400. {
  1401. /* look for just this one flag */
  1402. if (*p == D_IFNHELO)
  1403. {
  1404. setbitn(*p, d_flags);
  1405. break;
  1406. }
  1407. }
  1408. }
  1410. /* Set up the address for outgoing connection. */
  1411. if (bitnset(D_BINDIF, d_flags) &&
  1412.     (p = macvalue(macid("{if_addr}", NULL), e)) != NULL)
  1413. {
  1414. char *f;
  1416. memset(&clt_addr, '', sizeof clt_addr);
  1417. /* XXX set all necessary values... */
  1418. if ((f = macvalue(macid("{if_family}", NULL), e)) != NULL)
  1419. clt_addr.sa.sa_family = atoi(f);
  1420. else
  1421. clt_addr.sa.sa_family = AF_INET;
  1422. switch (clt_addr.sa.sa_family)
  1423. {
  1424. # if NETINET
  1425.   case AF_INET:
  1426. if ((clt_addr.sin.sin_addr.s_addr = inet_addr(p))
  1427.     != INADDR_NONE)
  1428. {
  1429. clt_bind = TRUE;
  1430. socksize = sizeof (struct sockaddr_in);
  1431. }
  1432. else if (clt_addr.sin.sin_port != 0)
  1433. {
  1434. clt_addr.sin.sin_addr.s_addr = INADDR_ANY;
  1435. clt_bind = TRUE;
  1436. socksize = sizeof (struct sockaddr_in);
  1437. }
  1438. break;
  1439. # endif /* NETINET */
  1441. # if NETINET6
  1442.   case AF_INET6:
  1443. f = strchr(p, ']');
  1444. if (f != NULL)
  1445. {
  1446. *f = '';
  1447. if (inet_pton(AF_INET6, p + 1,
  1448.       &clt_addr.sin6.sin6_addr) == 1)
  1449. {
  1450. *f = ']';
  1451. clt_bind = TRUE;
  1452. socksize = sizeof (struct sockaddr_in6);
  1453. }
  1454. }
  1455. if (!clt_bind && clt_addr.sin6.sin6_port != 0)
  1456. {
  1457. if (IN6_IS_ADDR_UNSPECIFIED(&clt_addr.sin6.sin6_addr))
  1458. clt_addr.sin6.sin6_addr = in6addr_any;
  1459. clt_bind = TRUE;
  1460. socksize = sizeof (struct sockaddr_in);
  1461. }
  1462. break;
  1463. # endif /* NETINET6 */
  1465. # if 0
  1466.   default:
  1467. syserr("554 5.3.5 Address= option unsupported for family %d",
  1468.        clt_addr.sa.sa_family);
  1469. break;
  1470. # endif /* 0 */
  1471. }
  1472. }
  1473. else
  1474. {
  1475. STRUCTCOPY(ClientAddr, clt_addr);
  1476. switch (clt_addr.sa.sa_family)
  1477. {
  1478.   case AF_UNSPEC:
  1479. # if NETINET
  1480. clt_addr.sa.sa_family = AF_INET;
  1481. /* FALLTHROUGH */
  1483.   case AF_INET:
  1484. if (clt_addr.sin.sin_addr.s_addr == 0)
  1485. clt_addr.sin.sin_addr.s_addr = INADDR_ANY;
  1486. else
  1487. clt_bind = TRUE;
  1488. if (clt_addr.sin.sin_port != 0)
  1489. clt_bind = TRUE;
  1490. socksize = sizeof (struct sockaddr_in);
  1491. break;
  1492. # endif /* NETINET */
  1493. # if NETINET6
  1494.   case AF_INET6:
  1495. if (IN6_IS_ADDR_UNSPECIFIED(&clt_addr.sin6.sin6_addr))
  1496. clt_addr.sin6.sin6_addr = in6addr_any;
  1497. else
  1498. clt_bind = TRUE;
  1499. socksize = sizeof (struct sockaddr_in6);
  1500. if (clt_addr.sin6.sin6_port != 0)
  1501. clt_bind = TRUE;
  1502. break;
  1503. # endif /* NETINET6 */
  1504. # if NETISO
  1505.   case AF_ISO:
  1506. socksize = sizeof clt_addr.siso;
  1507. clt_bind = TRUE;
  1508. break;
  1509. # endif /* NETISO */
  1510. }
  1511. }
  1513. /*
  1514. **  Set up the address for the mailer.
  1515. ** Accept "[a.b.c.d]" syntax for host name.
  1516. */
  1518. # if NETINET6
  1519.  v4retry:
  1520. # endif /* NETINET6 */
  1522. # if NAMED_BIND
  1523. h_errno = 0;
  1524. # endif /* NAMED_BIND */
  1525. errno = 0;
  1526. memset(&CurHostAddr, '', sizeof CurHostAddr);
  1527. memset(&addr, '', sizeof addr);
  1528. SmtpPhase = mci->mci_phase = "initial connection";
  1529. CurHostName = host;
  1531. if (host[0] == '[')
  1532. {
  1533. p = strchr(host, ']');
  1534. if (p != NULL)
  1535. {
  1536. # if NETINET
  1537. unsigned long hid = INADDR_NONE;
  1538. # endif /* NETINET */
  1539. # if NETINET6
  1540. struct sockaddr_in6 hid6;
  1541. # endif /* NETINET6 */
  1543. *p = '';
  1544. # if NETINET6
  1545. memset(&hid6, '', sizeof hid6);
  1546. # endif /* NETINET6 */
  1547. # if NETINET
  1548. if (family == AF_INET &&
  1549.     (hid = inet_addr(&host[1])) != INADDR_NONE)
  1550. {
  1551. addr.sin.sin_family = AF_INET;
  1552. addr.sin.sin_addr.s_addr = hid;
  1553. }
  1554. else
  1555. # endif /* NETINET */
  1556. # if NETINET6
  1557. if (family == AF_INET6 &&
  1558.     inet_pton(AF_INET6, &host[1],
  1559.       &hid6.sin6_addr) == 1)
  1560. {
  1561. addr.sin6.sin6_family = AF_INET6;
  1562. addr.sin6.sin6_addr = hid6.sin6_addr;
  1563. }
  1564. else
  1565. # endif /* NETINET6 */
  1566. {
  1567. /* try it as a host name (avoid MX lookup) */
  1568. hp = sm_gethostbyname(&host[1], family);
  1569. if (hp == NULL && p[-1] == '.')
  1570. {
  1571. # if NAMED_BIND
  1572. int oldopts = _res.options;
  1574. _res.options &= ~(RES_DEFNAMES|RES_DNSRCH);
  1575. # endif /* NAMED_BIND */
  1576. p[-1] = '';
  1577. hp = sm_gethostbyname(&host[1],
  1578.       family);
  1579. p[-1] = '.';
  1580. # if NAMED_BIND
  1581. _res.options = oldopts;
  1582. # endif /* NAMED_BIND */
  1583. }
  1584. *p = ']';
  1585. goto gothostent;
  1586. }
  1587. *p = ']';
  1588. }
  1589. if (p == NULL)
  1590. {
  1591. extern char MsgBuf[];
  1593. usrerrenh("5.1.2",
  1594.   "553 Invalid numeric domain spec "%s"",
  1595.   host);
  1596. mci_setstat(mci, EX_NOHOST, "5.1.2", MsgBuf);
  1597. errno = EINVAL;
  1598. return EX_NOHOST;
  1599. }
  1600. }
  1601. else
  1602. {
  1603. /* contortion to get around SGI cc complaints */
  1604. {
  1605. p = &host[strlen(host) - 1];
  1606. hp = sm_gethostbyname(host, family);
  1607. if (hp == NULL && *p == '.')
  1608. {
  1609. # if NAMED_BIND
  1610. int oldopts = _res.options;
  1612. _res.options &= ~(RES_DEFNAMES|RES_DNSRCH);
  1613. # endif /* NAMED_BIND */
  1614. *p = '';
  1615. hp = sm_gethostbyname(host, family);
  1616. *p = '.';
  1617. # if NAMED_BIND
  1618. _res.options = oldopts;
  1619. # endif /* NAMED_BIND */
  1620. }
  1621. }
  1622. gothostent:
  1623. if (hp == NULL)
  1624. {
  1625. # if NAMED_BIND
  1626. /* check for name server timeouts */
  1627. if (errno == ETIMEDOUT || h_errno == TRY_AGAIN ||
  1628.     (errno == ECONNREFUSED && UseNameServer))
  1629. {
  1630. save_errno = errno;
  1631. mci_setstat(mci, EX_TEMPFAIL, "4.4.3", NULL);
  1632. errno = save_errno;
  1633. return EX_TEMPFAIL;
  1634. }
  1635. # endif /* NAMED_BIND */
  1636. # if NETINET6
  1637. /*
  1638. **  Try v6 first, then fall back to v4.
  1639. **  If we found a v6 address, but no v4
  1640. **  addresses, then TEMPFAIL.
  1641. */
  1643. if (family == AF_INET6)
  1644. {
  1645. family = AF_INET;
  1646. goto v4retry;
  1647. }
  1648. if (v6found)
  1649. goto v6tempfail;
  1650. # endif /* NETINET6 */
  1651. save_errno = errno;
  1652. mci_setstat(mci, EX_NOHOST, "5.1.2", NULL);
  1653. errno = save_errno;
  1654. return EX_NOHOST;
  1655. }
  1656. addr.sa.sa_family = hp->h_addrtype;
  1657. switch (hp->h_addrtype)
  1658. {
  1659. # if NETINET
  1660.   case AF_INET:
  1661. memmove(&addr.sin.sin_addr,
  1662. hp->h_addr,
  1663. INADDRSZ);
  1664. break;
  1665. # endif /* NETINET */
  1667. # if NETINET6
  1668.   case AF_INET6:
  1669. memmove(&addr.sin6.sin6_addr,
  1670. hp->h_addr,
  1671. IN6ADDRSZ);
  1672. break;
  1673. # endif /* NETINET6 */
  1675.   default:
  1676. if (hp->h_length > sizeof addr.sa.sa_data)
  1677. {
  1678. syserr("makeconnection: long sa_data: family %d len %d",
  1679. hp->h_addrtype, hp->h_length);
  1680. mci_setstat(mci, EX_NOHOST, "5.1.2", NULL);
  1681. errno = EINVAL;
  1682. return EX_NOHOST;
  1683. }
  1684. memmove(addr.sa.sa_data,
  1685. hp->h_addr,
  1686. hp->h_length);
  1687. break;
  1688. }
  1689. addrno = 1;
  1690. }
  1692. /*
  1693. **  Determine the port number.
  1694. */
  1696. if (port == 0)
  1697. {
  1698. # ifdef NO_GETSERVBYNAME
  1699. port = htons(25);
  1700. # else /* NO_GETSERVBYNAME */
  1701. register struct servent *sp = getservbyname("smtp", "tcp");
  1703. if (sp == NULL)
  1704. {
  1705. if (LogLevel > 2)
  1706. sm_syslog(LOG_ERR, NOQID,
  1707.   "makeconnection: service "smtp" unknown");
  1708. port = htons(25);
  1709. }
  1710. else
  1711. port = sp->s_port;
  1712. # endif /* NO_GETSERVBYNAME */
  1713. }
  1715. switch (addr.sa.sa_family)
  1716. {
  1717. # if NETINET
  1718.   case AF_INET:
  1719. addr.sin.sin_port = port;
  1720. addrlen = sizeof (struct sockaddr_in);
  1721. break;
  1722. # endif /* NETINET */
  1724. # if NETINET6
  1725.   case AF_INET6:
  1726. addr.sin6.sin6_port = port;
  1727. addrlen = sizeof (struct sockaddr_in6);
  1728. break;
  1729. # endif /* NETINET6 */
  1731. # if NETISO
  1732.   case AF_ISO:
  1733. /* assume two byte transport selector */
  1734. memmove(TSEL((struct sockaddr_iso *) &addr), (char *) &port, 2);
  1735. addrlen = sizeof (struct sockaddr_iso);
  1736. break;
  1737. # endif /* NETISO */
  1739.   default:
  1740. syserr("Can't connect to address family %d", addr.sa.sa_family);
  1741. mci_setstat(mci, EX_NOHOST, "5.1.2", NULL);
  1742. errno = EINVAL;
  1743. return EX_NOHOST;
  1744. }
  1746. /*
  1747. **  Try to actually open the connection.
  1748. */
  1750. # ifdef XLA
  1751. /* if too many connections, don't bother trying */
  1752. if (!xla_noqueue_ok(host))
  1753. return EX_TEMPFAIL;
  1754. # endif /* XLA */
  1756. firstconnect = TRUE;
  1757. for (;;)
  1758. {
  1759. if (tTd(16, 1))
  1760. dprintf("makeconnection (%s [%s])n",
  1761. host, anynet_ntoa(&addr));
  1763. /* save for logging */
  1764. CurHostAddr = addr;
  1766. if (bitnset(M_SECURE_PORT, mci->mci_mailer->m_flags))
  1767. {
  1768. int rport = IPPORT_RESERVED - 1;
  1770. s = rresvport(&rport);
  1771. }
  1772. else
  1773. {
  1774. s = socket(addr.sa.sa_family, SOCK_STREAM, 0);
  1775. }
  1776. if (s < 0)
  1777. {
  1778. save_errno = errno;
  1779. syserr("makeconnection: cannot create socket");
  1780. # ifdef XLA
  1781. xla_host_end(host);
  1782. # endif /* XLA */
  1783. mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
  1784. errno = save_errno;
  1785. return EX_TEMPFAIL;
  1786. }
  1788. # ifdef SO_SNDBUF
  1789. if (TcpSndBufferSize > 0)
  1790. {
  1791. if (setsockopt(s, SOL_SOCKET, SO_SNDBUF,
  1792.        (char *) &TcpSndBufferSize,
  1793.        sizeof(TcpSndBufferSize)) < 0)
  1794. syserr("makeconnection: setsockopt(SO_SNDBUF)");
  1795. }
  1796. # endif /* SO_SNDBUF */
  1797. # ifdef SO_RCVBUF
  1798. if (TcpRcvBufferSize > 0)
  1799. {
  1800. if (setsockopt(s, SOL_SOCKET, SO_RCVBUF,
  1801.        (char *) &TcpRcvBufferSize,
  1802.        sizeof(TcpRcvBufferSize)) < 0)
  1803. syserr("makeconnection: setsockopt(SO_RCVBUF)");
  1804. }
  1805. # endif /* SO_RCVBUF */
  1808. if (tTd(16, 1))
  1809. dprintf("makeconnection: fd=%dn", s);
  1811. /* turn on network debugging? */
  1812. if (tTd(16, 101))
  1813. {
  1814. int on = 1;
  1816. (void) setsockopt(s, SOL_SOCKET, SO_DEBUG,
  1817.   (char *)&on, sizeof on);
  1818. }
  1819. if (e->e_xfp != NULL)
  1820. (void) fflush(e->e_xfp); /* for debugging */
  1821. errno = 0; /* for debugging */
  1823. if (clt_bind)
  1824. {
  1825. int on = 1;
  1827. switch (clt_addr.sa.sa_family)
  1828. {
  1829. # if NETINET
  1830.   case AF_INET:
  1831. if (clt_addr.sin.sin_port != 0)
  1832. (void) setsockopt(s, SOL_SOCKET,
  1833.   SO_REUSEADDR,
  1834.   (char *) &on,
  1835.   sizeof on);
  1836. break;
  1837. # endif /* NETINET */
  1839. # if NETINET6
  1840.   case AF_INET6:
  1841. if (clt_addr.sin6.sin6_port != 0)
  1842. (void) setsockopt(s, SOL_SOCKET,
  1843.   SO_REUSEADDR,
  1844.   (char *) &on,
  1845.   sizeof on);
  1846. break;
  1847. # endif /* NETINET6 */
  1848. }
  1850. if (bind(s, &clt_addr.sa, socksize) < 0)
  1851. {
  1852. save_errno = errno;
  1853. (void) close(s);
  1854. errno = save_errno;
  1855. syserr("makeconnection: cannot bind socket [%s]",
  1856.        anynet_ntoa(&clt_addr));
  1857. errno = save_errno;
  1858. return EX_TEMPFAIL;
  1859. }
  1860. }
  1862. /*
  1863. **  Linux seems to hang in connect for 90 minutes (!!!).
  1864. **  Time out the connect to avoid this problem.
  1865. */
  1867. if (setjmp(CtxConnectTimeout) == 0)
  1868. {
  1869. int i;
  1871. if (e->e_ntries <= 0 && TimeOuts.to_iconnect != 0)
  1872. ev = setevent(TimeOuts.to_iconnect, connecttimeout, 0);
  1873. else if (TimeOuts.to_connect != 0)
  1874. ev = setevent(TimeOuts.to_connect, connecttimeout, 0);
  1875. else
  1876. ev = NULL;
  1878. switch (ConnectOnlyTo.sa.sa_family)
  1879. {
  1880. # if NETINET
  1881.   case AF_INET:
  1882. addr.sin.sin_addr.s_addr = ConnectOnlyTo.sin.sin_addr.s_addr;
  1883. break;
  1884. # endif /* NETINET */
  1886. # if NETINET6
  1887.   case AF_INET6:
  1888. memmove(&addr.sin6.sin6_addr,
  1889. &ConnectOnlyTo.sin6.sin6_addr,
  1890. IN6ADDRSZ);
  1891. break;
  1892. # endif /* NETINET6 */
  1893. }
  1894. i = connect(s, (struct sockaddr *) &addr, addrlen);
  1895. save_errno = errno;
  1896. if (ev != NULL)
  1897. clrevent(ev);
  1898. if (i >= 0)
  1899. break;
  1900. }
  1901. else
  1902. save_errno = errno;
  1904. /* if running demand-dialed connection, try again */
  1905. if (DialDelay > 0 && firstconnect)
  1906. {
  1907. if (tTd(16, 1))
  1908. dprintf("Connect failed (%s); trying again...n",
  1909. errstring(save_errno));
  1910. firstconnect = FALSE;
  1911. (void) sleep(DialDelay);
  1912. continue;
  1913. }
  1915. /* couldn't connect.... figure out why */
  1916. (void) close(s);
  1918. if (LogLevel >= 14)
  1919. sm_syslog(LOG_INFO, e->e_id,
  1920.   "makeconnection (%s [%s]) failed: %s",
  1921.   host, anynet_ntoa(&addr),
  1922.   errstring(save_errno));
  1924. if (hp != NULL && hp->h_addr_list[addrno] != NULL)
  1925. {
  1926. if (tTd(16, 1))
  1927. dprintf("Connect failed (%s); trying new address....n",
  1928. errstring(save_errno));
  1929. switch (addr.sa.sa_family)
  1930. {
  1931. # if NETINET
  1932.   case AF_INET:
  1933. memmove(&addr.sin.sin_addr,
  1934. hp->h_addr_list[addrno++],
  1935. INADDRSZ);
  1936. break;
  1937. # endif /* NETINET */
  1939. # if NETINET6
  1940.   case AF_INET6:
  1941. memmove(&addr.sin6.sin6_addr,
  1942. hp->h_addr_list[addrno++],
  1943. IN6ADDRSZ);
  1944. break;
  1945. # endif /* NETINET6 */
  1947.   default:
  1948. memmove(addr.sa.sa_data,
  1949. hp->h_addr_list[addrno++],
  1950. hp->h_length);
  1951. break;
  1952. }
  1953. continue;
  1954. }
  1956. # if NETINET6
  1957. if (family == AF_INET6)
  1958. {
  1959. if (tTd(16, 1))
  1960. dprintf("Connect failed (%s); retrying with AF_INET....n",
  1961. errstring(save_errno));
  1962. v6found = TRUE;
  1963. family = AF_INET;
  1964. goto v4retry;
  1965. }
  1966. v6tempfail:
  1967. # endif /* NETINET6 */
  1968. /* couldn't open connection */
  1969. # if NETINET6
  1970. /* Don't clobber an already saved errno from v4retry */
  1971. if (errno > 0)
  1972. # endif /* NETINET6 */
  1973. save_errno = errno;
  1974. if (tTd(16, 1))
  1975. dprintf("Connect failed (%s)n", errstring(save_errno));
  1976. # ifdef XLA
  1977. xla_host_end(host);
  1978. # endif /* XLA */
  1979. mci_setstat(mci, EX_TEMPFAIL, "4.4.1", NULL);
  1980. errno = save_errno;
  1981. return EX_TEMPFAIL;
  1982. }
  1984. /* connection ok, put it into canonical form */
  1985. mci->mci_out = NULL;
  1986. if ((mci->mci_out = fdopen(s, "w")) == NULL ||
  1987.     (s = dup(s)) < 0 ||
  1988.     (mci->mci_in = fdopen(s, "r")) == NULL)
  1989. {
  1990. save_errno = errno;
  1991. syserr("cannot open SMTP client channel, fd=%d", s);
  1992. mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
  1993. if (mci->mci_out != NULL)
  1994. (void) fclose(mci->mci_out);
  1995. (void) close(s);
  1996. errno = save_errno;
  1997. return EX_TEMPFAIL;
  1998. }
  2000. /* find out name for Interface through which we connect */
  2001. len = sizeof addr;
  2002. if (getsockname(s, &addr.sa, &len) == 0)
  2003. {
  2004. char *name;
  2006. define(macid("{if_addr}", NULL), newstr(anynet_ntoa(&addr)),
  2007.        &BlankEnvelope);
  2008. name = hostnamebyanyaddr(&addr);
  2009. define(macid("{if_name}", NULL), newstr(name), &BlankEnvelope);
  2010. if (LogLevel > 11)
  2011. {
  2012. /* log connection information */
  2013. sm_syslog(LOG_INFO, e->e_id,
  2014.   "SMTP outcoming connect on %.40s", name);
  2015. }
  2016. if (bitnset(D_IFNHELO, d_flags))
  2017. {
  2018. if (name[0] != '[' && strchr(name, '.') != NULL)
  2019. mci->mci_heloname = newstr(name);
  2020. }
  2021. }
  2022. else
  2023. {
  2024. define(macid("{if_name}", NULL), NULL, &BlankEnvelope);
  2025. define(macid("{if_addr}", NULL), NULL, &BlankEnvelope);
  2026. }
  2027. mci_setstat(mci, EX_OK, NULL, NULL);
  2028. return EX_OK;
  2029. }
  2031. static void
  2032. connecttimeout()
  2033. {
  2034. errno = ETIMEDOUT;
  2035. longjmp(CtxConnectTimeout, 1);
  2036. }
  2037. /*
  2038. **  MAKECONNECTION_DS -- make a connection to a domain socket.
  2039. **
  2040. ** Parameters:
  2041. ** mux_path -- the path of the socket to connect to.
  2042. ** mci -- a pointer to the mail connection information
  2043. ** structure to be filled in.
  2044. **
  2045. ** Returns:
  2046. ** An exit code telling whether the connection could be
  2047. ** made and if not why not.
  2048. **
  2049. ** Side Effects:
  2050. ** none.
  2051. */
  2053. # if NETUNIX
  2054. int makeconnection_ds(mux_path, mci)
  2055. char *mux_path;
  2056. register MCI *mci;
  2057. {
  2058. int sock;
  2059. int rval, save_errno;
  2060. long sff = SFF_SAFEDIRPATH|SFF_OPENASROOT|SFF_NOLINK|SFF_ROOTOK|SFF_EXECOK;
  2061. struct sockaddr_un unix_addr;
  2063. /* if not safe, don't connect */
  2064. rval = safefile(mux_path, RunAsUid, RunAsGid, RunAsUserName,
  2065. sff, S_IRUSR|S_IWUSR, NULL);
  2067. if (rval != 0)
  2068. {
  2069. syserr("makeconnection_ds: unsafe domain socket");
  2070. mci_setstat(mci, EX_TEMPFAIL, "4.3.5", NULL);
  2071. errno = rval;
  2072. return EX_TEMPFAIL;
  2073. }
  2075. /* prepare address structure */
  2076. memset(&unix_addr, '', sizeof unix_addr);
  2077. unix_addr.sun_family = AF_UNIX;
  2079. if (strlen(mux_path) >= sizeof unix_addr.sun_path)
  2080. {
  2081. syserr("makeconnection_ds: domain socket name too long");
  2082. /* XXX why TEMPFAIL ? */
  2083. mci_setstat(mci, EX_TEMPFAIL, "5.3.5", NULL);
  2084. errno = ENAMETOOLONG;
  2085. return EX_UNAVAILABLE;
  2086. }
  2087. (void) strlcpy(unix_addr.sun_path, mux_path, sizeof unix_addr.sun_path);
  2089. /* initialize domain socket */
  2090. sock = socket(AF_UNIX, SOCK_STREAM, 0);
  2091. if (sock == -1)
  2092. {
  2093. save_errno = errno;
  2094. syserr("makeconnection_ds: could not create domain socket");
  2095. mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
  2096. errno = save_errno;
  2097. return EX_TEMPFAIL;
  2098. }
  2100. /* connect to server */
  2101. if (connect(sock, (struct sockaddr *) &unix_addr,
  2102.     sizeof(unix_addr)) == -1)
  2103. {
  2104. save_errno = errno;
  2105. syserr("Could not connect to socket %s", mux_path);
  2106. mci_setstat(mci, EX_TEMPFAIL, "4.4.1", NULL);
  2107. (void) close(sock);
  2108. errno = save_errno;
  2109. return EX_TEMPFAIL;
  2110. }
  2112. /* connection ok, put it into canonical form */
  2113. mci->mci_out = NULL;
  2114. if ((mci->mci_out = fdopen(sock, "w")) == NULL ||
  2115.     (sock = dup(sock)) < 0 ||
  2116.     (mci->mci_in = fdopen(sock, "r")) == NULL)
  2117. {
  2118. save_errno = errno;
  2119. syserr("cannot open SMTP client channel, fd=%d", sock);
  2120. mci_setstat(mci, EX_TEMPFAIL, "4.4.5", NULL);
  2121. if (mci->mci_out != NULL)
  2122. (void) fclose(mci->mci_out);
  2123. (void) close(sock);
  2124. errno = save_errno;
  2125. return EX_TEMPFAIL;
  2126. }
  2128. mci_setstat(mci, EX_OK, NULL, NULL);
  2129. errno = 0;
  2130. return EX_OK;
  2131. }
  2132. # endif /* NETUNIX */
  2133. /*
  2134. **  MYHOSTNAME -- return the name of this host.
  2135. **
  2136. ** Parameters:
  2137. ** hostbuf -- a place to return the name of this host.
  2138. ** size -- the size of hostbuf.
  2139. **
  2140. ** Returns:
  2141. ** A list of aliases for this host.
  2142. **
  2143. ** Side Effects:
  2144. ** Adds numeric codes to $=w.
  2145. */
  2147. struct hostent *
  2148. myhostname(hostbuf, size)
  2149. char hostbuf[];
  2150. int size;
  2151. {
  2152. register struct hostent *hp;
  2154. if (gethostname(hostbuf, size) < 0)
  2155. {
  2156. (void) strlcpy(hostbuf, "localhost", size);
  2157. }
  2158. hp = sm_gethostbyname(hostbuf, InetMode);
  2159. if (hp == NULL)
  2160. return NULL;
  2161. if (strchr(hp->h_name, '.') != NULL || strchr(hostbuf, '.') == NULL)
  2162. (void) cleanstrcpy(hostbuf, hp->h_name, size);
  2164. # if NETINFO
  2165. if (strchr(hostbuf, '.') == NULL)
  2166. {
  2167. char *domainname;
  2169. domainname = ni_propval("/locations", NULL, "resolver",
  2170. "domain", '');
  2171. if (domainname != NULL &&
  2172.     strlen(domainname) + strlen(hostbuf) + 1 < size)
  2173. {
  2174. (void) strlcat(hostbuf, ".", size);
  2175. (void) strlcat(hostbuf, domainname, size);
  2176. }
  2177. }
  2178. # endif /* NETINFO */
  2180. /*
  2181. **  If there is still no dot in the name, try looking for a
  2182. **  dotted alias.
  2183. */
  2185. if (strchr(hostbuf, '.') == NULL)
  2186. {
  2187. char **ha;
  2189. for (ha = hp->h_aliases; ha != NULL && *ha != NULL; ha++)
  2190. {
  2191. if (strchr(*ha, '.') != NULL)
  2192. {
  2193. (void) cleanstrcpy(hostbuf, *ha, size - 1);
  2194. hostbuf[size - 1] = '';
  2195. break;
  2196. }
  2197. }
  2198. }
  2200. /*
  2201. **  If _still_ no dot, wait for a while and try again -- it is
  2202. **  possible that some service is starting up.  This can result
  2203. **  in excessive delays if the system is badly configured, but
  2204. **  there really isn't a way around that, particularly given that
  2205. **  the config file hasn't been read at this point.
  2206. **  All in all, a bit of a mess.
  2207. */
  2209. if (strchr(hostbuf, '.') == NULL &&
  2210.     !getcanonname(hostbuf, size, TRUE))
  2211. {
  2212. sm_syslog(LOG_CRIT, NOQID,
  2213.   "My unqualified host name (%s) unknown; sleeping for retry",
  2214.   hostbuf);
  2215. message("My unqualified host name (%s) unknown; sleeping for retry",
  2216. hostbuf);
  2217. (void) sleep(60);
  2218. if (!getcanonname(hostbuf, size, TRUE))
  2219. {
  2220. sm_syslog(LOG_ALERT, NOQID,
  2221.   "unable to qualify my own domain name (%s) -- using short name",
  2222.   hostbuf);
  2223. message("WARNING: unable to qualify my own domain name (%s) -- using short name",
  2224. hostbuf);
  2225. }
  2226. }
  2227. return hp;
  2228. }
  2229. /*
  2230. **  ADDRCMP -- compare two host addresses
  2231. **
  2232. ** Parameters:
  2233. ** hp -- hostent structure for the first address
  2234. ** ha -- actual first address
  2235. ** sa -- second address
  2236. **
  2237. ** Returns:
  2238. ** 0 -- if ha and sa match
  2239. ** else -- they don't match
  2240. */
  2242. static int
  2243. addrcmp(hp, ha, sa)
  2244. struct hostent *hp;
  2245. char *ha;
  2246. SOCKADDR *sa;
  2247. {
  2248. # if NETINET6
  2249. u_char *a;
  2250. # endif /* NETINET6 */
  2252. switch (sa->sa.sa_family)
  2253. {
  2254. # if NETINET
  2255.   case AF_INET:
  2256. if (hp->h_addrtype == AF_INET)
  2257. return memcmp(ha, (char *) &sa->sin.sin_addr, INADDRSZ);
  2258. break;
  2259. # endif /* NETINET */
  2261. # if NETINET6
  2262.   case AF_INET6:
  2263. a = (u_char *) &sa->sin6.sin6_addr;
  2265. /* Straight binary comparison */
  2266. if (hp->h_addrtype == AF_INET6)
  2267. return memcmp(ha, a, IN6ADDRSZ);
  2269. /* If IPv4-mapped IPv6 address, compare the IPv4 section */
  2270. if (hp->h_addrtype == AF_INET &&
  2271.     IN6_IS_ADDR_V4MAPPED(&sa->sin6.sin6_addr))
  2272. return memcmp(a + IN6ADDRSZ - INADDRSZ, ha, INADDRSZ);
  2273. break;
  2274. # endif /* NETINET6 */
  2275. }
  2276. return -1;
  2277. }
  2278. /*
  2279. **  GETAUTHINFO -- get the real host name associated with a file descriptor
  2280. **
  2281. ** Uses RFC1413 protocol to try to get info from the other end.
  2282. **
  2283. ** Parameters:
  2284. ** fd -- the descriptor
  2285. ** may_be_forged -- an outage that is set to TRUE if the
  2286. ** forward lookup of RealHostName does not match
  2287. ** RealHostAddr; set to FALSE if they do match.
  2288. **
  2289. ** Returns:
  2290. ** The user@host information associated with this descriptor.
  2291. */
  2293. static jmp_buf CtxAuthTimeout;
  2295. static void
  2296. authtimeout()
  2297. {
  2298. longjmp(CtxAuthTimeout, 1);
  2299. }
  2301. char *
  2302. getauthinfo(fd, may_be_forged)
  2303. int fd;
  2304. bool *may_be_forged;
  2305. {
  2306. SOCKADDR_LEN_T falen;
  2307. register char *volatile p = NULL;
  2308. SOCKADDR la;
  2309. SOCKADDR_LEN_T lalen;
  2310. register struct servent *sp;
  2311. volatile int s;
  2312. int i = 0;
  2313. EVENT *ev;
  2314. int nleft;
  2315. struct hostent *hp;
  2316. char *ostype = NULL;
  2317. char **ha;
  2318. char ibuf[MAXNAME + 1];
  2319. static char hbuf[MAXNAME * 2 + 11];
  2321. *may_be_forged = FALSE;
  2322. falen = sizeof RealHostAddr;
  2323. if (isatty(fd) || (i = getpeername(fd, &RealHostAddr.sa, &falen)) < 0 ||
  2324.     falen <= 0 || RealHostAddr.sa.sa_family == 0)
  2325. {
  2326. if (i < 0 && errno != ENOTSOCK)
  2327. return NULL;
  2328. (void) snprintf(hbuf, sizeof hbuf, "%s@localhost",
  2329. RealUserName);
  2330. if (tTd(9, 1))
  2331. dprintf("getauthinfo: %sn", hbuf);
  2332. return hbuf;
  2333. }
  2335. if (RealHostName == NULL)
  2336. {
  2337. /* translate that to a host name */
  2338. RealHostName = newstr(hostnamebyanyaddr(&RealHostAddr));
  2339. if (strlen(RealHostName) > MAXNAME)
  2340. RealHostName[MAXNAME] = '';
  2341. }
  2343. /* cross check RealHostName with forward DNS lookup */
  2344. if (anynet_ntoa(&RealHostAddr)[0] == '[' ||
  2345.     RealHostName[0] == '[')
  2346. {
  2347. /*
  2348. **  address is not a socket or have an
  2349. **  IP address with no forward lookup
  2350. */
  2351. *may_be_forged = FALSE;
  2352. }
  2353. else
  2354. {
  2355. /* try to match the reverse against the forward lookup */
  2356. hp = sm_gethostbyname(RealHostName,
  2357.       RealHostAddr.sa.sa_family);
  2359. if (hp == NULL)
  2360. *may_be_forged = TRUE;
  2361. else
  2362. {
  2363. for (ha = hp->h_addr_list; *ha != NULL; ha++)
  2364. if (addrcmp(hp, *ha, &RealHostAddr) == 0)
  2365. break;
  2366. *may_be_forged = *ha == NULL;
  2367. }
  2368. }
  2370. if (TimeOuts.to_ident == 0)
  2371. goto noident;
  2373. lalen = sizeof la;
  2374. switch (RealHostAddr.sa.sa_family)
  2375. {
  2376. # if NETINET
  2377.   case AF_INET:
  2378. if (getsockname(fd, &la.sa, &lalen) < 0 ||
  2379.     lalen <= 0 ||
  2380.     la.sa.sa_family != AF_INET)
  2381. {
  2382. /* no ident info */
  2383. goto noident;
  2384. }
  2386. /* create ident query */
  2387. (void) snprintf(ibuf, sizeof ibuf, "%d,%drn",
  2388. ntohs(RealHostAddr.sin.sin_port),
  2389. ntohs(la.sin.sin_port));
  2391. /* create local address */
  2392. la.sin.sin_port = 0;
  2394. /* create foreign address */
  2395. #  ifdef NO_GETSERVBYNAME
  2396. RealHostAddr.sin.sin_port = htons(113);
  2397. #  else /* NO_GETSERVBYNAME */
  2398. sp = getservbyname("auth", "tcp");
  2399. if (sp != NULL)
  2400. RealHostAddr.sin.sin_port = sp->s_port;
  2401. else
  2402. RealHostAddr.sin.sin_port = htons(113);
  2403. break;
  2404. #  endif /* NO_GETSERVBYNAME */
  2405. # endif /* NETINET */
  2407. # if NETINET6
  2408.   case AF_INET6:
  2409. if (getsockname(fd, &la.sa, &lalen) < 0 ||
  2410.     lalen <= 0 ||
  2411.     la.sa.sa_family != AF_INET6)
  2412. {
  2413. /* no ident info */
  2414. goto noident;
  2415. }
  2417. /* create ident query */
  2418. (void) snprintf(ibuf, sizeof ibuf, "%d,%drn",
  2419. ntohs(RealHostAddr.sin6.sin6_port),
  2420. ntohs(la.sin6.sin6_port));
  2422. /* create local address */
  2423. la.sin6.sin6_port = 0;
  2425. /* create foreign address */
  2426. #  ifdef NO_GETSERVBYNAME
  2427. RealHostAddr.sin6.sin6_port = htons(113);
  2428. #  else /* NO_GETSERVBYNAME */
  2429. sp = getservbyname("auth", "tcp");
  2430. if (sp != NULL)
  2431. RealHostAddr.sin6.sin6_port = sp->s_port;
  2432. else
  2433. RealHostAddr.sin6.sin6_port = htons(113);
  2434. break;
  2435. #  endif /* NO_GETSERVBYNAME */
  2436. # endif /* NETINET6 */
  2437.   default:
  2438. /* no ident info */
  2439. goto noident;
  2440. }
  2442. s = -1;
  2443. if (setjmp(CtxAuthTimeout) != 0)
  2444. {
  2445. if (s >= 0)
  2446. (void) close(s);
  2447. goto noident;
  2448. }
  2450. /* put a timeout around the whole thing */
  2451. ev = setevent(TimeOuts.to_ident, authtimeout, 0);
  2453. /* connect to foreign IDENT server using same address as SMTP socket */
  2454. s = socket(la.sa.sa_family, SOCK_STREAM, 0);
  2455. if (s < 0)
  2456. {
  2457. clrevent(ev);
  2458. goto noident;
  2459. }
  2460. if (bind(s, &la.sa, lalen) < 0 ||
  2461.     connect(s, &RealHostAddr.sa, lalen) < 0)
  2462. {
  2463. goto closeident;
  2464. }
  2466. if (tTd(9, 10))
  2467. dprintf("getauthinfo: sent %s", ibuf);
  2469. /* send query */
  2470. if (write(s, ibuf, strlen(ibuf)) < 0)
  2471. goto closeident;
  2473. /* get result */
  2474. p = &ibuf[0];
  2475. nleft = sizeof ibuf - 1;
  2476. while ((i = read(s, p, nleft)) > 0)
  2477. {
  2478. p += i;
  2479. nleft -= i;
  2480. *p = '';
  2481. if (strchr(ibuf, 'n') != NULL)
  2482. break;
  2483. }
  2484. (void) close(s);
  2485. clrevent(ev);
  2486. if (i < 0 || p == &ibuf[0])
  2487. goto noident;
  2489. if (*--p == 'n' && *--p == 'r')
  2490. p--;
  2491. *++p = '';
  2493. if (tTd(9, 3))
  2494. dprintf("getauthinfo:  got %sn", ibuf);
  2496. /* parse result */
  2497. p = strchr(ibuf, ':');
  2498. if (p == NULL)
  2499. {
  2500. /* malformed response */
  2501. goto noident;
  2502. }
  2503. while (isascii(*++p) && isspace(*p))
  2504. continue;
  2505. if (strncasecmp(p, "userid", 6) != 0)
  2506. {
  2507. /* presumably an error string */
  2508. goto noident;
  2509. }
  2510. p += 6;
  2511. while (isascii(*p) && isspace(*p))
  2512. p++;
  2513. if (*p++ != ':')
  2514. {
  2515. /* either useridxx or malformed response */
  2516. goto noident;
  2517. }
  2519. /* p now points to the OSTYPE field */
  2520. while (isascii(*p) && isspace(*p))
  2521. p++;
  2522. ostype = p;
  2523. p = strchr(p, ':');
  2524. if (p == NULL)
  2525. {
  2526. /* malformed response */
  2527. goto noident;
  2528. }
  2529. else
  2530. {
  2531. char *charset;
  2533. *p = '';
  2534. charset = strchr(ostype, ',');
  2535. if (charset != NULL)
  2536. *charset = '';
  2537. }
  2539. /* 1413 says don't do this -- but it's broken otherwise */
  2540. while (isascii(*++p) && isspace(*p))
  2541. continue;
  2543. /* p now points to the authenticated name -- copy carefully */
  2544. if (strncasecmp(ostype, "other", 5) == 0 &&
  2545.     (ostype[5] == ' ' || ostype[5] == ''))
  2546. {
  2547. snprintf(hbuf, sizeof hbuf, "IDENT:");
  2548. cleanstrcpy(&hbuf[6], p, MAXNAME);
  2549. }
  2550. else
  2551. cleanstrcpy(hbuf, p, MAXNAME);
  2552. i = strlen(hbuf);
  2553. snprintf(&hbuf[i], sizeof hbuf - i, "@%s",
  2554.  RealHostName == NULL ? "localhost" : RealHostName);
  2555. goto postident;
  2557. closeident:
  2558. (void) close(s);
  2559. clrevent(ev);
  2561. noident:
  2562. if (RealHostName == NULL)
  2563. {
  2564. if (tTd(9, 1))
  2565. dprintf("getauthinfo: NULLn");
  2566. return NULL;
  2567. }
  2568. snprintf(hbuf, sizeof hbuf, "%s", RealHostName);
  2570. postident:
  2571. # if IP_SRCROUTE
  2572. #  ifndef GET_IPOPT_DST
  2573. #   define GET_IPOPT_DST(dst) (dst)
  2574. #  endif /* ! GET_IPOPT_DST */
  2575. /*
  2576. **  Extract IP source routing information.
  2577. **
  2578. ** Format of output for a connection from site a through b
  2579. ** through c to d:
  2580. ** loose:      @site-c@site-b:site-a
  2581. ** strict:    !@site-c@site-b:site-a
  2582. **
  2583. ** o - pointer within ipopt_list structure.
  2584. ** q - pointer within ls/ss rr route data
  2585. ** p - pointer to hbuf
  2586. */
  2588. if (RealHostAddr.sa.sa_family == AF_INET)
  2589. {
  2590. SOCKOPT_LEN_T ipoptlen;
  2591. int j;
  2592. u_char *q;
  2593. u_char *o;
  2594. int l;
  2595. struct IPOPTION ipopt;
  2597. ipoptlen = sizeof ipopt;
  2598. if (getsockopt(fd, IPPROTO_IP, IP_OPTIONS,
  2599.        (char *) &ipopt, &ipoptlen) < 0)
  2600. goto noipsr;
  2601. if (ipoptlen == 0)
  2602. goto noipsr;
  2603. o = (u_char *) ipopt.IP_LIST;
  2604. while (o != NULL && o < (u_char *) &ipopt + ipoptlen)
  2605. {
  2606. switch (*o)
  2607. {
  2608.   case IPOPT_EOL:
  2609. o = NULL;
  2610. break;
  2612.   case IPOPT_NOP:
  2613. o++;
  2614. break;
  2616.   case IPOPT_SSRR:
  2617.   case IPOPT_LSRR:
  2618. /*
  2619. **  Source routing.
  2620. ** o[0] is the option type (loose/strict).
  2621. ** o[1] is the length of this option,
  2622. ** including option type and
  2623. ** length.
  2624. ** o[2] is the pointer into the route
  2625. ** data.
  2626. ** o[3] begins the route data.
  2627. */
  2629. p = &hbuf[strlen(hbuf)];
  2630. l = sizeof hbuf - (hbuf - p) - 6;
  2631. snprintf(p, SPACELEFT(hbuf, p), " [%s@%.*s",
  2632.     *o == IPOPT_SSRR ? "!" : "",
  2633.     l > 240 ? 120 : l / 2,
  2634.     inet_ntoa(GET_IPOPT_DST(ipopt.IP_DST)));
  2635. i = strlen(p);
  2636. p += i;
  2637. l -= strlen(p);
  2639. j = o[1] / sizeof(struct in_addr) - 1;
  2641. /* q skips length and router pointer to data */
  2642. q = &o[3];
  2643. for ( ; j >= 0; j--)
  2644. {
  2645. struct in_addr addr;
  2647. memcpy(&addr, q, sizeof(addr));
  2648. snprintf(p, SPACELEFT(hbuf, p),
  2649.  "%c%.*s",
  2650.  j != 0 ? '@' : ':',
  2651.  l > 240 ? 120 :
  2652.  j == 0 ? l : l / 2,
  2653.  inet_ntoa(addr));
  2654. i = strlen(p);
  2655. p += i;
  2656. l -= i + 1;
  2657. q += sizeof(struct in_addr);
  2658. }
  2659. o += o[1];
  2660. break;
  2662.   default:
  2663. /* Skip over option */
  2664. o += o[1];
  2665. break;
  2666. }
  2667. }
  2668. snprintf(p, SPACELEFT(hbuf, p), "]");
  2669. goto postipsr;
  2670. }
  2672. noipsr:
  2673. # endif /* IP_SRCROUTE */
  2674. if (RealHostName != NULL && RealHostName[0] != '[')
  2675. {
  2676. p = &hbuf[strlen(hbuf)];
  2677. (void) snprintf(p, SPACELEFT(hbuf, p), " [%.100s]",
  2678. anynet_ntoa(&RealHostAddr));
  2679. }
  2680. if (*may_be_forged)
  2681. {
  2682. p = &hbuf[strlen(hbuf)];
  2683. (void) snprintf(p, SPACELEFT(hbuf, p), " (may be forged)");
  2684. }
  2686. # if IP_SRCROUTE
  2687. postipsr:
  2688. # endif /* IP_SRCROUTE */
  2689. if (tTd(9, 1))
  2690. dprintf("getauthinfo: %sn", hbuf);
  2691. return hbuf;
  2692. }
  2693. /*
  2694. **  HOST_MAP_LOOKUP -- turn a hostname into canonical form
  2695. **
  2696. ** Parameters:
  2697. ** map -- a pointer to this map.
  2698. ** name -- the (presumably unqualified) hostname.
  2699. ** av -- unused -- for compatibility with other mapping
  2700. ** functions.
  2701. ** statp -- an exit status (out parameter) -- set to
  2702. ** EX_TEMPFAIL if the name server is unavailable.
  2703. **
  2704. ** Returns:
  2705. ** The mapping, if found.
  2706. ** NULL if no mapping found.
  2707. **
  2708. ** Side Effects:
  2709. ** Looks up the host specified in hbuf.  If it is not
  2710. ** the canonical name for that host, return the canonical
  2711. ** name (unless MF_MATCHONLY is set, which will cause the
  2712. ** status only to be returned).
  2713. */
  2715. char *
  2716. host_map_lookup(map, name, av, statp)
  2717. MAP *map;
  2718. char *name;
  2719. char **av;
  2720. int *statp;
  2721. {
  2722. register struct hostent *hp;
  2723. # if NETINET
  2724. struct in_addr in_addr;
  2725. # endif /* NETINET */
  2726. # if NETINET6
  2727. struct in6_addr in6_addr;
  2728. # endif /* NETINET6 */
  2729. char *cp, *ans = NULL;
  2730. register STAB *s;
  2731. char hbuf[MAXNAME + 1];
  2733. /*
  2734. **  See if we have already looked up this name.  If so, just
  2735. **  return it.
  2736. */
  2738. s = stab(name, ST_NAMECANON, ST_ENTER);
  2739. if (bitset(NCF_VALID, s->s_namecanon.nc_flags))
  2740. {
  2741. if (tTd(9, 1))
  2742. dprintf("host_map_lookup(%s) => CACHE %sn",
  2743. name,
  2744. s->s_namecanon.nc_cname == NULL
  2745. ? "NULL"
  2746. : s->s_namecanon.nc_cname);
  2747. errno = s->s_namecanon.nc_errno;
  2748. # if NAMED_BIND
  2749. h_errno = s->s_namecanon.nc_herrno;
  2750. # endif /* NAMED_BIND */
  2751. *statp = s->s_namecanon.nc_stat;
  2752. if (*statp == EX_TEMPFAIL)
  2753. {
  2754. CurEnv->e_status = "4.4.3";
  2755. message("851 %s: Name server timeout",
  2756. shortenstring(name, 33));
  2757. }
  2758. if (*statp != EX_OK)
  2759. return NULL;
  2760. if (s->s_namecanon.nc_cname == NULL)
  2761. {
  2762. syserr("host_map_lookup(%s): bogus NULL cache entry, errno = %d, h_errno = %d",
  2763.        name,
  2764.        s->s_namecanon.nc_errno,
  2765.        s->s_namecanon.nc_herrno);
  2766. return NULL;
  2767. }
  2768. if (bitset(MF_MATCHONLY, map->map_mflags))
  2769. cp = map_rewrite(map, name, strlen(name), NULL);
  2770. else
  2771. cp = map_rewrite(map,
  2772.  s->s_namecanon.nc_cname,
  2773.  strlen(s->s_namecanon.nc_cname),
  2774.  av);
  2775. return cp;
  2776. }
  2778. /*
  2779. **  If we are running without a regular network connection (usually
  2780. **  dial-on-demand) and we are just queueing, we want to avoid DNS
  2781. **  lookups because those could try to connect to a server.
  2782. */
  2784. if (CurEnv->e_sendmode == SM_DEFER &&
  2785.     bitset(MF_DEFER, map->map_mflags))
  2786. {
  2787. if (tTd(9, 1))
  2788. dprintf("host_map_lookup(%s) => DEFERREDn", name);
  2789. *statp = EX_TEMPFAIL;
  2790. return NULL;
  2791. }
  2793. /*
  2794. **  If first character is a bracket, then it is an address
  2795. **  lookup.  Address is copied into a temporary buffer to
  2796. **  strip the brackets and to preserve name if address is
  2797. **  unknown.
  2798. */
  2800. if (tTd(9, 1))
  2801. dprintf("host_map_lookup(%s) => ", name);
  2802. if (*name != '[')
  2803. {
  2804. snprintf(hbuf, sizeof hbuf, "%s", name);
  2805. if (getcanonname(hbuf, sizeof hbuf - 1, !HasWildcardMX))
  2806. ans = hbuf;
  2807. }
  2808. else
  2809. {
  2810. if ((cp = strchr(name, ']')) == NULL)
  2811. return NULL;
  2812. *cp = '';
  2814. hp = NULL;
  2815. # if NETINET
  2816. if ((in_addr.s_addr = inet_addr(&name[1])) != INADDR_NONE)
  2817. hp = sm_gethostbyaddr((char *)&in_addr,
  2818.       INADDRSZ, AF_INET);
  2819. # endif /* NETINET */
  2820. # if NETINET6
  2821. if (hp == NULL &&
  2822.     inet_pton(AF_INET6, &name[1], &in6_addr) == 1)
  2823. hp = sm_gethostbyaddr((char *)&in6_addr,
  2824.       IN6ADDRSZ, AF_INET6);
  2825. # endif /* NETINET6 */
  2826. *cp = ']';
  2828. if (hp != NULL)
  2829. {
  2830. /* found a match -- copy out */
  2831. ans = denlstring((char *) hp->h_name, TRUE, TRUE);
  2832. }
  2833. }
  2835. s->s_namecanon.nc_flags |= NCF_VALID; /* will be soon */
  2837. /* Found an answer */
  2838. if (ans != NULL)
  2839. {
  2840. s->s_namecanon.nc_stat = *statp = EX_OK;
  2841. s->s_namecanon.nc_cname = newstr(ans);
  2842. if (bitset(MF_MATCHONLY, map->map_mflags))
  2843. cp = map_rewrite(map, name, strlen(name), NULL);
  2844. else
  2845. cp = map_rewrite(map, ans, strlen(ans), av);
  2846. return cp;
  2847. }
  2850. /* No match found */
  2851. s->s_namecanon.nc_errno = errno;
  2852. # if NAMED_BIND
  2853. s->s_namecanon.nc_herrno = h_errno;
  2854. if (tTd(9, 1))
  2855. dprintf("FAIL (%d)n", h_errno);
  2856. switch (h_errno)
  2857. {
  2858.   case TRY_AGAIN:
  2859. if (UseNameServer)
  2860. {
  2861. CurEnv->e_status = "4.4.3";
  2862. message("851 %s: Name server timeout",
  2863. shortenstring(name, 33));
  2864. }
  2865. *statp = EX_TEMPFAIL;
  2866. break;
  2868.   case HOST_NOT_FOUND:
  2869.   case NO_DATA:
  2870. *statp = EX_NOHOST;
  2871. break;
  2873.   case NO_RECOVERY:
  2874. *statp = EX_SOFTWARE;
  2875. break;
  2877.   default:
  2878. *statp = EX_UNAVAILABLE;
  2879. break;
  2880. }
  2881. # else /* NAMED_BIND */
  2882. if (tTd(9, 1))
  2883. dprintf("FAILn");
  2884. *statp = EX_NOHOST;
  2885. # endif /* NAMED_BIND */
  2886. s->s_namecanon.nc_stat = *statp;
  2887. return NULL;
  2888. }
  2889. #else /* DAEMON */
  2890. /* code for systems without sophisticated networking */
  2892. /*
  2893. **  MYHOSTNAME -- stub version for case of no daemon code.
  2894. **
  2895. ** Can't convert to upper case here because might be a UUCP name.
  2896. **
  2897. ** Mark, you can change this to be anything you want......
  2898. */
  2900. char **
  2901. myhostname(hostbuf, size)
  2902. char hostbuf[];
  2903. int size;
  2904. {
  2905. register FILE *f;
  2907. hostbuf[0] = '';
  2908. f = fopen("/usr/include/whoami", "r");
  2909. if (f != NULL)
  2910. {
  2911. (void) fgets(hostbuf, size, f);
  2912. fixcrlf(hostbuf, TRUE);
  2913. (void) fclose(f);
  2914. }
  2915. return NULL;
  2916. }
  2917. /*
  2918. **  GETAUTHINFO -- get the real host name associated with a file descriptor
  2919. **
  2920. ** Parameters:
  2921. ** fd -- the descriptor
  2922. ** may_be_forged -- an outage that is set to TRUE if the
  2923. ** forward lookup of RealHostName does not match
  2924. ** RealHostAddr; set to FALSE if they do match.
  2925. **
  2926. ** Returns:
  2927. ** The host name associated with this descriptor, if it can
  2928. ** be determined.
  2929. ** NULL otherwise.
  2930. **
  2931. ** Side Effects:
  2932. ** none
  2933. */
  2935. char *
  2936. getauthinfo(fd, may_be_forged)
  2937. int fd;
  2938. bool *may_be_forged;
  2939. {
  2940. *may_be_forged = FALSE;
  2941. return NULL;
  2942. }
  2943. /*
  2944. **  HOST_MAP_LOOKUP -- turn a hostname into canonical form
  2945. **
  2946. ** Parameters:
  2947. ** map -- a pointer to the database map.
  2948. ** name -- a buffer containing a hostname.
  2949. ** avp -- a pointer to a (cf file defined) argument vector.
  2950. ** statp -- an exit status (out parameter).
  2951. **
  2952. ** Returns:
  2953. ** mapped host name
  2954. ** FALSE otherwise.
  2955. **
  2956. ** Side Effects:
  2957. ** Looks up the host specified in name.  If it is not
  2958. ** the canonical name for that host, replace it with
  2959. ** the canonical name.  If the name is unknown, or it
  2960. ** is already the canonical name, leave it unchanged.
  2961. */
  2963. /*ARGSUSED*/
  2964. char *
  2965. host_map_lookup(map, name, avp, statp)
  2966. MAP *map;
  2967. char *name;
  2968. char **avp;
  2969. char *statp;
  2970. {
  2971. register struct hostent *hp = NULL;
  2972. char *cp;
  2974. # if NETINET6
  2975. hp = sm_gethostbyname(name, AF_INET6);
  2976. # endif /* NETINET6 */
  2977. if (hp == NULL)
  2978. hp = sm_gethostbyname(name, AF_INET);
  2979. if (hp == NULL)
  2980. {
  2981. # if NAMED_BIND
  2982. if (tTd(9, 1))
  2983. dprintf("FAIL (%d)n", h_errno);
  2984. switch (h_errno)
  2985. {
  2986.   case TRY_AGAIN:
  2987. if (UseNameServer)
  2988. {
  2989. CurEnv->e_status = "4.4.3";
  2990. message("851 %s: Name server timeout",
  2991. shortenstring(name, 33));
  2992. }
  2993. *statp = EX_TEMPFAIL;
  2994. break;
  2996.   case HOST_NOT_FOUND:
  2997.   case NO_DATA:
  2998. *statp = EX_NOHOST;
  2999. break;
  3001.   case NO_RECOVERY:
  3002. *statp = EX_SOFTWARE;
  3003. break;
  3005.   default:
  3006. *statp = EX_UNAVAILABLE;
  3007. break;
  3008. }
  3009. #else /* NAMED_BIND */
  3010. *statp = EX_NOHOST;
  3011. #endif /* NAMED_BIND */
  3012. return NULL;
  3013. }
  3014. if (bitset(MF_MATCHONLY, map->map_mflags))
  3015. cp = map_rewrite(map, name, strlen(name), NULL);
  3016. else
  3017. cp = map_rewrite(map, hp->h_name, strlen(hp->h_name), avp);
  3018. return cp;
  3019. }
  3021. #endif /* DAEMON */
  3022. /*
  3023. **  HOST_MAP_INIT -- initialize host class structures
  3024. */
  3026. bool
  3027. host_map_init(map, args)
  3028. MAP *map;
  3029. char *args;
  3030. {
  3031. register char *p = args;
  3033. for (;;)
  3034. {
  3035. while (isascii(*p) && isspace(*p))
  3036. p++;
  3037. if (*p != '-')
  3038. break;
  3039. switch (*++p)
  3040. {
  3041.   case 'a':
  3042. map->map_app = ++p;
  3043. break;
  3045.   case 'T':
  3046. map->map_tapp = ++p;
  3047. break;
  3049.   case 'm':
  3050. map->map_mflags |= MF_MATCHONLY;
  3051. break;
  3053.   case 't':
  3054. map->map_mflags |= MF_NODEFER;
  3055. break;
  3057.   case 'S': /* only for consistency */
  3058. map->map_spacesub = *++p;
  3059. break;
  3061.   case 'D':
  3062. map->map_mflags |= MF_DEFER;
  3063. break;
  3064. }
  3065. while (*p != '' && !(isascii(*p) && isspace(*p)))
  3066. p++;
  3067. if (*p != '')
  3068. *p++ = '';
  3069. }
  3070. if (map->map_app != NULL)
  3071. map->map_app = newstr(map->map_app);
  3072. if (map->map_tapp != NULL)
  3073. map->map_tapp = newstr(map->map_tapp);
  3074. return TRUE;
  3075. }
  3077. #if NETINET6
  3078. /*
  3079. **  ANYNET_NTOP -- convert an IPv6 network address to printable form.
  3080. **
  3081. ** Parameters:
  3082. ** s6a -- a pointer to an in6_addr structure.
  3083. ** dst -- buffer to store result in
  3084. ** dst_len -- size of dst buffer
  3085. **
  3086. ** Returns:
  3087. ** A printable version of that structure.
  3088. */
  3089. char *
  3090. anynet_ntop(s6a, dst, dst_len)
  3091. struct in6_addr *s6a;
  3092. char *dst;
  3093. size_t dst_len;
  3094. {
  3095. register char *ap;
  3097. if (IN6_IS_ADDR_V4MAPPED(s6a))
  3098. ap = (char *) inet_ntop(AF_INET,
  3099. &s6a->s6_addr[IN6ADDRSZ - INADDRSZ],
  3100. dst, dst_len);
  3101. else
  3102. ap = (char *) inet_ntop(AF_INET6, s6a, dst, dst_len);
  3103. return ap;
  3104. }
  3105. #endif /* NETINET6 */
  3106. /*
  3107. **  ANYNET_NTOA -- convert a network address to printable form.
  3108. **
  3109. ** Parameters:
  3110. ** sap -- a pointer to a sockaddr structure.
  3111. **
  3112. ** Returns:
  3113. ** A printable version of that sockaddr.
  3114. */
  3116. #ifdef USE_SOCK_STREAM
  3118. # if NETLINK
  3119. #  include <net/if_dl.h>
  3120. # endif /* NETLINK */
  3122. char *
  3123. anynet_ntoa(sap)
  3124. register SOCKADDR *sap;
  3125. {
  3126. register char *bp;
  3127. register char *ap;
  3128. int l;
  3129. static char buf[100];
  3131. /* check for null/zero family */
  3132. if (sap == NULL)
  3133. return "NULLADDR";
  3134. if (sap->sa.sa_family == 0)
  3135. return "0";
  3137. switch (sap->sa.sa_family)
  3138. {
  3139. # if NETUNIX
  3140.   case AF_UNIX:
  3141. if (sap->sunix.sun_path[0] != '')
  3142. snprintf(buf, sizeof buf, "[UNIX: %.64s]",
  3143. sap->sunix.sun_path);
  3144. else
  3145. snprintf(buf, sizeof buf, "[UNIX: localhost]");
  3146. return buf;
  3147. # endif /* NETUNIX */
  3149. # if NETINET
  3150.   case AF_INET:
  3151. return (char *) inet_ntoa(sap->sin.sin_addr);
  3152. # endif /* NETINET */
  3154. # if NETINET6
  3155.   case AF_INET6:
  3156. ap = anynet_ntop(&sap->sin6.sin6_addr, buf, sizeof buf);
  3157. if (ap != NULL)
  3158. return ap;
  3159. break;
  3160. # endif /* NETINET6 */
  3162. # if NETLINK
  3163.   case AF_LINK:
  3164. snprintf(buf, sizeof buf, "[LINK: %s]",
  3165. link_ntoa((struct sockaddr_dl *) &sap->sa));
  3166. return buf;
  3167. # endif /* NETLINK */
  3168.   default:
  3169. /* this case is needed when nothing is #defined */
  3170. /* in order to keep the switch syntactically correct */
  3171. break;
  3172. }
  3174. /* unknown family -- just dump bytes */
  3175. (void) snprintf(buf, sizeof buf, "Family %d: ", sap->sa.sa_family);
  3176. bp = &buf[strlen(buf)];
  3177. ap = sap->sa.sa_data;
  3178. for (l = sizeof sap->sa.sa_data; --l >= 0; )
  3179. {
  3180. (void) snprintf(bp, SPACELEFT(buf, bp), "%02x:", *ap++ & 0377);
  3181. bp += 3;
  3182. }
  3183. *--bp = '';
  3184. return buf;
  3185. }
  3186. /*
  3187. **  HOSTNAMEBYANYADDR -- return name of host based on address
  3188. **
  3189. ** Parameters:
  3190. ** sap -- SOCKADDR pointer
  3191. **
  3192. ** Returns:
  3193. ** text representation of host name.
  3194. **
  3195. ** Side Effects:
  3196. ** none.
  3197. */
  3199. char *
  3200. hostnamebyanyaddr(sap)
  3201. register SOCKADDR *sap;
  3202. {
  3203. register struct hostent *hp;
  3204. # if NAMED_BIND
  3205. int saveretry;
  3206. # endif /* NAMED_BIND */
  3207. # if NETINET6
  3208. struct in6_addr in6_addr;
  3209. # endif /* NETINET6 */
  3211. # if NAMED_BIND
  3212. /* shorten name server timeout to avoid higher level timeouts */
  3213. saveretry = _res.retry;
  3214. if (_res.retry * _res.retrans > 20)
  3215. _res.retry = 20 / _res.retrans;
  3216. # endif /* NAMED_BIND */
  3218. switch (sap->sa.sa_family)
  3219. {
  3220. # if NETINET
  3221.   case AF_INET:
  3222. hp = sm_gethostbyaddr((char *) &sap->sin.sin_addr,
  3223. INADDRSZ,
  3224. AF_INET);
  3225. break;
  3226. # endif /* NETINET */
  3228. # if NETINET6
  3229.   case AF_INET6:
  3230. hp = sm_gethostbyaddr((char *) &sap->sin6.sin6_addr,
  3231.       IN6ADDRSZ,
  3232.       AF_INET6);
  3233. break;
  3234. # endif /* NETINET6 */
  3236. # if NETISO
  3237.   case AF_ISO:
  3238. hp = sm_gethostbyaddr((char *) &sap->siso.siso_addr,
  3239. sizeof sap->siso.siso_addr,
  3240. AF_ISO);
  3241. break;
  3242. # endif /* NETISO */
  3244. # if NETUNIX
  3245.   case AF_UNIX:
  3246. hp = NULL;
  3247. break;
  3248. # endif /* NETUNIX */
  3250.   default:
  3251. hp = sm_gethostbyaddr(sap->sa.sa_data,
  3252.    sizeof sap->sa.sa_data,
  3253.    sap->sa.sa_family);
  3254. break;
  3255. }
  3257. # if NAMED_BIND
  3258. _res.retry = saveretry;
  3259. # endif /* NAMED_BIND */
  3261. # if NETINET || NETINET6
  3262. if (hp != NULL && hp->h_name[0] != '['
  3263. #  if NETINET6
  3264.     && inet_pton(AF_INET6, hp->h_name, &in6_addr) != 1
  3265. #  endif /* NETINET6 */
  3266. #  if NETINET
  3267.     && inet_addr(hp->h_name) == INADDR_NONE
  3268. #  endif /* NETINET */
  3269.     )
  3270. return denlstring((char *) hp->h_name, TRUE, TRUE);
  3271. # endif /* NETINET || NETINET6 */
  3272. # if NETUNIX
  3273. if (sap->sa.sa_family == AF_UNIX && sap->sunix.sun_path[0] == '')
  3274. return "localhost";
  3275. # endif /* NETUNIX */
  3276. {
  3277. static char buf[203];
  3279. (void) snprintf(buf, sizeof buf, "[%.200s]", anynet_ntoa(sap));
  3280. return buf;
  3281. }
  3282. }
  3283. #endif /* USE_SOCK_STREAM */