web_client.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <time.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

#include <string.h>
#include <string>

#include <wwwsys.h>
#include <WWWUtil.h>
#include <WWWCore.h>
#include <WWWInit.h>
#include <HTReqMan.h>
#include <HTTimer.h>
#include <HTEvent.h>
#include <HTEvtLst.h>
#include <HTDialog.h>

#include <archon/util/logger.H>
#include <archon/util/text.H>
#include <archon/util/uri.H>
#include <archon/util/pipe.H>
#include <archon/util/web_client.H>

namespace Archon
{
  namespace Utilities
  {
    namespace Web
    {
      using namespace std;

      namespace
      {
        struct SockEvents
        {
          SOCKET s;                           // Our socket
          HTEvent *events[HTEvent_TYPES];   // Event parameters for read, write, oob
          HTTimer *timeouts[HTEvent_TYPES];
        };

        struct EventOrder
        {
          HTEvent *event;
          SOCKET s;
          HTEventType type;
          HTPriority skipped;
        };

        enum SockEvents_action
        {
          SockEvents_mayCreate,
          SockEvents_find
        };

        fd_set FdArray[HTEvent_TYPES];
        SOCKET maxSocket = 0;               // Max socket file descriptor in use
        const int eventsToExecute = 10;     // How many to execute in one select loop
        HTList *hashTable[HT_M_HASH_SIZE];
        HTList *eventOrderList = 0;


        SockEvents *getSockEvents(SOCKET s, SockEvents_action action)
        {
          long v = s % HT_M_HASH_SIZE;
          HTList *cur;
          SockEvents *pres;

          /* if the socket doesn't exists, don't do anything */
          if(s == INVSOC) return 0;

          if(hashTable[v] == 0) hashTable[v] = HTList_new();
          cur = hashTable[v];
          while((pres = static_cast<SockEvents *>(HTList_nextObject(cur))))
            if(pres->s == s) return pres;

          if(action == SockEvents_mayCreate)
          {
            if((pres = static_cast<SockEvents *>(HT_CALLOC(1, sizeof(SockEvents)))) == 0)
              HT_OUTOFMEM("HTEventList_register");
            pres->s = s;
            HTList_addObject(hashTable[v], static_cast<void *>(pres));
            return pres;
          }
          return 0;
        }

        int remainingEventTypes(SockEvents *pres)
        {
          int ret = 0;
          for(int i = 0; i < HTEvent_TYPES; ++i)
            if(pres->events[i] != 0) ret |= 1<<i;
          return ret;
        }

        /*
         * Event timeout handler
         * If an event didn't occur before the timeout then call it explicitly
         * indicating that it timed out.
         */
        int eventTimeoutHandler(HTTimer *timer, void *param, HTEventType type)
        {
          SockEvents *sockp = static_cast<SockEvents *>(param);
          HTEvent *event = 0;

          // Check for read timeout
          if(sockp->timeouts[HTEvent_INDEX(HTEvent_READ)] == timer)
          {
            event = sockp->events[HTEvent_INDEX(HTEvent_READ)];
            HTTRACE(THD_TRACE, "Event....... READ timed out on %d.\n" _ sockp->s);
            return (*event->cbf) (sockp->s, event->param, HTEvent_TIMEOUT);
          }

          // Check for write timeout
          if(sockp->timeouts[HTEvent_INDEX(HTEvent_WRITE)] == timer)
          {
            event = sockp->events[HTEvent_INDEX(HTEvent_WRITE)];
            HTTRACE(THD_TRACE, "Event....... WRITE timed out on %d.\n" _ sockp->s);
            return (*event->cbf) (sockp->s, event->param, HTEvent_TIMEOUT);
          }

          // Check for out-of-band data timeout
          if(sockp->timeouts[HTEvent_INDEX(HTEvent_OOB)] == timer)
          {
            event = sockp->events[HTEvent_INDEX(HTEvent_OOB)];
            HTTRACE(THD_TRACE, "Event....... OOB timed out on %d.\n" _ sockp->s);
            return (*event->cbf) (sockp->s, event->param, HTEvent_TIMEOUT);
          }
          HTTRACE(THD_TRACE, "Event....... No event for timer %p with context %p\n" _ timer _ param);
          return HT_ERROR;
        }

