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