Annotation of libwww/Library/src/HTNet.html, revision 2.44.2.4
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>
2.44.2.4! frystyk 425:
! 426: <H3>
! 427: Call a Net Event Handler
! 428: </H3>
! 429:
! 430: This functions lets the caller play event manager as it can calls any
! 431: event handler with the event type and context passed to the function
! 432:
! 433: <PRE>
! 434: extern BOOL HTNet_execute (HTNet * net, HTEventType type);
! 435: </PRE>
! 436:
2.43 frystyk 437: <H3>
2.37 frystyk 438: Delete an Object
439: </H3>
440: <P>
441: Deletes the HTNet object from the list of active requests and calls any
442: registered call back functions IF not the status is HT_IGNORE. This is used
443: if we have internal requests that the app doesn't know about. We also see
444: if we have pending requests that can be started up now when we have a socket
2.43 frystyk 445: free. The filters are called in the reverse order of which they were registered
446: (last one first);
2.37 frystyk 447: <PRE>
448: extern BOOL HTNet_delete (HTNet * me, int status);
449: </PRE>
450: <H3>
451: Delete ALL HTNet Objects
452: </H3>
453: <P>
454: Deletes all HTNet object that might either be active or pending We DO NOT
455: call the call back functions - A crude way of saying goodbye!
456: <PRE>
457: extern BOOL HTNet_deleteAll (void);
458: </PRE>
2.36 eric 459: <H2>
2.38 frystyk 460: Net Class Methods
2.36 eric 461: </H2>
462: <H3>
463: Make an Object Wait
464: </H3>
465: <P>
466: Let a net object wait for a persistent socket. It will be launched from the
467: HTNet_delete() function when the socket gets free.
2.19 frystyk 468: <PRE>
469: extern BOOL HTNet_wait (HTNet *net);
470: </PRE>
2.36 eric 471: <H3>
472: Priority Management
473: </H3>
474: <P>
475: Each HTNet object is created with a priority which it inherits from the
476: <A HREF="HTReq.html">Request manager</A>. However, in some stuations it is
477: useful to be to change the current priority after the request has been started.
478: These two functions allow you to do this. The effect will show up the first
479: time (which might be imidiately) the socket blocks and control returns to
480: the event loop. Also have a look at how you can do this before the request
481: is issued in the <A HREF="HTReq.html">request manager</A>.
2.23 frystyk 482: <PRE>
483: extern HTPriority HTNet_priority (HTNet * net);
484: extern BOOL HTNet_setPriority (HTNet * net, HTPriority priority);
485: </PRE>
2.36 eric 486: <H3>
487: Persistent Connections
488: </H3>
489: <P>
490: You can set a Net object to handle persistent connections for example using
491: HTTP, NNTP, or FTP. You can control whether a Net object supports persistent
492: connections or not using this function.
2.33 frystyk 493: <PRE>
494: extern BOOL HTNet_persistent (HTNet * net);
495: </PRE>
2.36 eric 496: <P>
497: You can set or disable a Net object supporting persistent connections using
498: this function:
2.33 frystyk 499: <PRE>
2.43 frystyk 500: extern BOOL HTNet_setPersistent (HTNet * net,
501: BOOL persistent,
502: HTTransportMode mode);
2.33 frystyk 503: </PRE>
2.36 eric 504: <H3>
505: Kill a Request
506: </H3>
507: <P>
508: Kill the request by calling the call back function with a request for closing
509: the connection. Does not remove the object. This is done by HTNet_delete()
510: function which is called by the load routine. Returns OK if success, NO on
511: error
2.1 frystyk 512: <PRE>
2.17 frystyk 513: extern BOOL HTNet_kill (HTNet * me);
2.1 frystyk 514: </PRE>
2.36 eric 515: <H3>
516: Kill ALL requests
517: </H3>
518: <P>
519: Kills all registered (active+pending) requests by calling the call back function
520: with a request for closing the connection. We do not remove the HTNet object
521: as it is done by HTNet_delete(). Returns OK if success, NO on error
2.1 frystyk 522: <PRE>
2.17 frystyk 523: extern BOOL HTNet_killAll (void);
2.28 frystyk 524: </PRE>
2.36 eric 525: <H3>
526: Create Input and Output Streams
527: </H3>
528: <P>
529: You create the input stream and bind it to the channel using the following
530: methods. Please read the description in the
531: <A HREF="HTIOStream.html">HTIOStream module</A> on the parameters
532: <EM>target</EM>, <EM>param</EM>, and <EM>mode</EM>. Both methods return YES
533: if OK, else NO.
2.34 frystyk 534: <PRE>
2.44.2.1 eric 535: #if 0
2.34 frystyk 536: extern HTInputStream * HTNet_getInput (HTNet * net, HTStream * target,
537: void * param, int mode);
2.44.2.1 eric 538: #endif
539: extern HTOutputStream * HTNet_getOutput (HTNet * me, void * param, int mode);
2.34 frystyk 540: </PRE>
2.37 frystyk 541: <H3>
542: Net Context Descriptor
543: </H3>
2.36 eric 544: <P>
2.37 frystyk 545: Just like the <A HREF="../../../../WWW/Library/src/HTReq.html#context">request
546: object</A>, a net object can be assigned a context which keeps track of context
547: dependent information. The Library does not use this information nor does
548: it depend on it but it allows the application to customize a net object to
549: specific uses.
550: <PRE>extern BOOL HTNet_setContext (HTNet * net, void * context);
551: extern void * HTNet_context (HTNet * net);
552: </PRE>
2.36 eric 553: <H3>
554: Socket Descriptor
555: </H3>
2.28 frystyk 556: <PRE>
557: extern BOOL HTNet_setSocket (HTNet * net, SOCKET sockfd);
558: extern SOCKET HTNet_socket (HTNet * net);
2.17 frystyk 559: </PRE>
2.36 eric 560: <H3>
2.39 frystyk 561: The Request Object
562: </H3>
563: <P>
2.43 frystyk 564: The <A HREF="HTReq.html">Request object</A> is normally set up automatically
565: but can be changed at a later time.
2.39 frystyk 566: <PRE>
567: extern BOOL HTNet_setRequest (HTNet * net, HTRequest * request);
568: extern HTRequest * HTNet_request (HTNet * net);
569: </PRE>
2.44.2.3 frystyk 570:
571: <H3>
572: The Protocol Object
573: </H3>
574:
575: <PRE>
576: extern BOOL HTNet_setProtocol (HTNet * net, HTProtocol * protocol);
577: extern HTProtocol * HTNet_protocol (HTNet * net);
578: </PRE>
579:
2.39 frystyk 580: <H3>
2.36 eric 581: The Transport Object
582: </H3>
583: <P>
2.34 frystyk 584: The <A HREF="HTTransport.html">transport object</A> is normally set up
585: automatically but can be changed at a later time.
2.17 frystyk 586: <PRE>
2.34 frystyk 587: extern BOOL HTNet_setTransport (HTNet * net, HTTransport * tp);
588: extern HTTransport * HTNet_transport (HTNet * net);
589: </PRE>
2.36 eric 590: <H3>
591: The Channel Object
592: </H3>
2.34 frystyk 593: <PRE>
594: extern BOOL HTNet_setChannel (HTNet * net, HTChannel * channel);
595: extern HTChannel * HTNet_channel (HTNet * net);
596: </PRE>
2.36 eric 597: <H3>
598: The Host Object
599: </H3>
2.34 frystyk 600: <PRE>
601: extern BOOL HTNet_setHost (HTNet * net, HTHost * host);
602: extern HTHost * HTNet_host (HTNet * net);
603: </PRE>
2.36 eric 604: <H3>
605: The DNS Object
606: </H3>
2.43 frystyk 607: <P>
608: The DNS object keeps track of the DNS entries that we have already checked
609: out.
2.34 frystyk 610: <PRE>
611: extern BOOL HTNet_setDns (HTNet * net, HTdns * dns);
612: extern HTdns * HTNet_dns (HTNet * net);
613: </PRE>
2.43 frystyk 614: <P>
615: If we are talking to a multi-homed host then we may connect to any of the
616: homes. In that case we store the current home in the Net object so that we
617: can query about it later.
2.41 frystyk 618: <PRE>
619: extern int HTNet_home (HTNet * net);
620: </PRE>
2.44.2.2 frystyk 621:
622: <H3>
623: Target for Input Read Stream
624: </H3>
625:
626: <PRE>
627: extern HTStream * HTNet_readStream(HTNet * net);
628: extern BOOL HTNet_setReadStream (HTNet * net, HTStream * stream);
629: </PRE>
630:
2.34 frystyk 631: <PRE>
2.17 frystyk 632: #endif /* HTNET_H */
2.1 frystyk 633: </PRE>
2.36 eric 634: <P>
635: <HR>
2.34 frystyk 636: <ADDRESS>
2.44.2.4! frystyk 637: @(#) $Id: HTNet.html,v 2.44.2.3 1996/11/02 20:10:28 frystyk Exp $
2.34 frystyk 638: </ADDRESS>
2.36 eric 639: </BODY></HTML>
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to HTNet.html CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / libwww / Library / src