        /*
         * This function is called by the libwww to handle registration of new 
         *
         * For a given socket, reqister a request structure, a set of operations, 
         * a HTEventCallback function, and a priority. For this implementation, 
         * we allow only a single HTEventCallback function for all operations.
         * and the priority field is ignored.
         */
        int registerEvent(SOCKET s, HTEventType type, HTEvent *event)
        {
          int newset = 0;
          SockEvents *sockp;
          HTTRACE(THD_TRACE, "Event....... Register socket %d, request %p handler %p type %s at priority %d\n" _ 
                  s _ reinterpret_cast<unsigned>(event->request) _ 
                  reinterpret_cast<unsigned>(event->cbf) _ HTEvent_type2str(type) _ 
                  static_cast<unsigned>(event->priority));
          if(s==INVSOC || HTEvent_INDEX(type) >= HTEvent_TYPES) return 0;

          /*
           * Insert socket into appropriate file descriptor set. We also make sure
           * that it is registered in the global set.
           */
          HTTRACE(THD_TRACE, "Event....... Registering socket for %s\n" _ HTEvent_type2str(type));
          sockp = getSockEvents(s, SockEvents_mayCreate);
          sockp->s = s;
          sockp->events[HTEvent_INDEX(type)] = event;
          newset = remainingEventTypes(sockp);
          FD_SET(s, FdArray+HTEvent_INDEX(type));

          HTTRACEDATA(reinterpret_cast<char *>(FdArray)+HTEvent_INDEX(type), 8, "HTEventList_register: (s:%d)" _ s);

          if(s > maxSocket)
          {
            maxSocket = s ;
            HTTRACE(THD_TRACE, "Event....... New value for maxSocket is %d\n" _ maxSocket);
          }

          /*
          **  If the timeout has been set (relative in millis) then we register 
          **  a new timeout for this event unless we already have a timer.
          */
          if(event->millis >= 0)
          {
            sockp->timeouts[HTEvent_INDEX(type)] =
              HTTimer_new(sockp->timeouts[HTEvent_INDEX(type)],
                          eventTimeoutHandler, sockp, event->millis, YES, YES);
          }

          return HT_OK;
        }

        /*
         * Remove the registered information for the specified socket for the actions 
         * specified in ops. if no actions remain after the unregister, the registered
         * info is deleted, and, if the socket has been registered for notification, 
         * the HTEventCallback will be invoked.
         */
        int unregisterEvent(SOCKET s, HTEventType type)
        {
          long v = s % HT_M_HASH_SIZE;
          HTList *cur = hashTable[v];
          HTList *last = cur;
          SockEvents *pres;
          int ret = HT_ERROR;

          /* if the socket doesn't exists, don't do anything */
          if(s == INVSOC) return HT_OK;

          while(cur && (pres = static_cast<SockEvents *>(HTList_nextObject(cur))))
          {
            if(pres->s == s)
            {
              int remaining = 0;

              /*
               * Unregister the event from this action
               */
              pres->events[HTEvent_INDEX(type)] = 0;
              remaining = remainingEventTypes(pres);

              /*
               * Check to see of there was a timeout connected with the event.
               * If so then delete the timeout as well.
               */
              {
                HTTimer *timer = pres->timeouts[HTEvent_INDEX(type)];
                if(timer) HTTimer_delete(timer);
                pres->timeouts[HTEvent_INDEX(type)] = 0;
              }

              FD_CLR(s, FdArray+HTEvent_INDEX(type));

              HTTRACEDATA(reinterpret_cast<char *>(FdArray)+HTEvent_INDEX(type), 8, "HTEventList_unregister: (s:%d)" _ s);

              /*
              **  Check to see if we can delete the action completely. We do this
              **  if there are no more events registered.
              */
              if(remaining == 0)
              {
                HTList *doomed = cur;
                HTTRACE(THD_TRACE, "Event....... No more events registered for socket %d\n" _ s);
                HT_FREE(pres);
                pres = static_cast<SockEvents *>(HTList_nextObject(cur));
                HTList_quickRemoveElement(doomed, last);
              }
              ret = HT_OK;

              HTTRACE(THD_TRACE, "Event....... Socket %d unregistered for %s\n" _ s _ 
                      HTEvent_type2str(type));

              /* We found the socket and can break */
              break;
            }
            last = cur;
          }
          if(THD_TRACE)
          {
            if(ret == HT_ERROR)
              HTTRACE(THD_TRACE, "Event....... Couldn't find socket %d. Can't unregister type %s\n" _
                      s _ HTEvent_type2str(type));
          }
          return ret;
        }


