Annotation of libwww/Library/src/HTTCP.c, revision 2.114
2.31 frystyk 1: /* HTTCP.c
2.83 frystyk 2: ** TCP SPECIFIC CODE
2.31 frystyk 3: **
2.42 frystyk 4: ** (c) COPYRIGHT MIT 1995.
2.31 frystyk 5: ** Please first read the full copyright statement in the file COPYRIGH.
2.114 ! frystyk 6: ** @(#) $Id: HTTCP.c,v 2.113 1999/02/03 17:37:42 frystyk Exp $
1.1 timbl 7: **
8: ** This code is in common between client and server sides.
9: **
10: ** 16 Jan 92 TBL Fix strtol() undefined on CMU Mach.
11: ** 25 Jun 92 JFG Added DECNET option through TCP socket emulation.
2.7 duns 12: ** 13 Sep 93 MD Added correct return of vmserrorno for HTInetStatus.
13: ** Added decoding of vms error message for MULTINET.
2.13 frystyk 14: ** 31 May 94 HF Added cache on host id's; now use inet_ntoa() to
15: ** HTInetString and some other fixes. Added HTDoConnect
16: ** and HTDoAccept
1.1 timbl 17: */
18:
2.36 frystyk 19: /* Library include files */
2.108 frystyk 20: #include "wwwsys.h"
2.83 frystyk 21: #include "WWWUtil.h"
22: #include "WWWCore.h"
2.58 frystyk 23: #include "HTReqMan.h"
2.54 frystyk 24: #include "HTNetMan.h"
2.36 frystyk 25: #include "HTTCP.h" /* Implemented here */
2.29 frystyk 26:
2.95 frystyk 27: #include "HTHstMan.h"
28:
2.36 frystyk 29: /* VMS stuff */
30: #ifdef VMS
31: #ifndef MULTINET
32: #define FD_SETSIZE 32
33: #else /* Multinet */
34: #define FD_SETSIZE 256
35: #endif /* Multinet */
36: #endif /* VMS */
37:
2.13 frystyk 38: /* Macros and other defines */
2.113 frystyk 39: /* x ms penalty on a multi-homed host if IP-address is unreachable */
40: #define TCP_DELAY 30000
2.24 frystyk 41:
2.113 frystyk 42: /* x ms penalty on a multi-homed host if IP-address is down for unknown reason */
43: #define TCP_PENALTY 60000
2.24 frystyk 44:
2.93 eric 45: /* imperical study in socket call error codes
46: */
47: #ifdef _WINSOCKAPI_ /* windows */
48: #define NETCALL_ERROR(ret) (ret == SOCKET_ERROR)
49: #define NETCALL_DEADSOCKET(err) (err == WSAEBADF)
50: #define NETCALL_WOULDBLOCK(err) (err == WSAEWOULDBLOCK)
51: #else /* _WINSOCKAPI_ unix */
52: #define NETCALL_ERROR(ret) (ret < 0)
53: #define NETCALL_DEADSOCKET(err) (err == EBADF)
54: #if defined(EAGAIN) && defined(EALREADY)
55: #define NETCALL_WOULDBLOCK(err) (err == EINPROGRESS || \
56: err == EALREADY || \
57: err == EAGAIN)
58: #else /* (EAGAIN && EALREADY) */
59: #ifdef EALREADY
60: #define NETCALL_WOULDBLOCK(err) (err == EINPROGRESS || err == EALREADY)
61: #else /* EALREADY */
62: #ifdef EAGAIN
63: #define NETCALL_WOULDBLOCK(err) (err == EINPROGRESS || err == EAGAIN)
64: #else /* EAGAIN */
65: #define NETCALL_WOULDBLOCK(err) (err == EINPROGRESS)
66: #endif /* !EAGAIN */
67: #endif /* !EALREADY */
68: #endif /* !(EAGAIN && EALREADY) */
69: #endif /* !_WINSOCKAPI_ done */
2.112 frystyk 70:
71: #if defined(__svr4__) || defined (_WINSOCKAPI_)
72: #define HT_HOSTUNREACHABLE(e) ((e)==ECONNREFUSED || (e)==ETIMEDOUT || \
73: (e)==ENETUNREACH || (e)==EHOSTUNREACH || \
74: (e)==EHOSTDOWN)
75: #else
76: #define HT_HOSTUNREACHABLE(e) ((e)==ECONNREFUSED || (e)==ETIMEDOUT || \
77: (e)==ENETUNREACH || (e)==EHOSTUNREACH || \
78: (e)==EHOSTDOWN || (e)==EINVAL)
79: #endif
80:
2.13 frystyk 81: /* ------------------------------------------------------------------------- */
2.19 frystyk 82: /* CONNECTION ESTABLISHMENT MANAGEMENT */
83: /* ------------------------------------------------------------------------- */
2.13 frystyk 84:
2.95 frystyk 85: /* _makeSocket - create a socket, if !preemptive, set FIONBIO
2.93 eric 86: * returns 1: blocking
87: * 0: non-blocking
88: * -1: creation error
89: */
2.95 frystyk 90: PRIVATE int _makeSocket(HTHost * host, HTRequest * request, int preemptive, HTTransport * transport)
2.93 eric 91: {
2.95 frystyk 92: int status = 1;
93: SOCKET sockfd;
2.93 eric 94: #ifdef DECNET
2.95 frystyk 95: if ((sockfd=socket(AF_DECnet, SOCK_STREAM, 0))==INVSOC)
2.93 eric 96: #else
2.95 frystyk 97: if ((sockfd=socket(AF_INET, SOCK_STREAM,IPPROTO_TCP))==INVSOC)
2.93 eric 98: #endif
2.112 frystyk 99: {
100: HTRequest_addSystemError(request, ERR_FATAL, socerrno, NO, "socket");
2.95 frystyk 101: return -1;
2.112 frystyk 102: }
2.114 ! frystyk 103: HTTRACE(PROT_TRACE, "Socket...... Created %d\n" _ sockfd);
2.93 eric 104:
2.95 frystyk 105: /* Increase the number of sockets by one */
106: HTNet_increaseSocket();
2.97 frystyk 107:
108: /*
109: ** If we have compiled without Nagle's algorithm then try and turn
110: ** it off now
111: */
2.105 frystyk 112: #if defined(HT_NO_NAGLE) && defined(HAVE_SETSOCKOPT) && defined(TCP_NODELAY)
2.97 frystyk 113: {
114: int disable = 1;
2.101 frystyk 115: status = setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY,
116: (char *) &disable, sizeof(int));
2.97 frystyk 117: if (status == -1) {
2.114 ! frystyk 118: HTTRACE(PROT_TRACE, "Socket...... Could not disable Nagle's algorithm - error %d\n" _
2.97 frystyk 119: sockfd);
120: } else {
2.114 ! frystyk 121: HTTRACE(PROT_TRACE, "Socket...... Turned off Nagle's algorithm\n");
2.97 frystyk 122: }
123: }
124: #endif
2.93 eric 125:
2.95 frystyk 126: /* If non-blocking protocol then change socket status
127: ** I use fcntl() so that I can ask the status before I set it.
128: ** See W. Richard Stevens (Advan. Prog. in UNIX environment, p.364)
129: ** Be CAREFULL with the old `O_NDELAY' - it will not work as read()
130: ** returns 0 when blocking and NOT -1. FNDELAY is ONLY for BSD and
131: ** does NOT work on SVR4 systems. O_NONBLOCK is POSIX.
132: */
133: if (!preemptive) {
2.93 eric 134: #ifdef _WINSOCKAPI_
2.95 frystyk 135: { /* begin windows scope */
136: long levents = FD_READ | FD_WRITE | FD_ACCEPT |
137: FD_CONNECT | FD_CLOSE ;
138: int rv = 0 ;
139: u_long one = 1;
140:
141: status = ioctlsocket(sockfd, FIONBIO, &one) ==
142: SOCKET_ERROR ? -1 : 0;
143: } /* end scope */
2.93 eric 144: #else /* _WINSOCKAPI_ */
145: #if defined(VMS)
2.95 frystyk 146: {
147: int enable = 1;
148: status = IOCTL(sockfd, FIONBIO, &enable);
149: }
2.93 eric 150: #else /* VMS */
2.95 frystyk 151: if((status = fcntl(sockfd, F_GETFL, 0)) != -1) {
2.93 eric 152: #ifdef O_NONBLOCK
2.95 frystyk 153: status |= O_NONBLOCK; /* POSIX */
2.93 eric 154: #else /* O_NONBLOCK */
155: #ifdef F_NDELAY
156: status |= F_NDELAY; /* BSD */
157: #endif /* F_NDELAY */
158: #endif /* !O_NONBLOCK */
2.95 frystyk 159: status = fcntl(sockfd, F_SETFL, status);
160: }
2.93 eric 161: #endif /* !VMS */
162: #endif /* !_WINSOCKAPI_ */
2.114 ! frystyk 163: HTTRACE(PROT_TRACE, "Socket...... %slocking socket\n" _ status == -1 ? "B" : "Non-b");
2.95 frystyk 164: } else
2.114 ! frystyk 165: HTTRACE(PROT_TRACE, "Socket...... Blocking socket\n");
2.95 frystyk 166:
167: /*
168: ** Associate the channel with the host and create an input and and output stream
169: ** for this host/channel
170: */
2.103 frystyk 171: HTHost_setChannel(host, HTChannel_new(sockfd, NULL, YES));
2.95 frystyk 172: HTHost_getInput(host, transport, NULL, 0);
2.105 frystyk 173: HTHost_getOutput(host, transport, NULL, 0);
2.93 eric 174:
175: return status == -1 ? 1 : 0;
176: }
177:
2.13 frystyk 178: /* HTDoConnect()
179: **
180: ** Note: Any port indication in URL, e.g., as `host:port' overwrites
2.54 frystyk 181: ** the default port value.
2.13 frystyk 182: **
2.40 frystyk 183: ** returns HT_ERROR Error has occured or interrupted
184: ** HT_OK if connected
185: ** HT_WOULD_BLOCK if operation would have blocked
2.13 frystyk 186: */
2.54 frystyk 187: PUBLIC int HTDoConnect (HTNet * net, char * url, u_short default_port)
2.13 frystyk 188: {
2.95 frystyk 189: HTHost * me = HTNet_host(net);
2.88 frystyk 190: HTRequest * request = HTNet_request(net);
2.95 frystyk 191: int preemptive = net->preemptive;
192: int status = HT_OK;
193: char * hostname = HTHost_name(me);
2.13 frystyk 194:
2.55 frystyk 195: /* Jump into the state machine */
196: while (1) {
2.95 frystyk 197: switch (me->tcpstate) {
2.55 frystyk 198: case TCP_BEGIN:
2.91 frystyk 199: {
200: /*
201: ** Add the net object to the host object found above. If the
202: ** host is idle then we can start the request right away,
203: ** otherwise we must wait until it is free.
204: */
2.98 frystyk 205: if ((status = HTHost_addNet(net->host, net)) == HT_PENDING)
2.114 ! frystyk 206: HTTRACE(PROT_TRACE, "HTDoConnect. Pending...\n");
2.91 frystyk 207:
208: /*
2.95 frystyk 209: ** If we are pending then return here, otherwise go to next state
2.91 frystyk 210: ** which is setting up a channel
211: */
2.95 frystyk 212: me->tcpstate = TCP_CHANNEL;
2.114 ! frystyk 213: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_CHANNEL.\n" _ me);
2.91 frystyk 214: if (status == HT_PENDING) return HT_PENDING;
215: }
216: break;
2.83 frystyk 217:
2.91 frystyk 218: case TCP_CHANNEL:
2.83 frystyk 219: /*
2.91 frystyk 220: ** The next state depends on whether we have a connection
221: ** or not - if so then we can jump directly to connect() to
222: ** test it - otherwise we must around DNS to get the name
2.93 eric 223: ** Resolved
2.83 frystyk 224: */
2.95 frystyk 225: if (HTHost_channel(me) == NULL) {
226: me->tcpstate = TCP_DNS;
2.114 ! frystyk 227: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_DNS.\n" _ me);
2.95 frystyk 228: } else {
229:
230: /*
231: ** There is now one more using the channel
232: */
233: HTChannel_upSemaphore(me->channel);
234:
235: /*
236: ** We are now all set and can jump to connected mode
237: */
238: me->tcpstate = TCP_CONNECTED;
2.114 ! frystyk 239: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_CONNECTED.\n" _ me);
2.95 frystyk 240: }
241: hostname = HTHost_name(me);
2.55 frystyk 242: break;
243:
2.91 frystyk 244: case TCP_DNS:
2.95 frystyk 245: if ((status = HTParseInet(me, hostname, request)) < 0) {
2.114 ! frystyk 246: HTTRACE(PROT_TRACE, "HTDoConnect. Can't locate `%s\'\n" _ hostname);
2.91 frystyk 247: HTRequest_addError(request, ERR_FATAL, NO,
248: HTERR_NO_REMOTE_HOST,
249: (void *) hostname, strlen(hostname),
250: "HTDoConnect");
2.109 frystyk 251: me->tcpstate = TCP_DNS_ERROR;
2.114 ! frystyk 252: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_ERROR.\n" _ me);
2.27 frystyk 253: break;
2.55 frystyk 254: }
2.102 frystyk 255: if (!HTHost_retry(me) && status > 1) /* If multiple homes */
256: HTHost_setRetry(me, status);
2.95 frystyk 257: me->tcpstate = TCP_NEED_SOCKET;
2.114 ! frystyk 258: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_NEED_SOCKET.\n" _ me);
2.55 frystyk 259: break;
260:
261: case TCP_NEED_SOCKET:
2.112 frystyk 262: if (_makeSocket(me, request, preemptive, net->transport) == -1) {
263: me->tcpstate = TCP_ERROR;
264: break;
265: }
2.95 frystyk 266:
2.27 frystyk 267: /* If multi-homed host then start timer on connection */
2.102 frystyk 268: if (HTHost_retry(me)) me->connecttime = HTGetTimeInMillis();
2.65 frystyk 269:
270: /* Progress */
271: {
272: HTAlertCallback *cbf = HTAlert_find(HT_PROG_CONNECT);
2.95 frystyk 273: if (cbf) (*cbf)(request, HT_PROG_CONNECT, HT_MSG_NULL,
2.91 frystyk 274: NULL, hostname, NULL);
2.65 frystyk 275: }
2.95 frystyk 276: me->tcpstate = TCP_NEED_CONNECT;
2.114 ! frystyk 277: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_NEED_CONNECT.\n" _ me);
2.55 frystyk 278: break;
2.56 frystyk 279: case TCP_NEED_CONNECT:
2.95 frystyk 280: status = connect(HTChannel_socket(me->channel), (struct sockaddr *) &me->sock_addr,
281: sizeof(me->sock_addr));
2.55 frystyk 282: /*
283: * According to the Sun man page for connect:
284: * EINPROGRESS The socket is non-blocking and the con-
285: * nection cannot be completed immediately.
286: * It is possible to select(2) for comple-
287: * tion by selecting the socket for writ-
288: * ing.
289: * According to the Motorola SVR4 man page for connect:
290: * EAGAIN The socket is non-blocking and the con-
291: * nection cannot be completed immediately.
292: * It is possible to select for completion
293: * by selecting the socket for writing.
294: * However, this is only possible if the
295: * socket STREAMS module is the topmost
296: * module on the protocol stack with a
297: * write service procedure. This will be
298: * the normal case.
299: */
2.93 eric 300: if (NETCALL_ERROR(status))
2.55 frystyk 301: {
2.93 eric 302: if (NETCALL_WOULDBLOCK(socerrno))
2.55 frystyk 303: {
2.114 ! frystyk 304: HTTRACE(PROT_TRACE, "HTDoConnect. WOULD BLOCK `%s'\n" _ hostname);
2.95 frystyk 305: HTHost_register(me, net, HTEvent_CONNECT);
2.55 frystyk 306: return HT_WOULD_BLOCK;
307: }
308: if (socerrno == EISCONN) {
2.95 frystyk 309: me->tcpstate = TCP_CONNECTED;
2.114 ! frystyk 310: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_CONNECTED.\n" _ me);
2.55 frystyk 311: break;
312: }
2.93 eric 313: if (NETCALL_DEADSOCKET(socerrno)) /* We lost the socket */
2.58 frystyk 314: {
2.95 frystyk 315: me->tcpstate = TCP_NEED_SOCKET;
2.114 ! frystyk 316: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_NEED_SOCKET.\n" _ me);
2.55 frystyk 317: break;
2.27 frystyk 318: }
2.102 frystyk 319: if (HTHost_retry(me)) {
2.113 frystyk 320: me->connecttime = HTGetTimeInMillis() - me->connecttime;
2.54 frystyk 321: /* Added EINVAL `invalid argument' as this is what I
322: get back from a non-blocking connect where I should
323: get `connection refused' on BSD. SVR4 gives SIG_PIPE */
2.112 frystyk 324: if (HT_HOSTUNREACHABLE(socerrno))
2.95 frystyk 325: me->connecttime += TCP_DELAY;
2.54 frystyk 326: else
2.95 frystyk 327: me->connecttime += TCP_PENALTY;
2.102 frystyk 328: HTDNS_updateWeigths(me->dns, HTHost_home(me), me->connecttime);
2.55 frystyk 329: }
2.95 frystyk 330: me->tcpstate = TCP_ERROR;
2.114 ! frystyk 331: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_ERROR.\n" _ me);
2.95 frystyk 332: } else {
333: me->tcpstate = TCP_CONNECTED;
2.114 ! frystyk 334: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_CONNECTED.\n" _ me);
2.95 frystyk 335: }
2.55 frystyk 336: break;
337:
338: case TCP_CONNECTED:
2.95 frystyk 339: HTHost_unregister(me, net, HTEvent_CONNECT);
2.102 frystyk 340: if (HTHost_retry(me)) {
2.113 frystyk 341: me->connecttime = HTGetTimeInMillis() - me->connecttime;
2.102 frystyk 342: HTDNS_updateWeigths(me->dns, HTHost_home(me), me->connecttime);
2.27 frystyk 343: }
2.102 frystyk 344: HTHost_setRetry(me, 0);
2.100 eric 345: me->tcpstate = TCP_IN_USE;
2.114 ! frystyk 346: HTTRACE(PROT_TRACE, "HTHost %p connected.\n" _ me);
2.55 frystyk 347: return HT_OK;
348: break;
2.100 eric 349:
350: /* once a host is connected, subsequent connections are immediately OK */
351: case TCP_IN_USE:
352: if ((status = HTHost_addNet(net->host, net)) == HT_PENDING) {
2.114 ! frystyk 353: HTTRACE(PROT_TRACE, "HTDoConnect. Pending...\n");
2.100 eric 354: return HT_PENDING;
355: }
356:
357: HTChannel_upSemaphore(me->channel);
358: return HT_OK;
2.109 frystyk 359:
360: case TCP_DNS_ERROR:
361: HTHost_setRetry(me, 0);
362: me->tcpstate = TCP_BEGIN;
2.114 ! frystyk 363: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_BEGIN.\n" _ me);
2.112 frystyk 364: return HT_NO_HOST;
2.109 frystyk 365: break;
2.55 frystyk 366:
2.56 frystyk 367: case TCP_NEED_BIND:
368: case TCP_NEED_LISTEN:
2.55 frystyk 369: case TCP_ERROR:
2.95 frystyk 370: if (HTChannel_socket(me->channel) != INVSOC) {
371: NETCLOSE(HTChannel_socket(me->channel));
372: #if 1 /* @@@ */
373: if (HTHost_isPersistent(me)) { /* Inherited socket */
374: HTHost_setPersistent(me, NO, HT_TP_SINGLE);
375: me->tcpstate = TCP_NEED_SOCKET;
2.114 ! frystyk 376: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_NEED_SOCKET.\n" _ me);
2.55 frystyk 377: break;
378: }
2.95 frystyk 379: #endif
2.55 frystyk 380: }
381:
382: /* Do we have more homes to try? */
2.102 frystyk 383: HTHost_decreaseRetry(me);
2.112 frystyk 384: if (HT_HOSTUNREACHABLE(socerrno) && HTHost_retry(me) > 0) {
385: HTRequest_addSystemError(request, ERR_NON_FATAL, socerrno, NO,"connect");
2.95 frystyk 386: me->tcpstate = TCP_DNS;
2.114 ! frystyk 387: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_DNS.\n" _ me);
2.24 frystyk 388: break;
389: }
2.112 frystyk 390: HTRequest_addSystemError(request, ERR_FATAL, socerrno, NO, "connect");
2.91 frystyk 391: HTDNS_delete(hostname);
2.102 frystyk 392: HTHost_setRetry(me, 0);
2.95 frystyk 393: me->tcpstate = TCP_BEGIN;
2.114 ! frystyk 394: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_BEGIN.\n" _ me);
2.55 frystyk 395: return HT_ERROR;
396: break;
2.24 frystyk 397: }
2.55 frystyk 398: }
2.13 frystyk 399: }
400:
2.56 frystyk 401: /* HTDoAccept()
402: ** ------------
403: ** This function makes a non-blocking accept which will turn up as ready
404: ** read in the select.
405: ** Returns
406: ** HT_ERROR Error has occured or interrupted
407: ** HT_OK if connected
408: ** HT_WOULD_BLOCK if operation would have blocked
2.13 frystyk 409: */
2.88 frystyk 410: PUBLIC int HTDoAccept (HTNet * net, HTNet ** accepted)
2.13 frystyk 411: {
2.111 frystyk 412: HTHost * me = HTNet_host(net);
2.13 frystyk 413: int status;
2.95 frystyk 414: int size = sizeof(net->host->sock_addr);
2.88 frystyk 415: HTRequest * request = HTNet_request(net);
2.95 frystyk 416: if (!request || HTNet_socket(net)==INVSOC) {
2.114 ! frystyk 417: HTTRACE(PROT_TRACE, "HTDoAccept.. Invalid socket\n");
2.56 frystyk 418: return HT_ERROR;
2.13 frystyk 419: }
2.65 frystyk 420:
421: /* Progress report */
422: {
423: HTAlertCallback *cbf = HTAlert_find(HT_PROG_ACCEPT);
424: if (cbf) (*cbf)(request, HT_PROG_ACCEPT, HT_MSG_NULL,NULL, NULL, NULL);
425: }
2.95 frystyk 426: status = accept(HTNet_socket(net), (struct sockaddr *) &net->host->sock_addr, &size);
2.93 eric 427: if (NETCALL_ERROR(status))
2.23 duns 428: {
2.93 eric 429: if (NETCALL_WOULDBLOCK(socerrno))
2.56 frystyk 430: {
2.114 ! frystyk 431: HTTRACE(PROT_TRACE, "HTDoAccept.. WOULD BLOCK %d\n" _ HTNet_socket(net));
2.111 frystyk 432: HTHost_register(me, net, HTEvent_ACCEPT);
2.56 frystyk 433: return HT_WOULD_BLOCK;
434: }
2.65 frystyk 435: HTRequest_addSystemError(request, ERR_WARN, socerrno, YES, "accept");
2.114 ! frystyk 436: HTTRACE(PROT_TRACE, "HTDoAccept.. Accept failed\n");
2.56 frystyk 437: return HT_ERROR;
2.23 duns 438: }
2.71 frystyk 439:
2.114 ! frystyk 440: HTTRACE(PROT_TRACE, "Accepted.... socket %d\n" _ status);
2.88 frystyk 441:
442: /*
443: ** If accepted is the same as the net obejct then reuse it, else create
444: ** a new object and leave the original alone
445: */
446: if (*accepted == net)
447: HTDoClose(net);
448: else
449: *accepted = HTNet_dup(net);
2.95 frystyk 450: HTNet_setSocket(*accepted, status);
2.83 frystyk 451:
2.56 frystyk 452: return HT_OK;
453: }
454:
455:
456: /* HTDoListen
457: ** ----------
458: ** Listens on the specified port. 0 means that we chose it here
459: ** If master==INVSOC then we listen on all local interfaces (using a
460: ** wildcard). If !INVSOC then use this as the local interface
461: ** returns HT_ERROR Error has occured or interrupted
462: ** HT_OK if connected
463: */
2.67 frystyk 464: PUBLIC int HTDoListen (HTNet * net, u_short port, SOCKET master, int backlog)
2.56 frystyk 465: {
2.111 frystyk 466: HTHost * me = HTNet_host(net);
467: HTRequest * request = HTNet_request(net);
468: int preemptive = net->preemptive;
469: int status = HT_OK;
470: char * hostname = HTHost_name(me);
2.56 frystyk 471:
472: /* Jump into the state machine */
473: while (1) {
2.111 frystyk 474: switch (me->tcpstate) {
475: case TCP_BEGIN:
476: {
477: /*
478: ** Add the net object to the host object found above. If the
479: ** host is idle then we can start the request right away,
480: ** otherwise we must wait until it is free.
481: */
482: if ((status = HTHost_addNet(net->host, net)) == HT_PENDING)
2.114 ! frystyk 483: HTTRACE(PROT_TRACE, "HTDoListen.. Pending...\n");
2.111 frystyk 484:
485: /*
486: ** If we are pending then return here, otherwise go to next state
487: ** which is setting up a channel
488: */
489: me->tcpstate = TCP_CHANNEL;
2.114 ! frystyk 490: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_CHANNEL.\n" _ me);
2.111 frystyk 491: if (status == HT_PENDING) return HT_PENDING;
492: }
493: break;
494:
495: case TCP_CHANNEL:
496: /*
497: ** The next state depends on whether we have a connection or not.
498: */
499: if (HTHost_channel(me) == NULL) {
500: me->tcpstate = TCP_NEED_SOCKET;
2.114 ! frystyk 501: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_SOCKET.\n" _ me);
2.111 frystyk 502: } else {
503:
504: /*
505: ** There is now one more using the channel
506: */
507: HTChannel_upSemaphore(me->channel);
508:
509: /*
510: ** We are now all set and can jump to connected mode
511: */
512: me->tcpstate = TCP_CONNECTED;
2.114 ! frystyk 513: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_CONNECTED.\n" _ me);
2.56 frystyk 514: }
2.111 frystyk 515: hostname = HTHost_name(me);
2.56 frystyk 516: break;
517:
2.111 frystyk 518: case TCP_NEED_SOCKET:
2.112 frystyk 519: if (_makeSocket(me, request, preemptive, net->transport) == -1) {
520: me->tcpstate = TCP_ERROR;
2.111 frystyk 521: break;
2.112 frystyk 522: }
2.111 frystyk 523:
524: /* Progress */
525: {
526: HTAlertCallback *cbf = HTAlert_find(HT_PROG_ACCEPT);
527: if (cbf) (*cbf)(request, HT_PROG_ACCEPT, HT_MSG_NULL,
528: NULL, hostname, NULL);
529: }
530: me->tcpstate = TCP_NEED_BIND;
2.114 ! frystyk 531: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_NEED_BIND\n" _ me);
2.56 frystyk 532: break;
533:
2.111 frystyk 534: case TCP_NEED_BIND:
2.114 ! frystyk 535: HTTRACE(PROT_TRACE, "Socket...... Binding socket %d\n" _ HTNet_socket(net));
2.111 frystyk 536: status = bind(HTNet_socket(net), (struct sockaddr *) &me->sock_addr,
537: sizeof(me->sock_addr));
538: if (NETCALL_ERROR(status)) {
2.114 ! frystyk 539: HTTRACE(PROT_TRACE, "Socket...... Bind failed %d\n" _ socerrno);
2.111 frystyk 540: me->tcpstate = TCP_ERROR;
541: } else {
2.114 ! frystyk 542: HTTRACE(PROT_TRACE, "Socket...... Starting listening on socket %d\n" _ HTNet_socket(net));
2.111 frystyk 543: me->tcpstate = TCP_NEED_LISTEN;
544: }
2.56 frystyk 545: break;
546:
2.111 frystyk 547: case TCP_NEED_LISTEN:
2.95 frystyk 548: status = listen(HTNet_socket(net), backlog);
2.93 eric 549: if (NETCALL_ERROR(status))
2.111 frystyk 550: me->tcpstate = TCP_ERROR;
2.56 frystyk 551: else
2.111 frystyk 552: me->tcpstate = TCP_CONNECTED;
2.56 frystyk 553: break;
554:
2.111 frystyk 555: case TCP_CONNECTED:
556: HTHost_unregister(me, net, HTEvent_ACCEPT);
557: HTHost_setRetry(me, 0);
558: me->tcpstate = TCP_IN_USE;
2.114 ! frystyk 559: HTTRACE(PROT_TRACE, "HTHost %p listening.\n" _ me);
2.56 frystyk 560: return HT_OK;
561: break;
2.13 frystyk 562:
2.111 frystyk 563: /* once a host is connected, subsequent connections are immediately OK */
564: case TCP_IN_USE:
565: if ((status = HTHost_addNet(net->host, net)) == HT_PENDING) {
2.114 ! frystyk 566: HTTRACE(PROT_TRACE, "HTDoListen.. Pending...\n");
2.111 frystyk 567: return HT_PENDING;
568: }
569:
570: HTChannel_upSemaphore(me->channel);
571: return HT_OK;
572:
573: case TCP_NEED_CONNECT:
574: case TCP_DNS:
575: case TCP_DNS_ERROR:
576: case TCP_ERROR:
577: if (HTChannel_socket(me->channel) != INVSOC) {
578: NETCLOSE(HTChannel_socket(me->channel));
579: #if 1 /* @@@ */
580: if (HTHost_isPersistent(me)) { /* Inherited socket */
581: HTHost_setPersistent(me, NO, HT_TP_SINGLE);
582: me->tcpstate = TCP_NEED_SOCKET;
2.114 ! frystyk 583: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_NEED_SOCKET.\n" _ me);
2.111 frystyk 584: break;
585: }
586: #endif
587: }
588:
589: HTRequest_addSystemError(request, ERR_FATAL, socerrno, NO, "accept");
590: HTHost_setRetry(me, 0);
591: me->tcpstate = TCP_BEGIN;
2.114 ! frystyk 592: HTTRACE(PROT_TRACE, "HTHost %p going to state TCP_BEGIN.\n" _ me);
2.56 frystyk 593: return HT_ERROR;
594: break;
595: }
2.38 frystyk 596: }
1.1 timbl 597: }
598:
2.83 frystyk 599: /* HTDoClose
600: ** ---------
601: ** Closes a file descriptor whatever means are available on the current
602: ** platform. If we have unix file descriptors then use this otherwise use
603: ** the ANSI C file descriptors
604: **
605: ** returns HT_ERROR Error has occured or interrupted
606: ** HT_OK if connected
607: ** HT_WOULD_BLOCK if operation would have blocked
608: */
2.87 frystyk 609: PUBLIC int HTDoClose (HTNet * net)
2.83 frystyk 610: {
611: int status = -1;
2.95 frystyk 612: if (net && HTNet_socket(net) != INVSOC) {
2.114 ! frystyk 613: HTTRACE(PROT_TRACE, "HTDoClose... Close %d\n" _ HTNet_socket(net));
2.95 frystyk 614: status = NETCLOSE(HTNet_socket(net));
615: /* HTEvent_unregister(HTNet_socket(net), (SockOps) FD_ALL); */
2.91 frystyk 616: HTNet_decreaseSocket();
2.95 frystyk 617: HTNet_setSocket(net, INVSOC);
2.91 frystyk 618:
619: /*
620: ** As we have a socket available we check for whether
621: ** we can start any pending requests. We do this by asking for
622: ** pending Host objects. If none then use the current object
623: */
624: HTHost_launchPending(net->host);
625:
626: } else
2.114 ! frystyk 627: HTTRACE(PROT_TRACE, "HTDoClose... No pending requests\n");
2.83 frystyk 628: return status < 0 ? HT_ERROR : HT_OK;
629: }
2.91 frystyk 630:
2.83 frystyk 631:
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