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