        int addEvent(SOCKET s, HTEventType type, ms_t now)
        {
          EventOrder *pres;
          HTList *cur = eventOrderList;
          HTList *insertAfter = cur;
          SockEvents *sockp = getSockEvents(s, SockEvents_find);
          HTEvent *event;

          if(sockp == 0 || (event = sockp->events[HTEvent_INDEX(type)]) == 0)
          {
            HTTRACE(THD_TRACE, "EventOrder.. no event found for socket %d, type %s.\n" _
                    s _ HTEvent_type2str(type));
            return HT_ERROR;
          }

          /* Fixup the timeout */
          if(sockp->timeouts[HTEvent_INDEX(type)])
            HTTimer_refresh(sockp->timeouts[HTEvent_INDEX(type)], now);

          /* Look to see if it's already here from before */
          while((pres = static_cast<EventOrder *>(HTList_nextObject(cur))))
          {
            if(pres->s == s && pres->event == event && pres->type == type)
            {
              ++*(reinterpret_cast<int *>(&(pres->skipped)));
              return HT_OK;
            }
            if(pres->event->priority+pres->skipped > event->priority)
              insertAfter = cur;
          }

          /* Create a new element */
          if((pres = static_cast<EventOrder *>(HT_CALLOC(1, sizeof(EventOrder)))) == 0)
            HT_OUTOFMEM("EventOrder_add");
          pres->event = event;
          pres->s = s;
          pres->type = type;
          HTList_addObject(insertAfter, static_cast<void *>(pres));
          return HT_OK;
        }

        int executeAndDeleteEvents()
        {
          HTList *cur = eventOrderList;
          EventOrder *pres;
          int i = 0;
          HTTRACE(THD_TRACE, "EventOrder.. execute ordered events\n");
          if(cur == 0) return NO;
          while((pres = static_cast<EventOrder *>(HTList_removeLastObject(cur))) && i<eventsToExecute)
          {
            HTEvent *event = pres->event;
            int ret;
            HTTRACE(THD_TRACE, "EventList... calling socket %d, request %p handler %p type %s\n" _ 
                    pres->s _ reinterpret_cast<unsigned>(event->request) _ 
                    reinterpret_cast<unsigned>(event->cbf) _ HTEvent_type2str(pres->type));
            ret = (*pres->event->cbf)(pres->s, pres->event->param, pres->type);
            HT_FREE(pres);
            if(ret != HT_OK) return ret;
            i++;
          }
          return HT_OK;
        }

        bool clearAllEvents()
        {
          HTList *cur = eventOrderList;
          EventOrder *pres;
          HTTRACE(THD_TRACE, "EventOrder.. Clearing all ordered events\n");
          if(cur)
          {
            while((pres = static_cast<EventOrder *>(HTList_nextObject(cur))))
              HT_FREE(pres);
            return true;
          }
          return false;
        }

        int printer(const char *fmt, va_list pArgs) throw()
        {
          return HT_OK; // vfprintf(stdout, fmt, pArgs);
        }

        int tracer(const char *fmt, va_list pArgs) throw()
        {
          return HT_OK; // vfprintf(stderr, fmt, pArgs);
        }
      }

      Mutex clientExistsMutex;
      bool clientExists = false;

      struct DefaultClient: Client
      {
        string applicationName;
        string applicationVersion;
        string cacheRootPath;
        long cacheSize;
        int maxSockets;
        Time eventHandlerMaxIdle;

        Mutex mutex;
        bool libwwwInitialized;

        bool eventHandlerActive;
        unsigned numberOfRequests;
        bool terminate;

        Condition requestChange;
        Condition eventHandlerQuit;

        DefaultClient(string applicationName, string applicationVersion,
                      string cacheRootPath, long cacheSize,
                      int maxSockets) throw(UnexpectedException):
          applicationName(applicationName),
          applicationVersion(applicationVersion),
          cacheRootPath(cacheRootPath),
          cacheSize(cacheSize),
          maxSockets(maxSockets),
          eventHandlerMaxIdle(10.0),
          libwwwInitialized(false),
          eventHandlerActive(false),
          numberOfRequests(0),
          terminate(false),
          requestChange(mutex),
          eventHandlerQuit(mutex)
        {
          Mutex::Lock l(clientExistsMutex);
          if(clientExists)
            ARCHON_THROW1(ResourceException,
                          "Only one client may exist at a time");
          clientExists = true;
        }

