Annotation of libwww/Library/src/HTChannl.c, revision 2.12.2.4
2.1 frystyk 1: /* HTChannl.c
2: ** CONTAINS STREAMS FOR READING AND WRITING TO AND FROM A TRANSPORT
3: **
4: ** (c) COPYRIGHT MIT 1995.
5: ** Please first read the full copyright statement in the file COPYRIGH.
2.12.2.4! frystyk 6: ** @(#) $Id: HTChannl.c,v 2.12.2.3 1996/11/03 00:49:38 eric Exp $
2.1 frystyk 7: **
8: **
9: ** HISTORY:
10: ** April 96 HFN Written
11: */
12:
13: /* Library Include files */
14: #include "sysdep.h"
15: #include "WWWUtil.h"
16: #include "HTAlert.h"
2.10 frystyk 17: #include "HTHost.h"
2.1 frystyk 18: #include "HTError.h"
19: #include "HTChannl.h" /* Implemented here */
20:
21: #define HASH_SIZE 67
22: #define HASH(s) ((s) % HASH_SIZE)
23:
24: struct _HTChannel {
25: SOCKET sockfd; /* Socket */
26: FILE * fp;
27: HTInputStream * input; /* Input stream */
28: HTOutputStream * output; /* Output stream */
29: BOOL active; /* Active or passive channel */
30: int semaphore; /* On channel use */
2.10 frystyk 31: HTHost * host; /* Zombie connections */
2.1 frystyk 32: };
33:
34: struct _HTInputStream {
35: const HTInputStreamClass * isa;
36: };
37:
38: struct _HTOutputStream {
39: const HTOutputStreamClass * isa;
40: };
41:
42: PRIVATE HTList ** channels = NULL; /* List of channels */
43:
44: /* ------------------------------------------------------------------------- */
45:
46: PRIVATE void free_channel (HTChannel * ch)
47: {
48: if (ch) {
49:
50: /* Close the input and output stream */
2.11 frystyk 51: if (ch->input) {
52: (*ch->input->isa->close)(ch->input);
53: ch->input = NULL;
54: }
55: if (ch->output) {
56: (*ch->output->isa->close)(ch->output);
57: ch->output = NULL;
58: }
2.1 frystyk 59:
60: /* Close the socket */
61: if (ch->sockfd != INVSOC) {
62: NETCLOSE(ch->sockfd);
2.12.2.1 eric 63: /* HTEvent_unregister(ch->sockfd, all options); */
2.10 frystyk 64: HTNet_decreaseSocket();
2.1 frystyk 65: if (PROT_TRACE)
66: HTTrace("Channel..... Deleted %p, socket %d\n", ch,ch->sockfd);
67: }
2.12.2.2 eric 68: ch->sockfd = INVSOC;
2.1 frystyk 69:
70: /* Close the file */
71: if (ch->fp) {
72: fclose(ch->fp);
73: if (PROT_TRACE)
74: HTTrace("Channel..... Deleted %p, file %p\n", ch, ch->fp);
75: }
76: HT_FREE(ch);
77: }
78: }
79:
80: /*
81: ** A channel is uniquely identified by a socket.
82: ** Note that we don't create the input and output stream - they are
2.10 frystyk 83: ** created later.
2.1 frystyk 84: **
85: ** We only keep a hash on sockfd's as we don't have to look for channels
86: ** for ANSI file descriptors.
87: */
2.12.2.1 eric 88: PUBLIC HTChannel * HTChannel_new (SOCKET sockfd, BOOL active)
2.1 frystyk 89: {
2.12.2.1 eric 90: HTList * list = NULL;
91: HTChannel * ch = NULL;
92: int hash = sockfd < 0 ? 0 : HASH(sockfd);
93: if (PROT_TRACE) HTTrace("Channel..... Hash value is %d\n", hash);
94: if (!channels) {
95: if (!(channels = (HTList **) HT_CALLOC(HASH_SIZE,sizeof(HTList*))))
96: HT_OUTOFMEM("HTChannel_new");
2.1 frystyk 97: }
2.12.2.1 eric 98: if (!channels[hash]) channels[hash] = HTList_new();
99: list = channels[hash];
100: if ((ch = (HTChannel *) HT_CALLOC(1, sizeof(HTChannel))) == NULL)
101: HT_OUTOFMEM("HTChannel_new");
102: ch->sockfd = sockfd;
103: ch->active = active;
104: ch->semaphore = 1;
105: HTList_addObject(list, (void *) ch);
106:
107: if (PROT_TRACE) HTTrace("Channel..... Added %p to list %p\n", ch,list);
108: return ch;
2.1 frystyk 109: }
110:
111: /*
112: ** Look for a channel object if we for some reason should have lost it
113: ** Returns NULL if nothing found
114: */
115: PUBLIC HTChannel * HTChannel_find (SOCKET sockfd)
116: {
117: if (channels && sockfd != INVSOC) {
118: int hash = HASH(sockfd);
119: HTList * list = channels[hash];
120: if (list) {
121: HTChannel * ch = NULL;
122: while ((ch = (HTChannel *) HTList_nextObject(list)))
123: if (ch->sockfd == sockfd) return ch;
124: }
125: }
126: return NULL;
127: }
128:
129: /*
130: ** When deleting a channel we first look at if there are no more requests
131: ** using the channel (the semaphore is <= 0). Then, if the socket supports
132: ** persistent connections then we register the channel in the Host cache
133: ** and wait until the other end closes it or we get a time out on our side
134: */
2.6 eric 135: PUBLIC BOOL HTChannel_delete (HTChannel * channel, int status)
2.1 frystyk 136: {
137: if (channel) {
2.2 frystyk 138: if (PROT_TRACE) HTTrace("Channel..... Delete %p with semaphore %d\n",
2.1 frystyk 139: channel, channel->semaphore);
140: /*
141: ** We call the free methods on both the input stream and the output
142: ** stream so that we can free up the stream pipes. However, note that
143: ** this doesn't mean that we close the input stream and output stream
144: ** them selves - only the generic streams
145: */
2.12 frystyk 146: if (status != HT_IGNORE) {
2.12.2.3 eric 147: if (channel->input) {
2.12 frystyk 148: if (status == HT_INTERRUPTED)
149: (*channel->input->isa->abort)(channel->input, NULL);
150: else
151: (*channel->input->isa->_free)(channel->input);
2.12.2.4! frystyk 152: #if 0
2.12.2.3 eric 153: channel->input = NULL;
2.12.2.4! frystyk 154: #endif
2.12.2.3 eric 155: }
156: if (channel->output) {
2.12 frystyk 157: if (status == HT_INTERRUPTED)
158: (*channel->output->isa->abort)(channel->output, NULL);
159: else
160: (*channel->output->isa->_free)(channel->output);
2.12.2.4! frystyk 161: #if 0
2.12.2.3 eric 162: channel->output = NULL;
2.12.2.4! frystyk 163: #endif
2.12.2.3 eric 164: }
2.12 frystyk 165: }
2.1 frystyk 166:
167: /*
168: ** Check whether this channel is used by other objects or we can
169: ** delete it and free memory.
170: */
2.12.2.2 eric 171: if (channel->semaphore <= 0 && channels && channel->sockfd != INVSOC) {
2.1 frystyk 172: int hash = HASH(channel->sockfd);
173: HTList * list = channels[hash];
174: if (list) {
175: HTList_removeObject(list, (void *) channel);
176: free_channel(channel);
177: return YES;
178: }
2.8 frystyk 179: } else
180: HTChannel_downSemaphore(channel);
2.1 frystyk 181: }
182: return NO;
183: }
184:
185: /* HTChannel_deleteAll
186: ** -------------------
187: ** Destroys all channels. This is called by HTLibTerminate(0
188: */
2.9 frystyk 189: PUBLIC BOOL HTChannel_deleteAll (void)
2.1 frystyk 190: {
191: if (channels) {
192: HTList * cur;
193: int cnt;
194: for (cnt=0; cnt<HASH_SIZE; cnt++) {
195: if ((cur = channels[cnt])) {
196: HTChannel * pres;
197: while ((pres = (HTChannel *) HTList_nextObject(cur)) != NULL)
198: free_channel(pres);
199: }
200: HTList_delete(channels[cnt]);
201: }
202: HT_FREE(channels);
203: }
204: return YES;
205: }
206:
207: /*
2.10 frystyk 208: ** Return the socket associated with this channel
2.1 frystyk 209: */
2.10 frystyk 210: PUBLIC SOCKET HTChannel_socket (HTChannel * channel)
2.1 frystyk 211: {
2.10 frystyk 212: return channel ? channel->sockfd : INVSOC;
2.1 frystyk 213: }
214:
2.12.2.1 eric 215: PUBLIC void HTChannel_setSocket (HTChannel * channel, SOCKET socket)
216: {
217: if (channel)
218: channel->sockfd = socket;
219: }
220:
2.10 frystyk 221: /*
222: ** Return the file descriptor associated with this channel
223: */
224: PUBLIC FILE * HTChannel_file (HTChannel * channel)
2.1 frystyk 225: {
2.10 frystyk 226: return channel ? channel->fp : NULL;
2.1 frystyk 227: }
228:
229: /*
2.10 frystyk 230: ** We keep the associated Host object in case we have a
231: ** sleeping connection.
2.1 frystyk 232: */
2.10 frystyk 233: PUBLIC BOOL HTChannel_setHost (HTChannel * ch, HTHost * host)
2.1 frystyk 234: {
2.12.2.1 eric 235: if (ch) {
2.10 frystyk 236: ch->host = host;
237: return YES;
238: }
239: return NO;
2.4 frystyk 240: }
241:
2.10 frystyk 242: PUBLIC HTHost * HTChannel_host (HTChannel * ch)
2.4 frystyk 243: {
2.10 frystyk 244: return (ch ? ch->host : NULL);
2.1 frystyk 245: }
246:
247: /*
248: ** Increase the semaphore for this channel
249: */
250: PUBLIC void HTChannel_upSemaphore (HTChannel * channel)
251: {
252: if (channel) {
253: channel->semaphore++;
254: if (PROT_TRACE)
255: HTTrace("Channel..... Semaphore increased to %d for channel %p\n",
256: channel->semaphore, channel);
257: }
258: }
259:
260: /*
261: ** Decrease the semaphore for this channel
262: */
263: PUBLIC void HTChannel_downSemaphore (HTChannel * channel)
264: {
265: if (channel) {
266: channel->semaphore--;
267: if (channel->semaphore <= 0) channel->semaphore = 0;
268: if (PROT_TRACE)
269: HTTrace("Channel..... Semaphore decreased to %d for channel %p\n",
2.7 frystyk 270: channel->semaphore, channel);
271: }
272: }
273:
274: /*
275: ** Explicitly set the semaphore for this channel
276: */
277: PUBLIC void HTChannel_setSemaphore (HTChannel * channel, int semaphore)
278: {
279: if (channel) {
280: channel->semaphore = semaphore;
281: if (channel->semaphore <= 0) channel->semaphore = 0;
282: if (PROT_TRACE)
283: HTTrace("Channel..... Semaphore set to %d for channel %p\n",
2.1 frystyk 284: channel->semaphore, channel);
285: }
286: }
287:
288: /*
289: ** Create the input stream and bind it to the channel
290: ** Please read the description in the HTIOStream module on the parameters
291: */
2.10 frystyk 292: PUBLIC BOOL HTChannel_setInput (HTChannel * ch, HTInputStream * input)
2.1 frystyk 293: {
294: if (ch) {
295: ch->input = input;
296: return YES;
297: }
298: return NO;
299: }
300:
301: PUBLIC HTInputStream * HTChannel_input (HTChannel * ch)
302: {
303: return ch ? ch->input : NULL;
304: }
305:
306: /*
307: ** Create the output stream and bind it to the channel
308: ** Please read the description in the HTIOStream module on the parameters
309: */
2.10 frystyk 310: PUBLIC BOOL HTChannel_setOutput (HTChannel * ch, HTOutputStream * output)
2.1 frystyk 311: {
312: if (ch) {
313: ch->output = output;
314: return YES;
315: }
316: return NO;
317: }
318:
319: PUBLIC HTOutputStream * HTChannel_output (HTChannel * ch)
320: {
321: return ch ? ch->output : NULL;
322: }
323:
Webmaster