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