        ~DefaultClient()
        {
          {
            Mutex::Lock l(mutex);
            if(libwwwInitialized)
            {
              // Kill all active requests
              HTNet_killAll();

              // Kill event loop
              terminate = true;
              requestChange.notifyAll();
              while(eventHandlerActive) eventHandlerQuit.wait();

              clearAllEvents();

              // Clean up the persistent cache (if any)
              HTCacheTerminate();

              // Clean up all the global preferences
              HTFormat_deleteAll();

              // Remove bindings between suffixes, media types
              HTBind_deleteAll();

              // Terminate libwww
              HTLibTerminate();

              libwwwInitialized = false;
            }
          }
          {
            Mutex::Lock l(clientExistsMutex);
            clientExists = false;
          }
        }

        Ref<Response> request(Ref<Request>) throw(RequestException);
      };

      Ref<Client> Client::get(string applicationName,
                              string applicationVersion, int maxSockets)
        throw(UnexpectedException)
      {
        return new DefaultClient(applicationName, applicationVersion,
                                 "", -1, maxSockets);
      }

      Ref<Client> Client::get(string applicationName,
                              string applicationVersion,
                              string cacheRootPath, long cacheSize,
                              int maxSockets)
        throw(UnexpectedException)
      {
        return new DefaultClient(applicationName, applicationVersion,
                                 cacheRootPath, cacheSize, maxSockets);
      }

      struct DefaultRequest: Client::Request
      {
        DefaultRequest(const Uri &uri): Client::Request(uri) {}
      };

      Ref<Client::Request> Client::Request::get(const Uri &uri)
      {
        return new DefaultRequest(uri);
      }

      HTErrorMessage libwwwErrors[HTERR_ELEMENTS] = {HTERR_ENGLISH_INITIALIZER};

      struct DefaultResponse: Client::Response, Stream::Pipe
      {
        DefaultResponse(DefaultClient *client):
          Stream::Pipe(4096, true), client(client),
          setupDone(false), setup(*this) {}

        string getContentType()
        {
          return contentType;
        }

        void doSetup(HTRequest *request)
        {
          HTParentAnchor *anchor = HTRequest_anchor(request);
          HTFormat format = HTAnchor_format(anchor);
          {
            Mutex::Lock l(*this);
            contentType = HTAtom_name(format);
            setupDone = true;
          }
          setup.notifyAll();
        }

        void setError(HTRequest *request, int status)
        {
          string m;
          if(HTList *l = HTRequest_error(request))
            while(HTError *e = (HTError *)HTList_nextObject(l))
            {
              if(m.size()) m += ", ";
              HTErrorMessage &n = libwwwErrors[HTError_index(e)];
              if(n.code) m += Text::toString(n.code) + " - ";
              m += n.msg;
              break; // We want only the last error for now
            }
          if(!m.size()) m += Text::toString(status);
          {
            Mutex::Lock l(*this);
            error = m;
            setupDone = true;
          }
          setup.notifyAll();
        }

        void waitForSetup()
        {
          Mutex::Lock l(*this);
          while(!setupDone) setup.wait();
        }

        DefaultClient *client;

        string error;
        string contentType;

        bool setupDone;
        Condition setup;

        void refDispose(Mutex::Lock &l)
        {
          Stream::Pipe::refDispose(l);
        }
      };



      namespace
      {
        struct LibwwwStream;

        struct LibwwwStreamClass
        {
          char *name;
          int (*flush)(LibwwwStream *);
          int (*_free)(LibwwwStream *);
          int (*abort)(LibwwwStream *, HTList *errorlist);
          int (*put_character)(LibwwwStream *, char);
          int (*put_string)(LibwwwStream *, const char *);
          int (*put_block)(LibwwwStream *, const char *, int);
        };

        struct LibwwwStream
        {
          const LibwwwStreamClass *isa;
          HTRequest *request;
          Ref<Stream::Writer> writer;
          DefaultResponse *response;
          bool setupDone;

          LibwwwStream(HTRequest *request,
                       Ref<Stream::Writer> writer,
                       DefaultResponse *response);
        };

        int libwwwFlush(LibwwwStream *) throw() { return HT_OK; }
        int libwwwFree(LibwwwStream *) throw()  { return HT_OK; }

        int libwwwAbort(LibwwwStream *, HTList *errorlist) throw()
        {
          cerr << "Libwww::Stream::ABORT\n"; return HT_ERROR;
        }

        void doSetup(LibwwwStream *stream)
        {
          stream->response->doSetup(stream->request);
          stream->setupDone = true;
        }

