Annotation of libwww/Library/src/HTEvtLst.c, revision 2.36
2.4 eric 1: /* HTEvtLst.c
2.1 frystyk 2: ** EVENT MANAGER
3: **
4: ** (c) COPYRIGHT MIT 1995.
5: ** Please first read the full copyright statement in the file COPYRIGH.
2.36 ! frystyk 6: ** @(#) $Id: HTEvtLst.c,v 2.35 1999/02/19 23:09:35 frystyk Exp $
2.1 frystyk 7: **
8: ** Updated HTEvent module
9: ** This new module combines the functions of the old HTEvent module and
10: ** the HTThread module. We retain the old HTThread module, but it
11: ** consists of calls to the HTEvent interfaces
12: **
13: ** Authors:
14: ** HFN Henrik Frystyk <frystyk@w3.org>
15: ** CLB Charlie Brooks <cbrooks@osf.org>
16: ** Bugs
17: **
18: */
19:
20: /* WSAAsyncSelect and windows app stuff need the following definitions:
21: * WWW_WIN_ASYNC - enable WSAAsyncSelect instead of select
22: * _WIN23 - win32 libararies - may be window or console app
23: * _WINSOCKAPI_ - using WINSOCK.DLL - not necessarily the async routines.
24: * _CONSOLE - the console app for NT
25: *
26: * first pass: EGP - 10/26/95
27: */
28:
29: /* Implementation dependent include files */
2.21 frystyk 30: #include "wwwsys.h"
2.1 frystyk 31: #include "WWWUtil.h"
32: #include "WWWCore.h"
33: #include "HTReqMan.h"
34: #include "HTTimer.h"
2.5 eric 35: #include "HTEvent.h"
2.1 frystyk 36: #include "HTEvtLst.h" /* Implemented here */
37:
38: /* Type definitions and global variables etc. local to this module */
39: #define MILLI_PER_SECOND 1000
2.32 frystyk 40: #define HASH(s) ((s) % HT_M_HASH_SIZE)
2.34 frystyk 41:
2.32 frystyk 42: #define EVENTS_TO_EXECUTE 10 /* how many to execute in one select loop */
2.1 frystyk 43:
2.34 frystyk 44: #define HT_FS_BYTES(a) ((((a)/16)+1) * 4)
2.15 frystyk 45:
2.3 eric 46: typedef struct {
47: SOCKET s ; /* our socket */
48: HTEvent * events[HTEvent_TYPES]; /* event parameters for read, write, oob */
2.5 eric 49: HTTimer * timeouts[HTEvent_TYPES];
2.3 eric 50: } SockEvents;
51:
2.34 frystyk 52: typedef struct {
53: HTEvent * event;
54: SOCKET s;
55: HTEventType type;
56: HTPriority skipped;
57: } EventOrder;
58:
2.3 eric 59: typedef enum {
60: SockEvents_mayCreate,
61: SockEvents_find
62: } SockEvents_action;
2.1 frystyk 63:
2.34 frystyk 64: PRIVATE HTList * HashTable [HT_M_HASH_SIZE];
65: PRIVATE HTList * EventOrderList = NULL;
2.1 frystyk 66: PRIVATE int HTEndLoop = 0; /* If !0 then exit event loop */
67:
2.34 frystyk 68: #ifdef WWW_WIN_ASYNC
69: #define TIMEOUT 1 /* WM_TIMER id */
70: PRIVATE HWND HTSocketWin;
71: PRIVATE ATOM HTclass;
72: PRIVATE HINSTANCE HTinstance;
73: PRIVATE unsigned long HTwinMsg;
74: #else /* WWW_WIN_ASYNC */
75: PRIVATE fd_set FdArray[HTEvent_TYPES];
76: PRIVATE SOCKET MaxSock = 0; /* max socket value in use */
77: #endif /* !WWW_WIN_ASYNC */
78:
79: /* ------------------------------------------------------------------------- */
80: /* DEBUG FUNCTIONS */
2.1 frystyk 81: /* ------------------------------------------------------------------------- */
82:
2.36 ! frystyk 83: #ifdef HTDEBUG
2.34 frystyk 84: PRIVATE void Event_trace (HTEvent * event)
2.8 frystyk 85: {
2.34 frystyk 86: if (event) {
2.36 ! frystyk 87: HTTRACE(ALL_TRACE, "%8p: %3d %6d %8p %8p %8p" _
! 88: event _ event->priority _ event->millis _ event->cbf _
! 89: event->param _ event->request);
2.34 frystyk 90: }
2.8 frystyk 91: }
92:
2.34 frystyk 93: PRIVATE void Event_traceHead (void)
2.8 frystyk 94: {
2.36 ! frystyk 95: HTTRACE(ALL_TRACE, " event: pri millis callback param request ");
2.8 frystyk 96: }
97:
2.34 frystyk 98: PRIVATE void Timer_trace (HTTimer * timer)
2.1 frystyk 99: {
2.34 frystyk 100: if (timer) {
2.36 ! frystyk 101: HTTRACE(ALL_TRACE, "%8p: %6d %ld %c %8p" _
! 102: timer _
! 103: HTTimer_expiresAbsolute(timer) _
! 104: HTTimer_expiresRelative(timer) _
! 105: HTTimer_isRelative(timer) ? 'R' : 'A' _
2.34 frystyk 106: HTTimer_callback(timer));
2.1 frystyk 107: }
108: }
109:
2.34 frystyk 110: PRIVATE void Timer_traceHead (void)
2.3 eric 111: {
2.36 ! frystyk 112: HTTRACE(ALL_TRACE, " timer: millis expires ? param callback ");
2.3 eric 113: }
2.34 frystyk 114:
2.1 frystyk 115: /*
116: ** A simple debug function that dumps all the socket arrays
117: ** as trace messages
118: */
2.3 eric 119: PRIVATE void EventList_dump (void)
2.1 frystyk 120: {
2.18 frystyk 121: int v = 0;
2.3 eric 122: HTList* cur;
123: SockEvents * pres;
2.36 ! frystyk 124: HTTRACE(ALL_TRACE, "Event....... Dumping socket events\n");
! 125: HTTRACE(ALL_TRACE, "soc ");
2.34 frystyk 126: Event_traceHead();
2.36 ! frystyk 127: HTTRACE(ALL_TRACE, " ");
2.34 frystyk 128: Timer_traceHead();
2.36 ! frystyk 129: HTTRACE(ALL_TRACE, "\n");
2.32 frystyk 130: for (v = 0; v < HT_M_HASH_SIZE; v++) {
2.3 eric 131: cur = HashTable[v];
132: while ((pres = (SockEvents *) HTList_nextObject(cur))) {
133: int i;
2.36 ! frystyk 134: HTTRACE(ALL_TRACE, "%3d \n" _ pres->s);
2.3 eric 135: for (i = 0; i < HTEvent_TYPES; i++)
136: if (pres->events[i]) {
137: static char * names[HTEvent_TYPES] = {"read", "writ", "xcpt"};
2.36 ! frystyk 138: HTTRACE(ALL_TRACE, "%s " _ names[i]);
2.34 frystyk 139: Event_trace(pres->events[i]);
2.36 ! frystyk 140: HTTRACE(ALL_TRACE, " ");
2.34 frystyk 141: Timer_trace(pres->timeouts[i]);
2.36 ! frystyk 142: HTTRACE(ALL_TRACE, " ");
2.3 eric 143: }
2.36 ! frystyk 144: HTTRACE(ALL_TRACE, "\n");
2.3 eric 145: }
146: }
2.1 frystyk 147: }
2.36 ! frystyk 148: #endif /* HTDEBUG */
2.1 frystyk 149:
150: /* ------------------------------------------------------------------------- */
2.34 frystyk 151: /* EVENT TIMING FUNCTIONS */
152: /* ------------------------------------------------------------------------- */
153:
154: #ifdef WWW_WIN_ASYNC
155: PRIVATE BOOL Timer_setWindowsTimer (HTTimer * timer)
156: {
157: HWND hwnd;
158: UINT id;
159: hwnd = HTEventList_getWinHandle(&id);
160: return SetTimer(hwnd, (UINT)timer, (UINT)HTTimer_getTime(timer), NULL) != 0;
161: }
162:
163: PRIVATE BOOL Timer_deleteWindowsTimer (HTTimer * timer)
164: {
165: HWND hwnd;
166: UINT id;
167: hwnd = HTEventList_getWinHandle(&id);
168: return KillTimer(hwnd, (UINT)timer) != 0;
169: }
170: #endif /* WWW_WIN_ASYNC */
171:
172: /*
173: ** Event timeout handler
174: ** If an event didn't occur before the timeout then call it explicitly
175: ** indicating that it timed out.
176: */
2.5 eric 177: PRIVATE int EventListTimerHandler (HTTimer * timer, void * param, HTEventType type)
178: {
2.11 frystyk 179: SockEvents * sockp = (SockEvents *) param;
180: HTEvent * event = NULL;
2.34 frystyk 181:
182: /* Check for read timeout */
183: if (sockp->timeouts[HTEvent_INDEX(HTEvent_READ)] == timer) {
2.5 eric 184: event = sockp->events[HTEvent_INDEX(HTEvent_READ)];
2.36 ! frystyk 185: HTTRACE(THD_TRACE, "Event....... READ timed out on %d.\n" _ sockp->s);
2.5 eric 186: return (*event->cbf) (sockp->s, event->param, HTEvent_TIMEOUT);
187: }
2.34 frystyk 188:
189: /* Check for write timeout */
190: if (sockp->timeouts[HTEvent_INDEX(HTEvent_WRITE)] == timer) {
2.5 eric 191: event = sockp->events[HTEvent_INDEX(HTEvent_WRITE)];
2.36 ! frystyk 192: HTTRACE(THD_TRACE, "Event....... WRITE timed out on %d.\n" _ sockp->s);
2.5 eric 193: return (*event->cbf) (sockp->s, event->param, HTEvent_TIMEOUT);
194: }
2.34 frystyk 195:
196: /* Check for out-of-band data timeout */
197: if (sockp->timeouts[HTEvent_INDEX(HTEvent_OOB)] == timer) {
2.5 eric 198: event = sockp->events[HTEvent_INDEX(HTEvent_OOB)];
2.36 ! frystyk 199: HTTRACE(THD_TRACE, "Event....... OOB timed out on %d.\n" _ sockp->s);
2.5 eric 200: return (*event->cbf) (sockp->s, event->param, HTEvent_TIMEOUT);
201: }
2.36 ! frystyk 202: HTTRACE(THD_TRACE, "Event....... No event for timer %p with context %p\n" _ timer _ param);
2.5 eric 203: return HT_ERROR;
204: }
205:
2.34 frystyk 206: PUBLIC void CheckSockEvent (HTTimer * timer, HTTimerCallback * cbf, void * param)
207: {
208: SockEvents * sockp = (SockEvents *)param;
209: if (cbf == EventListTimerHandler &&
210: sockp->timeouts[0] != timer &&
211: sockp->timeouts[1] != timer &&
212: sockp->timeouts[2] != timer) {
2.36 ! frystyk 213: HTDEBUGBREAK("Bad timer %p\n" _ timer);
2.34 frystyk 214: }
215: }
216:
217: /* ------------------------------------------------------------------------- */
218: /* EVENT ORDERING STUFF */
2.5 eric 219: /* ------------------------------------------------------------------------- */
2.1 frystyk 220:
2.34 frystyk 221: PRIVATE SockEvents * SockEvents_get (SOCKET s, SockEvents_action action)
2.2 eric 222: {
2.34 frystyk 223: long v = HASH(s);
224: HTList* cur;
225: SockEvents * pres;
226: if (HashTable[v] == NULL) HashTable[v] = HTList_new();
227: cur = HashTable[v];
228: while ((pres = (SockEvents *) HTList_nextObject(cur)))
229: if (pres->s == s) return pres;
230:
231: if (action == SockEvents_mayCreate) {
232: if ((pres = (SockEvents *) HT_CALLOC(1, sizeof(SockEvents))) == NULL)
233: HT_OUTOFMEM("HTEventList_register");
234: pres->s = s;
235: HTList_addObject(HashTable[v], (void *)pres);
236: return pres;
237: }
238: return NULL;
2.2 eric 239: }
240:
2.34 frystyk 241: PRIVATE int EventOrder_add (SOCKET s, HTEventType type, ms_t now)
2.2 eric 242: {
243: EventOrder * pres;
244: HTList * cur = EventOrderList;
245: HTList * insertAfter = cur;
2.5 eric 246: SockEvents * sockp = SockEvents_get(s, SockEvents_find);
247: HTEvent * event;
2.2 eric 248:
2.5 eric 249: if (sockp == NULL || (event = sockp->events[HTEvent_INDEX(type)]) == NULL) {
2.36 ! frystyk 250: HTTRACE(THD_TRACE, "EventOrder.. no event found for socket %d, type %s.\n" _
! 251: s _ HTEvent_type2str(type));
2.2 eric 252: return HT_ERROR;
253: }
254:
2.34 frystyk 255: /* Fixup the timeout */
2.5 eric 256: if (sockp->timeouts[HTEvent_INDEX(type)])
257: HTTimer_refresh(sockp->timeouts[HTEvent_INDEX(type)], now);
258:
2.34 frystyk 259: /* Look to see if it's already here from before */
2.2 eric 260: while ((pres = (EventOrder *) HTList_nextObject(cur))) {
261: if (pres->s == s && pres->event == event && pres->type == type) {
262: pres->skipped++;
263: return HT_OK;
264: }
265: if (pres->event->priority+pres->skipped > event->priority)
266: insertAfter = cur;
267: }
268:
2.34 frystyk 269: /* Create a new element */
2.2 eric 270: if ((pres = (EventOrder *) HT_CALLOC(1, sizeof(EventOrder))) == NULL)
271: HT_OUTOFMEM("EventOrder_add");
272: pres->event = event;
273: pres->s = s;
274: pres->type = type;
275: HTList_addObject(insertAfter, (void *)pres);
276: return HT_OK;
277: }
278:
279: PUBLIC int EventOrder_executeAndDelete (void)
280: {
2.4 eric 281: HTList * cur = EventOrderList;
2.2 eric 282: EventOrder * pres;
283: int i = 0;
2.36 ! frystyk 284: HTTRACE(THD_TRACE, "EventOrder.. execute ordered events\n");
2.4 eric 285: if (cur == NULL) return NO;
2.34 frystyk 286: while ((pres=(EventOrder *) HTList_removeLastObject(cur)) && i<EVENTS_TO_EXECUTE) {
2.5 eric 287: HTEvent * event = pres->event;
288: int ret;
2.36 ! frystyk 289: HTTRACE(THD_TRACE, "EventList... calling socket %d, request %p handler %p type %s\n" _
! 290: pres->s _ (void *) event->request _
! 291: (void *) event->cbf _ HTEvent_type2str(pres->type));
2.5 eric 292: ret = (*pres->event->cbf)(pres->s, pres->event->param, pres->type);
2.2 eric 293: HT_FREE(pres);
2.34 frystyk 294: if (ret != HT_OK) return ret;
2.2 eric 295: i++;
296: }
297: return HT_OK;
298: }
299:
300: PUBLIC BOOL EventOrder_deleteAll (void)
301: {
302: HTList * cur = EventOrderList;
303: EventOrder * pres;
2.36 ! frystyk 304: HTTRACE(THD_TRACE, "EventOrder.. all ordered events\n");
2.4 eric 305: if (cur == NULL) return NO;
2.2 eric 306: while ((pres = (EventOrder *) HTList_nextObject(cur)))
307: HT_FREE(pres);
308: HTList_delete(EventOrderList);
309: EventOrderList = NULL;
310: return YES;
311: }
312:
313: /* ------------------------------------------------------------------------- */
2.34 frystyk 314: /* EVENT REGISTRATION */
315: /* ------------------------------------------------------------------------- */
2.1 frystyk 316:
317: /*
2.15 frystyk 318: ** ResetMaxSock - reset the value of the maximum socket in use
319: */
2.17 frystyk 320: #ifndef WWW_WIN_ASYNC
2.15 frystyk 321: PRIVATE void __ResetMaxSock (void)
322: {
323: SOCKET cnt;
324: SOCKET t_max = 0;
325: SOCKET old_max = MaxSock;
326: for (cnt = 0 ; cnt <= MaxSock; cnt++) {
327: if (FD_ISSET(cnt, (FdArray + HTEvent_INDEX(HTEvent_READ))) ||
328: FD_ISSET(cnt, (FdArray + HTEvent_INDEX(HTEvent_WRITE))) ||
329: FD_ISSET(cnt, (FdArray + HTEvent_INDEX(HTEvent_OOB))))
330: if (cnt > t_max) t_max = cnt;
331: }
332: MaxSock = t_max+1;
2.36 ! frystyk 333: HTTRACE(THD_TRACE, "Event....... Reset MaxSock from %u to %u\n" _ old_max _ MaxSock);
2.15 frystyk 334: return;
335: }
2.17 frystyk 336: #endif /* !WWW_WIN_ASYNC */
2.15 frystyk 337:
2.34 frystyk 338: PRIVATE int EventList_remaining (SockEvents * pres)
2.19 frystyk 339: {
340: int ret = 0;
341: int i;
342: for (i = 0; i < HTEvent_TYPES; i++)
343: if (pres->events[i] != NULL)
344: ret |= 1<<i;
345: return ret;
346: }
347:
2.15 frystyk 348: /*
2.1 frystyk 349: ** For a given socket, reqister a request structure, a set of operations,
350: ** a HTEventCallback function, and a priority. For this implementation,
351: ** we allow only a single HTEventCallback function for all operations.
352: ** and the priority field is ignored.
353: */
354: PUBLIC int HTEventList_register (SOCKET s, HTEventType type, HTEvent * event)
355: {
2.19 frystyk 356: int newset = 0;
2.3 eric 357: SockEvents * sockp;
2.36 ! frystyk 358: HTTRACE(THD_TRACE, "Event....... Register socket %d, request %p handler %p type %s at priority %d\n" _
! 359: s _ (void *) event->request _
! 360: (void *) event->cbf _ HTEvent_type2str(type) _
2.1 frystyk 361: (unsigned) event->priority);
2.4 eric 362: if (s==INVSOC || HTEvent_INDEX(type) >= HTEvent_TYPES)
2.1 frystyk 363: return 0;
364:
365: /*
366: ** Insert socket into appropriate file descriptor set. We also make sure
367: ** that it is registered in the global set.
368: */
2.36 ! frystyk 369: HTTRACE(THD_TRACE, "Event....... Registering socket for %s\n" _ HTEvent_type2str(type));
2.3 eric 370: sockp = SockEvents_get(s, SockEvents_mayCreate);
371: sockp->s = s;
372: sockp->events[HTEvent_INDEX(type)] = event;
2.19 frystyk 373: newset = EventList_remaining(sockp);
2.3 eric 374: #ifdef WWW_WIN_ASYNC
2.19 frystyk 375: if (WSAAsyncSelect(s, HTSocketWin, HTwinMsg, HTEvent_BITS(newset)) < 0) {
2.36 ! frystyk 376: HTTRACE(THD_TRACE, "Event....... WSAAsyncSelect returned `%s'!" _ HTErrnoString(socerrno));
2.3 eric 377: return HT_ERROR;
2.19 frystyk 378: }
2.3 eric 379: #else /* WWW_WIN_ASYNC */
2.1 frystyk 380: FD_SET(s, FdArray+HTEvent_INDEX(type));
2.36 ! frystyk 381:
! 382: HTTRACEDATA((char *) FdArray+HTEvent_INDEX(type), 8, "HTEventList_register: (s:%d)" _ s);
! 383:
2.15 frystyk 384: if (s > MaxSock) {
385: MaxSock = s ;
2.36 ! frystyk 386: HTTRACE(THD_TRACE, "Event....... New value for MaxSock is %d\n" _ MaxSock);
2.15 frystyk 387: }
2.3 eric 388: #endif /* !WWW_WIN_ASYNC */
2.11 frystyk 389:
2.1 frystyk 390: /*
2.11 frystyk 391: ** If the timeout has been set (relative in millis) then we register
392: ** a new timeout for this event unless we already have a timer.
2.1 frystyk 393: */
394: if (event->millis >= 0) {
2.11 frystyk 395: sockp->timeouts[HTEvent_INDEX(type)] =
396: HTTimer_new(sockp->timeouts[HTEvent_INDEX(type)],
2.22 frystyk 397: EventListTimerHandler, sockp, event->millis, YES, YES);
2.1 frystyk 398: }
399:
400: return HT_OK;
401: }
402:
403: /*
404: ** Remove the registered information for the specified socket for the actions
405: ** specified in ops. if no actions remain after the unregister, the registered
406: ** info is deleted, and, if the socket has been registered for notification,
407: ** the HTEventCallback will be invoked.
408: */
2.34 frystyk 409: PUBLIC int HTEventList_unregister (SOCKET s, HTEventType type)
2.1 frystyk 410: {
2.3 eric 411: long v = HASH(s);
412: HTList * cur = HashTable[v];
413: HTList * last = cur;
414: SockEvents * pres;
2.9 eric 415: int ret = HT_ERROR;
2.2 eric 416:
2.9 eric 417: while (cur && (pres = (SockEvents *) HTList_nextObject(cur))) {
2.2 eric 418: if (pres->s == s) {
2.19 frystyk 419: int remaining = 0;
2.1 frystyk 420:
421: /*
422: ** Unregister the event from this action
423: */
2.2 eric 424: pres->events[HTEvent_INDEX(type)] = NULL;
2.19 frystyk 425: remaining = EventList_remaining(pres);
2.1 frystyk 426:
427: /*
428: ** Check to see of there was a timeout connected with the event.
429: ** If so then delete the timeout as well.
430: */
431: {
2.2 eric 432: HTTimer * timer = pres->timeouts[HTEvent_INDEX(type)];
2.19 frystyk 433: if (timer) HTTimer_delete(timer);
434: pres->timeouts[HTEvent_INDEX(type)] = NULL;
2.1 frystyk 435: }
436:
2.18 frystyk 437: #ifdef WWW_WIN_ASYNC
438: if (WSAAsyncSelect(s, HTSocketWin, HTwinMsg, remaining) < 0)
439: ret = HT_ERROR;
440: #else /* WWW_WIN_ASYNC */
441: FD_CLR(s, FdArray+HTEvent_INDEX(type));
2.36 ! frystyk 442:
! 443: HTTRACEDATA((char*)FdArray+HTEvent_INDEX(type), 8, "HTEventList_unregister: (s:%d)" _ s);
! 444:
2.18 frystyk 445: #endif /* !WWW_WIN_ASYNC */
446:
2.1 frystyk 447: /*
448: ** Check to see if we can delete the action completely. We do this
449: ** if there are no more events registered.
450: */
2.19 frystyk 451: if (remaining == 0) {
2.9 eric 452: HTList * doomed = cur;
2.36 ! frystyk 453: HTTRACE(THD_TRACE, "Event....... No more events registered for socket %d\n" _ s);
2.15 frystyk 454:
455: #ifndef WWW_WIN_ASYNC
456: /* Check to see if we have to update MaxSock */
2.34 frystyk 457: if (pres->s >= MaxSock) __ResetMaxSock();
2.15 frystyk 458: #endif /* !WWW_WIN_ASYNC */
459:
2.2 eric 460: HT_FREE(pres);
2.9 eric 461: pres = (SockEvents *) HTList_nextObject(cur);
462: HTList_quickRemoveElement(doomed, last);
463: }
464: ret = HT_OK;
2.15 frystyk 465:
2.36 ! frystyk 466: HTTRACE(THD_TRACE, "Event....... Socket %d unregistered for %s\n" _ s _
2.18 frystyk 467: HTEvent_type2str(type));
2.15 frystyk 468:
2.34 frystyk 469: /* We found the socket and can break */
2.15 frystyk 470: break;
2.9 eric 471: }
472: last = cur;
2.1 frystyk 473: }
2.34 frystyk 474: if (THD_TRACE) {
475: if (ret == HT_ERROR)
2.36 ! frystyk 476: HTTRACE(THD_TRACE, "Event....... Couldn't find socket %d. Can't unregister type %s\n" _
! 477: s _ HTEvent_type2str(type));
2.34 frystyk 478: }
2.9 eric 479: return ret;
2.1 frystyk 480: }
481:
482: /*
483: ** Unregister all sockets
484: ** N.B. we just remove them for our internal data structures: it is up to the
485: ** application to actually close the socket.
486: */
2.2 eric 487: PUBLIC int HTEventList_unregisterAll (void)
2.1 frystyk 488: {
489: int i;
2.36 ! frystyk 490: HTTRACE(THD_TRACE, "Unregister.. all sockets\n");
2.32 frystyk 491: for (i = 0 ; i < HT_M_HASH_SIZE; i++) {
2.2 eric 492: HTList * cur = HashTable[i];
2.3 eric 493: SockEvents * pres;
494: while ((pres = (SockEvents *) HTList_nextObject(cur))) {
495: #ifdef WWW_WIN_ASYNC
496: WSAAsyncSelect(pres->s, HTSocketWin, HTwinMsg, 0);
497: #endif /* WWW_WIN_ASYNC */
2.2 eric 498: HT_FREE(pres);
2.3 eric 499: }
2.2 eric 500: HTList_delete(HashTable[i]);
501: HashTable[i] = NULL;
2.1 frystyk 502: }
2.34 frystyk 503:
2.3 eric 504: #ifndef WWW_WIN_ASYNC
505: MaxSock = 0 ;
2.36 ! frystyk 506: HTTRACE(THD_TRACE, "Event....... New value for MaxSock is %d\n" _ MaxSock);
2.1 frystyk 507: FD_ZERO(FdArray+HTEvent_INDEX(HTEvent_READ));
508: FD_ZERO(FdArray+HTEvent_INDEX(HTEvent_WRITE));
509: FD_ZERO(FdArray+HTEvent_INDEX(HTEvent_OOB));
2.3 eric 510: #endif /* !WWW_WIN_ASYNC */
2.34 frystyk 511:
2.2 eric 512: EventOrder_deleteAll();
2.1 frystyk 513: return 0;
514: }
515:
516: /*
517: ** Dispatch the event to the appropriate event handler.
518: ** If no event handler is found then just return.
519: */
2.5 eric 520: PUBLIC int HTEventList_dispatch (SOCKET s, HTEventType type, ms_t now)
2.1 frystyk 521: {
2.3 eric 522: SockEvents * sockp = SockEvents_get(s, SockEvents_find);
523: if (sockp) {
524: HTEvent * event = sockp->events[HTEvent_INDEX(type)];
2.1 frystyk 525:
2.34 frystyk 526: /* Fixup the timeout */
2.5 eric 527: if (sockp->timeouts[HTEvent_INDEX(type)])
528: HTTimer_refresh(sockp->timeouts[HTEvent_INDEX(type)], now);
2.34 frystyk 529:
2.1 frystyk 530: /*
531: ** If we have found an event object for this event then see
532: ** is we should call it.
533: */
534: if (event && event->priority!=HT_PRIORITY_OFF)
535: return (*event->cbf) (s, event->param, type);
2.36 ! frystyk 536: HTTRACE(THD_TRACE, "Dispatch.... Handler %p NOT called\n" _ sockp);
2.1 frystyk 537: return HT_OK;
538: }
2.36 ! frystyk 539: HTTRACE(THD_TRACE, "Dispatch.... Bad socket %d\n" _ s);
2.1 frystyk 540: return NO;
541: }
542:
2.3 eric 543: PUBLIC HTEvent * HTEventList_lookup (SOCKET s, HTEventType type)
544: {
545: SockEvents * sockp = NULL;
546: if ((sockp = SockEvents_get(s, SockEvents_find)) == NULL)
547: return NULL;
548: return sockp->events[HTEvent_INDEX(type)];
549: }
550:
2.34 frystyk 551: /* ------------------------------------------------------------------------- */
552: /* THE EVENT LOOP */
553: /* ------------------------------------------------------------------------- */
554:
555: /*
556: ** Start eventloop
2.3 eric 557: */
2.34 frystyk 558: PUBLIC int HTEventList_newLoop (void)
2.3 eric 559: {
2.34 frystyk 560: return HTEventList_loop (NULL);
2.3 eric 561: }
562:
2.34 frystyk 563: /*
564: ** Stops the event loop. The function does not guarantee
565: ** that all requests have terminated. This is for the app to do
566: */
567: PUBLIC void HTEventList_stopLoop (void)
2.3 eric 568: {
2.34 frystyk 569: HTEndLoop = 1;
2.3 eric 570: }
571:
2.34 frystyk 572: /*
573: ** There are now two versions of the event loop. The first is if you want
574: ** to use async I/O on windows, and the other is if you want to use normal
575: ** Unix setup with sockets
2.3 eric 576: */
2.34 frystyk 577: PUBLIC int HTEventList_loop (HTRequest * theRequest)
2.3 eric 578: {
2.34 frystyk 579: #ifdef WWW_WIN_ASYNC
2.3 eric 580:
581: MSG msg;
2.25 frystyk 582: int status;
2.30 frystyk 583: while (!HTEndLoop && GetMessage(&msg,0,0,0)) {
2.3 eric 584: TranslateMessage(&msg);
585: DispatchMessage(&msg);
586: }
2.25 frystyk 587:
588: status = HTEndLoop;
589:
590: /* Reset HTEndLoop in case we want to start again */
591: HTEndLoop = 0;
592:
593: return (status == 1 ? HT_OK : HT_ERROR);
2.3 eric 594:
595: #else /* WWW_WIN_ASYNC */
596:
2.1 frystyk 597: fd_set treadset, twriteset, texceptset;
598: struct timeval waittime, * wt;
599: int active_sockets;
600: int maxfds;
2.5 eric 601: ms_t timeout;
602: ms_t now;
2.1 frystyk 603: SOCKET s;
2.5 eric 604: int status = HT_OK;
2.1 frystyk 605:
2.2 eric 606: EventOrderList = HTList_new(); /* is kept around until EventOrder_deleteAll */
607:
2.1 frystyk 608: /* Don't leave this loop until we leave the application */
2.27 frystyk 609: while (!HTEndLoop) {
2.1 frystyk 610: treadset = FdArray[HTEvent_INDEX(HTEvent_READ)];
611: twriteset = FdArray[HTEvent_INDEX(HTEvent_WRITE)];
612: texceptset = FdArray[HTEvent_INDEX(HTEvent_OOB)];
613:
614: /*
615: ** Timeval struct copy needed for linux, as it set the value to the
616: ** remaining timeout while exiting the select. (and perhaps for
617: ** other OS). Code borrowed from X server.
618: */
619: wt = NULL;
2.5 eric 620: if ((status = HTTimer_next(&timeout)))
621: return status;
622: if (timeout != 0) {
2.1 frystyk 623: waittime.tv_sec = timeout / MILLI_PER_SECOND;
624: waittime.tv_usec = (timeout % MILLI_PER_SECOND) *
625: (1000000 / MILLI_PER_SECOND);
626: wt = &waittime;
627: }
628:
2.18 frystyk 629: maxfds = MaxSock;
630:
2.36 ! frystyk 631: HTTRACEDATA((char*)&treadset, HT_FS_BYTES(maxfds),
! 632: "HTEventList_loop pre treadset: (maxfd:%d)" _ maxfds);
! 633: HTTRACEDATA((char*)&twriteset, HT_FS_BYTES(maxfds),
! 634: "HTEventList_loop pre twriteset:");
! 635: HTTRACEDATA((char*)&texceptset, HT_FS_BYTES(maxfds),
! 636: "HTEventList_loop pre texceptset:");
! 637: HTTRACE(THD_TRACE, "Event Loop.. calling select: maxfds is %d\n" _ maxfds);
2.15 frystyk 638:
2.1 frystyk 639: #ifdef __hpux
640: active_sockets = select(maxfds+1, (int *)&treadset, (int *)&twriteset,
641: (int *)&texceptset, wt);
642: #else
643: active_sockets = select(maxfds+1, &treadset, &twriteset, &texceptset, wt);
644: #endif
2.2 eric 645:
2.5 eric 646: now = HTGetTimeInMillis();
2.18 frystyk 647:
2.36 ! frystyk 648: HTTRACEDATA((char*)&treadset, HT_FS_BYTES(maxfds),
! 649: "HTEventList_loop post treadset: (active_sockets:%d)" _ active_sockets);
! 650: HTTRACEDATA((char*)&twriteset, HT_FS_BYTES(maxfds),
! 651: "HTEventList_loop post twriteset: (errno:%d)" _ errno);
! 652: HTTRACEDATA((char*)&texceptset, HT_FS_BYTES(maxfds),
! 653: "HTEventList_loop post texceptset:");
! 654: HTTRACE(THD_TRACE, "Event Loop.. select returns %d\n" _ active_sockets);
2.1 frystyk 655:
656: if (active_sockets == -1) {
2.20 frystyk 657: #ifdef EINTR
658: if (socerrno == EINTR) {
659: /*
660: ** EINTR The select() function was interrupted before any
661: ** of the selected events occurred and before the
662: ** timeout interval expired.
663: **
664: ** If SA_RESTART has been set for the interrupting
665: ** signal, it is implementation-dependent whether
666: ** select() restarts or returns with EINTR.
667: */
2.36 ! frystyk 668: HTTRACE(THD_TRACE, "Event Loop.. select was interruted - try again\n");
2.20 frystyk 669: continue;
670: }
671: #endif /* EINTR */
2.28 frystyk 672: #ifdef EBADF
673: if (socerrno == EBADF) {
674: /*
675: ** EBADF One or more of the file descriptor sets specified
676: ** a file descriptor that is not a valid open file
677: ** descriptor.
678: */
2.36 ! frystyk 679: HTTRACE(THD_TRACE, "Event Loop.. One or more sockets were not through their connect phase - try again\n");
2.28 frystyk 680: continue;
681: }
682: #endif
2.36 ! frystyk 683: HTTRACE(THD_TRACE, "Event Loop.. select returned error %d\n" _ socerrno);
! 684:
! 685: #ifdef HTDEBUG
2.3 eric 686: EventList_dump();
2.36 ! frystyk 687: #endif /* HTDEBUG */
! 688:
2.1 frystyk 689: return HT_ERROR;
690: }
691:
692: /*
693: ** We had a timeout so now we check and see if we have a timeout
2.5 eric 694: ** handler to call. Let HTTimer_next get it.
2.1 frystyk 695: */
2.5 eric 696: if (active_sockets == 0)
2.1 frystyk 697: continue;
698:
2.34 frystyk 699: /* There were active sockets. Determine which fd sets they were in */
2.1 frystyk 700: for (s = 0 ; s <= maxfds ; s++) {
701: if (FD_ISSET(s, &texceptset))
2.34 frystyk 702: if ((status = EventOrder_add(s, HTEvent_OOB, now)) != HT_OK)
2.1 frystyk 703: return status;
704: if (FD_ISSET(s, &twriteset))
2.34 frystyk 705: if ((status = EventOrder_add(s, HTEvent_WRITE, now)) != HT_OK)
2.1 frystyk 706: return status;
707: if (FD_ISSET(s, &treadset))
2.34 frystyk 708: if ((status = EventOrder_add(s, HTEvent_READ, now)) != HT_OK)
2.1 frystyk 709: return status;
710: }
2.34 frystyk 711: if ((status = EventOrder_executeAndDelete()) != HT_OK) return status;
2.27 frystyk 712: };
2.25 frystyk 713:
714: /* Reset HTEndLoop in case we want to start again */
715: HTEndLoop = 0;
2.34 frystyk 716: return HT_OK;
717: #endif /* !WWW_WIN_ASYNC */
718: }
719:
720: /* ------------------------------------------------------------------------- */
721: /* EVENT INITIALIZATION AND TERMINATION */
722: /* ------------------------------------------------------------------------- */
723:
724: #ifdef WWW_WIN_ASYNC
725:
726: /* Only responsible for WM_TIMER and WSA_AsyncSelect */
727: PRIVATE LRESULT CALLBACK AsyncWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
728: {
729: WORD event;
730: SOCKET sock;
731: HTEventType type;
732: ms_t now = HTGetTimeInMillis();
733:
734: /* timeout stuff */
735: if (uMsg == WM_TIMER) {
736: HTTimer_dispatch((HTTimer *)wParam);
737: return (0);
738: }
739:
740: if (uMsg != HTwinMsg) /* not our async message */
741: return (DefWindowProc(hwnd, uMsg, wParam, lParam));
742:
743: event = LOWORD(lParam);
744: sock = (SOCKET)wParam;
745: switch (event) {
746: case FD_READ: type = HTEvent_READ; break;
747: case FD_WRITE: type = HTEvent_WRITE; break;
748: case FD_ACCEPT: type = HTEvent_ACCEPT; break;
749: case FD_CONNECT: type = HTEvent_CONNECT; break;
750: case FD_OOB: type = HTEvent_OOB; break;
751: case FD_CLOSE: type = HTEvent_CLOSE; break;
2.36 ! frystyk 752: default: HTDEBUGBREAK("Unknown event %d\n" _ event);
2.34 frystyk 753: }
754: if (HTEventList_dispatch((int)sock, type, now) != HT_OK)
755: HTEndLoop = -1;
756: return (0);
757: }
2.1 frystyk 758:
2.34 frystyk 759: /* HTEventList_get/setWinHandle
760: ** --------------------------
761: ** Managing the windows handle on Windows
762: */
763: PUBLIC BOOL HTEventList_setWinHandle (HWND window, unsigned long message)
764: {
765: HTSocketWin = window;
766: HTwinMsg = message;
767: return YES;
2.1 frystyk 768: }
769:
2.34 frystyk 770: PUBLIC HWND HTEventList_getWinHandle (unsigned long * pMessage)
771: {
772: if (pMessage)
773: *pMessage = HTwinMsg;
774: return (HTSocketWin);
775: }
776: #endif /* WWW_WIN_ASYNC */
2.12 eric 777:
2.34 frystyk 778: PUBLIC BOOL HTEventInit (void)
2.12 eric 779: {
2.34 frystyk 780: #ifdef WWW_WIN_ASYNC
781: /*
782: ** We are here starting a hidden window to take care of events from
783: ** the async select() call in the async version of the event loop in
784: ** the Internal event manager (HTEvtLst.c)
785: */
786: static char className[] = "AsyncWindowClass";
787: WNDCLASS wc;
788: OSVERSIONINFO osInfo;
789:
790: wc.style=0;
791: wc.lpfnWndProc=(WNDPROC)AsyncWindowProc;
792: wc.cbClsExtra=0;
793: wc.cbWndExtra=0;
794: wc.hIcon=0;
795: wc.hCursor=0;
796: wc.hbrBackground=0;
797: wc.lpszMenuName=(LPSTR)0;
798: wc.lpszClassName=className;
799:
800: osInfo.dwOSVersionInfoSize = sizeof(osInfo);
801: GetVersionEx(&osInfo);
802: if (osInfo.dwPlatformId == VER_PLATFORM_WIN32s || osInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
803: wc.hInstance=GetModuleHandle(NULL); /* 95 and non threaded platforms */
804: else
805: wc.hInstance=GetCurrentProcess(); /* NT and hopefully everything following */
806: HTinstance = wc.hInstance;
807: HTclass = RegisterClass(&wc);
808: if (!HTclass) {
2.36 ! frystyk 809: HTTRACE(THD_TRACE, "HTLibInit.. Can't RegisterClass \"%s\"\n" _ className);
! 810: return NO;
2.34 frystyk 811: }
812: if (!(HTSocketWin = CreateWindow(className, "WWW_WIN_ASYNC", WS_POPUP, CW_USEDEFAULT, CW_USEDEFAULT,
813: CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, wc.hInstance,0))) {
2.36 ! frystyk 814: #ifdef HTDEBUG
2.34 frystyk 815: char space[50];
2.36 ! frystyk 816: HTTRACE(THD_TRACE, "HTLibInit.. Can't Create Window \"WWW_WIN_ASYNC\" - error:");
2.34 frystyk 817: sprintf(space, "%ld\n", GetLastError());
2.36 ! frystyk 818: HTTRACE(THD_TRACE, space);
! 819: #endif /* HTDEBUG */
2.34 frystyk 820: return NO;
821: }
822: HTwinMsg = WM_USER; /* use first available message since app uses none */
823:
824: /* Register platform specific timer handlers for windows */
825: HTTimer_registerSetTimerCallback(Timer_setWindowsTimer);
826: HTTimer_registerDeleteTimerCallback(Timer_deleteWindowsTimer);
827:
828: #endif /* WWW_WIN_ASYNC */
829:
830: #ifdef _WINSOCKAPI_
831: /*
832: ** Initialise WinSock DLL. This must also be shut down! PMH
833: */
834: {
835: WSADATA wsadata;
836: if (WSAStartup(DESIRED_WINSOCK_VERSION, &wsadata)) {
2.36 ! frystyk 837: HTTRACE(THD_TRACE, "HTEventInit. Can't initialize WinSoc\n");
2.34 frystyk 838: WSACleanup();
839: return NO;
840: }
841: if (wsadata.wVersion < MINIMUM_WINSOCK_VERSION) {
2.36 ! frystyk 842: HTTRACE(THD_TRACE, "HTEventInit. Bad version of WinSoc\n");
2.34 frystyk 843: WSACleanup();
844: return NO;
845: }
2.36 ! frystyk 846: HTTRACE(APP_TRACE, "HTEventInit. Using WinSoc version \"%s\".\n" _
2.34 frystyk 847: wsadata.szDescription);
2.12 eric 848: }
2.34 frystyk 849: #endif /* _WINSOCKAPI_ */
850:
851: HTEvent_setRegisterCallback(HTEventList_register);
852: HTEvent_setUnregisterCallback(HTEventList_unregister);
853: return YES;
2.12 eric 854: }
855:
2.34 frystyk 856: PUBLIC BOOL HTEventTerminate (void)
857: {
858: #ifdef _WINSOCKAPI_
859: WSACleanup();
860: #endif /* _WINSOCKAPI_ */
861:
862: #ifdef WWW_WIN_ASYNC
863: DestroyWindow(HTSocketWin);
864: UnregisterClass((LPCTSTR)HTclass, HTinstance);
865: #endif /* WWW_WIN_ASYNC */
866:
867: return YES;
868: }
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to HTEvtLst.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / libwww / Library / src