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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
InetFaxServer.c++
资源名称：hylafax-5.3.0.tar.gz　[点击查看]
上传用户：weiyuanprp
上传日期：2020-05-20
资源大小：1169k
文件大小：19k
源码类别：

传真(Fax)编程

开发平台：

C/C++

InetFaxServer.c++：源码内容
  1. /* $Id: InetFaxServer.c++,v 1.8 2009/09/08 00:24:46 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1995-1996 Sam Leffler
  4.  * Copyright (c) 1995-1996 Silicon Graphics, Inc.
  5.  * HylaFAX is a trademark of Silicon Graphics
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  26. #include "port.h"
  27. #include "Dispatcher.h"
  28. #include "InetFaxServer.h"
  29. #include "Sys.h"
  30. #include "Socket.h"
  31. #include "config.h"
  33. #include <string.h>
  34. #include <netdb.h>
  35. #include <ctype.h>
  37. extern "C" {
  38. #include <arpa/inet.h>
  40. #include <netinet/in_systm.h>
  41. #include <netinet/ip.h>
  42. }
  44. InetSuperServer::InetSuperServer(const char* p, int bl)
  45.     : SuperServer("INET", bl)
  46.     , port(p)
  47. {
  48.     bindaddress = NULL;
  49. }
  51. InetSuperServer::~InetSuperServer() {}
  53. void
  54. InetSuperServer::setBindAddress(const char *bindaddr)
  55. {
  56.     bindaddress = bindaddr;
  57. }
  59. void
  60. InetSuperServer::setAddressFamily(const char *addrfamily)
  61. {
  62.     addressfamily = addrfamily;
  63. }
  65. bool
  66. InetSuperServer::startServer(void)
  67. {
  68.     Socket::Address addr;
  69.     struct addrinfo hints, *ai;
  70.     memset(&hints, 0, sizeof(hints));
  72.     /*
  73.      * Most BSDs seem to have some complications when using IPv6.  Since
  74.      * most users will not be using IPv6 the default is then IPv4-only.
  75.      */
  76.     hints.ai_family = AF_INET; // default
  77.     if (addressfamily) {
  78. if (strncmp(addressfamily, "IPv6", 4) == 0) hints.ai_family = AF_INET6;
  79. else if (strncmp(addressfamily, "IPv4", 4) == 0) hints.ai_family = AF_INET;
  80. else if (strncmp(addressfamily, "all", 3) == 0) hints.ai_family = AF_UNSPEC;
  81.     }
  83.     hints.ai_flags = AI_PASSIVE;
  84. #ifdef AI_ADDRCONFIG
  85.     hints.ai_flags |= AI_ADDRCONFIG;
  86. #endif
  87.     hints.ai_socktype = SOCK_STREAM;
  89.     struct protoent* pp = getprotobyname(FAX_PROTONAME);
  90.     if (pp)
  91. hints.ai_protocol = pp->p_proto;
  93.     if (getaddrinfo(bindaddress, port, &hints, &ai) == 0)  {
  94. memcpy(&addr, ai->ai_addr, ai->ai_addrlen);
  95. freeaddrinfo(ai);
  96.     } else {
  97. logDebug("Couldn't get address information for port "%s"",
  98. (const char*) port);
  99. /*
  100.  * Somethings broken here, let's pick some conservative defaults
  101.  */
  102. memset(&addr, 0, sizeof(addr));
  103. Socket::family(addr) = AF_INET;
  104. addr.in.sin_port = htons(FAX_DEFPORT);
  105.     }
  107.     int s = socket(Socket::family(addr), SOCK_STREAM, 0);
  108.     if (s >= 0) {
  109. int on = 1;
  110. if (Socket::setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) >= 0) {
  111.     if (Socket::bind(s, &addr, Socket::socklen(addr)) >= 0) {
  112. (void) listen(s, getBacklog());
  113. Dispatcher::instance().link(s, Dispatcher::ReadMask, this);
  114. return (true); // success
  115.     }
  116. }
  117. Sys::close(s);
  118. logError("HylaFAX %s: bind (port %u): %m",
  119.     getKind(), ntohs(Socket::port(addr)));
  120.     } else
  121. logError("HylaFAX %s: socket: %m", getKind());
  122.     return (false);
  123. }
  124. HylaFAXServer* InetSuperServer::newChild(void) { return new InetFaxServer; }
  126. InetFaxServer* InetFaxServer::_instance = NULL;
  128. InetFaxServer::InetFaxServer()
  129. {
  130.     usedefault = true;
  131.     swaitmax = 90; // wait at most 90 seconds
  132.     swaitint = 5; // interval between retries
  134.     memset(&data_dest, 0, sizeof (data_dest));
  135.     Socket::family(data_dest) = AF_INET6; // We'll allow AF_INET6 by default.
  137.     hostent* hp = Socket::gethostbyname(hostname);
  139.     if (hp != NULL)
  140.     {
  141. hostname = hp->h_name;
  142.         struct in_addr in;
  143.         memcpy(&in, hp->h_addr, sizeof (in));
  144.         hostaddr = inet_ntoa(in);
  145.     }
  147.     fxAssert(_instance == NULL,
  148. "Cannot create multiple InetFaxServer instances");
  149.     _instance = this;
  150. }
  151. InetFaxServer::~InetFaxServer() {}
  153. InetFaxServer& InetFaxServer::instance() { return *_instance; }
  155. void
  156. InetFaxServer::initServer(void)
  157. {
  158.     HylaFAXServer::initServer();
  159.     usedefault = true;
  160. }
  162. void
  163. InetFaxServer::open(void)
  164. {
  165.     setupNetwork(STDIN_FILENO);
  166.     HylaFAXServer::open();
  167.     if (TRACE(CONNECT))
  168.         logInfo("HylaFAX INET connection from %s [%s]",
  169.     (const char*) remotehost, (const char*) remoteaddr);
  170. }
  172. static const char*
  173. topDomain(const fxStr& h)
  174. {
  175.     int dots = 0;
  176.     u_int l = h.length();
  178.     if(l <= 0) return(NULL);  // out early
  180.     for (;;) {
  181. l = h.nextR(l, '.');
  182. if (l == 0)
  183.     return (&h[0]);  // return whole string
  184. if (++dots == 2)
  185.     return (&h[l]);
  186. l -=1;    //back over the dot
  187.     }
  188. }
  190. /*
  191.  * Check whether host h is in our local domain,
  192.  * defined as sharing the last two components of the domain part,
  193.  * or the entire domain part if the local domain has only one component.
  194.  * If either name is unqualified (contains no '.'),
  195.  * assume that the host is local, as it will be
  196.  * interpreted as such.
  197.  */
  198. bool
  199. InetFaxServer::isLocalDomain(const fxStr& h)
  200. {
  201.     const char* p1 = topDomain(hostname);
  202.     const char* p2 = topDomain(h);
  203.     return (p1 == NULL || p2 == NULL || strcasecmp(p1, p2) == 0);
  204. }
  206. /*
  207.  * Check host identity returned by getnameinfo to
  208.  * weed out clients trying to spoof us (this is mostly
  209.  * a sanity check; if they have full control of DNS
  210.  * they can still spoof)
  211.  * Look up the name and check that the peer's address
  212.  * corresponds to the host name.
  213.  */
  214. bool
  215. InetFaxServer::checkHostIdentity(const char*name)
  216. {
  218.     struct addrinfo hints, *ai;
  220.     memset(&hints, 0, sizeof(hints));
  221.     hints.ai_flags = AI_CANONNAME;
  222.     hints.ai_socktype = SOCK_STREAM;
  224.     if (getaddrinfo(name, NULL, &hints, &ai) == 0) {
  225. for (struct addrinfo *aip = ai; aip != NULL; aip = aip->ai_next) {
  226.     Socket::Address *addr = (Socket::Address*)aip->ai_addr;
  227.     if (aip->ai_family != Socket::family(peer_addr))
  228. continue;
  229.     if ( (aip->ai_family == AF_INET6 &&
  230.      memcmp(&addr->in6.sin6_addr, &peer_addr.in6.sin6_addr, sizeof(struct in6_addr)) ==0)
  231.  ||(aip->ai_family == AF_INET &&
  232.      memcmp(&addr->in.sin_addr, &peer_addr.in.sin_addr, sizeof(struct in_addr)) ==0)
  233.        ) {
  234. freeaddrinfo(ai);
  235. return true;
  236.     }
  237. }
  238. reply(130, "Warning, client address "%s" is not listed for host name "%s".",
  239.     (const char*) remoteaddr, name);
  240. freeaddrinfo(ai);
  241.     } else
  242. reply(130, "Warning, no inverse address mapping for client host name "%s".",
  243.     (const char*) name);
  244.     return (false);
  245. }
  247. void
  248. InetFaxServer::setupNetwork(int fd)
  249. {
  250.     socklen_t addrlen;
  252.     addrlen = sizeof (peer_addr);
  253.     if (Socket::getpeername(fd, &peer_addr, &addrlen) < 0) {
  254.         logError("getpeername: %m (incorrect hfaxd invocation?)");
  255.         dologout(-1);
  256.     }
  257.     addrlen = sizeof (ctrl_addr);
  258.     if (Socket::getsockname(fd, &ctrl_addr, &addrlen) < 0) {
  259.         logError("getsockname: %m");
  260.         dologout(-1);
  261.     }
  262. #if defined(IPTOS_LOWDELAY)
  263.     { int tos = IPTOS_LOWDELAY;
  264.       if (Socket::setsockopt(fd, IPPROTO_IP, IP_TOS, &tos, sizeof (tos)) < 0)
  265.           logWarning("setsockopt (IP_TOS): %m");
  266.     }
  267. #endif
  268. #if defined(SO_LINGER) && !defined(__linux__)
  269.     { struct linger opt;
  270.       opt.l_onoff = 1;
  271.       opt.l_linger = 60;
  272.       if (Socket::setsockopt(fd, SOL_SOCKET, SO_LINGER, &opt, sizeof (opt)) < 0)
  273. logWarning("setsockopt (SO_LINGER): %m");
  274.     }
  275. #endif
  276.     /* anchor socket to avoid multi-homing problems */
  277.     data_source = ctrl_addr;
  278.     Socket::port(data_source) = htons(ntohs(Socket::port(ctrl_addr)-1));
  279. #ifdef  F_SETOWN
  280.     if (fcntl(fd, F_SETOWN, getpid()) == -1)
  281.         logError("fcntl (F_SETOWN): %m");
  282. #endif
  283. #if defined(SO_OOBINLINE)
  284.     /* handle urgent data inline */
  285.     { int on = 1;
  286.       if (Socket::setsockopt(fd, SOL_SOCKET, SO_OOBINLINE, &on, sizeof (on)) < 0)
  287.         logError("setsockopt (SO_OOBINLINE): %m");
  288.     }
  289. #endif
  290. #ifdef SIGURG
  291.     /*
  292.      * XXX This is #ifdef'd for ISC but indicates a problem
  293.      * XXX in the underlying system.  Without support for
  294.      * XXX urgent data clients will not be able to abort an
  295.      * XXX ongoing operation such as a file transfer.
  296.      */
  297.     signal(SIGURG, fxSIGHANDLER(sigURG));
  298. #endif
  299.     signal(SIGPIPE, fxSIGHANDLER(sigPIPE));
  301.     char hostbuf[128];
  303.     remoteaddr = inet_ntop(Socket::family(peer_addr), Socket::addr(peer_addr), hostbuf, sizeof(hostbuf));
  305.     getnameinfo((struct sockaddr*)&peer_addr, Socket::socklen(peer_addr),
  306.     hostbuf, sizeof(hostbuf), NULL, 0, 0);
  308.     if (remoteaddr == "0.0.0.0")
  309.         remotehost = "localhost";
  310.     else if (checkHostIdentity(hostbuf))
  311. remotehost = hostbuf;
  312.     else
  313. remotehost =  remoteaddr;
  314.     Dispatcher::instance().link(STDIN_FILENO, Dispatcher::ReadMask, this);
  315. }
  317. void
  318. InetFaxServer::handleUrgentData(void)
  319. {
  320.     /*
  321.      * Only process the urgent data is we are expecting it.
  322.      * Specifically, if a file transfer, synchronous job
  323.      * wait, or other potentially long-running operation is
  324.      * taking place we do a setjmp and set a flag so that
  325.      * if the client requests an abort operation (ABOR) then
  326.      * we longjmp below to break out of the op.
  327.      */
  328.     if ((state & (S_TRANSFER|S_WAITTRIG)) == 0) {
  329. if (IS(WAITFIFO)) {
  330.     fifoResponse = "User aborted operation";
  331.     state &= ~S_WAITFIFO;
  332. }
  333.         return;
  334.     }
  335.     char line[8];
  336.     if (!getCmdLine(line, sizeof (line))) {
  337.         reply(221, "You could at least say goodbye.");
  338.         dologout(0);
  339.     } else if (strcasecmp(line, "ABORn") == 0) {
  340. /*
  341.  * Abort the operation in progress.  Two reply
  342.  * codes are sent on the control channel; one
  343.  * for the outstanding operation and one for the
  344.  * abort command.
  345.  */
  346.         reply(426, "Operation aborted. Data connection closed.");
  347.         reply(226, "Abort successful");
  348.         longjmp(urgcatch, 1); // XXX potential memory leak
  349.     } else if (strcasecmp(line, "STATn") == 0) {
  350.         if (file_size != (off_t) -1)
  351.             reply(213, "Status: %lu of %lu bytes transferred",
  352.                   byte_count, file_size);
  353.         else
  354.             reply(213, "Status: %lu bytes transferred", byte_count);
  355.     } else
  356. pushCmdData(line, strlen(line));
  357. }
  359. void
  360. InetFaxServer::sigURG(int)
  361. {
  362.     int old_errno = errno;
  363.     InetFaxServer::instance().handleUrgentData();
  364.     errno = old_errno;
  365. }
  367. void
  368. InetFaxServer::lostConnection(void)
  369. {
  370.     if (TRACE(PROTOCOL))
  371.         logDebug("Lost connection to %s [%s]",
  372.     (const char*) remotehost, (const char*) remoteaddr);
  373.     dologout(-1);
  374. }
  376. void
  377. InetFaxServer::sigPIPE(int)
  378. {
  379.     int old_errno = errno;
  380.     InetFaxServer::instance().lostConnection();
  381.     errno = old_errno;
  382. }
  384. static bool
  385. setupPassiveDataSocket(int pdata, Socket::Address& pasv_addr)
  386. {
  387.     socklen_t len = Socket::socklen(pasv_addr);
  388.     return (
  389. Socket::bind(pdata, (struct sockaddr*)&pasv_addr, len) >= 0 &&
  390.         Socket::getsockname(pdata, (struct sockaddr*)&pasv_addr, &len) >= 0 &&
  391. listen(pdata, 1) >= 0
  392.     );
  393. }
  395. #define UC(b) (((int) b) & 0xff)
  397. /*
  398.  * Note: a response of 425 is not mentioned as a possible response to the
  399.  * PASV command in RFC959. However, it has been blessed as a legitimate
  400.  * response by Jon Postel in a telephone conversation with Rick Adams on 25
  401.  * Jan 89.
  402.  */
  403. void
  404. InetFaxServer::passiveCmd(void)
  405. {
  406.     if (tokenBody[0] == 'E') {
  407. pasv_addr = ctrl_addr;
  408. logDebug("Extended passive requested for family %d", Socket::family(pasv_addr));
  409. pdata = socket(Socket::family(pasv_addr), SOCK_STREAM, 0);
  410. if (pdata >= 0) {
  411.     Socket::port(pasv_addr) = 0;
  412.     if (!setupPassiveDataSocket(pdata, pasv_addr))
  413. (void) Sys::close(pdata), pdata = -1;
  414. }
  415. if (pdata >= 0) {
  416.     reply(229, "Entering Extended Passive Mode (|||%u|)",
  417.     ntohs(Socket::port(pasv_addr)));
  418. } else
  419.     perror_reply(425, "Cannot setup extended passive connection", errno);
  420. return;
  421.     }
  422.     if (Socket::family(ctrl_addr) != AF_INET) {
  423. reply(500, "Cannot use PASV with IPv6 connections");
  424. return;
  425.     }
  426.     if (pdata < 0) {
  427. pdata = socket(AF_INET, SOCK_STREAM, 0);
  428. if (pdata >= 0) {
  429.     pasv_addr = ctrl_addr;
  430.     pasv_addr.in.sin_port = 0;
  431.     if (!setupPassiveDataSocket(pdata, pasv_addr))
  432. (void) Sys::close(pdata), pdata = -1;
  433. }
  434.     }
  435.     if (pdata >= 0) {
  436. const u_char* a = (const u_char*) &pasv_addr.in.sin_addr;
  437. const u_char* p = (const u_char*) &pasv_addr.in.sin_port;
  438. reply(227, "Entering passive mode (%d,%d,%d,%d,%d,%d)", UC(a[0]),
  439.       UC(a[1]), UC(a[2]), UC(a[3]), UC(p[0]), UC(p[1]));
  440.     } else
  441. perror_reply(425, "Cannot setup passive connection", errno);
  442. }
  444. void
  445. InetFaxServer::printaddr(FILE* fd, const char* leader, const struct sockaddr_in& sin)
  446. {
  447.     const u_char* a = (const u_char *) &sin.sin_addr;
  448.     const u_char* p = (const u_char *) &sin.sin_port;
  449.     fprintf(fd, "%s (%d,%d,%d,%d,%d,%d)rn", leader,
  450.        UC(a[0]), UC(a[1]), UC(a[2]), UC(a[3]), UC(p[0]), UC(p[1]));
  451. }
  453. void
  454. InetFaxServer::netStatus(FILE* fd)
  455. {
  456.     if (data != -1)
  457.         fprintf(fd, "    Client data connection openrn");
  458.     else if (pdata != -1)
  459.         printaddr(fd, "    In passive mode", pasv_addr);
  460.     else if (!usedefault)
  461.         printaddr(fd, "    PORT", data_dest);
  462.     else
  463.         fprintf(fd, "    No client data connectionrn");
  464. }
  466. /*
  467.  * Creat a socket for a data transfer.
  468.  */
  469. FILE*
  470. InetFaxServer::getDataSocket(const char* mode)
  471. {
  472.     if (data >= 0)
  473.         return (fdopen(data, mode));
  474.     int s = socket(Socket::family(data_dest), SOCK_STREAM, 0);
  475.     if (s < 0)
  476.         goto bad;
  477.     { int on = 1;
  478.       if (Socket::setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
  479.         goto bad;
  480.     }
  481.     { int ntry; // XXX for __GNUC__
  482.       for (ntry = 1;; ntry++) {
  483.         if (Socket::bind(s, &data_source, Socket::socklen(data_source)) >= 0)
  484.             break;
  485.         if (errno != EADDRINUSE || ntry > 10)
  486.             goto bad;
  487.         sleep(ntry);
  488.       }
  489.     }
  490. #ifdef IPTOS_THROUGHPUT
  491.     { int on = IPTOS_THROUGHPUT;
  492.       if (Socket::setsockopt(s, IPPROTO_IP, IP_TOS, &on, sizeof (on)) < 0)
  493.           logWarning("setsockopt (IP_TOS): %m");
  494.     }
  495. #endif
  496.     return (fdopen(s, mode));
  497. bad:
  498.     (void) Sys::close(s);
  499.     return (NULL);
  500. }
  502. bool
  503. InetFaxServer::dataConnect(void)
  504. {
  505.     return Socket::connect(data, &data_dest, Socket::socklen(data_dest)) >= 0;
  506. }
  508. /*
  509.  * Establish a data connection for a file transfer operation.
  510.  */
  511. FILE*
  512. InetFaxServer::openDataConn(const char* mode, int& code)
  513. {
  514.     byte_count = 0;
  515.     if (pdata >= 0) { // passive mode, wait for connection
  516.         struct sockaddr_in from;
  517.         socklen_t fromlen = sizeof (from);
  518. // XXX don't block, select....????
  519.         int s = Socket::accept(pdata, (struct sockaddr*) &from, &fromlen);
  520.         if (s < 0) {
  521.             reply(425, "Cannot open data connection.");
  522.             (void) Sys::close(pdata);
  523.             pdata = -1;
  524.             return (NULL);
  525.         }
  526. // XXX verify peer address???
  527.         (void) Sys::close(pdata);
  528.         pdata = s;
  529. #ifdef IPTOS_LOWDELAY
  530.         int tos = IPTOS_LOWDELAY;
  531.         (void) Socket::setsockopt(s, IPPROTO_IP, IP_TOS, &tos, sizeof (tos));
  533. #endif
  534. code = 150;
  535.         return (fdopen(pdata, mode));
  536.     }
  537.     if (data >= 0) {
  538. code = 125;
  539.         usedefault = 1;
  540.         return (fdopen(data, mode));
  541.     }
  542.     if (usedefault)
  543.         data_dest = peer_addr;
  544.     usedefault = 1;
  545.     FILE* file = getDataSocket(mode);
  546.     if (file == NULL) {
  547.         reply(425, "Cannot create data socket (%s,%d): %s.",
  548.               inet_ntoa(data_source.in.sin_addr),
  549.               ntohs(data_source.in.sin_port), strerror(errno));
  550. return (NULL);
  551.     }
  552.     data = fileno(file);
  553.     for (int swait = 0; !dataConnect(); swait += swaitint) {
  554. if (!(errno == EADDRINUSE || errno == EINTR) || swait >= swaitmax) {
  555.     perror_reply(425, "Cannot build data connection", errno);
  556.     fclose(file);
  557.     data = -1;
  558.     return (NULL);
  559. }
  560. sleep(swaitint);
  561.     }
  562.     code = 150;
  563.     return (file);
  564. }
  566. bool
  567. InetFaxServer::hostPort()
  568. {
  569.     logDebug("Parsing hostPort(): "%s"", (const char*)tokenBody);
  571.     if (tokenBody[0] == 'E')
  572.     {
  573. fxStr s;
  574. if (! STRING(s))
  575. {
  576.     logDebug("Couldn't get string: "%s"", (const char*)tokenBody);
  577.     syntaxError("EPRT |family|address|port|");
  578.     return false;
  579. }
  580. logDebug("Parsing "%s"", (const char*)s);
  581. /*
  582.  * Minimual length for EPRT is: 9
  583.  *       |X|X::|X|
  584.  */
  585. char c = s[0];
  586. logDebug(" `-> s.length() = %d", s.length());
  587. logDebug(" `-> s[0] = '%c'", s[0]);
  588. logDebug(" `-> s[2] = '%c'", s[2]);
  589. logDebug(" `-> s[%d] = '%c'", s.length()-1, s[s.length()-1]);
  590. if (s.length() > 9
  591. && c == s[0] && (s[1] == '1' || s[1] == '2') && c == s[2]
  592. && c == s[s.length()-1]) {
  593.     logDebug("Looks like extended syntax: "%s" [%X: %c]", (const char*)s, c&0xFF, c);
  595.     u_int pos = 3;
  596.     fxStr a = s.token(pos, c);
  597.     logDebug("`-> Got a: %s[%u]", (const char*)a, pos);
  598.     fxStr p = s.token(pos, c);
  599.     logDebug("`-> Got a: %s[%u]", (const char*)p, pos);
  600.     if (pos != s.length() )
  601.     {
  602. logDebug("Parsing EPRT style failed");
  603. syntaxError("EPRT |family|address|port|");
  604. return false;
  605.     }
  607.     logDebug("Parsed: Family %c Address %s Port %s", s[1], (const char*)a, (const char*)p);
  608.     struct addrinfo hints, *ai;
  610.     memset(&hints, 0, sizeof(hints));
  611. #ifdef AI_NUMERICHOST
  612.     hints.ai_flags |= AI_NUMERICHOST;
  613. #endif
  614. #ifdef AI_NUMERICSERV
  615.     hints.ai_flags |= AI_NUMERICSERV;
  616. #endif
  617.     hints.ai_socktype = SOCK_STREAM;
  618.     switch (s[1])
  619.     {
  620. case '1':
  621.     hints.ai_family = AF_INET;
  622.     break;
  623. case '2':
  624.     hints.ai_family = AF_INET6;
  625.     break;
  626. default:
  627.     reply(500, "EPRT: Invalid family "%c"", s[1]);
  628.     }
  629.     if (getaddrinfo(a, p, &hints, &ai) != 0) {
  630.     reply(500, "EPRT couldn't parse family "%c" address "%s" port "%s"",
  631. s[1], (const char*)a, (const char*)p);
  632.     return false;
  633.     }
  635.     memcpy(&data_dest, ai->ai_addr, ai->ai_addrlen);
  636.     freeaddrinfo(ai);
  637.     return true;
  638. }
  639. logDebug("Couldn't parse "%s"", (const char*)s);
  640. syntaxError("Couldn't parse extended port");
  641. return false;
  642.     }
  644.     long a0, a1, a2, a3;
  645.     long p0, p1;
  646.     bool syntaxOK = 
  647.       NUMBER(a0)
  648. && COMMA() && NUMBER(a1)
  649. && COMMA() && NUMBER(a2)
  650. && COMMA() && NUMBER(a3)
  651. && COMMA() && NUMBER(p0)
  652. && COMMA() && NUMBER(p1)
  653. ;
  654.     if (syntaxOK) {
  655. data_dest.in.sin_family = AF_INET;
  656. u_char* a = (u_char*) &data_dest.in.sin_addr;
  657. u_char* p = (u_char*) &data_dest.in.sin_port;
  658. a[0] = UC(a0); a[1] = UC(a1); a[2] = UC(a2); a[3] = UC(a3);
  659. p[0] = UC(p0); p[1] = UC(p1);
  660. return (true);
  661.     }
  663.     return false;
  664. }
  666. void
  667. InetFaxServer::portCmd(Token t)
  668. {
  669.     if (t == T_EPRT)
  670. logcmd(T_EPRT, "|%d|%s|%u|", 1, inet_ntoa(data_dest.in.sin_addr), data_dest.in.sin_port);
  671.     else
  672. logcmd(T_PORT, "%s;%u", inet_ntoa(data_dest.in.sin_addr), data_dest.in.sin_port);
  673.     usedefault = false;
  674.     if (pdata >= 0)
  675.        (void) Sys::close(pdata), pdata = -1;
  677.     if (t == T_EPRT)
  678. ack(200, cmdToken(T_EPRT));
  679.     else
  680. ack(200, cmdToken(T_PORT));
  681. }