Annotation of libwww/Library/src/HTNet.html, revision 2.44.2.3
2.1 frystyk 1: <HTML>
2: <HEAD>
2.43 frystyk 3: <TITLE>W3C Reference Library libwww HTNet Class</TITLE>
2.1 frystyk 4: </HEAD>
5: <BODY>
2.43 frystyk 6: <H1>
7: The Net Class
2.36 eric 8: </H1>
2.5 frystyk 9: <PRE>
10: /*
2.8 frystyk 11: ** (c) COPYRIGHT MIT 1995.
2.5 frystyk 12: ** Please first read the full copyright statement in the file COPYRIGH.
13: */
14: </PRE>
2.36 eric 15: <P>
2.38 frystyk 16: The Net class manages information related to a "thread" in libwww. As libwww
17: threads are not really threads but a notion of using interleaved, non-blocking
18: I/O for accessing data objects from the network (or local file system), they
19: can be used on any platform with or without support for native threads. In
20: the case where you have an application using real threads the Net class is
21: simply a object maintaining links to all other objects involved in serving
22: the request. If you are using the libwww pseudo threads then the Net object
23: contains enough information to stop and start a request based on which BSD
24: sockets are ready. In practise this is of course transparent to the application
25: - this is just to explain the difference.
26: <P>
27: When a <A HREF="HTReq.html">Request object</A> is passed to the Library ,
28: the core creates a new HTNet object pr <A HREF="HTChannl.html">channel</A>
29: used by the request. In many cases a request only uses a single
30: <A HREF="HTChannl.html">channel object </A>but for example FTP requests use
31: at least two - one for the control connection and one for the data connection.
32: <P>
33: You can find more information about the libwww pseudo thread model in the
34: <A HREF="../User/Architecture/"> Multithread Specifications</A>.
2.36 eric 35: <P>
36: This module is implemented by <A HREF="HTNet.c">HTNet.c</A>, and it is a
37: part of the <A HREF="http://www.w3.org/pub/WWW/Library/">W3C Reference
38: Library</A>.
2.1 frystyk 39: <PRE>
2.17 frystyk 40: #ifndef HTNET_H
41: #define HTNET_H
2.1 frystyk 42: </PRE>
2.36 eric 43: <P>
44: The <CODE>HTNet</CODE> object is the core of the request queue management.
45: This object contains information about the socket descriptor, the input read
46: buffer etc. required to identify and service a request.
2.1 frystyk 47: <PRE>
2.18 frystyk 48: typedef struct _HTNet HTNet;
2.34 frystyk 49:
2.36 eric 50: #include "HTEvent.h"
2.34 frystyk 51: #include "HTReq.h"
2.44 frystyk 52: #include "HTResponse.h"
2.34 frystyk 53: #include "HTTrans.h"
54: #include "HTHost.h"
2.44.2.3! frystyk 55: #include "HTProt.h"
2.34 frystyk 56: #include "HTChannl.h"
57: #include "HTDNS.h"
2.1 frystyk 58: </PRE>
2.36 eric 59: <H2>
2.44 frystyk 60: <A NAME="callout">Generic BEFORE and AFTER Filter Management</A>
2.36 eric 61: </H2>
62: <P>
2.43 frystyk 63: Filter functions can be registered to be called <EM>before</EM> and
2.44 frystyk 64: <EM>after</EM> a request has either been started or has terminated. The
65: conditions for <I>BEFORE</I> and <I>AFTER</I> filters are not the same so
66: we maintain them independently. Filters can be registered globally or locally.
67: The global filters are registered directly by the Net Object (this module)
68: and the local filters are registered by the
69: <A HREF="HTReq.html">HTRequest</A> Object. However, both local and
70: global filters use the same regisration mechanism which we provide here.
71: <H3>
72: Filter Ordering
73: </H3>
74: <P>
75: Filters can be registered by anyone and as they are an often used mechanism
76: for introducing extensions in libwww, they are videly used to handle
77: authentication, redirection, etc. Many filters can be registered at once
78: and not all of the filters may know about the other filters. Therefore, it
79: is difficult to specify an absolute ordering by which the filters should
80: be called. Instead you can decide a relative order by which the filters should
81: be called. The order works pretty much like the Unix priority mechanism running
82: from <CODE>HT_FILTER_FIRST</CODE> to <CODE>HT_FILTER_LAST</CODE> having
83: <CODE>HT_FILTER_MIDDLE</CODE> being the "normal" case.
84: <PRE>
85: #define HT_FILTER_FIRST 0
86: #define HT_FILTER_MIDDLE 5
87: #define HT_FILTER_LAST 10
88: </PRE>
89: <P>
90: In case multiple filters are registered with the same order then they are
91: called in the <I>inverse</I> order they were registered.
92: <H3>
93: Filter URL Templates
94: </H3>
95: <P>
96: Both <I>BEFORE</I> and <I>AFTER</I> filters can be registered with a <I>URL
97: template</I> in which case they are only called when the <I>Request URL</I>
98: matches the template. A template is simply a string which is matched against
99: the <I>Request URL</I>. The string can be terminated by a single
100: "<CODE>*</CODE>" in which case all strings matching the template up til the
101: "*" is considered a match. A template can be as short as the access scheme
102: which enmables a filter for a specific access method only, for example
103: "<CODE>http//<star></CODE>".
104: <H3>
105: BEFORE Filters
106: </H3>
107: <P>
108: A <I>BEFORE</I> filter is called whenever we issue a request and they have
109: been selected by the execution procedure. <I>BEFORE</I> filters are registered
110: with a <I>context</I> and a <I>filter order</I> by which they are to be called
111: and a <I>URL template</I> which may be NULL. In this case, the filter is
112: called on every request. The mode can be used by anybody to pass an extra
113: parameter to a filter. This is not really OO thinking - but hey - this is C ;-)
114: <PRE>typedef int HTNetBefore (HTRequest * request, void * param, int mode);
115: </PRE>
116: <P>
117: You can add a <I>BEFORE</I> filter in the list provided by the caller. Several
118: filters can be registered in which case they are called with the filter ordering
119: in mind.
120: <PRE>
121: extern BOOL HTNetCall_addBefore (HTList * list, HTNetBefore * before,
122: const char * tmplate, void * param,
123: int order);
124: </PRE>
125: <P>
126: You can also unregister all instances of a BEFORE filter from a list using
127: the following function
128: <PRE>
129: extern BOOL HTNetCall_deleteBefore (HTList * list, HTNetBefore * before);
130: </PRE>
131: <P>
132: You get rid of all BEFORE filters usign this function
133: <PRE>
134: extern BOOL HTNetCall_deleteBeforeAll (HTList * list);
135: </PRE>
136: <P>
137: The BEFORE filters are expected and called if appropriate every time we issue
138: a new request. Libwww calls the BEFORE filters in the order specified at
139: registration time. If a filter returns other than HT_OK then stop and return
140: immediately. Otherwise return what the last filter returns.
141: <PRE>
142: extern int HTNetCall_executeBefore (HTList * list, HTRequest * request);
143: </PRE>
144: <H3>
145: AFTER Filters
146: </H3>
147: <P>
148: An <I>AFTER</I> filter is called whenever we have terminated a request. That
149: is, on the way out from the <A HREF="HTProt.html">protocol module</A> and
150: back to the application. <I>AFTER</I> filters are registered with a
151: <I>context</I>, a <I>status</I>, a <I>filter order</I> by which they are
152: to be called and a <I>URL template</I> which may be NULL. The status of the
153: request may determine which filter to call. The set of possible values are
154: given below. An <I>AFTER</I> filter can be registered to handle one or more
155: of the codes.
2.17 frystyk 156: <DL>
2.36 eric 157: <DT>
158: HT_ERROR
159: <DD>
160: An error occured
161: <DT>
162: HT_LOADED
163: <DD>
164: The document was loaded
165: <DT>
166: HT_NO_DATA
167: <DD>
168: OK, but no data
169: <DT>
2.43 frystyk 170: HT_NO_ACCESS
171: <DD>
172: The request could not be succeeded due to lack of credentials
173: <DT>
174: HT_NO_PROXY_ACCESS
175: <DD>
176: The request could not be succeeded due to lack of credentials for accessing
177: an intermediate proxy
178: <DT>
2.36 eric 179: HT_RETRY
180: <DD>
181: Retry request after at a later time
182: <DT>
2.40 frystyk 183: HT_PERM_REDIRECT
2.36 eric 184: <DD>
2.40 frystyk 185: The request has been permanently redirected and we send back the new URL
186: <DT>
187: HT_TEMP_REDIRECT
188: <DD>
189: The request has been temporaryly redirected and we send back the new URL
2.36 eric 190: <DT>
191: HT_ALL
192: <DD>
193: All of above
2.17 frystyk 194: </DL>
2.36 eric 195: <P>
2.44 frystyk 196: A Protocol module can also in certain cases return a <CODE>HT_IGNORE </CODE>in
197: which case no filters are called
198: <PRE>
199: typedef int HTNetAfter (HTRequest * request, HTResponse * response,
200: void * param, int status);
201: </PRE>
202: <P>
203: You can register a AFTER filter in the list provided by the caller. Several
204: filters can be registered in which case they are called with the filter ordering
205: in mind.
2.1 frystyk 206: <PRE>
2.44 frystyk 207: extern BOOL HTNetCall_addAfter (HTList * list, HTNetAfter * after,
208: const char * tmplate, void * param,
209: int status, int order);
2.9 frystyk 210: </PRE>
2.36 eric 211: <P>
2.44 frystyk 212: You can either unregister all filters registered for a given status using this function or the filter for all status codes.
2.9 frystyk 213: <PRE>
2.44 frystyk 214: extern BOOL HTNetCall_deleteAfter (HTList * list, HTNetAfter * after);
215: extern BOOL HTNetCall_deleteAfterStatus (HTList * list, int status);
2.1 frystyk 216: </PRE>
2.36 eric 217: <P>
2.44 frystyk 218: You can also delete all AFTER filters in list
2.24 frystyk 219: <PRE>
2.44 frystyk 220: extern BOOL HTNetCall_deleteAfterAll (HTList * list);
2.24 frystyk 221: </PRE>
2.36 eric 222: <P>
2.44 frystyk 223: This function calls all the AFTER filters in the order specified at registration
224: time and if it has the right status code and it's not <CODE>HT_IGNORE</CODE>.
225: We also check for any template and whether it matches or not. If a filter
226: returns other than HT_OK then stop and return immediately. Otherwise return
227: what the last filter returns.
2.24 frystyk 228: <PRE>
2.44 frystyk 229: extern int HTNetCall_executeAfter (HTList * list, HTRequest * request,
230: int status);
2.24 frystyk 231: </PRE>
2.44 frystyk 232: <H2>
233: Global BEFORE and AFTER Filter Management
234: </H2>
235: <P>
236: Global filters are inspected on every request (they do not have to be called
237: - only if the conditions match). You can also register filters locally in
238: the Request object.
239: <H4>
240: Global BEFORE Filters
241: </H4>
2.36 eric 242: <P>
2.44 frystyk 243: These are the methods to handle global <I>BEFORE</I> Filters.
2.24 frystyk 244: <PRE>
2.44 frystyk 245: extern BOOL HTNet_setBefore (HTList * list);
246:
247: extern HTList * HTNet_before (void);
2.42 frystyk 248:
2.44 frystyk 249: extern BOOL HTNet_addBefore (HTNetBefore * before, const char * tmplate,
250: void * param, int order);
2.42 frystyk 251:
2.44 frystyk 252: extern BOOL HTNet_deleteBefore (HTNetBefore * before);
2.24 frystyk 253: </PRE>
2.36 eric 254: <P>
2.44 frystyk 255: You can call both the local and the global BEFORE filters (if any)
256: <PRE>
257: extern int HTNet_executeBeforeAll (HTRequest * request);
258: </PRE>
259: <H4>
260: Global AFTER Filters
261: </H4>
262: <P>
263: These are the methods to handle global <I>AFTER</I> Filters.
2.10 frystyk 264: <PRE>
2.44 frystyk 265: extern BOOL HTNet_setAfter (HTList * list);
266:
267: extern HTList * HTNet_after (void);
268:
269: extern BOOL HTNet_addAfter (HTNetAfter * after, const char * tmplate,
270: void * param, int status, int order);
2.42 frystyk 271:
2.44 frystyk 272: extern BOOL HTNet_deleteAfter (HTNetAfter * after);
2.42 frystyk 273:
2.44 frystyk 274: extern BOOL HTNet_deleteAfterStatus (int status);
275: </PRE>
276: <P>
277: You can call both the local and the global AFTER filters (if any)
278: <PRE>
279: extern int HTNet_executeAfterAll (HTRequest * request, int status);
2.10 frystyk 280: </PRE>
2.36 eric 281: <H2>
2.43 frystyk 282: Socket Resource Management
2.36 eric 283: </H2>
284: <P>
285: The request queue ensures that no more than a fixed number of TCP connections
286: are open at the same time. If more requests are handed to the Library, they
287: are put into the pending queue and initiated when sockets become free.
288: <H3>
289: Number of Simultanous open TCP connections
290: </H3>
291: <P>
292: Set the max number of simultanous sockets. The default value is HT_MAX_SOCKETS
293: which is 6. The number of persistent connections depend on this value as
294: a deadlock can occur if all available sockets a persistent (see the
295: <A HREF="HTDNS.html">DNS Manager</A> for more information on setting the
296: number of persistent connections). The number of persistent connections can
297: never be more than the max number of sockets-2, so letting newmax=2 prevents
298: persistent sockets.
2.1 frystyk 299: <PRE>
2.17 frystyk 300: extern BOOL HTNet_setMaxSocket (int newmax);
301: extern int HTNet_maxSocket (void);
2.1 frystyk 302: </PRE>
2.36 eric 303: <H3>
2.43 frystyk 304: Socket Counters
305: </H3>
306: <PRE>
307: extern void HTNet_increaseSocket (void);
308: extern void HTNet_decreaseSocket (void);
309:
310: extern int HTNet_availableSockets (void);
311: </PRE>
312: <H3>
313: Persistent Socket Counters
314: </H3>
315: <PRE>
316: extern void HTNet_increasePersistentSocket (void);
317: extern void HTNet_decreasePersistentSocket (void);
318:
319: extern int HTNet_availablePersistentSockets (void);
320: </PRE>
321: <H3>
322: Any Ongoing Connections?
323: </H3>
324: <P>
325: Returns whether there are active requests. Idle persistent sockets do not
326: count as active.
327: <PRE>
328: extern BOOL HTNet_isIdle (void);
329: </PRE>
330: <H3>
2.36 eric 331: List Active Queue
332: </H3>
333: <P>
334: Returns the list of active requests that are currently having an open connection.
335: Returns list of HTNet objects or NULL if error.
2.1 frystyk 336: <PRE>
2.17 frystyk 337: extern HTList *HTNet_activeQueue (void);
2.22 frystyk 338: extern BOOL HTNet_idle (void);
2.29 frystyk 339: </PRE>
2.36 eric 340: <H3>
341: Are we Active?
342: </H3>
343: <P>
344: We have some small functions that tell whether there are registered requests
345: in the Net manager. There are tree queues: The <EM>active</EM>, the
346: <EM>pending</EM>, and the <EM>persistent</EM>. The <EM>active</EM> queue
347: is the set of requests that are actively sending or receiving data. The
348: <EM>pending</EM> is the requests that we have registered but which are waiting
349: for a free socket. The <EM>Persistent</EM> queue are requets that are waiting
350: to use the same socket in order to save network resoures (if the server
351: understands persistent connections).
352: <H4>
2.44.2.3! frystyk 353: Active Requests?
2.36 eric 354: </H4>
355: <P>
2.29 frystyk 356: Returns whether there are requests in the <EM>active</EM> queue or not
357: <PRE>
358: extern BOOL HTNet_idle (void);
359: </PRE>
2.36 eric 360: <H4>
361: Registered Requests?
362: </H4>
363: <P>
364: Returns whether there are requests registered in any of the lists or not
2.29 frystyk 365: <PRE>
366: extern BOOL HTNet_isEmpty (void);
2.1 frystyk 367: </PRE>
2.36 eric 368: <H3>
369: List Pending Queue
370: </H3>
371: <P>
372: Returns the list of pending requests that are waiting to become active. Returns
373: list of HTNet objects or NULL if error
2.1 frystyk 374: <PRE>
2.17 frystyk 375: extern HTList *HTNet_pendingQueue (void);
2.1 frystyk 376: </PRE>
2.36 eric 377: <H2>
2.37 frystyk 378: Creation and Deletion Methods
2.36 eric 379: </H2>
380: <P>
2.37 frystyk 381: The Net object is intended to live as long as the request is still active.
382: In that regard it is very similar to the <A HREF="HTReq.html">Request Object
383: </A>. However, the main difference is that a Net object represents a "thread"
384: in the Library and a request may have multiple "threads" - an example is
385: a FTP request which has a thread to handle the control connection and one
386: to handle the data connections.
387: <H3>
388: Create a new Object
389: </H3>
390: <P>
391: If we have more than HTMaxActive connections already then put this into the
392: pending queue, else start the request by calling the call back function
393: registered with this access method. Returns YES if OK, else NO
2.27 frystyk 394: <PRE>
2.28 frystyk 395: extern BOOL HTNet_newClient (HTRequest * request);
2.27 frystyk 396: </PRE>
2.36 eric 397: <P>
398: You can create a new HTNet object as a new request to be handled. If we have
399: more than HTMaxActive connections already then return NO. Returns YES if
400: OK, else NO
2.17 frystyk 401: <PRE>
2.39 frystyk 402: extern BOOL HTNet_newServer (HTRequest * request, HTNet * net, char *access);
2.26 frystyk 403: </PRE>
2.36 eric 404: <P>
2.27 frystyk 405: And you can create a plain new HTNet object using the following method:
2.26 frystyk 406: <PRE>
2.44.2.2 frystyk 407: extern HTNet * HTNet_new (HTRequest * request);
2.20 frystyk 408: </PRE>
2.36 eric 409: <H3>
2.37 frystyk 410: Duplicate an existing Object
2.36 eric 411: </H3>
412: <P>
413: Creates a new HTNet object as a duplicate of the same request. Returns YES
414: if OK, else NO.
2.20 frystyk 415: <PRE>
2.30 frystyk 416: extern HTNet * HTNet_dup (HTNet * src);
2.17 frystyk 417: </PRE>
2.37 frystyk 418: <H3>
2.43 frystyk 419: Launch a Net Object
420: </H3>
421: <P>
422: Start a Net obejct by calling the protocol module.
423: <PRE>extern BOOL HTNet_start (HTNet * net);
424: </PRE>
425: <H3>
2.37 frystyk 426: Delete an Object
427: </H3>
428: <P>
429: Deletes the HTNet object from the list of active requests and calls any
430: registered call back functions IF not the status is HT_IGNORE. This is used
431: if we have internal requests that the app doesn't know about. We also see
432: if we have pending requests that can be started up now when we have a socket
2.43 frystyk 433: free. The filters are called in the reverse order of which they were registered
434: (last one first);
2.37 frystyk 435: <PRE>
436: extern BOOL HTNet_delete (HTNet * me, int status);
437: </PRE>
438: <H3>
439: Delete ALL HTNet Objects
440: </H3>
441: <P>
442: Deletes all HTNet object that might either be active or pending We DO NOT
443: call the call back functions - A crude way of saying goodbye!
444: <PRE>
445: extern BOOL HTNet_deleteAll (void);
446: </PRE>
2.36 eric 447: <H2>
2.38 frystyk 448: Net Class Methods
2.36 eric 449: </H2>
450: <H3>
451: Make an Object Wait
452: </H3>
453: <P>
454: Let a net object wait for a persistent socket. It will be launched from the
455: HTNet_delete() function when the socket gets free.
2.19 frystyk 456: <PRE>
457: extern BOOL HTNet_wait (HTNet *net);
458: </PRE>
2.36 eric 459: <H3>
460: Priority Management
461: </H3>
462: <P>
463: Each HTNet object is created with a priority which it inherits from the
464: <A HREF="HTReq.html">Request manager</A>. However, in some stuations it is
465: useful to be to change the current priority after the request has been started.
466: These two functions allow you to do this. The effect will show up the first
467: time (which might be imidiately) the socket blocks and control returns to
468: the event loop. Also have a look at how you can do this before the request
469: is issued in the <A HREF="HTReq.html">request manager</A>.
2.23 frystyk 470: <PRE>
471: extern HTPriority HTNet_priority (HTNet * net);
472: extern BOOL HTNet_setPriority (HTNet * net, HTPriority priority);
473: </PRE>
2.36 eric 474: <H3>
475: Persistent Connections
476: </H3>
477: <P>
478: You can set a Net object to handle persistent connections for example using
479: HTTP, NNTP, or FTP. You can control whether a Net object supports persistent
480: connections or not using this function.
2.33 frystyk 481: <PRE>
482: extern BOOL HTNet_persistent (HTNet * net);
483: </PRE>
2.36 eric 484: <P>
485: You can set or disable a Net object supporting persistent connections using
486: this function:
2.33 frystyk 487: <PRE>
2.43 frystyk 488: extern BOOL HTNet_setPersistent (HTNet * net,
489: BOOL persistent,
490: HTTransportMode mode);
2.33 frystyk 491: </PRE>
2.36 eric 492: <H3>
493: Kill a Request
494: </H3>
495: <P>
496: Kill the request by calling the call back function with a request for closing
497: the connection. Does not remove the object. This is done by HTNet_delete()
498: function which is called by the load routine. Returns OK if success, NO on
499: error
2.1 frystyk 500: <PRE>
2.17 frystyk 501: extern BOOL HTNet_kill (HTNet * me);
2.1 frystyk 502: </PRE>
2.36 eric 503: <H3>
504: Kill ALL requests
505: </H3>
506: <P>
507: Kills all registered (active+pending) requests by calling the call back function
508: with a request for closing the connection. We do not remove the HTNet object
509: as it is done by HTNet_delete(). Returns OK if success, NO on error
2.1 frystyk 510: <PRE>
2.17 frystyk 511: extern BOOL HTNet_killAll (void);
2.28 frystyk 512: </PRE>
2.36 eric 513: <H3>
514: Create Input and Output Streams
515: </H3>
516: <P>
517: You create the input stream and bind it to the channel using the following
518: methods. Please read the description in the
519: <A HREF="HTIOStream.html">HTIOStream module</A> on the parameters
520: <EM>target</EM>, <EM>param</EM>, and <EM>mode</EM>. Both methods return YES
521: if OK, else NO.
2.34 frystyk 522: <PRE>
2.44.2.1 eric 523: #if 0
2.34 frystyk 524: extern HTInputStream * HTNet_getInput (HTNet * net, HTStream * target,
525: void * param, int mode);
2.44.2.1 eric 526: #endif
527: extern HTOutputStream * HTNet_getOutput (HTNet * me, void * param, int mode);
2.34 frystyk 528: </PRE>
2.37 frystyk 529: <H3>
530: Net Context Descriptor
531: </H3>
2.36 eric 532: <P>
2.37 frystyk 533: Just like the <A HREF="../../../../WWW/Library/src/HTReq.html#context">request
534: object</A>, a net object can be assigned a context which keeps track of context
535: dependent information. The Library does not use this information nor does
536: it depend on it but it allows the application to customize a net object to
537: specific uses.
538: <PRE>extern BOOL HTNet_setContext (HTNet * net, void * context);
539: extern void * HTNet_context (HTNet * net);
540: </PRE>
2.36 eric 541: <H3>
542: Socket Descriptor
543: </H3>
2.28 frystyk 544: <PRE>
545: extern BOOL HTNet_setSocket (HTNet * net, SOCKET sockfd);
546: extern SOCKET HTNet_socket (HTNet * net);
2.17 frystyk 547: </PRE>
2.36 eric 548: <H3>
2.39 frystyk 549: The Request Object
550: </H3>
551: <P>
2.43 frystyk 552: The <A HREF="HTReq.html">Request object</A> is normally set up automatically
553: but can be changed at a later time.
2.39 frystyk 554: <PRE>
555: extern BOOL HTNet_setRequest (HTNet * net, HTRequest * request);
556: extern HTRequest * HTNet_request (HTNet * net);
557: </PRE>
2.44.2.3! frystyk 558:
! 559: <H3>
! 560: The Protocol Object
! 561: </H3>
! 562:
! 563: <PRE>
! 564: extern BOOL HTNet_setProtocol (HTNet * net, HTProtocol * protocol);
! 565: extern HTProtocol * HTNet_protocol (HTNet * net);
! 566: </PRE>
! 567:
2.39 frystyk 568: <H3>
2.36 eric 569: The Transport Object
570: </H3>
571: <P>
2.34 frystyk 572: The <A HREF="HTTransport.html">transport object</A> is normally set up
573: automatically but can be changed at a later time.
2.17 frystyk 574: <PRE>
2.34 frystyk 575: extern BOOL HTNet_setTransport (HTNet * net, HTTransport * tp);
576: extern HTTransport * HTNet_transport (HTNet * net);
577: </PRE>
2.36 eric 578: <H3>
579: The Channel Object
580: </H3>
2.34 frystyk 581: <PRE>
582: extern BOOL HTNet_setChannel (HTNet * net, HTChannel * channel);
583: extern HTChannel * HTNet_channel (HTNet * net);
584: </PRE>
2.36 eric 585: <H3>
586: The Host Object
587: </H3>
2.34 frystyk 588: <PRE>
589: extern BOOL HTNet_setHost (HTNet * net, HTHost * host);
590: extern HTHost * HTNet_host (HTNet * net);
591: </PRE>
2.36 eric 592: <H3>
593: The DNS Object
594: </H3>
2.43 frystyk 595: <P>
596: The DNS object keeps track of the DNS entries that we have already checked
597: out.
2.34 frystyk 598: <PRE>
599: extern BOOL HTNet_setDns (HTNet * net, HTdns * dns);
600: extern HTdns * HTNet_dns (HTNet * net);
601: </PRE>
2.43 frystyk 602: <P>
603: If we are talking to a multi-homed host then we may connect to any of the
604: homes. In that case we store the current home in the Net object so that we
605: can query about it later.
2.41 frystyk 606: <PRE>
607: extern int HTNet_home (HTNet * net);
608: </PRE>
2.44.2.2 frystyk 609:
610: <H3>
611: Target for Input Read Stream
612: </H3>
613:
614: <PRE>
615: extern HTStream * HTNet_readStream(HTNet * net);
616: extern BOOL HTNet_setReadStream (HTNet * net, HTStream * stream);
617: </PRE>
618:
2.34 frystyk 619: <PRE>
2.17 frystyk 620: #endif /* HTNET_H */
2.1 frystyk 621: </PRE>
2.36 eric 622: <P>
623: <HR>
2.34 frystyk 624: <ADDRESS>
2.44.2.3! frystyk 625: @(#) $Id: HTNet.html,v 2.44.2.2 1996/10/30 23:22:06 frystyk Exp $
2.34 frystyk 626: </ADDRESS>
2.36 eric 627: </BODY></HTML>
Webmaster