Category

Development Platform
Home > SourceCode/Document > Internet-Socket-Network > Browser Client > View Code
HTTCP.c
Package: arena-beta-2b-src.tar.gz　[view]
Upload User: zlh9724
Upload Date: 2007-01-04
Package Size: 1991k
Code Size: 30k
Category:

Browser Client

Development Platform:

Unix_Linux

HTTCP.c：Code Content
  1. /* HTTCP.c
  2. ** GENERIC COMMUNICATION CODE
  3. **
  4. ** (c) COPYRIGHT MIT 1995.
  5. ** Please first read the full copyright statement in the file COPYRIGH.
  6. **
  7. ** This code is in common between client and server sides.
  8. **
  9. ** 16 Jan 92  TBL Fix strtol() undefined on CMU Mach.
  10. ** 25 Jun 92  JFG  Added DECNET option through TCP socket emulation.
  11. ** 13 Sep 93  MD   Added correct return of vmserrorno for HTInetStatus.
  12. ** Added decoding of vms error message for MULTINET.
  13. ** 31 May 94  HF Added cache on host id's; now use inet_ntoa() to
  14. ** HTInetString and some other fixes. Added HTDoConnect
  15. ** and HTDoAccept
  16. */
  18. /* Library include files */
  19. #include "tcp.h"
  20. #include "HTUtils.h"
  21. #include "HTString.h"
  22. #include "HTAtom.h"
  23. #include "HTList.h"
  24. #include "HTParse.h"
  25. #include "HTAlert.h"
  26. #include "HTError.h"
  27. #include "HTReqMan.h"
  28. #include "HTNetMan.h"
  29. #include "HTDNS.h"
  30. #include "HTTCP.h"  /* Implemented here */
  32. /* VMS stuff */
  33. #ifdef VMS
  34. #ifndef MULTINET
  35. #define FD_SETSIZE 32
  36. #else /* Multinet */
  37. #define FD_SETSIZE 256
  38. #endif /* Multinet */
  39. #endif /* VMS */
  41. /* Macros and other defines */
  42. /* x seconds penalty on a multi-homed host if IP-address is down */
  43. #define TCP_PENALTY 1200
  45. /* x seconds penalty on a multi-homed host if IP-address is timed out */
  46. #define TCP_DELAY 600
  48. #ifndef RESOLV_CONF
  49. #define RESOLV_CONF "/etc/resolv.conf"
  50. #endif
  52. PRIVATE char *hostname = NULL;     /* The name of this host */
  53. PRIVATE char *mailaddress = NULL;      /* Current mail address */
  55. /* ------------------------------------------------------------------------- */
  57. /*
  58. ** Returns the string equivalent to the errno passed in the argument.
  59. ** We can't use errno directly as we have both errno and socerrno. The
  60. ** result is a static buffer.
  61. */
  62. PUBLIC CONST char * HTErrnoString (int errornumber)
  63. {
  65. #ifdef HAVE_STRERROR
  66.     return strerror(errornumber);
  67. #else
  68. #ifdef VMS
  69.     static char buf[60];
  70.     sprintf(buf,"Unix errno = %ld dec, VMS error = %lx hex", errornumber,
  71.     vaxc$errno);
  72.     return buf;
  73. #else 
  74. #ifdef _WINSOCKAPI_ 
  75. static char buf[60];
  76. sprintf(buf, "Unix errno = %ld dec, WinSock erro = %ld", errornumber, WSAGetLastError());
  77. return buf;
  78. #else
  79.     return (errornumber < sys_nerr ? sys_errlist[errornumber]:"Unknown error");
  80. #endif  /* WINDOWS */
  81. #endif /* VMS */
  82. #endif /* HAVE_STRERROR */
  83. }
  86. /* Debug error message
  87. */
  88. PUBLIC int HTInetStatus (int errnum, char * where)
  89. {
  90. #if ! (defined(VMS) || defined(WINDOWS))
  92.     if (PROT_TRACE)
  93. TTYPrint(TDEST, "TCP errno... %d after call to %s() failed.n............ %sn", errno, where, HTErrnoString(errnum));
  95. #else /* VMS */
  96. #ifdef VMS 
  97.     if (PROT_TRACE) TTYPrint(TDEST, "         Unix error number          = %ld decn", errno);
  98.     if (PROT_TRACE) TTYPrint(TDEST, "         VMS error                  = %lx hexn", vaxc$errno);
  99. #endif
  100. #ifdef WINDOWS 
  101.     if (PROT_TRACE) TTYPrint(TDEST, "         Unix error number          = %ld decn", errno);
  102.     if (PROT_TRACE) TTYPrint(TDEST, "         NT error                  = %lx hexn", WSAGetLastError());
  103. #endif 
  105. #ifdef MULTINET
  106.     if (PROT_TRACE) TTYPrint(TDEST, "         Multinet error             = %lx hexn", socket_errno); 
  107.     if (PROT_TRACE) TTYPrint(TDEST, "         Error String               = %sn", vms_errno_string());
  108. #endif /* MULTINET */
  110. #endif /* VMS */
  112. #ifdef VMS
  113.     /* errno happen to be zero if vaxc$errno <> 0 */
  114.     return -vaxc$errno;
  115. #else
  116.     return -errno;
  117. #endif
  118. }
  121. /* Parse a cardinal value        parse_cardinal()
  122. ** ----------------------
  123. **
  124. ** On entry,
  125. ** *pp     points to first character to be interpreted, terminated by
  126. **     non 0:9 character.
  127. ** *pstatus    points to status already valid
  128. ** maxvalue    gives the largest allowable value.
  129. **
  130. ** On exit,
  131. ** *pp     points to first unread character
  132. ** *pstatus    points to status updated iff bad
  133. */
  135. PUBLIC unsigned int HTCardinal (int * pstatus,
  136. char ** pp,
  137. unsigned int max_value)
  138. {
  139.     unsigned int n=0;
  140.     if ( (**pp<'0') || (**pp>'9')) {     /* Null string is error */
  141. *pstatus = -3;  /* No number where one expeceted */
  142. return 0;
  143.     }
  144.     while ((**pp>='0') && (**pp<='9')) n = n*10 + *((*pp)++) - '0';
  146.     if (n>max_value) {
  147. *pstatus = -4;  /* Cardinal outside range */
  148. return 0;
  149.     }
  151.     return n;
  152. }
  154. /* ------------------------------------------------------------------------- */
  155. /*                 SIGNAL HANDLING       */
  156. /* ------------------------------------------------------------------------- */
  158. #ifdef WWWLIB_SIG
  159. /*     HTSetSignal
  160. **  This function sets up signal handlers. This might not be necessary to
  161. **  call if the application has its own handlers.
  162. */
  163. #include <signal.h>
  164. PUBLIC void HTSetSignal (void)
  165. {
  166.     /* On some systems (SYSV) it is necessary to catch the SIGPIPE signal
  167.     ** when attemting to connect to a remote host where you normally should
  168.     ** get `connection refused' back
  169.     */
  170.     if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) {
  171. if (PROT_TRACE) TTYPrint(TDEST, "HTSignal.... Can't catch SIGPIPEn");
  172.     } else {
  173. if (PROT_TRACE) TTYPrint(TDEST, "HTSignal.... Ignoring SIGPIPEn");
  174.     }
  175. }
  176. #else
  177. #ifdef WWW_WIN_DLL
  178. PUBLIC void HTSetSignal (void) {}
  179. #endif /* WWW_WIN_DLL */
  180. #endif /* WWWLIB_SIG */
  182. /* ------------------------------------------------------------------------- */
  183. /*              HOST NAME FUNCTIONS       */
  184. /* ------------------------------------------------------------------------- */
  186. /* Produce a string for an Internet address
  187. ** ----------------------------------------
  188. **
  189. ** On exit,
  190. ** returns a pointer to a static string which must be copied if
  191. ** it is to be kept.
  192. */
  193. PUBLIC CONST char * HTInetString (SockA * sin)
  194. {
  195. #ifndef DECNET  /* Function only used below for a trace message */
  196. #if 0
  197.     /* This dumps core on some Sun systems :-(. The problem is now, that 
  198.        the current implememtation only works for IP-addresses and not in
  199.        other address spaces. */
  200.     return inet_ntoa(sin->sin_addr);
  201. #endif
  202.     static char string[16];
  203.     sprintf(string, "%d.%d.%d.%d",
  204.     (int)*((unsigned char *)(&sin->sin_addr)+0),
  205.     (int)*((unsigned char *)(&sin->sin_addr)+1),
  206.     (int)*((unsigned char *)(&sin->sin_addr)+2),
  207.     (int)*((unsigned char *)(&sin->sin_addr)+3));
  208.     return string;
  209. #else
  210.     return "";
  211. #endif /* Decnet */
  212. }
  214. /* Parse a network node address and port
  215. ** -------------------------------------
  216. **  It is assumed that any portnumber and numeric host address
  217. ** is given in decimal notation. Separation character is '.'
  218. ** Any port number given in host name overrides all other values.
  219. ** 'host' might be modified.
  220. **      Returns:
  221. **         >0 Number of homes
  222. **  0 Wait for persistent socket
  223. ** -1 Error
  224. */
  225. PRIVATE int HTParseInet (HTNet * net, char * host)
  226. {
  227.     int status = 1;
  228.     SockA *sin = &net->sock_addr;
  230. #ifdef DECNET
  231.     /* read Decnet node name. @@ Should know about DECnet addresses, but it's
  232.        probably worth waiting until the Phase transition from IV to V. */
  234.     sin->sdn_nam.n_len = min(DN_MAXNAML, strlen(host));  /* <=6 in phase 4 */
  235.     strncpy (sin->sdn_nam.n_name, host, sin->sdn_nam.n_len + 1);
  237.     if (PROT_TRACE) TTYPrint(TDEST,  
  238. "DECnet: Parsed address as object number %d on host %.6s...n",
  239.       sin->sdn_objnum, host);
  240. #else /* Internet */
  241.     {
  242. char *strptr = host;
  243. while (*strptr) {
  244.     if (*strptr == ':') {
  245. *strptr = '';    /* Don't want port number in numeric host */
  246. break;
  247.     }
  248.     if (!isdigit(*strptr) && *strptr != '.')
  249. break;
  250.     strptr++;
  251. }
  252. if (!*strptr) {
  253. #ifdef GUSI
  254.     sin->sin_addr = inet_addr(host);   /* See netinet/in.h */
  255. #else
  256.     sin->sin_addr.s_addr = inet_addr(host);   /* See arpa/inet.h */
  257. #endif
  258. } else
  259.     status = HTGetHostByName(net, host);
  261. if (PROT_TRACE) {
  262.     if (status > 0)
  263. TTYPrint(TDEST, "ParseInet... as port %d on %s with %d homesn",
  264. (int) ntohs(sin->sin_port), HTInetString(sin), status);
  265. }
  266.     }
  267. #endif /* Internet vs. Decnet */
  268.     return status;
  269. }
  272. /* HTGetDomainName
  273. ** Returns the current domain name without the local host name.
  274. ** The response is pointing to a static area that might be changed
  275. ** using HTSetHostName().
  276. **
  277. ** Returns NULL on error, "" if domain name is not found
  278. */
  279. PUBLIC CONST char *HTGetDomainName (void)
  280. {
  281.     CONST char *host = HTGetHostName();
  282.     char *domain;
  283.     if (host && *host) {
  284. if ((domain = strchr(host, '.')) != NULL)
  285.     return ++domain;
  286. else
  287.     return "";
  288.     } else
  289. return NULL;
  290. }
  293. /* HTSetHostName
  294. ** Sets the current hostname inclusive domain name.
  295. ** If this is not set then the default approach is used using
  296. ** HTGetHostname().
  297. */
  298. PUBLIC void HTSetHostName (char * host)
  299. {
  300.     if (host && *host) {
  301. char *strptr;
  302. StrAllocCopy(hostname, host);
  303. strptr = hostname;
  304. while (*strptr) {
  305.     *strptr = TOLOWER(*strptr);
  306.     strptr++;
  307. }
  308. if (*(hostname+strlen(hostname)-1) == '.')    /* Remove trailing dot */
  309.     *(hostname+strlen(hostname)-1) = '';
  310.     } else {
  311. if (PROT_TRACE) TTYPrint(TDEST, "SetHostName. Bad argument ignoredn");
  312.     }
  313. }
  316. /* HTGetHostName
  317. ** Returns the name of this host. It uses the following algoritm:
  318. **
  319. ** 1) gethostname()
  320. ** 2) if the hostname doesn't contain any '.' try to read
  321. **    /etc/resolv.conf. If there is no domain line in this file then
  322. ** 3) Try getdomainname and do as the man pages say for resolv.conf (sun)
  323. **    If there is no domain line in this file, then it is derived
  324. **    from the domain name set by the domainname(1) command, usually
  325. **    by removing the first component. For example, if the domain-
  326. **    name is set to ``foo.podunk.edu'' then the default domain name
  327. **    used will be ``pudunk.edu''.
  328. **
  329. ** This is the same procedure as used by res_init() and sendmail.
  330. **
  331. ** Return: hostname on success else NULL
  332. */
  333. PUBLIC CONST char * HTGetHostName (void)
  334. {
  335.     BOOL got_it = NO;
  336.     FILE *fp;
  337.     char name[MAXHOSTNAMELEN+1];
  338.     if (hostname) {           /* If already done */
  339. if (*hostname)
  340.     return hostname;
  341. else
  342.     return NULL;     /* We couldn't get the last time */
  343.     }
  344.     *(name+MAXHOSTNAMELEN) = '';
  346. #ifndef NO_GETHOSTNAME
  347.     if (gethostname(name, MAXHOSTNAMELEN)) {       /* Maybe without domain */
  348. if (PROT_TRACE)
  349.     TTYPrint(TDEST, "HostName.... Can't get host namen");
  350. return NULL;
  351.     }
  352.     if (PROT_TRACE)
  353. TTYPrint(TDEST, "HostName.... Local host name is  `%s'n", name);
  354.     StrAllocCopy(hostname, name);
  355.     {
  356. char *strptr = strchr(hostname, '.');
  357. if (strptr != NULL)    /* We have it all */
  358.     got_it = YES;
  359.     }
  361. #ifndef NO_RESOLV_CONF
  362.     /* Now try the resolver config file */
  363.     if (!got_it && (fp = fopen(RESOLV_CONF, "r")) != NULL) {
  364. char buffer[80];
  365. *(buffer+79) = '';
  366. while (fgets(buffer, 79, fp)) {
  367.     if (!strncasecomp(buffer, "domain", 6)) {
  368. char *domainstr = buffer+6;
  369. char *end;
  370. while (*domainstr == ' ' || *domainstr == 't')
  371.     domainstr++;
  372. end = domainstr;
  373. while (*end && !isspace(*end))
  374.     end++;
  375. *end = '';
  376. if (*domainstr) {
  377.     StrAllocCat(hostname, ".");
  378.     StrAllocCat(hostname, domainstr);
  379.     got_it = YES;
  380.     break;
  381. }
  382.     }
  383. }
  384. fclose(fp);
  385.     }
  386. #endif /* NO_RESOLV_CONF */
  388. #ifndef NO_GETDOMAINNAME
  389.     /* If everything else has failed then try getdomainname */
  390.     if (!got_it) {
  391. if (getdomainname(name, MAXHOSTNAMELEN)) {
  392.     if (PROT_TRACE)
  393. TTYPrint(TDEST, "HostName.... Can't get domain namen");
  394.     StrAllocCopy(hostname, "");
  395.     return NULL;
  396. }
  398. /* If the host name and the first part of the domain name are different
  399.    then use the former as it is more exact (I guess) */
  400. if (strncmp(name, hostname, (int) strlen(hostname))) {
  401.     char *domain = strchr(name, '.');
  402.     if (!domain)
  403. domain = name;
  404.     StrAllocCat(hostname, domain);
  405. }
  406.     }
  407. #endif /* NO_GETDOMAINNAME */
  409.     {
  410. char *strptr = hostname;
  411. while (*strptr) {     
  412.     *strptr = TOLOWER(*strptr);
  413.     strptr++;
  414. }
  415. if (*(hostname+strlen(hostname)-1) == '.')    /* Remove trailing dot */
  416.     *(hostname+strlen(hostname)-1) = '';
  417.     }
  418. #endif /* NO_GETHOSTNAME */
  420.     if (PROT_TRACE)
  421. TTYPrint(TDEST, "HostName.... Full host name is `%s'n", hostname);
  422.     return hostname;
  423. }
  426. /*
  427. ** Free the host name. Called from HTLibTerminate
  428. */
  429. PUBLIC void HTFreeHostName (void)
  430. {
  431.     HT_FREE(hostname);
  432. }
  435. /*        HTSetMailAddress
  436. ** Sets the current mail address plus host name and domain name.
  437. ** If this is not set then the default approach is used using
  438. ** HTGetMailAddress(). If the argument is NULL or "" then HTGetMailAddress
  439. ** returns NULL on a succeding request.
  440. */
  441. PUBLIC void HTSetMailAddress (char * address)
  442. {
  443.     if (!address || !*address)
  444. StrAllocCopy(mailaddress, "");
  445.     else
  446. StrAllocCopy(mailaddress, address);
  447.     if (WWWTRACE)
  448. TTYPrint(TDEST, "SetMailAdr.. Set mail address to `%s'n",
  449. mailaddress);
  450. }
  453. /*        HTGetMailAddress
  454. **
  455. ** Get the mail address of the current user on the current host. The
  456. ** domain name used is the one initialized in HTSetHostName or
  457. ** HTGetHostName. The login name is determined using (ordered):
  458. **
  459. ** getlogin
  460. ** getpwuid(getuid())
  461. **
  462. ** The weakness about the last attempt is if the user has multiple
  463. ** login names each with the same user ID. If this fails as well then:
  464. **
  465. ** LOGNAME environment variable
  466. ** USER environment variable
  467. **
  468. ** Returns NULL if error else pointer to static string
  469. */
  470. PUBLIC CONST char * HTGetMailAddress (void)
  471. {
  472. #ifdef HT_REENTRANT
  473.     char name[LOGNAME_MAX+1];    /* For getlogin_r */
  474. #endif
  475.     char *login;
  476.     CONST char *domain;
  477.     struct passwd *pw_info;
  478.     if (mailaddress) {
  479. if (*mailaddress)
  480.     return mailaddress;
  481. else
  482.     return NULL;       /* No luck the last time so we wont try again */
  483.     }
  485. #ifdef VMS
  486.     if ((login = (char *) cuserid(NULL)) == NULL) {
  487.         if (PROT_TRACE) TTYPrint(TDEST, "MailAddress. cuserid returns NULLn");
  488.     }
  489. #else
  490. #ifdef WIN32 
  491.     login = getenv("USERNAME") ;
  492. #else 
  493. #ifdef WWW_MSWINDOWS
  494.     login = "PCUSER";   /* @@@ COULD BE BETTER @@@ */
  495. #else
  496. #ifdef GUSI
  497.     if ((login = getenv("LOGNAME")) == NULL) 
  498. login = "MACUSER";
  499. #else /* Unix like... */
  500. #ifdef HT_REENTRANT
  501.     if ((login = (char *) getlogin_r(name, LOGNAME_MAX)) == NULL) {
  502. #else
  503.     if ((login = (char *) getlogin()) == NULL) {
  504. #endif
  505. if (PROT_TRACE)
  506.     TTYPrint(TDEST, "MailAddress. getlogin returns NULLn");
  507. if ((pw_info = getpwuid(getuid())) == NULL) {
  508.     if (PROT_TRACE)
  509. TTYPrint(TDEST, "MailAddress. getpwid returns NULLn");
  510.     if ((login = getenv("LOGNAME")) == NULL) {
  511. if (PROT_TRACE)
  512.     TTYPrint(TDEST, "MailAddress. LOGNAME not foundn");
  513. if ((login = getenv("USER")) == NULL) {
  514.     if (PROT_TRACE)
  515. TTYPrint(TDEST,"MailAddress. USER not foundn");
  516.     return NULL; /* I GIVE UP */
  517. }
  518.     }
  519. } else
  520.     login = pw_info->pw_name;
  521.     }
  522. #endif /* GUSI */
  523. #endif /* WWW_MSWINDOWS */
  524. #endif /* WIN32 */
  525. #endif /* VMS */
  527.     if (login) {
  528. StrAllocCopy(mailaddress, login);
  529. StrAllocCat(mailaddress, "@");
  530. if ((domain = HTGetHostName()) != NULL)
  531.     StrAllocCat(mailaddress, domain);
  532. else {
  533.     *mailaddress = '';
  534.     return NULL; /* Domain name not available */
  535. }
  536. return mailaddress;
  537.     }
  538.     return NULL;
  539. }
  542. /*
  543. ** Free the mail address. Called from HTLibTerminate
  544. */
  545. PUBLIC void HTFreeMailAddress (void)
  546. {
  547.     HT_FREE(mailaddress);
  548. }
  551. /* ------------------------------------------------------------------------- */
  552. /*               CONNECTION ESTABLISHMENT MANAGEMENT       */
  553. /* ------------------------------------------------------------------------- */
  555. /* HTDoConnect()
  556. **
  557. ** Note: Any port indication in URL, e.g., as `host:port' overwrites
  558. ** the default port value.
  559. **
  560. ** returns HT_ERROR Error has occured or interrupted
  561. ** HT_OK if connected
  562. ** HT_WOULD_BLOCK  if operation would have blocked
  563. */
  564. PUBLIC int HTDoConnect (HTNet * net, char * url, u_short default_port)
  565. {
  566.     int status;
  567.     HTRequest * request = net->request;
  568.     char *fullhost = HTParse(url, "", PARSE_HOST);
  569.     char *at_sign;
  570.     char *host;
  572.     /* if there's an @ then use the stuff after it as a hostname */
  573.     if ((at_sign = strchr(fullhost, '@')) != NULL)
  574. host = at_sign+1;
  575.     else
  576. host = fullhost;
  577.     if (!*host) {
  578. HTRequest_addError(request, ERR_FATAL, NO, HTERR_NO_HOST,
  579.    NULL, 0, "HTDoConnect");
  580. HT_FREE(fullhost);
  581. return HT_ERROR;
  582.     }
  584.     /* Jump into the state machine */
  585.     while (1) {
  586. switch (net->tcpstate) {
  587.   case TCP_BEGIN:
  588.     {
  589. char *port = strchr(host, ':');
  590. SockA *sin = &net->sock_addr;
  591. memset((void *) sin, '', sizeof(SockA));
  592. if (port++ && isdigit(*port)) {
  593. #ifdef DECNET
  594.     sin->sdn_family = AF_DECnet;
  595.     sin->sdn_objnum=(unsigned char)(strtol(port,(char**)0,10));
  596. #else
  597.     sin->sin_family = AF_INET;
  598.     sin->sin_port = htons(atol(port));
  599. #endif
  600. } else {
  601. #ifdef DECNET
  602.     sin->sdn_family = AF_DECnet;
  603.     net->sock_addr.sdn_objnum = DNP_OBJ;
  604. #else  /* Internet */
  605.     sin->sin_family = AF_INET;
  606.     sin->sin_port = htons(default_port);
  607. #endif
  608. }
  609.     }
  610.     if (PROT_TRACE)
  611. TTYPrint(TDEST, "HTDoConnect. Looking up `%s'n", host);
  612.     net->tcpstate = TCP_DNS;
  613.     break;
  615.   case TCP_DNS:
  616.     if ((status = HTParseInet(net, host)) < 0) {
  617. if (PROT_TRACE)
  618.     TTYPrint(TDEST, "HTDoConnect. Can't locate `%s'n", host);
  619. HTRequest_addError(request, ERR_FATAL, NO,HTERR_NO_REMOTE_HOST,
  620.    (void *) host, strlen(host), "HTDoConnect");
  621. net->tcpstate = TCP_ERROR;
  622. break;
  623.     }
  625.     /*
  626.     ** Wait for a persistent connection. When we return, we check
  627.     ** that the socket hasn't been closed in the meantime
  628.     */
  629.     if (!status) {
  630. net->tcpstate = TCP_NEED_CONNECT;
  631. HT_FREE(fullhost);
  632. HTNet_wait(net);
  633. return HT_PERSISTENT;
  634.     }
  636.     if (!net->retry && status > 1) /* If multiple homes */
  637. net->retry = status;
  638.     if (net->sockfd != INVSOC) {    /* Reusing socket */
  639. if (PROT_TRACE)
  640.     TTYPrint(TDEST, "HTDoConnect. REUSING SOCKET %dn",
  641.     net->sockfd);
  642. net->tcpstate = TCP_CONNECTED;
  643.     } else
  644. net->tcpstate = TCP_NEED_SOCKET;
  645.     break;
  647.   case TCP_NEED_SOCKET:
  648. #ifdef DECNET
  649.     if ((net->sockfd=socket(AF_DECnet, SOCK_STREAM, 0))==INVSOC)
  650. #else
  651.     if ((net->sockfd=socket(AF_INET, SOCK_STREAM,IPPROTO_TCP))==INVSOC)
  652. #endif
  653.     {
  654. HTRequest_addSystemError(request, ERR_FATAL, socerrno, NO, "socket");
  655. net->tcpstate = TCP_ERROR;
  656. break;
  657.     }
  658.     if (PROT_TRACE)
  659. TTYPrint(TDEST, "HTDoConnect. Created socket %dn",net->sockfd);
  661.     /* If non-blocking protocol then change socket status
  662.     ** I use FCNTL so that I can ask the status before I set it.
  663.     ** See W. Richard Stevens (Advan. Prog. in UNIX environment, p.364)
  664.     ** Be CAREFULL with the old `O_NDELAY' - it will not work as read()
  665.     ** returns 0 when blocking and NOT -1. FNDELAY is ONLY for BSD and
  666.     ** does NOT work on SVR4 systems. O_NONBLOCK is POSIX.
  667.     */
  668.     if (!net->preemptive) {
  669. #ifdef _WINSOCKAPI_
  670. { /* begin windows scope  */
  671.     HTRequest * rq = request;
  672.     long levents = FD_READ | FD_WRITE | FD_ACCEPT | 
  673. FD_CONNECT | FD_CLOSE ;
  674.     int rv = 0 ;
  675.     
  676. #ifdef WWW_WIN_ASYNC
  677.     /* N.B WSAAsyncSelect() turns on non-blocking I/O */
  678.     rv = WSAAsyncSelect( net->sockfd, rq->hwnd, 
  679. rq->winMsg, levents);
  680.     if (rv == SOCKET_ERROR) {
  681. status = -1 ;
  682. if (PROT_TRACE) 
  683.     TTYPrint(TDEST, "HTDoConnect. WSAAsyncSelect() fails: %dn", 
  684.      WSAGetLastError());
  685.     } /* error returns */
  686. #else
  687.     int enable = 1;
  688.     status = IOCTL(net->sockfd, FIONBIO, &enable);
  689. #endif
  690. } /* end scope */
  691. #else 
  692. #if defined(VMS)
  693. {
  694.     int enable = 1;
  695.     status = IOCTL(net->sockfd, FIONBIO, &enable);
  696. }
  697. #else
  698. if((status = FCNTL(net->sockfd, F_GETFL, 0)) != -1) {
  699.     status |= O_NONBLOCK; /* POSIX */
  700.     status = FCNTL(net->sockfd, F_SETFL, status);
  701. }
  702. #endif /* VMS */
  703. #endif /* WINDOW */
  704. if (PROT_TRACE) {
  705.     if (status == -1)
  706. TTYPrint(TDEST, "HTDoConnect. Only blocking worksn");
  707.     else
  708. TTYPrint(TDEST, "HTDoConnect. Non-blocking socketn");
  709. }
  710.     } else if (PROT_TRACE)
  711. TTYPrint(TDEST, "HTDoConnect. Blocking socketn");
  713.     /* If multi-homed host then start timer on connection */
  714.     if (net->retry) net->connecttime = time(NULL);
  716.     /* Progress */
  717.     {
  718. HTAlertCallback *cbf = HTAlert_find(HT_PROG_CONNECT);
  719. if (cbf)
  720.   (*cbf)(request,HT_PROG_CONNECT,HT_MSG_NULL,NULL,host,NULL);
  721.     }
  722.     net->tcpstate = TCP_NEED_CONNECT;
  723.     break;
  725.   case TCP_NEED_CONNECT:
  726.     status = connect(net->sockfd, (struct sockaddr *) &net->sock_addr,
  727.      sizeof(net->sock_addr));
  728.     /*
  729.      * According to the Sun man page for connect:
  730.      *     EINPROGRESS         The socket is non-blocking and the  con-
  731.      *                         nection cannot be completed immediately.
  732.      *                         It is possible to select(2) for  comple-
  733.      *                         tion  by  selecting the socket for writ-
  734.      *                         ing.
  735.      * According to the Motorola SVR4 man page for connect:
  736.      *     EAGAIN              The socket is non-blocking and the  con-
  737.      *                         nection cannot be completed immediately.
  738.      *                         It is possible to select for  completion
  739.      *                         by  selecting  the  socket  for writing.
  740.      *                         However, this is only  possible  if  the
  741.      *                         socket  STREAMS  module  is  the topmost
  742.      *                         module on  the  protocol  stack  with  a
  743.      *                         write  service  procedure.  This will be
  744.      *                         the normal case.
  745.      */
  746. #ifdef _WINSOCKAPI_
  747.     if (status == SOCKET_ERROR)
  748. #else
  749.     if (status < 0) 
  750. #endif
  751.     {
  752. #ifdef EAGAIN
  753. if (socerrno==EINPROGRESS || socerrno==EAGAIN)
  754. #else 
  755. #ifdef _WINSOCKAPI_
  756. if (socerrno==WSAEWOULDBLOCK)
  757. #else
  758. if (socerrno==EINPROGRESS)
  759. #endif /* _WINSOCKAPI_ */
  760. #endif /* EAGAIN */
  761. {
  762.     if (PROT_TRACE)
  763. TTYPrint(TDEST,"HTDoConnect. WOULD BLOCK `%s'n",host);
  764.     HTEvent_Register(net->sockfd, request, (SockOps)FD_CONNECT,
  765.      net->cbf, net->priority);
  766.     HT_FREE(fullhost);
  767.     return HT_WOULD_BLOCK;
  768. }
  769. if (socerrno == EISCONN) {
  770.     net->tcpstate = TCP_CONNECTED;
  771.     break;
  772. }
  773. #ifdef _WINSOCKAPI_
  774. if (socerrno == WSAEBADF)          /* We lost the socket */
  775. #else
  776. if (socerrno == EBADF)          /* We lost the socket */
  777. #endif
  778. {
  779.     net->tcpstate = TCP_NEED_SOCKET;
  780.     break;
  781. }
  782. if (net->retry) {
  783.     net->connecttime -= time(NULL);
  784.     /* Added EINVAL `invalid argument' as this is what I 
  785.        get back from a non-blocking connect where I should 
  786.        get `connection refused' on BSD. SVR4 gives SIG_PIPE */
  787. #if defined(__srv4__) || defined (_WINSOCKAPI_)
  788.     if (socerrno==ECONNREFUSED || socerrno==ETIMEDOUT ||
  789. socerrno==ENETUNREACH || socerrno==EHOSTUNREACH ||
  790. socerrno==EHOSTDOWN)
  791. #else
  792.     if (socerrno==ECONNREFUSED || socerrno==ETIMEDOUT ||
  793. socerrno==ENETUNREACH || socerrno==EHOSTUNREACH ||
  794. socerrno==EHOSTDOWN || socerrno==EINVAL)
  795. #endif
  796.         net->connecttime += TCP_DELAY;
  797.     else
  798.         net->connecttime += TCP_PENALTY;
  799.     HTDNS_updateWeigths(net->dns, net->home, net->connecttime);
  800. }
  801. net->tcpstate = TCP_ERROR;
  802.     } else
  803. net->tcpstate = TCP_CONNECTED;
  804.     break;
  806.   case TCP_CONNECTED:
  807.     HTEvent_UnRegister(net->sockfd, (SockOps) FD_CONNECT);
  808.     if (net->retry) {
  809. net->connecttime -= time(NULL);
  810. HTDNS_updateWeigths(net->dns, net->home, net->connecttime);
  811.     }
  812.     net->retry = 0;
  813.     HT_FREE(fullhost);
  814.     net->tcpstate = TCP_BEGIN;
  815.     return HT_OK;
  816.     break;
  818.   case TCP_NEED_BIND:
  819.   case TCP_NEED_LISTEN:
  820.   case TCP_ERROR:
  821.     if (PROT_TRACE) TTYPrint(TDEST, "HTDoConnect. Connect failedn");
  822.     if (net->sockfd != INVSOC) {
  823.         HTEvent_UnRegister(net->sockfd, (SockOps) FD_ALL);
  824. NETCLOSE(net->sockfd);
  825. net->sockfd = INVSOC;
  826. if (HTDNS_socket(net->dns) != INVSOC) {  /* Inherited socket */
  827.     HTDNS_setSocket(net->dns, INVSOC);
  828.     net->tcpstate = TCP_NEED_SOCKET;
  829.     break;
  830. }
  831.     }
  833.     /* Do we have more homes to try? */
  834.     if (--net->retry > 0) {
  835.         HTRequest_addSystemError(request, ERR_NON_FATAL, socerrno, NO,
  836.       "connect");
  837. net->tcpstate = TCP_DNS;
  838. break;
  839.     }
  840.     HTRequest_addSystemError(request, ERR_FATAL,socerrno,NO,"connect");
  841.     HTDNS_delete(host);
  842.     net->retry = 0;
  843.     HT_FREE(fullhost);
  844.     net->tcpstate = TCP_BEGIN;
  845.     return HT_ERROR;
  846.     break;
  847. }
  848.     }
  849. }
  851. /* HTDoAccept()
  852. ** ------------
  853. ** This function makes a non-blocking accept which will turn up as ready
  854. ** read in the select.
  855. ** Returns
  856. ** HT_ERROR Error has occured or interrupted
  857. ** HT_OK if connected
  858. ** HT_WOULD_BLOCK  if operation would have blocked
  859. */
  860. PUBLIC int HTDoAccept (HTNet * net)
  861. {
  862.     int status;
  863.     int size = sizeof(net->sock_addr);
  864.     HTRequest *request = net->request;
  865.     if (net->sockfd==INVSOC) {
  866. if (PROT_TRACE) TTYPrint(TDEST, "HTDoAccept.. Invalid socketn");
  867. return HT_ERROR;
  868.     }
  870.     /* Progress report */
  871.     {
  872. HTAlertCallback *cbf = HTAlert_find(HT_PROG_ACCEPT);
  873. if (cbf) (*cbf)(request, HT_PROG_ACCEPT, HT_MSG_NULL,NULL, NULL, NULL);
  874.     }
  875.     status = accept(net->sockfd, (struct sockaddr *) &net->sock_addr, &size);
  876. #ifdef _WINSOCKAPI_
  877.     if (status == SOCKET_ERROR)
  878. #else
  879.     if (status < 0) 
  880. #endif
  881.     {
  882. #ifdef EAGAIN
  883. if (socerrno==EINPROGRESS || socerrno==EAGAIN)
  884. #else 
  885. #ifdef _WINSOCKAPI_
  886.         if (socerrno==WSAEWOULDBLOCK)
  887. #else
  888. if (socerrno==EINPROGRESS)
  889. #endif /* _WINSOCKAPI_ */
  890. #endif /* EAGAIN */
  891. {
  892.     if (PROT_TRACE)
  893. TTYPrint(TDEST,"HTDoAccept.. WOULD BLOCK %dn", net->sockfd);
  894.     HTEvent_Register(net->sockfd, request, (SockOps) FD_ACCEPT,
  895.      net->cbf, net->priority);
  896.     return HT_WOULD_BLOCK;
  897. }
  898. HTRequest_addSystemError(request, ERR_WARN, socerrno, YES, "accept");
  899. if (PROT_TRACE) TTYPrint(TDEST, "HTDoAccept.. Accept failedn");
  900. if (HTDNS_socket(net->dns) != INVSOC) {    /* Inherited socket */
  901.     HTDNS_setSocket(net->dns, INVSOC);
  902. }
  903. return HT_ERROR;
  904.     }
  906.     /* Swap to new socket */
  907.     HTEvent_UnRegister(net->sockfd, (SockOps) FD_ACCEPT);
  908.     net->sockfd = status;
  909.     if (PROT_TRACE) TTYPrint(TDEST, "Accepted.... socket %dn", status);
  910.     return HT_OK;
  911. }
  914. /* HTDoListen
  915. ** ----------
  916. ** Listens on the specified port. 0 means that we chose it here
  917. ** If master==INVSOC then we listen on all local interfaces (using a 
  918. ** wildcard). If !INVSOC then use this as the local interface
  919. ** returns HT_ERROR Error has occured or interrupted
  920. ** HT_OK if connected
  921. */
  922. PUBLIC int HTDoListen (HTNet * net, u_short port, SOCKET master, int backlog)
  923. {
  924.     int status;
  926.     /* Jump into the state machine */
  927.     while (1) {
  928. switch (net->tcpstate) {
  929.   case TCP_BEGIN:
  930.     {
  931. SockA *sin = &net->sock_addr;
  932. memset((void *) sin, '', sizeof(SockA));
  933. #ifdef DECNET
  934. sin->sdn_family = AF_DECnet;
  935. sin->sdn_objnum = port;
  936. #else
  937. sin->sin_family = AF_INET;
  938. if (master != INVSOC) {
  939.     int len = sizeof(SockA);
  940.     if (getsockname(master, (struct sockaddr *) sin, &len)<0) {
  941. HTRequest_addSystemError(net->request, ERR_FATAL,
  942.  socerrno, NO, "getsockname");
  943. net->tcpstate = TCP_ERROR;
  944. break;
  945.     }
  946. } else
  947.     sin->sin_addr.s_addr = INADDR_ANY;
  948. sin->sin_port = htons(port);
  949. #endif
  950.     }
  951.     if (PROT_TRACE)
  952. TTYPrint(TDEST, "HTDoListen.. Listen on port %dn", port);
  953.     net->tcpstate = TCP_NEED_SOCKET;
  954.     break;
  956.   case TCP_NEED_SOCKET:
  957. #ifdef DECNET
  958.     if ((net->sockfd=socket(AF_DECnet, SOCK_STREAM, 0))==INVSOC)
  959. #else
  960.     if ((net->sockfd=socket(AF_INET, SOCK_STREAM,IPPROTO_TCP))==INVSOC)
  961. #endif
  962.     {
  963. HTRequest_addSystemError(net->request, ERR_FATAL, socerrno,
  964.  NO, "socket");
  965. net->tcpstate = TCP_ERROR;
  966. break;
  967.     }
  968.     if (PROT_TRACE)
  969. TTYPrint(TDEST, "HTDoListen.. Created socket %dn",net->sockfd);
  971.     /* If non-blocking protocol then change socket status
  972.     ** I use FCNTL so that I can ask the status before I set it.
  973.     ** See W. Richard Stevens (Advan. Prog. in UNIX environment, p.364)
  974.     ** Be CAREFULL with the old `O_NDELAY' - it will not work as read()
  975.     ** returns 0 when blocking and NOT -1. FNDELAY is ONLY for BSD and
  976.     ** does NOT work on SVR4 systems. O_NONBLOCK is POSIX.
  977.     */
  978.     if (!net->preemptive) {
  979. #ifdef _WINSOCKAPI_ 
  980. { /* begin windows scope  */
  981.     long levents = FD_READ | FD_WRITE | FD_ACCEPT | 
  982. FD_CONNECT | FD_CLOSE ;
  983.     int rv = 0 ;
  984.     
  985. #ifdef WWW_WIN_ASYNC
  986.     /* N.B WSAAsyncSelect() turns on non-blocking I/O */
  987.     rv = WSAAsyncSelect(net->sockfd, net->request->hwnd, 
  988. net->request->winMsg, levents);
  989.     if (rv == SOCKET_ERROR) {
  990. status = -1 ;
  991. if (PROT_TRACE) 
  992.     TTYPrint(TDEST, "HTDoListen.. WSAAsyncSelect() fails: %dn", 
  993.      WSAGetLastError());
  994. } /* error returns */
  995. #else
  996.     int enable = 1 ;
  997.     status = IOCTL(net->sockfd, FIONBIO, &enable);
  998. #endif
  999. } /* end scope */
  1000. #else 
  1001. #if defined(VMS)
  1002. {
  1003.     int enable = 1;
  1004.     status = IOCTL(net->sockfd, FIONBIO, &enable);
  1005. }
  1006. #else
  1007. if((status = FCNTL(net->sockfd, F_GETFL, 0)) != -1) {
  1008.     status |= O_NONBLOCK;     /* POSIX */
  1009.     status = FCNTL(net->sockfd, F_SETFL, status);
  1010. }
  1011. #endif /* VMS */
  1012. #endif /* WINDOW */
  1013. if (PROT_TRACE) {
  1014.     if (status == -1)
  1015. TTYPrint(TDEST, "HTDoListen.. Blocking socketn");
  1016.     else
  1017. TTYPrint(TDEST, "HTDoListen.. Non-blocking socketn");
  1018. }
  1019.     }
  1020.     net->tcpstate = TCP_NEED_BIND;
  1021.     break;
  1023.   case TCP_NEED_BIND:
  1024.     status = bind(net->sockfd, (struct sockaddr *) &net->sock_addr,
  1025.   sizeof(net->sock_addr));
  1026. #ifdef _WINSOCKAPI_
  1027.     if (status == SOCKET_ERROR)
  1028. #else
  1029.     if (status < 0) 
  1030. #endif
  1031.     {
  1032. if (PROT_TRACE)
  1033.     TTYPrint(TDEST, "Bind........ failed %dn", socerrno);
  1034. net->tcpstate = TCP_ERROR;
  1035.     } else
  1036. net->tcpstate = TCP_NEED_LISTEN;
  1037.     break;
  1039.   case TCP_NEED_LISTEN:
  1040.     status = listen(net->sockfd, backlog);
  1041. #ifdef _WINSOCKAPI_
  1042.     if (status == SOCKET_ERROR)
  1043. #else
  1044.     if (status < 0) 
  1045. #endif
  1046. net->tcpstate = TCP_ERROR;
  1047.     else
  1048. net->tcpstate = TCP_CONNECTED;
  1049.     break;
  1051.   case TCP_CONNECTED:
  1052.     net->tcpstate = TCP_BEGIN;
  1053.     if (PROT_TRACE)
  1054. TTYPrint(TDEST,"HTDoListen.. Bind and listen on port %d %sn",
  1055. (int) ntohs(net->sock_addr.sin_port),
  1056. HTInetString(&net->sock_addr));
  1057.     return HT_OK;
  1058.     break;
  1060.   case TCP_NEED_CONNECT:
  1061.   case TCP_DNS:
  1062.   case TCP_ERROR:
  1063.     if (PROT_TRACE) TTYPrint(TDEST, "HTDoListen.. Listen failedn");
  1064.     HTRequest_addSystemError(net->request, ERR_FATAL, socerrno, NO, "HTDoListen");
  1065.     net->tcpstate = TCP_BEGIN;
  1066.     return HT_ERROR;
  1067.     break;
  1068. }
  1069.     }
  1070. }