Annotation of libwww/Library/src/HTNet.c, revision 2.55
2.23 frystyk 1: /* HTNet.c
2: ** ASYNCRONOUS SOCKET MANAGEMENT
2.1 frystyk 3: **
2.10 frystyk 4: ** (c) COPYRIGHT MIT 1995.
2.4 frystyk 5: ** Please first read the full copyright statement in the file COPYRIGH.
6: **
7: ** This is the implementation of the internal library multithreading
2.1 frystyk 8: ** functions. This includes an interrupt handler and a event loop.
9: **
10: ** History:
2.14 frystyk 11: ** 12 June 94 Written by Henrik Frystyk, frystyk@w3.org
2.17 frystyk 12: ** 31 May 95 Charlie Brooks cbrooks@osf.org
13: **
2.1 frystyk 14: */
15:
2.9 frystyk 16: /* Implemention dependent include files */
2.52 frystyk 17: #include "sysdep.h"
2.9 frystyk 18:
2.1 frystyk 19: /* Library include files */
20: #include "HTUtils.h"
2.16 frystyk 21: #include "HTProt.h"
2.1 frystyk 22: #include "HTError.h"
2.25 frystyk 23: #include "HTAlert.h"
2.37 frystyk 24: #include "HTParse.h"
2.23 frystyk 25: #include "HTReqMan.h"
2.17 frystyk 26: #include "HTEvntrg.h"
2.23 frystyk 27: #include "HTStream.h"
2.55 ! frystyk 28:
! 29: #include "HTMux.h"
! 30:
2.24 frystyk 31: #include "HTNetMan.h" /* Implemented here */
2.1 frystyk 32:
2.9 frystyk 33: #ifdef WIN32
34: #include <io.h>
35: #endif
36:
2.23 frystyk 37: #ifndef HT_MAX_SOCKETS
38: #define HT_MAX_SOCKETS 6
39: #endif
40:
2.33 frystyk 41: typedef struct _NetCall {
2.30 frystyk 42: HTNetCallback * cbf;
2.23 frystyk 43: int status; /* Status associated with this callback */
2.33 frystyk 44: } NetCall;
2.23 frystyk 45:
46: struct _HTStream {
2.52 frystyk 47: const HTStreamClass * isa;
2.23 frystyk 48: /* ... */
49: };
50:
51: PRIVATE int HTMaxActive = HT_MAX_SOCKETS; /* Max active requests */
2.33 frystyk 52: PRIVATE HTList *HTBefore = NULL; /* List of call back functions */
53: PRIVATE HTList *HTAfter = NULL; /* List of call back functions */
2.24 frystyk 54:
2.23 frystyk 55: PRIVATE HTList *HTNetActive = NULL; /* List of active requests */
56: PRIVATE HTList *HTNetPending = NULL; /* List of pending requests */
2.24 frystyk 57: PRIVATE HTList *HTNetPersistent = NULL; /* List of persistent connections */
2.1 frystyk 58:
59: /* ------------------------------------------------------------------------- */
60:
2.23 frystyk 61: /*
62: ** Set the max number of simultanous sockets. Default is HT_MAX_SOCKETS
2.1 frystyk 63: */
2.23 frystyk 64: PUBLIC BOOL HTNet_setMaxSocket (int newmax)
65: {
66: if (newmax > 0) {
67: HTMaxActive = newmax;
68: return YES;
69: }
70: return NO;
71: }
72:
73: PUBLIC int HTNet_maxSocket (void)
2.1 frystyk 74: {
2.23 frystyk 75: return HTMaxActive;
76: }
77:
78: /* ------------------------------------------------------------------------- */
2.33 frystyk 79: /* Call Back Functions */
2.23 frystyk 80: /* ------------------------------------------------------------------------- */
81:
2.33 frystyk 82: /* HTNetCall_add
83: ** -------------
84: ** Register a call back function that is to be called on every request.
85: ** Several call back functions can be registered
2.23 frystyk 86: ** in which case all of them are called in the order of which they
87: ** were registered.
88: **
89: ** The status signifies which call back function to call depending of the
90: ** result of the request. This can be
91: **
92: ** HT_ERROR An error occured
93: ** HT_LOADED The document was loaded
94: ** HT_NO_DATA OK, but no data
2.33 frystyk 95: ** HT_REDIRECT If we received a redirection
2.23 frystyk 96: ** HT_RETRY Retry request after at a later time
97: ** HT_ALL All of above
98: */
2.33 frystyk 99: PUBLIC BOOL HTNetCall_add (HTList * list, HTNetCallback *cbf, int status)
2.23 frystyk 100: {
2.33 frystyk 101: if (WWWTRACE)
2.50 eric 102: HTTrace("Call Add.... HTNetCallback %p\n", (void *) cbf);
2.33 frystyk 103: if (list && cbf) {
2.49 frystyk 104: NetCall *me;
105: if ((me = (NetCall *) HT_CALLOC(1, sizeof(NetCall))) == NULL)
106: HT_OUTOFMEM("HTNetCall_add");
2.33 frystyk 107: me->cbf = cbf;
108: me->status = status;
109: return HTList_addObject(list, (void *) me);
2.23 frystyk 110: }
111: return NO;
112: }
113:
2.33 frystyk 114: /* HTNetCall_delete
115: ** ----------------
116: ** Unregister a call back function from a list
2.23 frystyk 117: */
2.33 frystyk 118: PUBLIC BOOL HTNetCall_delete (HTList * list, HTNetCallback *cbf)
2.23 frystyk 119: {
2.33 frystyk 120: if (WWWTRACE)
2.50 eric 121: HTTrace("Call delete HTNetCallback %p\n", (void *) cbf);
2.33 frystyk 122: if (list && cbf) {
123: HTList *cur = list;
124: NetCall *pres;
125: while ((pres = (NetCall *) HTList_nextObject(cur))) {
2.23 frystyk 126: if (pres->cbf == cbf) {
2.33 frystyk 127: HTList_removeObject(list, (void *) pres);
2.49 frystyk 128: HT_FREE(pres);
2.23 frystyk 129: return YES;
130: }
131: }
132: }
133: return NO;
134: }
2.1 frystyk 135:
2.33 frystyk 136: /* HTNetCall_deleteAll
2.23 frystyk 137: ** -------------------
138: ** Unregisters all call back functions
139: */
2.33 frystyk 140: PUBLIC BOOL HTNetCall_deleteAll (HTList * list)
2.23 frystyk 141: {
2.33 frystyk 142: if (WWWTRACE)
2.50 eric 143: HTTrace("Call delete All callback functions\n");
2.33 frystyk 144: if (list) {
145: HTList *cur = list;
146: NetCall *pres;
147: while ((pres = (NetCall *) HTList_nextObject(cur))) {
148: HTList_removeObject(list, (void *) pres);
2.49 frystyk 149: HT_FREE(pres);
2.23 frystyk 150: }
2.33 frystyk 151: HTList_delete(list);
2.23 frystyk 152: return YES;
153: }
154: return NO;
155: }
156:
2.33 frystyk 157: /* HTNetCall_execute
158: ** -----------------
2.23 frystyk 159: ** Call all the call back functions registered in the list IF not the
160: ** status is HT_IGNORE.
161: ** The callback functions are called in the order of which they
162: ** were registered. At the moment an application callback function is
163: ** called, it can free the request object - it is no longer used by the
164: ** Library.
2.33 frystyk 165: ** Returns what the last callback function returns
2.23 frystyk 166: */
2.33 frystyk 167: PUBLIC int HTNetCall_execute (HTList * list, HTRequest * request, int status)
2.23 frystyk 168: {
2.33 frystyk 169: int ret = HT_OK;
170: if (list && request && status != HT_IGNORE) {
171: int cnt = HTList_count(list);
2.23 frystyk 172: while (--cnt >= 0) {
2.33 frystyk 173: NetCall *pres = (NetCall *) HTList_objectAt(list, cnt);
2.23 frystyk 174: if (pres && (pres->status == status || pres->status == HT_ALL)) {
2.33 frystyk 175: if (WWWTRACE)
2.50 eric 176: HTTrace("Net callback %p (request=%p, status=%d)\n",
2.23 frystyk 177: (void *) pres->cbf, request, status);
2.33 frystyk 178: if ((ret = (*(pres->cbf))(request, status)) != HT_OK) break;
2.23 frystyk 179: }
180: }
2.1 frystyk 181: }
2.33 frystyk 182: return ret;
183: }
184:
185: /*
186: ** Global set of callback functions BEFORE the request is issued
187: ** list can be NULL
188: */
189: PUBLIC BOOL HTNet_setBefore (HTList *list)
190: {
191: if (HTBefore) HTNetCall_deleteAll(HTBefore);
192: HTBefore = list;
193: return YES;
194: }
195:
196: PUBLIC HTList * HTNet_before (void)
197: {
198: return HTBefore;
199: }
200:
201: PUBLIC int HTNet_callBefore (HTRequest *request, int status)
202: {
203: return HTNetCall_execute(HTBefore, request, status);
204: }
205:
206: PUBLIC BOOL HTNetCall_addBefore (HTNetCallback *cbf, int status)
207: {
208: if (!HTBefore) HTBefore = HTList_new();
209: return HTNetCall_add(HTBefore, cbf, status);
210: }
211:
212: /*
213: ** Global set of callback functions AFTER the request is issued
214: ** list can be NULL
215: */
216: PUBLIC BOOL HTNet_setAfter (HTList *list)
217: {
218: if (HTAfter) HTNetCall_deleteAll(HTAfter);
219: HTAfter = list;
220: return YES;
221: }
222:
223: PUBLIC HTList * HTNet_after (void)
224: {
225: return HTAfter;
226: }
227:
228: PUBLIC int HTNet_callAfter (HTRequest *request, int status)
229: {
230: return HTNetCall_execute(HTAfter, request, status);
231: }
232:
233: PUBLIC BOOL HTNetCall_addAfter (HTNetCallback *cbf, int status)
234: {
235: if (!HTAfter) HTAfter = HTList_new();
236: return HTNetCall_add(HTAfter, cbf, status);
2.1 frystyk 237: }
238:
2.23 frystyk 239: /* ------------------------------------------------------------------------- */
240: /* Request Queue */
241: /* ------------------------------------------------------------------------- */
2.1 frystyk 242:
2.23 frystyk 243: /* HTNet_activeQueue
244: ** -----------------
245: ** Returns the list of active requests that are currently having an open
246: ** connection.
247: ** Returns list of HTNet objects or NULL if error
2.1 frystyk 248: */
2.23 frystyk 249: PUBLIC HTList *HTNet_activeQueue (void)
250: {
251: return HTNetActive;
252: }
2.17 frystyk 253:
2.40 frystyk 254: /* HTNet_idle
255: ** ----------
256: ** Returns whether there are active requests
2.28 frystyk 257: */
2.29 frystyk 258: PUBLIC BOOL HTNet_idle (void)
2.28 frystyk 259: {
2.29 frystyk 260: return HTList_isEmpty(HTNetActive);
2.28 frystyk 261: }
262:
2.40 frystyk 263: /* HTNet_empty
264: ** -----------
265: ** Returns whether there are requests registered or not
266: */
267: PUBLIC BOOL HTNet_isEmpty (void)
268: {
269: return (HTList_isEmpty(HTNetActive) && HTList_isEmpty(HTNetPersistent) &&
270: HTList_isEmpty(HTNetPending));
271: }
272:
2.23 frystyk 273: /* HTNet_pendingQueue
274: ** ------------------
275: ** Returns the list of pending requests that are waiting to become active
276: ** Returns list of HTNet objects or NULL if error
277: */
278: PUBLIC HTList *HTNet_pendingQueue (void)
2.1 frystyk 279: {
2.23 frystyk 280: return HTNetPending;
2.1 frystyk 281: }
282:
2.23 frystyk 283: /* ------------------------------------------------------------------------- */
2.55 ! frystyk 284: /* Connection Specifics */
! 285: /* ------------------------------------------------------------------------- */
! 286:
! 287: /* HTNet_Persistent
! 288: ** ----------------
! 289: ** Check whether the net object handles persistent connections
! 290: ** If we have a DNS entry then check that as well.
! 291: */
! 292: PUBLIC BOOL HTNet_persistent (HTNet * net)
! 293: {
! 294: if (net) {
! 295: return net->dns ?
! 296: (net->persistent = HTDNS_socket(net->dns)!=INVSOC) :
! 297: net->persistent;
! 298: }
! 299: return NO;
! 300: }
! 301:
! 302: /* HTNet_persistent
! 303: ** ----------------
! 304: ** Set the net object to handle persistent connections
! 305: ** If we also have a DNS entry then update that as well
! 306: */
! 307: PUBLIC BOOL HTNet_setPersistent (HTNet * net, BOOL persistent)
! 308: {
! 309: if (net) {
! 310: if (PROT_TRACE) HTTrace("Net......... Persistent connection set %s\n",
! 311: persistent ? "ON" : "OFF");
! 312: net->persistent = persistent;
! 313: return net->dns ?
! 314: HTDNS_setSocket(net->dns, persistent ? net->sockfd : INVSOC) : YES;
! 315: }
! 316: return NO;
! 317: }
! 318:
! 319: /* ------------------------------------------------------------------------- */
2.23 frystyk 320: /* Creation and deletion methods */
321: /* ------------------------------------------------------------------------- */
322:
2.27 frystyk 323: /* HTNet_duplicate
324: ** ---------------
325: ** Creates a new HTNet object as a duplicate of the same request.
326: ** Returns YES if OK, else NO
327: ** BUG: We do not check if we have a socket free!
328: */
2.43 frystyk 329: PUBLIC HTNet * HTNet_dup (HTNet * src)
2.27 frystyk 330: {
2.43 frystyk 331: HTNet * me;
2.54 eric 332: if (!src) return 0;
2.49 frystyk 333: if ((me = (HTNet *) HT_MALLOC(sizeof(HTNet))) == NULL)
334: HT_OUTOFMEM("HTNet_dup");
2.44 frystyk 335: memcpy((void *) me, src, sizeof(HTNet));
2.43 frystyk 336: return me;
2.27 frystyk 337: }
338:
2.30 frystyk 339: /* HTNet_priority
340: ** --------------
341: ** Get the current priority of the Net object
342: */
343: PUBLIC HTPriority HTNet_priority (HTNet * net)
344: {
2.51 frystyk 345: return (net ? net->priority : HT_PRIORITY_INV);
2.30 frystyk 346: }
347:
348: /* HTNet_setPriority
349: ** -----------------
350: ** Set the current priority of the Net object
351: ** This will change the priority next time the thread is blocked
352: */
353: PUBLIC BOOL HTNet_setPriority (HTNet * net, HTPriority priority)
354: {
355: if (net) {
356: net->priority = priority;
357: return YES;
358: }
359: return NO;
360: }
361:
2.36 frystyk 362: /* create_object
363: ** -------------
364: ** Creates an HTNet object
365: */
366: PRIVATE HTNet * create_object (HTRequest * request)
367: {
368: HTNet * me;
2.49 frystyk 369: if ((me = (HTNet *) HT_CALLOC(1, sizeof(HTNet))) == NULL)
370: HT_OUTOFMEM("HTNet_new");
2.36 frystyk 371: me->request = request;
372: request->net = me;
2.37 frystyk 373: me->tcpstate = TCP_BEGIN;
2.47 frystyk 374: if (!HTNetActive) HTNetActive = HTList_new();
2.36 frystyk 375: return me;
376: }
377:
2.37 frystyk 378: /* HTNet_new
379: ** ---------
380: ** This function creates a new HTNet object and assigns the socket number
381: ** to it. This is intended to be used when you are going to listen on a
382: ** socket using the HTDoListen() function in HTTCP.c. The function do NOT
383: ** call any of the callback functions.
384: ** Returns new object or NULL on error
385: */
386: PUBLIC HTNet * HTNet_new (HTRequest * request, SOCKET sockfd)
387: {
388: HTNet * me;
2.50 eric 389: if (WWWTRACE) HTTrace("HTNet_new... Create empty Net object\n");
2.37 frystyk 390: if (!request || sockfd==INVSOC) return NULL;
391: if ((me = create_object(request)) == NULL) return NULL;
2.45 frystyk 392: me->preemptive = request->preemptive;
2.37 frystyk 393: me->priority = request->priority;
394: me->sockfd = sockfd;
395: return me;
396: }
397:
398: /* HTNet_newServer
399: ** ---------------
400: ** Create a new HTNet object as a new request to be handled. If we have
401: ** more than HTMaxActive connections already then return NO.
402: ** Returns YES if OK, else NO
403: */
2.46 frystyk 404: PUBLIC BOOL HTNet_newServer (HTRequest * request, SOCKET sockfd, char * access)
2.37 frystyk 405: {
406: HTNet * me;
407: HTProtocol * protocol;
408: if (!request) return NO;
409:
410: /* Check if we can start the request, else return immediately */
411: if (HTList_count(HTNetActive) > HTMaxActive) {
2.50 eric 412: if (PROT_TRACE) HTTrace("HTNet new... NO SOCKET AVAILABLE\n");
2.37 frystyk 413: HTNetCall_execute(HTAfter, request, HT_RETRY);
414: return YES;
415: }
416:
417: /* Find a protocol object for this access scheme */
2.46 frystyk 418: protocol = HTProtocol_find(request, access);
2.37 frystyk 419:
420: /* Create new net object and bind it to the request object */
421: if ((me = create_object(request)) == NULL) return NO;
2.45 frystyk 422: me->preemptive = (HTProtocol_preemptive(protocol) || request->preemptive);
2.37 frystyk 423: me->priority = request->priority;
2.38 frystyk 424: me->sockfd = sockfd;
2.37 frystyk 425: if (!(me->cbf = HTProtocol_server(protocol))) {
2.50 eric 426: if (WWWTRACE) HTTrace("HTNet_new... NO CALL BACK FUNCTION!\n");
2.49 frystyk 427: HT_FREE(me);
2.37 frystyk 428: return NO;
429: }
430: request->retrys++;
431:
432: /* Start the server request */
433: HTList_addObject(HTNetActive, (void *) me);
434: if (WWWTRACE)
2.50 eric 435: HTTrace("HTNet_new... starting SERVER request %p with net object %p\n", request, me);
2.37 frystyk 436: (*(me->cbf))(me->sockfd, request, FD_NONE);
437: return YES;
438: }
2.36 frystyk 439:
2.30 frystyk 440: /* HTNet_new
441: ** ---------
2.23 frystyk 442: ** Create a new HTNet object as a new request to be handled. If we have
443: ** more than HTMaxActive connections already then put this into the
444: ** pending queue, else start the request by calling the call back
445: ** function registered with this access method.
446: ** Returns YES if OK, else NO
447: */
2.37 frystyk 448: PUBLIC BOOL HTNet_newClient (HTRequest * request)
2.23 frystyk 449: {
2.33 frystyk 450: int status;
451: HTNet * me;
2.37 frystyk 452: HTProtocol * protocol;
453: char * physical = NULL;
2.27 frystyk 454: if (!request) return NO;
2.33 frystyk 455: /*
456: ** First we do all the "BEFORE" callbacks in order to see if we are to
457: ** continue with this request or not. If we receive a callback status
458: ** that is NOT HT_OK then jump directly to the after callbacks and return
459: */
2.34 frystyk 460: if ((status = HTNetCall_execute(HTBefore, request, HT_OK)) != HT_OK) {
2.33 frystyk 461: HTNetCall_execute(HTAfter, request, status);
462: return YES;
463: }
464:
2.36 frystyk 465: /*
466: ** If no translation was provided by the application then use the anchor
467: ** address directly
468: */
2.33 frystyk 469: if (!(physical = HTAnchor_physical(request->anchor)) || !*physical) {
2.36 frystyk 470: char * addr = HTAnchor_address((HTAnchor *) request->anchor);
2.50 eric 471: if (WWWTRACE) HTTrace("HTNet New... Using default address\n");
2.36 frystyk 472: HTAnchor_setPhysical(request->anchor, addr);
2.37 frystyk 473: physical = HTAnchor_physical(request->anchor);
2.49 frystyk 474: HT_FREE(addr);
2.33 frystyk 475: }
476:
2.37 frystyk 477: /* Find a protocol object for this access scheme */
478: {
479: char * access = HTParse(physical, "", PARSE_ACCESS);
480: if ((protocol = HTProtocol_find(request, access)) == NULL) {
2.50 eric 481: if (WWWTRACE) HTTrace("HTNet_new... NO PROTOCOL OBJECT\n");
2.49 frystyk 482: HT_FREE(access);
2.37 frystyk 483: return NO;
484: }
2.49 frystyk 485: HT_FREE(access);
2.37 frystyk 486: }
487:
2.23 frystyk 488: /* Create new net object and bind it to the request object */
2.36 frystyk 489: if ((me = create_object(request)) == NULL) return NO;
2.45 frystyk 490: me->preemptive = (HTProtocol_preemptive(protocol) || request->preemptive);
2.30 frystyk 491: me->priority = request->priority;
2.23 frystyk 492: me->sockfd = INVSOC;
2.37 frystyk 493: if (!(me->cbf = HTProtocol_client(protocol))) {
2.50 eric 494: if (WWWTRACE) HTTrace("HTNet_new... NO CALL BACK FUNCTION!\n");
2.49 frystyk 495: HT_FREE(me);
2.23 frystyk 496: return NO;
497: }
2.25 frystyk 498: request->retrys++;
2.23 frystyk 499:
500: /*
501: ** Check if we can start the request, else put it into pending queue
502: ** If so then call the call back function associated with the anchor.
503: ** We use the INVSOC as we don't have a valid socket yet!
504: */
505: if (HTList_count(HTNetActive) < HTMaxActive) {
506: HTList_addObject(HTNetActive, (void *) me);
2.33 frystyk 507: if (WWWTRACE)
2.50 eric 508: HTTrace("HTNet_new... starting request %p (retry=%d) with net object %p\n",
2.43 frystyk 509: request, request->retrys, me);
2.25 frystyk 510: (*(me->cbf))(me->sockfd, request, FD_NONE);
2.23 frystyk 511: } else {
2.35 frystyk 512: HTAlertCallback *cbf = HTAlert_find(HT_PROG_WAIT);
2.23 frystyk 513: if (!HTNetPending) HTNetPending = HTList_new();
2.33 frystyk 514: if (WWWTRACE)
2.50 eric 515: HTTrace("HTNet_new... request %p registered as pending\n",
2.25 frystyk 516: request);
2.35 frystyk 517: if (cbf) (*cbf)(request, HT_PROG_WAIT, HT_MSG_NULL, NULL, NULL, NULL);
2.25 frystyk 518: HTList_addObject(HTNetPending, (void *) me);
2.23 frystyk 519: }
2.36 frystyk 520: return YES;
521: }
522:
2.23 frystyk 523: /* delete_object
524: ** -------------
525: ** Deletes an HTNet object
2.40 frystyk 526: ** Return YES if OK, else NO
2.15 frystyk 527: */
2.23 frystyk 528: PRIVATE BOOL delete_object (HTNet *net, int status)
2.15 frystyk 529: {
2.33 frystyk 530: if (WWWTRACE)
2.50 eric 531: HTTrace("HTNet_delete Remove net object %p\n", net);
2.23 frystyk 532: if (net) {
533:
534: /* Free stream with data FROM network to application */
535: if (net->target) {
536: if (status == HT_INTERRUPTED)
537: (*net->target->isa->abort)(net->target, NULL);
538: else
539: (*net->target->isa->_free)(net->target);
2.48 frystyk 540: net->target = NULL;
2.23 frystyk 541: }
542:
543: /* Close socket */
544: if (net->sockfd != INVSOC) {
2.45 frystyk 545: HTEvent_UnRegister(net->sockfd, (SockOps) FD_ALL);
2.24 frystyk 546: if (HTDNS_socket(net->dns) == INVSOC) {
547: if ((status = NETCLOSE(net->sockfd)) < 0)
2.33 frystyk 548: HTRequest_addSystemError(net->request, ERR_FATAL,
549: socerrno, NO, "NETCLOSE");
2.55 ! frystyk 550: if (WWWTRACE) HTTrace("HTNet_delete closing %d\n",net->sockfd);
2.24 frystyk 551: } else {
2.55 ! frystyk 552: if (WWWTRACE) HTTrace("HTNet_delete keeping %d\n",net->sockfd);
2.25 frystyk 553: HTDNS_clearActive(net->dns);
554: /* Here we should probably use a low priority */
555: HTEvent_Register(net->sockfd, net->request, (SockOps) FD_READ,
556: HTDNS_closeSocket, net->priority);
2.24 frystyk 557: }
2.23 frystyk 558: }
559: if (net->request)
560: net->request->net = NULL; /* Break link to request */
2.49 frystyk 561: HT_FREE(net);
2.23 frystyk 562: return status ? NO : YES;
563: }
564: return NO;
565: }
566:
567: /* HTNet_delete
568: ** ------------
569: ** Deletes the HTNet object from the list of active requests and calls
570: ** any registered call back functions IF not the status is HT_IGNORE.
571: ** This is used if we have internal requests that the app doesn't know
572: ** about. We also see if we have pending requests that can be started
573: ** up now when we have a socket free.
574: ** The callback functions are called in the reverse order of which they
575: ** were registered (last one first)
2.40 frystyk 576: ** Return YES if OK, else NO
2.23 frystyk 577: */
578: PUBLIC BOOL HTNet_delete (HTNet * net, int status)
579: {
2.33 frystyk 580: if (WWWTRACE)
2.50 eric 581: HTTrace("HTNetDelete. Object and call callback functions\n");
2.23 frystyk 582: if (HTNetActive && net) {
2.36 frystyk 583: SOCKET cs = net->sockfd; /* Current sockfd */
2.23 frystyk 584:
585: /* Remove object and call callback functions */
586: HTRequest *request = net->request;
2.42 frystyk 587: if (HTList_removeObject(HTNetActive, (void *) net) != YES)
2.40 frystyk 588: if (WWWTRACE)
2.50 eric 589: HTTrace("HTNetDelete. %p not registered!\n", net);
2.23 frystyk 590: delete_object(net, status);
2.33 frystyk 591: HTNetCall_execute(HTAfter, request, status);
2.23 frystyk 592:
2.25 frystyk 593: /*
594: ** See first if we have a persistent request queued up for this socket
595: ** If not then see if there is a pending request
596: */
597: if (HTNetPersistent) {
598: HTList *cur = HTNetPersistent;
599: HTNet *next;
600: while ((next = (HTNet *) HTList_nextObject(cur))) {
601: if (next->sockfd == cs) {
2.33 frystyk 602: if (WWWTRACE)
2.50 eric 603: HTTrace("HTNet delete Launch request %p on WARM socket %d (net object %p)\n",
2.39 frystyk 604: next->request, next->sockfd, next);
2.28 frystyk 605: HTList_addObject(HTNetActive, (void *) next);
606: HTList_removeObject(HTNetPersistent, (void *) next);
2.41 frystyk 607: (*(next->cbf))(next->sockfd, next->request, FD_WRITE);
2.25 frystyk 608: break;
609: }
610: }
611: } else if (HTList_count(HTNetActive) < HTMaxActive &&
612: HTList_count(HTNetPending)) {
2.23 frystyk 613: HTNet *next = (HTNet *) HTList_removeFirstObject(HTNetPending);
614: if (next) {
615: HTList_addObject(HTNetActive, (void *) next);
2.33 frystyk 616: if (WWWTRACE)
2.50 eric 617: HTTrace("HTNet delete launch PENDING request %p\n",
2.23 frystyk 618: next->request);
619: (*(next->cbf))(INVSOC, next->request, FD_NONE);
620: }
621: }
622: return YES;
623: }
624: return NO;
625: }
626:
627: /* HTNet_deleteAll
628: ** ---------------
629: ** Deletes all HTNet object that might either be active or pending
2.25 frystyk 630: ** We DO NOT call the call back functions - A crude way of saying goodbye!
2.23 frystyk 631: */
632: PUBLIC BOOL HTNet_deleteAll (void)
633: {
2.33 frystyk 634: if (WWWTRACE)
2.50 eric 635: HTTrace("HTNetDelete. Remove all Net objects, NO callback\n");
2.25 frystyk 636: if (HTNetPersistent) {
637: HTList *cur = HTNetPersistent;
638: HTNet *pres;
639: while ((pres = (HTNet *) HTList_nextObject(cur))) {
640: pres->sockfd = INVSOC; /* Don't close it more than once */
641: delete_object(pres, HT_INTERRUPTED);
642: }
643: HTList_delete(HTNetPersistent);
644: HTNetPersistent = NULL;
645: }
2.23 frystyk 646: if (HTNetPending) {
647: HTList *cur = HTNetPending;
648: HTNet *pres;
649: while ((pres = (HTNet *) HTList_nextObject(cur)))
650: delete_object(pres, HT_INTERRUPTED);
651: HTList_delete(HTNetPending);
652: HTNetPending = NULL;
653: }
654: if (HTNetActive) {
655: HTList *cur = HTNetActive;
656: HTNet *pres;
657: while ((pres = (HTNet *) HTList_nextObject(cur)))
658: delete_object(pres, HT_INTERRUPTED);
659: HTList_delete(HTNetActive);
660: HTNetActive = NULL;
661: }
662: return NO;
2.15 frystyk 663: }
664:
2.25 frystyk 665: /* HTNet_wait
666: ** ----------
667: ** Let a net object wait for a persistent socket. It will be launched
668: ** from the HTNet_delete() function
2.40 frystyk 669: ** Return YES if OK, else NO
2.25 frystyk 670: */
671: PUBLIC BOOL HTNet_wait (HTNet *net)
672: {
673: if (net) {
2.33 frystyk 674: if (WWWTRACE)
2.50 eric 675: HTTrace("HTNet_wait.. request %p is waiting for presistent socket %d\n",
2.40 frystyk 676: net->request, net->sockfd);
677:
678: /* Take it out of the active queue and add it to persistent queue */
679: if (HTList_removeObject(HTNetActive, (void *) net) != YES) {
2.50 eric 680: if (WWWTRACE) HTTrace("HTNet_wait.. not registered!\n");
2.40 frystyk 681: return NO;
682: }
2.25 frystyk 683: if (!HTNetPersistent) HTNetPersistent = HTList_new();
2.40 frystyk 684: return HTList_addObject(HTNetPersistent, (void *) net);
2.25 frystyk 685: }
686: return NO;
687: }
688:
2.23 frystyk 689: /* ------------------------------------------------------------------------- */
690: /* Killing requests */
691: /* ------------------------------------------------------------------------- */
692:
693: /* HTNet_kill
694: ** ----------
695: ** Kill the request by calling the call back function with a request for
696: ** closing the connection. Does not remove the object. This is done by
697: ** HTNet_delete() function which is called by the load routine.
698: ** Returns OK if success, NO on error
699: */
700: PUBLIC BOOL HTNet_kill (HTNet * me)
701: {
702: if (HTNetActive && me) {
2.25 frystyk 703: HTList *cur = HTNetActive;
2.23 frystyk 704: HTNet *pres;
2.25 frystyk 705: while ((pres = (HTNet *) HTList_nextObject(cur))) {
2.23 frystyk 706: if (pres == me) {
2.25 frystyk 707: (*(pres->cbf))(pres->sockfd, pres->request, FD_CLOSE);
2.23 frystyk 708: return YES;
709: }
710: }
711: }
2.33 frystyk 712: if (WWWTRACE)
2.50 eric 713: HTTrace("HTNet_kill.. object %p is not registered\n", me);
2.23 frystyk 714: return NO;
715: }
716:
717: /* HTNet_killAll
718: ** -------------
719: ** Kills all registered (active+pending) requests by calling the call
720: ** back function with a request for closing the connection. We do not
721: ** remove the HTNet object as it is done by HTNet_delete().
722: ** Returns OK if success, NO on error
723: */
724: PUBLIC BOOL HTNet_killAll (void)
725: {
726: HTNet *pres;
2.33 frystyk 727: if (WWWTRACE)
2.50 eric 728: HTTrace("HTNet_kill.. ALL registered requests!!!\n");
2.23 frystyk 729:
2.25 frystyk 730: /* We start off in persistent queue so we avoid racing */
731: if (HTNetPersistent) {
732: while ((pres = (HTNet *) HTList_lastObject(HTNetPersistent)) != NULL) {
733: pres->sockfd = INVSOC;
734: (*(pres->cbf))(pres->sockfd, pres->request, FD_CLOSE);
735: HTList_removeObject(HTNetPersistent, pres);
736: }
737: }
2.23 frystyk 738: if (HTNetPending) {
739: while ((pres = (HTNet *) HTList_lastObject(HTNetPending)) != NULL) {
2.25 frystyk 740: (*(pres->cbf))(pres->sockfd, pres->request, FD_CLOSE);
2.23 frystyk 741: HTList_removeObject(HTNetPending, pres);
742: }
743: }
744: if (HTNetActive) {
745: while ((pres = (HTNet *) HTList_lastObject(HTNetActive)) != NULL)
2.25 frystyk 746: (*(pres->cbf))(pres->sockfd, pres->request, FD_CLOSE);
2.23 frystyk 747: }
748: return YES;
749: }
2.38 frystyk 750:
751: /* ------------------------------------------------------------------------- */
752: /* Data Access Methods */
753: /* ------------------------------------------------------------------------- */
754:
755: /*
756: ** Get and set the socket number
757: */
758: PUBLIC BOOL HTNet_setSocket (HTNet * net, SOCKET sockfd)
759: {
760: if (net) {
761: net->sockfd = sockfd;
762: return YES;
763: }
764: return NO;
765: }
766:
767: PUBLIC SOCKET HTNet_socket (HTNet * net)
768: {
769: return (net ? net->sockfd : INVSOC);
770: }
771:
2.55 ! frystyk 772: /*
! 773: ** Get and set the target for this Net object. If we have a interleaved socket
! 774: ** then add the HTDemux stream so that we can get the right part back
! 775: */
! 776: PUBLIC BOOL HTNet_setTarget (HTNet * net, HTStream * target)
! 777: {
! 778: if (net) {
! 779: HTChannelMode mode = HTChannel_mode(net->sockfd, NULL);
! 780: #if 0
! 781: net->target = (mode==HT_CH_INTERLEAVED) ?
! 782: HTDemux_new(net, target) : target;
! 783: #else
! 784: net->target = HTDemux_new(net, target);
! 785: #endif
! 786: return YES;
! 787: }
! 788: return NO;
! 789: }
! 790:
! 791: PUBLIC HTStream * HTNet_target (HTNet * net)
! 792: {
! 793: return (net ? net->target : NULL);
! 794: }
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to HTNet.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / libwww / Library / src