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