        int libwwwPutCharacter(LibwwwStream *stream, char c) throw()
        {
          if(!stream->setupDone) doSetup(stream);
          try
          {
            stream->response->write(&c, 1);
          }
          catch(Stream::WriteException &) { return HT_ERROR; }
          catch(ThreadTerminatedException &) { return HT_ERROR; }
          return HT_OK;
        }

        int libwwwPutString(LibwwwStream *stream, const char *s) throw()
        {
          if(!stream->setupDone) doSetup(stream);
          try
          {
            stream->response->writeAll(s, strlen(s));
          }
          catch(Stream::WriteException &) { return HT_ERROR; }
          catch(ThreadTerminatedException &) { return HT_ERROR; }
          return HT_OK;
        }

        int libwwwPutBlock(LibwwwStream *stream, const char *b, int l) throw()
        {
          if(!stream->setupDone) doSetup(stream);
          try
          {
            stream->response->writeAll(b, l);
          }
          catch(Stream::WriteException &) { return HT_ERROR; }
          catch(ThreadTerminatedException &) { return HT_ERROR; }
          return HT_OK;
        }

        const LibwwwStreamClass libwwwRequestContextClass =
        {
          "libwwwStream",
          libwwwFlush,
          libwwwFree,
          libwwwAbort,
          libwwwPutCharacter,
          libwwwPutString,
          libwwwPutBlock
        };

        LibwwwStream::LibwwwStream(HTRequest *request,
                                   Ref<Stream::Writer> writer,
                                   DefaultResponse *response):
          isa(&libwwwRequestContextClass),
          request(request), writer(writer), response(response),
          setupDone(false) {}



        int terminateConnection(HTRequest *request, HTResponse *response,
                                void *param, int status) throw()
        {
          LibwwwStream *stream =
            static_cast<LibwwwStream *>(HTRequest_context(request));

          if(!stream->setupDone)
          {
            if(status == 200) stream->response->doSetup(request);
            else stream->response->setError(request, status);
          }

          --stream->response->client->numberOfRequests;

          delete stream;
          //HTRequest_delete(request);

          return HT_OK;
        }


        void libwwwEventHandler(DefaultClient *client)
        {
          //Logger::get()->log("LibwwwEventHandler: started");

          Mutex::Lock l(client->mutex);

          for(;;)
          {
            ms_t timeout;
            fd_set treadset;
            fd_set twriteset;
            fd_set texceptset;
            int maxfds;

            Time wakeup = Time::now();
            wakeup += client->eventHandlerMaxIdle;

            // Wait if there are no requests. Quit if we timed out or
            // are terminated.
            for(;;)
            {
              if(!client->terminate)
              {
                if(client->numberOfRequests) break;
                if(!client->requestChange.timedWait(wakeup)) continue;
              }

              // Timed out or was terminated
              client->eventHandlerActive = false;
              //Logger::get()->log("LibwwwEventHandler: stopped");
              client->eventHandlerQuit.notifyAll();
              l.release();
              return;
            }

            /*
             * Inspect all registered timers. Every expired timer will
             * get its handler called, and the time to the next
             * expiration is returned in the argument. This scheme has
             * a flaw since if we add a new event that expires before
             * the timeout determined below then its timeout handler
             * might not get called as soon as it should.
             */
            if(HTTimer_next(&timeout))
              ARCHON_THROW1(InternalException,
                            "HTTimer_next failed");

            /*
             *  Now we copy the current active file descriptors to pass them to select.
             */
            treadset   = FdArray[HTEvent_INDEX(HTEvent_READ)];
            twriteset  = FdArray[HTEvent_INDEX(HTEvent_WRITE)];
            texceptset = FdArray[HTEvent_INDEX(HTEvent_OOB)];

            /* And also get the max socket value */
            maxfds = maxSocket;

            wakeup = Time::now();
            wakeup.addMilliSeconds(timeout);
            int activeSockets = client->requestChange.select(maxfds+1, &treadset, &twriteset, &texceptset, wakeup);
            if(activeSockets <= 0) continue;

            unsigned long now = HTGetTimeInMillis();

            /* There were active sockets. Determine which fd sets they were in */
            for(SOCKET s = 0; s <= maxfds; ++s)
            {
              if(FD_ISSET(s, &texceptset) && addEvent(s, HTEvent_OOB, now) != HT_OK)
                ARCHON_THROW1(InternalException,
                              "addEvent failed");
              if(FD_ISSET(s, &twriteset) && addEvent(s, HTEvent_WRITE, now) != HT_OK)
                ARCHON_THROW1(InternalException,
                              "addEvent failed");
              if(FD_ISSET(s, &treadset) && addEvent(s, HTEvent_READ, now) != HT_OK)
                ARCHON_THROW1(InternalException,
                              "addEvent failed");
            }
            if(executeAndDeleteEvents() != HT_OK)
              ARCHON_THROW1(InternalException,
                            "executeAndDeleteEvents failed");
          }
        }
      }


