Annotation of libwww/Library/src/HTHost.html, revision 2.24
2.1 frystyk 1: <HTML>
2: <HEAD>
2.14 frystyk 3: <TITLE>W3C Sample Code Library libwww Host Class</TITLE>
2.1 frystyk 4: </HEAD>
5: <BODY>
2.3 frystyk 6: <H1>
7: The Host Class
8: </H1>
2.1 frystyk 9: <PRE>
10: /*
11: ** (c) COPYRIGHT MIT 1995.
12: ** Please first read the full copyright statement in the file COPYRIGH.
13: */
14: </PRE>
2.3 frystyk 15: <P>
16: The Host class manages what we know about a remote host. This can for example
17: be what type of host it is, and what version it is using. Notice that a host
18: object can be used to describe both a server or a client - all information
19: in the Host object can be shared regardless of whether it is to be used in
20: a server application or a client application.
21: <P>
22: This module is implemented by <A HREF="HTHost.c">HTHost.c</A>, and it is
2.21 frystyk 23: a part of the <A HREF="http://www.w3.org/Library/"> W3C Sample Code
2.3 frystyk 24: Library</A>.
2.1 frystyk 25: <PRE>
26: #ifndef HTHOST_H
27: #define HTHOST_H
28:
29: typedef struct _HTHost HTHost;
2.8 frystyk 30: #define HOST_HASH_SIZE 67
2.1 frystyk 31:
32: #include "HTChannl.h"
33: #include "HTReq.h"
2.2 frystyk 34: #include "HTEvent.h"
2.8 frystyk 35: #include "HTProt.h"
2.15 frystyk 36: #include "HTTimer.h"
2.1 frystyk 37: </PRE>
2.3 frystyk 38: <P>
39: The Host class contains information about the remote host, for example the
40: type (HTTP/1.0, HTTP/1.1, FTP etc.) along with information on how the connections
41: can be used (if it supports persistent connections, interleaved access etc.)
42: <H2>
2.24 ! frystyk 43: <A NAME="Creation">Creation and Deletion Methods</A>
2.3 frystyk 44: </H2>
45: <P>
46: We keep a cache of information that we know about a remote host. This allows
2.5 frystyk 47: us to be much more detailed in generating requests. Search the host info
48: cache for a host object or create a new one and add it. Examples of host
49: names are
2.1 frystyk 50: <UL>
2.3 frystyk 51: <LI>
52: www.w3.org
53: <LI>
54: www.foo.com:8000
2.1 frystyk 55: </UL>
2.3 frystyk 56: <H3>
57: Add a Host Object
58: </H3>
2.1 frystyk 59: <PRE>
2.10 eric 60: extern HTHost * HTHost_new (char * host, u_short u_port);
61: extern HTHost * HTHost_newWParse(HTRequest * request, char * url, u_short u_port);
2.8 frystyk 62: extern int HTHost_hash (HTHost * host);
2.1 frystyk 63: </PRE>
2.3 frystyk 64: <H3>
65: Delete a Host Object
66: </H3>
67: <P>
68: The Host Class contains an automatic garbage collection of Host objects so
69: that we don't keep information around that is stale.
2.6 frystyk 70: <H3>
71: Find a Host Object
72: </H3>
73: <P>
74: Searches the cache of known hosts to see if we already have information about
75: this host. If not then we return NULL.
2.24 ! frystyk 76: <PRE>
! 77: extern HTHost * HTHost_find (char * host);
! 78: </PRE>
! 79: <H3>
! 80: Is Host Idle?
! 81: </H3>
! 82: <P>
! 83: You can use this function to see whether a host object is idle or in use.
! 84: We have several modes describing how and when a host is idle. This is a function
! 85: of the <A HREF="HTTrans.html">Transport Object</A>
! 86: <PRE>
! 87: extern BOOL HTHost_isIdle (HTHost * host);
2.6 frystyk 88: </PRE>
2.3 frystyk 89: <H2>
2.24 ! frystyk 90: <A NAME="Remote">Remote Host Information</A>
2.3 frystyk 91: </H2>
92: <P>
2.12 frystyk 93: We keep track of the capabilities of the host in the other end so thatwe
94: may adjust our queries to fit it better
2.3 frystyk 95: <H3>
2.5 frystyk 96: Remote Host Name
97: </H3>
98: <P>
99: Get the name of the remote host. This is set automatically when a new Host
100: object and can be asked for at any point in time. You can not change the
101: host name but must create a new Host object instead.
102: <PRE>
103: extern char * HTHost_name (HTHost * host);
104: </PRE>
105: <H3>
106: Remote Host Protocol Class and Version
2.3 frystyk 107: </H3>
108: <P>
109: Define the <EM>host class</EM> of the host at the other end. A class is a
110: generic description of the protocol which is exactly like the access method
111: in a URL, for example "http" etc. The <EM>host version</EM> is a finer
112: distinction (sub-class) between various versions of the host class, for example
113: HTTP/0.9, HTTP/1.1 etc. The host version is a bit flag that the protocol
114: module can define on its own. That way we don't have to change this module
115: when registering a new protocol module. The <EM>host type</EM> is a description
116: of whether we can keep the connection persistent or not.
2.1 frystyk 117: <PRE>
118: extern char * HTHost_class (HTHost * host);
119: extern void HTHost_setClass (HTHost * host, char * s_class);
120:
121: extern int HTHost_version (HTHost * host);
122: extern void HTHost_setVersion (HTHost * host, int version);
123: </PRE>
2.3 frystyk 124: <H3>
2.12 frystyk 125: Public Methods accessible on This Host
2.4 frystyk 126: </H3>
127: <P>
128: A server can inform a client about the supported methods using the
129: <CODE>Public</CODE> header.
130: <PRE>extern HTMethod HTHost_publicMethods (HTHost * me);
131: extern void HTHost_setPublicMethods (HTHost * me, HTMethod methodset);
132: extern void HTHost_appendPublicMethods (HTHost * me, HTMethod methodset);
133: </PRE>
2.12 frystyk 134: <H3>
2.4 frystyk 135: Server Name of Remote Host
2.12 frystyk 136: </H3>
2.4 frystyk 137: <P>
138: A server can send its server application name and version in a HTTP response.
139: We pick up this information and add it to the Host object
140: <PRE>extern char * HTHost_server (HTHost * host);
141: extern BOOL HTHost_setServer (HTHost * host, const char * server);
142: </PRE>
2.12 frystyk 143: <H3>
2.4 frystyk 144: User Agent Name of Remote Host
2.12 frystyk 145: </H3>
2.4 frystyk 146: <P>
147: A client can send the name of the client application in a HTTP request. We
2.5 frystyk 148: pick up this information and add it to the Host Object
2.4 frystyk 149: <PRE>extern char * HTHost_userAgent (HTHost * host);
150: extern BOOL HTHost_setUserAgent (HTHost * host, const char * userAgent);
151: </PRE>
2.12 frystyk 152: <H3>
2.7 frystyk 153: Range Units Accepted by this Host
2.12 frystyk 154: </H3>
2.7 frystyk 155: <P>
156: Since all HTTP entities are represented in HTTP messages as sequences of
157: bytes, the concept of a byte range is meaningful for any HTTP entity. (However,
158: not all clients and servers need to support byte-range operations.) Byte
159: range specifications in HTTP apply to the sequence of bytes in the entity-body
160: (not necessarily the same as the message-body). A byte range operation may
161: specify a single range of bytes, or a set of ranges within a single entity.
162: <P>
163: You can also check whether a specific range unit is OK. We always say
164: <CODE>YES</CODE> except if we have a specific statement from the server that
165: it doesn't understand byte ranges - that is - it has sent "none" in a
166: "Accept-Range" response header
167: <PRE>
168: extern char * HTHost_rangeUnits (HTHost * host);
169: extern BOOL HTHost_setRangeUnits (HTHost * host, const char * units);
170: extern BOOL HTHost_isRangeUnitAcceptable (HTHost * host, const char * unit);
171: </PRE>
2.18 frystyk 172: <H3>
2.23 frystyk 173: User Defined Contexts
2.18 frystyk 174: </H3>
2.23 frystyk 175: <P>
176: This can be used for anything that the application would like to keep tabs
177: on.
2.18 frystyk 178: <PRE>
179: extern void HTHost_setContext (HTHost * me, void * context);
180: extern void * HTHost_context (HTHost * me);
181: </PRE>
2.12 frystyk 182: <H2>
2.24 ! frystyk 183: Register a Request on a Host Object
2.12 frystyk 184: </H2>
2.3 frystyk 185: <P>
2.24 ! frystyk 186: Requests are queued in the Host object until we have
! 187: <A HREF="#Pending">resources to start them</A>. The request is in the form
! 188: of a <A HREF="HTNet.html">Net object</A> as we may have multiple socket requests
! 189: per <A HREF="HTReq.html">Request object</A>. This is for example the case
! 190: with <A HREF="WWWFTp.html">FTP</A> which uses two connections.
2.1 frystyk 191: <PRE>
2.24 ! frystyk 192: extern int HTHost_addNet (HTHost * host, HTNet * net);
! 193: extern BOOL HTHost_deleteNet (HTHost * host, HTNet * net, int status);
2.1 frystyk 194:
2.24 ! frystyk 195: extern HTList * HTHost_net (HTHost * host);
! 196: </PRE>
! 197: <H2>
! 198: Channels
! 199: </H2>
! 200: <P>
! 201: A <A HREF="HTChannl.html">Channel object</A> is an abstraction for a transport,
! 202: like a TCP connection, for example. Each host object can have at most one
! 203: channel object associated with it.
! 204: <H3>
! 205: Create a Channel to a Host
! 206: </H3>
! 207: <P>
! 208: As a <A HREF="HTNet.html">Net Object</A> doesn't necessarily know whether
! 209: there is a channel up and running and whether that channel can be reused,
! 210: it must do an explicit connect the the host.
! 211: <PRE>
! 212: extern int HTHost_connect (HTHost * host, HTNet * net, char * url,
! 213: HTProtocolId port);
2.1 frystyk 214: </PRE>
2.3 frystyk 215: <H3>
2.24 ! frystyk 216: Is Channel About to Close?
2.3 frystyk 217: </H3>
218: <P>
2.24 ! frystyk 219: As soon as we know that a channel is about to close (for example because
! 220: the server sends us a <TT>Connection: close</TT> header field) then we register
! 221: this informtation in the Host object:
2.1 frystyk 222: <PRE>
2.15 frystyk 223: extern BOOL HTHost_setCloseNotification (HTHost * host, BOOL mode);
224: extern BOOL HTHost_closeNotification (HTHost * host);
2.1 frystyk 225: </PRE>
2.3 frystyk 226: <H3>
2.24 ! frystyk 227: Find Channel Associated with a Host Object
2.3 frystyk 228: </H3>
229: <P>
2.24 ! frystyk 230: Here you can find an already associated channel with a host object or you
! 231: can explicitly associate a channel with a host object.
2.1 frystyk 232: <PRE>
2.24 ! frystyk 233: extern BOOL HTHost_setChannel (HTHost * host, HTChannel * channel);
! 234: extern HTChannel * HTHost_channel (HTHost * host);
2.1 frystyk 235: </PRE>
2.24 ! frystyk 236: <H3>
! 237: Delete a Channel
! 238: </H3>
2.3 frystyk 239: <P>
2.24 ! frystyk 240: When a channel is deleted, it must be unregistered from the host object which
! 241: is done by this operation:
2.1 frystyk 242: <PRE>
2.24 ! frystyk 243: extern BOOL HTHost_clearChannel (HTHost * host, int status);
2.1 frystyk 244: </PRE>
2.5 frystyk 245: <H2>
2.24 ! frystyk 246: <A NAME="Transport">Transport Mode</A>
2.12 frystyk 247: </H2>
248: <P>
2.24 ! frystyk 249: The way a channel can be used depends on the
! 250: <A HREF="HTTrans.html">transport</A> and what mode the channel is in. The
! 251: mode (whether we can use persistent connections, pipeline, etc.) may change
! 252: mode in the middle of a connection If the new mode is lower than the old
! 253: mode then adjust the pipeline accordingly. That is, if we are going into
! 254: single mode then move all entries in the pipeline and move the rest to the
! 255: pending queue. They will get launched at a later point in time.
! 256: <PRE>
! 257: extern HTTransportMode HTHost_mode (HTHost * host, BOOL * active);
2.12 frystyk 258: extern BOOL HTHost_setMode (HTHost * host, HTTransportMode mode);
259: </PRE>
260: <H2>
2.24 ! frystyk 261: <A NAME="Pending">Handling Pending Requests</A>
2.5 frystyk 262: </H2>
263: <P>
2.24 ! frystyk 264: There are two ways we can end up with pending requests:
2.5 frystyk 265: <OL>
266: <LI>
267: If we are out of sockets then register new host objects as pending.
268: <LI>
269: If we are pending on a connection then register new net objects as pending
270: </OL>
271: <P>
272: This set of functions handles pending host objects and can start new requests
273: as resources get available. The first function checks the host object for
274: any pending <A HREF="HTNet.html">Net objects</A> and return the first of
275: these Net objects.
2.3 frystyk 276: <PRE>
2.5 frystyk 277: extern HTNet * HTHost_nextPendingNet (HTHost * host);
278: </PRE>
279: <P>
280: The second checks the list of pending host objects waiting for a socket and
281: returns the first of these Host objects.
282: <PRE>
283: extern HTHost * HTHost_nextPendingHost (void);
284: </PRE>
2.24 ! frystyk 285: <H3>
! 286: Start the Next Pending reqeust
! 287: </H3>
2.5 frystyk 288: <P>
289: Start the next pending request if any. First we look for pending requests
290: for the same host and then we check for any other pending hosts. If nothing
2.24 ! frystyk 291: pending then register a close event handler to have something catching the
! 292: socket if the remote server closes the connection, for example due to timeout.
2.8 frystyk 293: <PRE>
294: extern BOOL HTHost_launchPending (HTHost * host);
295: </PRE>
2.22 frystyk 296: <H3>
2.24 ! frystyk 297: Stop Launch of Pending Requests
2.22 frystyk 298: </H3>
2.23 frystyk 299: <P>
2.24 ! frystyk 300: Controls whether pending requests should be automatically activated. The
! 301: default is on, but if turned off then no pending requests are launched.
2.22 frystyk 302: <PRE>
2.24 ! frystyk 303: extern void HTHost_enable_PendingReqLaunch (void);
! 304: extern void HTHost_disable_PendingReqLaunch (void);
2.22 frystyk 305: </PRE>
2.12 frystyk 306: <H2>
2.24 ! frystyk 307: <A NAME="Persistent">Persistent Connections</A>
2.12 frystyk 308: </H2>
2.24 ! frystyk 309: <P>
! 310: We don't want more than (Max open sockets) - 2 connections to be persistent
! 311: in order to avoid deadlock. You can set the max number of simultaneous open
! 312: connection in the <A HREF="HTNet.html"#Resources>HTNet manager</A>.
! 313: <H3>
! 314: Is this host Persistent?
! 315: </H3>
2.8 frystyk 316: <PRE>
2.24 ! frystyk 317: extern BOOL HTHost_setPersistent (HTHost * host, BOOL persistent,
! 318: HTTransportMode mode);
! 319: extern BOOL HTHost_isPersistent (HTHost * host);
2.8 frystyk 320: </PRE>
321: <H3>
2.24 ! frystyk 322: Persistent Connection Timeouts
2.8 frystyk 323: </H3>
2.12 frystyk 324: <P>
2.24 ! frystyk 325: If the server doesn't close the connection on us then we close it after a
! 326: while so that we don't unnecessarily take up resources (see also how the
! 327: <A HREF="#RequestTimeout">timeouts of individual requests </A>can be set).
! 328: Libwww provides two mechanisms: an active timeout and a passive timeout.
! 329: The former uses <A HREF="HTTimer.html">libwww timers</A> and is the preferred
! 330: mechanism, the latter passively looks at the Host object when a new request
! 331: is issued in order to determine whether the existing channel can be reused.
! 332: This is primariliy for non-preemptive requests which in general is deprecated.
! 333: <P>
! 334: By default we have an active timeout of 60 secs and a passive timeout of
! 335: 120 secs (the latter is longer as this is less reliable). Active timeout
! 336: s can be accessed using these functions:
2.8 frystyk 337: <PRE>
2.24 ! frystyk 338: extern BOOL HTHost_setActiveTimeout (ms_t timeout);
! 339: extern ms_t HTHost_activeTimeout (void);
2.8 frystyk 340: </PRE>
2.12 frystyk 341: <P>
2.24 ! frystyk 342: and passive timeouts can be accessed using these functions
2.8 frystyk 343: <PRE>
2.24 ! frystyk 344: extern time_t HTHost_persistTimeout (void);
! 345: extern BOOL HTHost_setPersistTimeout (time_t timeout);
2.8 frystyk 346: </PRE>
2.12 frystyk 347: <P>
2.24 ! frystyk 348: The following two functions are deprecated:
! 349: <PRE>
! 350: extern void HTHost_setPersistExpires (HTHost * host, time_t expires);
! 351: extern time_t HTHost_persistExpires (HTHost * host);
2.12 frystyk 352: </PRE>
2.8 frystyk 353: <H3>
2.24 ! frystyk 354: Keeping Track of Number of Reqeusts
2.8 frystyk 355: </H3>
2.12 frystyk 356: <P>
2.24 ! frystyk 357: Another way to detect when a connection is about to close is to count the
! 358: number of requests made. For example, the (current) default bevaior by most
! 359: Apache servers is to close a TCP connection after 100 requests. I don't quite
! 360: think it makes sense to control the close of a connection like this but anyway,
! 361: there we go.
2.8 frystyk 362: <PRE>
2.24 ! frystyk 363: extern void HTHost_setReqsPerConnection (HTHost * host, int reqs);
! 364: extern int HTHost_reqsPerConnection (HTHost * host);
! 365: extern void HTHost_setReqsMade (HTHost * host, int reqs);
! 366: extern int HTHost_reqsMade (HTHost * host);
2.8 frystyk 367: </PRE>
2.24 ! frystyk 368: <H2>
! 369: <A NAME="R&W">Read and Write Management</A>
! 370: </H2>
! 371: <P>
! 372: Which <A HREF="HTNet.html">Net object</A> can read and/or write? When doing
! 373: pipelining, we essentially serialize requests and therefore we must keep
! 374: track of who can read and who can write.
2.8 frystyk 375: <H3>
2.12 frystyk 376: Get the Next Net object for Reading and Writing
2.8 frystyk 377: </H3>
378: <PRE>
379: extern HTNet * HTHost_firstNet (HTHost * host);
380: extern HTNet * HTHost_getReadNet (HTHost * host);
381: extern HTNet * HTHost_getWriteNet (HTHost * host);
382: </PRE>
383: <H3>
384: Get input and output Streams for this Host
385: </H3>
386: <PRE>
387: extern HTInputStream * HTHost_getInput (HTHost * host, HTTransport * transport,
388: void * param, int mode);
389:
390: extern HTOutputStream * HTHost_getOutput (HTHost * host, HTTransport * tp,
391: void * param, int mode);
392: </PRE>
393: <H3>
2.24 ! frystyk 394: Reading Data and Keeping Track of how Much
2.8 frystyk 395: </H3>
2.24 ! frystyk 396: <P>
! 397: Because of the push streams, the streams must keep track of how much data
! 398: actually was consumed by that stream.
2.8 frystyk 399: <PRE>
400: extern int HTHost_read(HTHost * host, HTNet * net);
2.24 ! frystyk 401:
2.8 frystyk 402: extern BOOL HTHost_setConsumed(HTHost * host, size_t bytes);
2.24 ! frystyk 403: extern BOOL HTHost_setRemainingRead(HTHost * host, size_t remainaing);
! 404: extern size_t HTHost_remainingRead (HTHost * host);
2.3 frystyk 405: </PRE>
2.12 frystyk 406: <H2>
2.24 ! frystyk 407: <A NAME="Pipeline">Pipelining Requests</A>
2.23 frystyk 408: </H2>
409: <P>
2.24 ! frystyk 410: When possible, we try to pipeline requests onto the same connection as this
! 411: saves a lot of time and leads to much higher throughput.
! 412: <H3>
! 413: How many Requests can we Pipeline onto the same Connection?
! 414: </H3>
! 415: <P>
! 416: Use these functions to set the max number of requests that can be pipelined
! 417: at any one time on a single, persistent connection. The higher the number,
! 418: the more we have to recover if the server closes the connection prematurely.
! 419: The default is about 50 requests which is enough to fill most links.
! 420: <PRE>
! 421: extern BOOL HTHost_setMaxPipelinedRequests (int max);
! 422: extern int HTHost_maxPipelinedRequests (void);
! 423: </PRE>
2.23 frystyk 424: <H3>
425: Pipeline Recovery
426: </H3>
427: <P>
2.24 ! frystyk 428: Pipelines normally run by themselves (requests are issued and responses
! 429: recieved). However, it may be necessry to either prematurely abort a pipeline
! 430: or to recover a broken pipeline due to communication problems with the server.
2.23 frystyk 431: In case a pipeline is broken then we have to recover it and start again.
432: This is handled automatically by the host object, so you do not have to call
433: this one explicitly.
434: <PRE>
435: extern BOOL HTHost_recoverPipe (HTHost * host);
436: extern BOOL HTHost_doRecover (HTHost * host);
437: </PRE>
438: <H3>
439: Kill a Pipeline
440: </H3>
441: <P>
442: Call this function to terminate all requests (pending as well as active)
443: registered with a host object. This is typically the function that handles
444: timeout, abort (user hits the red button, etc). You can also use the
445: <A HREF="HTNet.html">HTNet object kill method</A> which in terms call this
446: function.
447: <PRE>extern BOOL HTHost_killPipe (HTHost * host);
448: </PRE>
449: <H2>
2.24 ! frystyk 450: <A NAME="Event">Event Management</A>
! 451: </H2>
! 452: <P>
! 453: These functions are used to register and unregister events (read, write,
! 454: etc.) so that the host object knows about it.
! 455: <PRE>
! 456: extern int HTHost_register(HTHost * host, HTNet * net, HTEventType type);
! 457: extern int HTHost_unregister(HTHost * host, HTNet * net, HTEventType type);
! 458: extern int HTHost_tickleFirstNet(HTHost * host, HTEventType type);
! 459:
! 460: extern SockA * HTHost_getSockAddr(HTHost * host);
! 461: </PRE>
! 462: <H3>
! 463: <A NAME="RequestTimeout">Request Timeouts</A>
! 464: </H3>
! 465: <P>
! 466: Events can be assigned a timeout which causes the event to be triggered if
! 467: the timeout happens before other action is available on the socket. You can
! 468: assign a global timeout for all host object using the following methods.
! 469: The default is no timeout.
! 470: <PRE>
! 471: extern int HTHost_eventTimeout (void);
! 472: extern void HTHost_setEventTimeout (int millis);
! 473: </PRE>
! 474: <H2>
! 475: <A NAME="Delayed">Delayed Flush Timer</A>
! 476: </H2>
! 477: <P>
! 478: These methods can control how long we want to wait for a flush on a pipelined
! 479: channel. The default is 30ms which is OK in most situations.
! 480: <PRE>
! 481: extern BOOL HTHost_setWriteDelay (HTHost * host, ms_t delay);
! 482: extern ms_t HTHost_writeDelay (HTHost * host);
! 483: extern int HTHost_findWriteDelay(HTHost * host, ms_t lastFlushTime, int buffSize);
! 484: </PRE>
! 485: <P>
! 486: It is also possible to explicitly require a flush using the following method.
! 487: This can also be set directly in the <A HREF="HTReq.html">request object</A>
! 488: for a single request.
! 489: <PRE>
! 490: extern int HTHost_forceFlush(HTHost * host);
! 491: </PRE>
! 492: <P>
! 493: You can also set the <EM>global</EM> value so that all new host objects (and
! 494: therefore all new requests) will inherit this value instead of setting it
! 495: individually.
! 496: <PRE>extern BOOL HTHost_setDefaultWriteDelay (ms_t delay);
! 497: extern ms_t HTHost_defaultWriteDelay (void);
! 498: </PRE>
! 499: <H2>
2.12 frystyk 500: Multi homed Host Management
501: </H2>
502: <P>
2.24 ! frystyk 503: We keep track of hosts with multiple IP addresses - socalled <I>multi-homed
! 504: hosts</I>. This is used for two things: finding the fastest IP address of
! 505: that host and as a backup if one or more of the hosts are down. This is handled
! 506: in connection with the <A HREF="HTDNS.html">DNS manager</A>
2.1 frystyk 507: <PRE>
2.12 frystyk 508: extern BOOL HTHost_setHome (HTHost * host, int home);
509: extern int HTHost_home (HTHost * host);
2.13 frystyk 510:
511: extern BOOL HTHost_setRetry (HTHost * host, int retry);
512: extern int HTHost_retry (HTHost * host);
513: extern BOOL HTHost_decreaseRetry (HTHost * host);
2.19 kahan 514: </PRE>
2.23 frystyk 515: <H2>
516: Notify Request that it has become Active
517: </H2>
2.19 kahan 518: <P>
2.24 ! frystyk 519: A new callback plugged to the activation of a request which allows an application
! 520: to know when a request has become active.
2.19 kahan 521: <PRE>
2.24 ! frystyk 522: typedef int HTHost_ActivateRequestCallback (HTRequest * request);
! 523: extern void HTHost_setActivateRequestCallback
! 524: (HTHost_ActivateRequestCallback * cbf);
2.19 kahan 525: </PRE>
526: <P>
2.12 frystyk 527: <PRE>
2.1 frystyk 528: #endif /* HTHOST_H */
529: </PRE>
2.3 frystyk 530: <P>
531: <HR>
2.1 frystyk 532: <ADDRESS>
2.24 ! frystyk 533: @(#) $Id: HTHost.html,v 2.23 1998/10/20 13:17:19 frystyk Exp $
2.1 frystyk 534: </ADDRESS>
2.3 frystyk 535: </BODY></HTML>
Webmaster