Annotation of Amaya/amaya/AHTBridge.c, revision 1.1
1.1 ! cvs 1: /* AHTBridge.c
! 2: * INTERFACE BRIDGE TO XT, LIBWWW, and AMAYA
! 3: *
! 4: * (c) COPYRIGHT
! 5: * Please first read the full copyright statement in the file COPYRIGH.
! 6: *
! 7: * This module implments the callback setup and handlers between
! 8: * the Xt, libwww, and Amaya procedures
! 9: *
! 10: * History:
! 11: * May 02 96 JK First semi-stable version, Jose Kahan
! 12: * June 01 96 JK First almost-complete version, Jose Kahan
! 13: */
! 14:
! 15: /* Unix/C/X */
! 16: #include "thot_gui.h"
! 17: #include "thot_sys.h"
! 18: #include "message.h"
! 19: #include "dialog.h"
! 20: #include "application.h"
! 21: #include "content.h"
! 22: #include "view.h"
! 23: #include "interface.h"
! 24: #include "amaya.h"
! 25:
! 26: #if 0
! 27: #include "AHTCommon.h"
! 28: #include "query.h"
! 29: #endif
! 30:
! 31: #include "AHTBridge.h" /* implemented here */
! 32:
! 33: #ifdef WWW_XWINDOWS
! 34: /* Amaya's X appcontext */
! 35: extern XtAppContext app_cont;
! 36: #endif
! 37:
! 38:
! 39: #ifndef HACK_WWW
! 40: extern PUBLIC HTEventCallback* HTEvent_Retrieve (SOCKET, SockOps, HTRequest** arp);
! 41: #endif
! 42:
! 43: /*
! 44: ** Private functions
! 45: */
! 46: #ifdef __STDC__
! 47: static void RequestKillReadXtevent (AHTReqContext*);
! 48: static void RequestKillWriteXtevent (AHTReqContext*);
! 49: static void RequestKillExceptXtevent (AHTReqContext*);
! 50: #else
! 51: static void RequestKillReadXtevent ();
! 52: static void RequestKillWriteXtevent ();
! 53: static void RequestKillExceptXtevent ();
! 54: #endif /*__STDC__*/
! 55:
! 56: /*
! 57: * Private variables
! 58: */
! 59:
! 60: /*
! 61: * this set of SockOps map our WinSock "socket event SockOps" into
! 62: * our read and write sets. Note that under the canonical Unix model,
! 63: * a non-blocking socket passed to an accept() call will appear as readable,
! 64: * whilst a non-blocking call to connect() will appear as writeable. In add.
! 65: * if the connection has been closed, the socket will appear readable under
! 66: * BSD Unix semantics
! 67: */
! 68: PRIVATE const SockOps ReadBits = FD_READ | FD_ACCEPT | FD_CLOSE;
! 69: PRIVATE const SockOps WriteBits = FD_WRITE | FD_CONNECT ;
! 70: PRIVATE const SockOps ExceptBits = FD_OOB ;
! 71:
! 72: /*
! 73: * Private functions
! 74: */
! 75:
! 76: /*
! 77: * Callback that acts as a bridge between X and wwwlib.
! 78: * This function is equivalent to the library's __DoCallback()
! 79: * function, but with a different API, to conform to Xt's event loop
! 80: * specifications. For more info, cf. the library's HTEvntrg.c module.
! 81: */
! 82:
! 83: #ifdef WWW_XWINDOWS
! 84: #ifdef __STDC__
! 85: XtInputCallbackProc AHTCallback_bridge (caddr_t cd, int* s, XtInputId* id)
! 86: #else
! 87: XtInputCallbackProc AHTCallback_bridge (cd, s, id)
! 88: caddr_t cd ;
! 89: int* s ;
! 90: XtInputId* id ;
! 91: #endif /* __STDC__ */
! 92:
! 93: #else /* WWW_XWINDOWS */
! 94: /* some winproc someday? */
! 95: LONG AHTCallback_bridge (caddr_t cd, int* s)
! 96: #endif /* !WWW_XWINDOWS */
! 97: {
! 98: int status;
! 99: HTRequest* rqp = NULL;
! 100: AHTReqContext* me;
! 101: SOCKET sock;
! 102: SockOps ops; /* what value goes here ? Ask eric */
! 103:
! 104: /* Libwww 4.1 does not take into account the third parameter
! 105: for this function call */
! 106:
! 107: #ifdef HACK_WWW
! 108: HTEventCallback* cbf;
! 109: #else
! 110: HTEventCallback* cbf = (HTEventCallback*) __RetrieveCBF(*s, ops, &rqp);
! 111: #endif
! 112: me = HTRequest_context (rqp);
! 113:
! 114: #if 0
! 115: switch ((XtInputId) cd) {
! 116: case XtInputReadMask:
! 117: ops = me->read_ops;
! 118: if (me->read_xtinput_id) {
! 119: XtRemoveInput (me->read_xtinput_id);
! 120: if (THD_TRACE)
! 121: fprintf (stderr, "(BT) removing Xtinput %lu R (AHTBridge before cbf), sock %d\n", me->read_xtinput_id, *s);
! 122: me->read_xtinput_id = 0;
! 123: }
! 124: break;
! 125: case XtInputWriteMask:
! 126: ops = me->write_ops;
! 127: if (me->write_xtinput_id) {
! 128: XtRemoveInput(me->write_xtinput_id);
! 129: if (THD_TRACE)
! 130: fprintf (stderr, "(BT) removing Xtinput %lu W (AHTBridge before cbf), sock %d\n", me->write_xtinput_id, *s);
! 131: me->write_xtinput_id = 0;
! 132: }
! 133: break;
! 134: case XtInputExceptMask:
! 135: ops = me->except_ops;
! 136: if (me->except_xtinput_id) {
! 137: XtRemoveInput (me->except_xtinput_id);
! 138: if (THD_TRACE)
! 139: fprintf(stderr, "(BT) removing Xtinput %lu E (AHTBridge before cbf), sock %d\n", me->except_xtinput_id, *s);
! 140: me->except_xtinput_id = 0;
! 141: }
! 142: break;
! 143: } /* switch */
! 144: #endif
! 145:
! 146: if (THD_TRACE)
! 147: fprintf (stderr, "AHTBridge: Processing url %s \n", me->urlName);
! 148:
! 149:
! 150: #ifdef WWW_XWINDOWS
! 151: switch ((XtInputId) cd) {
! 152: case XtInputReadMask:
! 153: ops = me->read_ops;
! 154: ops = FD_READ;
! 155: break;
! 156: case XtInputWriteMask:
! 157: ops = me->write_ops;
! 158: ops = FD_WRITE;
! 159: break;
! 160: case XtInputExceptMask:
! 161: ops = me->except_ops;
! 162: ops = FD_OOB;
! 163: break;
! 164: } /* switch */
! 165: #endif WWW_XWINDOWS
! 166:
! 167: /*
! 168: * Liberate the input, so that when a pending socket is activated,
! 169: * the socket status will be ... available
! 170: *
! 171: * verify if I can limit this to the unregister function
! 172: * does not look so
! 173: *
! 174: * although it makes no sense, callbacks can be null
! 175: */
! 176:
! 177: if (!cbf || !rqp || rqp->priority == HT_PRIORITY_OFF) {
! 178: if (THD_TRACE)
! 179: HTTrace("Callback.... No callback found\n");
! 180: /* put some more code to correctly destroy this request */
! 181: return (0);
! 182: }
! 183:
! 184: me->reqStatus = HT_BUSY;
! 185:
! 186: if ((status = (*cbf) (*s, rqp, ops)) != HT_OK)
! 187: HTTrace("Callback.... received != HT_OK");
! 188:
! 189: /* Several states can happen after this callback. They
! 190: * are indicated by the me->reqStatus structure member and
! 191: * the fds external variables. The following lines examine
! 192: * the states and correspondly update the Xt event register
! 193: *
! 194: * Regarding the me->reqStatus member, we have the following
! 195: * possible states:
! 196: *
! 197: * HT_BUSY: Request has blocked
! 198: * HT_WAITING: Request has been reissued
! 199: * HT_ABORT: Request has been stopped
! 200: * HT_END: Request has ended
! 201: */
! 202:
! 203: /* Has the request been stopped?
! 204: *
! 205: * we verify if the request exists. If it has ended, me will have
! 206: * a reqStatus with an HT_END value */
! 207:
! 208: /* Was the stop button pressed? */
! 209:
! 210: #ifdef WWW_XWINDOWS
! 211: if (me->reqStatus == HT_ABORT) {
! 212: me->reqStatus = HT_WAITING;
! 213: StopRequest (me->docid);
! 214: if (THD_TRACE)
! 215: fprintf(stderr, "(BF) removing Xtinput %lu !RWE (Stop buttonl), sock %d\n", me->read_xtinput_id, sock);
! 216: return(0);
! 217: }
! 218: #endif /* WWW_XWINDOWS */
! 219:
! 220: /* the request is being reissued */
! 221:
! 222: if (me->reqStatus == HT_WAITING) {
! 223: /*
! 224: * (1) The old request has ended and the library
! 225: * assigned the old socket number to a pending
! 226: * request.
! 227: *
! 228: * (2) The request has been reissued after an
! 229: * authentication or redirection directive and
! 230: * we are using the same old socket number.
! 231: */
! 232:
! 233: if (THD_TRACE)
! 234: fprintf(stderr, "*** detected a reissue of request \n");
! 235: return(0);
! 236: }
! 237:
! 238:
! 239: /* verify if the request is still alive !! */
! 240:
! 241: if ((me->request->net == (HTNet*) NULL) || (me->reqStatus == HT_END || me->reqStatus == HT_ERR)) {
! 242: /* the socket is now being used by a different request, so the request has ended */
! 243: #ifdef WWW_XWINDOWS
! 244: if (THD_TRACE)
! 245: fprintf(stderr, "(BF) removing Xtinput %lu !RWE, sock %d (Request has ended)\n", *id, *s);
! 246: #endif
! 247: if ((me->mode & AMAYA_ASYNC) || (me->mode & AMAYA_IASYNC)) {
! 248: AHTPrintPendingRequestStatus (me->docid, YES);
! 249: AHTReqContext_delete(me);
! 250: }
! 251: else
! 252: if (me->reqStatus != HT_END && HTError_hasSeverity(HTRequest_error(me->request), ERR_NON_FATAL))
! 253: me->reqStatus = HT_ERR;
! 254: return(0);
! 255: }
! 256: me->reqStatus = HT_WAITING;
! 257: return (0);
! 258: }
! 259:
! 260:
! 261: /*
! 262: * This function is called whenever a socket is available
! 263: * for a request. It the necessary events to the Xt
! 264: * A small interface to the HTLoadAnchor libwww function.
! 265: * It prepares Xt to handle the asynchronous data requests.
! 266: */
! 267:
! 268: #ifdef __STDC__
! 269: int Add_NewSocket_to_Loop (HTRequest* request, HTAlertOpcode op, int msgnum, const char* dfault, void* input, HTAlertPar* reply)
! 270: #else
! 271: int Add_NewSocket_to_Loop (request, op, msgnum, dfault, input, reply)
! 272: HTRequest* request;
! 273: HTAlertOpcode op;
! 274: int msgnum;
! 275: const char* dfault;
! 276: void* input;
! 277: HTAlertPar* reply;
! 278: #endif /*__STDC__*/
! 279: {
! 280: SOCKET req_socket;
! 281: AHTReqContext* me = HTRequest_context (request);
! 282:
! 283: /* AmayaOpenRequests *reqState; */
! 284:
! 285: if(me->reqStatus == HT_NEW_PENDING) {
! 286: /* we are opening a pending request */
! 287: if ((me->output = fopen (me->outputfile, "w")) == NULL) {
! 288: me->outputfile[0] = '\0'; /* file could not be opened */
! 289: TtaSetStatus (me->docid, 1, TtaGetMessage (AMAYA, AM_CANNOT_CREATE_FILE),
! 290: me->outputfile);
! 291: me->reqStatus = HT_ERR;
! 292: return(HT_ERROR);
! 293: }
! 294: if (THD_TRACE)
! 295: fprintf(stderr, "Add_NewSocket_to_Loop: Activating pending %s . Open fd %d\n", me->urlName, (int) me->output);
! 296: HTRequest_setOutputStream (me->request,
! 297: AHTFWriter_new (me->request, me->output, YES));
! 298: }
! 299:
! 300: me->reqStatus = HT_WAITING;
! 301:
! 302: if (THD_TRACE)
! 303: fprintf(stderr, "(Activating a pending request\n");
! 304:
! 305: /* reusing this function to save on file descriptors */
! 306:
! 307:
! 308: return (HT_OK);
! 309:
! 310: /***
! 311: if(me->method == METHOD_PUT || me->method == METHOD_POST)
! 312: return (HT_OK);
! 313: ***/
! 314:
! 315: /* get the socket number associated to the request */
! 316:
! 317: req_socket = HTNet_socket(request->net);
! 318:
! 319: if (req_socket == INVSOC) {
! 320: /* this should never be true */
! 321: return (HT_ERROR);
! 322: }
! 323:
! 324: /* add the input */
! 325:
! 326: #ifdef WWW_XWINDOWS
! 327: me->write_xtinput_id =
! 328: XtAppAddInput (app_cont,req_socket, (XtPointer) XtInputWriteMask,
! 329: (XtInputCallbackProc) AHTCallback_bridge, NULL);
! 330: if (THD_TRACE)
! 331: fprintf(stderr, "(BT) adding Xtinput %lu Socket %d W \n", me->write_xtinput_id, req_socket);
! 332:
! 333: if (me->write_xtinput_id == (XtInputId) NULL) {
! 334: TtaSetStatus(me->docid, 1, TtaGetMessage(AMAYA, AM_XT_ERROR), me->urlName);
! 335:
! 336: /* I still need to add some error treatment here, to liberate memory */
! 337: return (HT_ERROR);
! 338: }
! 339:
! 340: #endif /* WWW_XWINDOWS */
! 341: /* To speed up the stop performances, we move the active requests to the top of the Amaya list */
! 342:
! 343: /*
! 344: reqState = DocRequestState(Amaya->open_requests, me->docid);
! 345:
! 346: if(reqState->counter > 1) {
! 347: HTList_removeObject (Amaya->reqlist, (void *) me);
! 348: HTList_addObject (Amaya->reqlist, (void *) me);
! 349: }
! 350: */
! 351: return (HT_OK);
! 352: }
! 353:
! 354:
! 355: /*
! 356: * This function is called whenever a socket is available
! 357: * for a request. It the necessary events to the Xt
! 358: * A small interface to the HTLoadAnchor libwww function.
! 359: * It prepares Xt to handle the asynchronous data requests.
! 360: */
! 361:
! 362: #ifdef __STDC__
! 363: int AHTEvent_register(SOCKET sock, HTRequest* rqp, SockOps ops, HTEventCallback* cbf, HTPriority p)
! 364: #else
! 365: int AHTEvent_register(sock, rqp, ops, cbf, p)
! 366: SOCKET sock;
! 367: HTRequest* rqp;
! 368: SockOps ops;
! 369: HTEventCallback* cbf;
! 370: HTPriority p;
! 371: #endif /*__STDC__*/
! 372: {
! 373: AHTReqContext* me;
! 374: int status;
! 375:
! 376: if (sock == INVSOC)
! 377: return (0);
! 378:
! 379: /* get the request associated to the socket number */
! 380:
! 381: if((status = HTEventrg_register (sock, rqp, ops,
! 382: cbf,p )) != HT_OK )
! 383: return (status);
! 384:
! 385: if(rqp) {
! 386:
! 387: me = HTRequest_context(rqp);
! 388:
! 389: /* verify if we need to open the fd */
! 390:
! 391: if(me->reqStatus == HT_NEW_PENDING) {
! 392: /* we are opening a pending request */
! 393: if ((me->output = fopen (me->outputfile, "w")) == NULL) {
! 394: me->outputfile[0] = '\0'; /* file could not be opened */
! 395: TtaSetStatus (me->docid, 1, TtaGetMessage (AMAYA, AM_CANNOT_CREATE_FILE),
! 396: me->outputfile);
! 397: me->reqStatus = HT_ERR;
! 398: return(HT_ERROR);
! 399: }
! 400: HTRequest_setOutputStream (me->request,
! 401: AHTFWriter_new (me->request, me->output, YES));
! 402: me->reqStatus = HT_WAITING;
! 403:
! 404: if (THD_TRACE)
! 405: fprintf(stderr,"AHTEvent_register: Activating pending request url %s, fd %d\n", me->urlName, (int) me->output);
! 406: }
! 407:
! 408: if (THD_TRACE)
! 409: fprintf(stderr,"AHTEvent_register: url %s, sock %d, ops %lu \n",
! 410: me->urlName, sock, ops);
! 411:
! 412: /* add the input */
! 413: if(me->reqStatus == HT_NEW)
! 414: me->reqStatus = HT_WAITING;
! 415:
! 416: if (ops & ReadBits) {
! 417: me->read_ops = ops;
! 418:
! 419: #ifdef WWW_XWINDOWS
! 420: if(me->read_xtinput_id)
! 421: XtRemoveInput(me->read_xtinput_id);
! 422: me->read_xtinput_id =
! 423: XtAppAddInput(app_cont,
! 424: sock,
! 425: (XtPointer) XtInputReadMask,
! 426: (XtInputCallbackProc) AHTCallback_bridge,
! 427: (XtPointer) XtInputReadMask);
! 428: if (THD_TRACE)
! 429: fprintf(stderr, "(BT) adding Xtinput %lu Socket %d R\n",
! 430: me->read_xtinput_id, sock);
! 431: #endif /* WWW_XWINDOWS */
! 432: }
! 433:
! 434: if(ops & WriteBits) {
! 435: me->write_ops= ops;
! 436: #ifdef WWW_XWINDOWS
! 437: if (me->write_xtinput_id)
! 438: XtRemoveInput(me->write_xtinput_id);
! 439: me->write_xtinput_id = XtAppAddInput (app_cont, sock,
! 440: (XtPointer) XtInputWriteMask,
! 441: (XtInputCallbackProc) AHTCallback_bridge,
! 442: (XtPointer) XtInputWriteMask);
! 443: if (THD_TRACE)
! 444: fprintf(stderr, "(BT) adding Xtinput %lu Socket %d W\n",
! 445: me->write_xtinput_id, sock);
! 446: #endif /* WWW_XWINDOWS */
! 447: }
! 448:
! 449: if (ops & ExceptBits) {
! 450: me->except_ops = ops;
! 451: #ifdef WWW_XWINDOWS
! 452: if (me->except_xtinput_id)
! 453: XtRemoveInput(me->except_xtinput_id);
! 454:
! 455: me->except_xtinput_id = XtAppAddInput (app_cont, sock,
! 456: (XtPointer) XtInputExceptMask,
! 457: (XtInputCallbackProc) AHTCallback_bridge,
! 458: (XtPointer) XtInputExceptMask);
! 459: if (THD_TRACE)
! 460: fprintf(stderr, "(BT) adding Xtinput %lu Socket %d E\n", me->except_xtinput_id, sock);
! 461: #endif /* WWW_XWINDOWS */
! 462: }
! 463: }
! 464:
! 465:
! 466:
! 467: #if 0
! 468: if (me->xtinput_id == (XtInputId) NULL) {
! 469: TtaSetStatus(me->docid, 1, TtaGetMessage(AMAYA, AM_XT_ERROR), me->urlName);
! 470:
! 471: /* I still need to add some error treatment here, to liberate memory */
! 472: return (HT_ERROR);
! 473: }
! 474:
! 475: #endif
! 476:
! 477: return (status);
! 478: }
! 479:
! 480: #ifdef __STDC__
! 481: int AHTEvent_unregister (SOCKET sock, SockOps ops)
! 482: #else
! 483: int AHTEvent_unregister (sock, ops)
! 484: SOCKET sock;
! 485: SockOps ops;
! 486: #endif /*__STDC__*/
! 487: {
! 488: int status;
! 489:
! 490: HTRequest* rqp = NULL;
! 491: AHTReqContext* me;
! 492:
! 493: /* Libwww 4.1 does not take into account the third parameter
! 494: ** for this function call */
! 495:
! 496: HTEventCallback* cbf = (HTEventCallback*) __RetrieveCBF(sock, (SockOps) NULL, &rqp);
! 497:
! 498: if (cbf) {
! 499: #ifdef WWW_XWINDOWS
! 500: if(rqp) {
! 501: me = HTRequest_context(rqp);
! 502:
! 503: if(ops & ReadBits)
! 504: RequestKillReadXtevent (me);
! 505:
! 506: if(ops & WriteBits)
! 507: RequestKillWriteXtevent (me);
! 508:
! 509: if(ops & ExceptBits)
! 510: RequestKillExceptXtevent (me);
! 511:
! 512: #endif /* WWW_XWINDOWS */
! 513:
! 514: }
! 515: }
! 516:
! 517: status = HTEventrg_unregister(sock, ops);
! 518: return(status);
! 519: }
! 520:
! 521: #ifdef __STDC__
! 522: void RequestKillAllXtevents (AHTReqContext* me)
! 523: #else
! 524: void RequestKillAllXtevents (me)
! 525: AHTReqContext* me;
! 526: #endif /*__STDC__*/
! 527: {
! 528: #ifdef WWW_XWINDOWS
! 529: if (THD_TRACE)
! 530: fprintf(stderr, "Request_kill: Clearing Xtinputs\n");
! 531:
! 532: RequestKillReadXtevent (me);
! 533: RequestKillWriteXtevent (me);
! 534: RequestKillExceptXtevent (me);
! 535: #endif /* WWW_XWINDOWS */
! 536: }
! 537:
! 538: #ifdef __STDC__
! 539: static void RequestKillReadXtevent (AHTReqContext* me)
! 540: #else
! 541: static void RequestKillReadXtevent (me)
! 542: AHTReqContext* me;
! 543: #endif /*__STDC__*/
! 544: {
! 545: #ifdef WWW_XWINDOWS
! 546: if (me->read_xtinput_id) {
! 547: if (THD_TRACE)
! 548: fprintf (stderr, "Request_kill: Clearing Read Xtinputs%lu\n", me->read_xtinput_id);
! 549: XtRemoveInput (me->read_xtinput_id);
! 550: me->read_xtinput_id = (XtInputId) NULL;
! 551: }
! 552: #endif /* WWW_XWINDOWS */
! 553: }
! 554:
! 555: #ifdef __STDC__
! 556: static void RequestKillWriteXtevent (AHTReqContext* me)
! 557: #else
! 558: static void RequestKillWriteXtevent (me)
! 559: AHTReqContext* me;
! 560: #endif /*__STDC__*/
! 561: {
! 562: #ifdef WWW_XWINDOWS
! 563: if (me->write_xtinput_id) {
! 564: if (THD_TRACE)
! 565: fprintf(stderr, "Request_kill: Clearing Write Xtinputs %lu\n", me->write_xtinput_id);
! 566: XtRemoveInput(me->write_xtinput_id);
! 567: me->write_xtinput_id = (XtInputId) NULL;
! 568: }
! 569: #endif /* WWW_XWINDOWS */
! 570: }
! 571:
! 572: #ifdef __STDC__
! 573: static void RequestKillExceptXtevent (AHTReqContext* me)
! 574: #else
! 575: static void RequestKillExceptXtevent (me)
! 576: AHTReqContext* me;
! 577: #endif /*__STDC__*/
! 578: {
! 579: #ifdef WWW_XWINDOWS
! 580: if (me->except_xtinput_id) {
! 581: if (THD_TRACE)
! 582: fprintf (stderr, "Request_kill: Clearing Except Xtinputs %lu\n", me->except_xtinput_id);
! 583: XtRemoveInput (me->except_xtinput_id);
! 584: me->except_xtinput_id = (XtInputId) NULL;
! 585: }
! 586: #endif /* WWW_XWINDOWS */
! 587: }
! 588:
! 589:
! 590:
! 591:
! 592:
! 593:
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to AHTBridge.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / Amaya / amaya