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