      Ref<Client::Response> DefaultClient::request(Ref<Request> request) throw(RequestException)
      {
        bool startEventHandler = false;

        Mutex::Lock l(mutex);

        if(!libwwwInitialized)
        {
          // If the Library is not already initialized then do it
          HTLibInit(applicationName.c_str(), applicationVersion.c_str());

          // Register the default set of messages and dialog functions 
          HTAlertInit();
          HTAlert_setInteractive(YES);

          // Register the default set of transport protocols
          HTTransportInit();

          // Register the default set of application protocol modules
          //HTProtocolPreemptiveInit();
          HTProtocolInit();

          // Initialize suffix bindings for local files
          HTBind_init();

          // Set max number of sockets we want open simultanously
          HTNet_setMaxSocket(maxSockets);

          // The persistent cache does not work in preemptive mode
          if(cacheSize > 0) HTCacheInit(cacheRootPath.c_str(), cacheSize);

          // Register the default set of BEFORE and AFTER filters
          HTNetInit();

          // Set up the default set of Authentication schemes
          HTAAInit();

          // Get any proxy or gateway environment variables
          HTProxy_getEnvVar();

          HTList *converters = HTList_new();

          // Register the default set of converters
          HTConverterInit(converters);

          // Register the default libwww HTML parser
          //HTMLInit(converters);

          // Set the convertes as global converters for all requests
          HTFormat_setConversion(converters);

          // Register the default set of transfer encoders and
          // decoders
          HTList *transferEncodings = HTList_new();
          HTTransferEncoderInit(transferEncodings);
          HTFormat_setTransferCoding(transferEncodings);

          // Register the default set of content encoders and decoders
          HTList *contentEncodings = HTList_new();
          HTContentEncoderInit(contentEncodings);
          if(HTList_count(contentEncodings) > 0)
            HTFormat_setContentCoding(contentEncodings);
          else
          {
            HTList_delete(contentEncodings);
            contentEncodings = 0;
          }

          // Register the default set of MIME header parsers
          HTMIMEInit();

          // Register the default set of file suffix bindings
          HTFileInit();

          // Register the default set of Icons for directory listings
          HTIconInit(0);

          // Register our own event manager
          HTEvent_setRegisterCallback(registerEvent);
          HTEvent_setUnregisterCallback(unregisterEvent);

          // Gotta set up our own traces
          HTPrint_setCallback(printer);
          HTTrace_setCallback(tracer);

          HTSetTraceMessageMask(""); // See http://www.w3.org/Library/src/HTHome.html#Trace
    
          // Add our own filter to handle termination
          HTNet_addAfter(terminateConnection, 0, 0, HT_ALL, HT_FILTER_LAST);

          eventOrderList = HTList_new();

          libwwwInitialized = true;
        }

        // Create a pipe with expanding buffers
        DefaultResponse *defaultResponse = new DefaultResponse(this);
        Ref<Response> response(defaultResponse);
        Ref<Stream::Writer> writer(defaultResponse);

        HTRequest *htRequest = HTRequest_new();

        LibwwwStream *stream = new LibwwwStream(htRequest, writer, defaultResponse);

        // The stream object is not deallocated by Libwww.
        HTRequest_setOutputStream(htRequest, reinterpret_cast<HTStream *>(stream));
        HTRequest_setOutputFormat(htRequest, WWW_SOURCE);

        // The context object is not deallocated by Libwww.
        HTRequest_setContext(htRequest, stream);

        //HTRequest_setFlush(request, YES);
        HTRequest_setPreemptive(htRequest, NO);

        HTAnchor *anchor = HTAnchor_findAddress(request->getUri().toString().c_str());

        ++numberOfRequests;

        if(!eventHandlerActive) eventHandlerActive = startEventHandler = true;

        HTLoadAnchor(anchor, htRequest);

        l.release();

        if(startEventHandler) Thread::run(libwwwEventHandler, this);
        else requestChange.notifyAll();

        defaultResponse->waitForSetup();
        if(defaultResponse->error.size())
          ARCHON_THROW1(RequestException, defaultResponse->error);

        return response;
      }
    }
  }
}

---