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