File:
[Public] /
libwww /
Library /
src /
HTReader.c
Revision
2.31:
download - view:
text,
annotated -
select for diffs
Tue Jul 11 09:15:28 2000 UTC (23 years, 11 months ago) by
kahan
Branches:
MAIN
CVS tags:
repeat-requests,
candidate-5-4-1,
before_webdav,
Release-5-4-0,
Release-5-3-1,
HEAD,
Amaya-6-3,
Amaya-6-1,
Amaya-5-2,
Amaya-4-3-2,
Amaya-4-3-1,
Amaya-4-3,
Amaya-4-1-2,
Amaya-4-1-0,
Amaya-4-0-0,
Amaya-3-2-1,
Amaya
JK: completed the error handler for a NETREAD (recv) operation.
/* HTReader.c
** READ STREAM FROM THE NETWORK USING TCP
**
** (c) COPYRIGHT MIT 1995.
** Please first read the full copyright statement in the file COPYRIGH.
** @(#) $Id: HTReader.c,v 2.31 2000/07/11 09:15:28 kahan Exp $
**
** HISTORY:
** 6 June 95 HFN Written
*/
/* Library Include files */
#include "wwwsys.h"
#include "WWWUtil.h"
#include "WWWCore.h"
#include "HTNetMan.h"
#include "HTReader.h" /* Implemented here */
struct _HTStream {
const HTStreamClass * isa;
/* ... */
};
struct _HTInputStream {
const HTInputStreamClass * isa;
HTChannel * ch;
HTHost * host;
char * write; /* Last byte written */
char * read; /* Last byte read */
int b_read;
char data [INPUT_BUFFER_SIZE]; /* buffer */
};
/* ------------------------------------------------------------------------- */
PRIVATE int HTReader_flush (HTInputStream * me)
{
HTNet * net = HTHost_getReadNet(me->host);
return net && net->readStream ? (*net->readStream->isa->flush)(net->readStream) : HT_OK;
}
PRIVATE int HTReader_free (HTInputStream * me)
{
HTNet * net = HTHost_getReadNet(me->host);
if (net && net->readStream) {
int status = (*net->readStream->isa->_free)(net->readStream);
if (status == HT_OK) net->readStream = NULL;
return status;
}
return HT_OK;
}
PRIVATE int HTReader_abort (HTInputStream * me, HTList * e)
{
HTNet * net = HTHost_getReadNet(me->host);
if (net && net->readStream) {
int status = (*net->readStream->isa->abort)(net->readStream, NULL);
if (status != HT_IGNORE) net->readStream = NULL;
}
return HT_ERROR;
}
#ifdef FIND_SIGNATURES
/* Push data from a socket down a stream
** -------------------------------------
**
** This routine is responsible for creating and PRESENTING any
** graphic (or other) objects described by the file. As this function
** max reads a chunk of data on size INPUT_BUFFER_SIZE, it can be used
** with both blocking or non-blocking sockets. It will always return to
** the event loop, however if we are using blocking I/O then we get a full
** buffer read, otherwise we get what's available.
**
** Returns HT_LOADED if finished reading
** HT_OK if OK, but more to read
** HT_ERROR if error,
** HT_WOULD_BLOCK if read or write would block
** HT_PAUSE if stream is paused
*/
PRIVATE char * strnstr(char * haystack, int *pLen, char * needle)
{
int found = 0;
int need = strlen(needle);
int i, start;
for (start = i = 0; i < *pLen; i++)
if (haystack[i] == needle[found]) {
if (++found == need) {
i -= need - 1; /* beginning of string */
*pLen -= i;
return haystack+i;
}
} else {
found = 0;
}
*pLen = 0;
return NULL;
}
#endif /* FIND_SIGNATURES */
PRIVATE int HTReader_read (HTInputStream * me)
{
HTHost * host = me->host;
SOCKET soc = HTChannel_socket(me->ch);
HTNet * net = HTHost_getReadNet(host);
HTRequest * request = HTNet_request(net);
int status;
if (!net->readStream) {
HTTRACE(STREAM_TRACE, "Read Socket. No read stream for net object %p\n" _ net);
return HT_ERROR;
}
/* Read from socket if we got rid of all the data previously read */
do {
/* don't read if we have to push unwritten data from last call */
if (me->write >= me->read) {
if ((me->b_read = NETREAD(soc, me->data, INPUT_BUFFER_SIZE)) < 0) {
#ifdef EAGAIN
if (socerrno==EAGAIN || socerrno==EWOULDBLOCK) /* POSIX */
#else
if (socerrno==EWOULDBLOCK) /* BSD */
#endif
{
HTTRACE(STREAM_TRACE, "Read Socket. WOULD BLOCK fd %d\n" _ soc);
HTHost_register(host, net, HTEvent_READ);
return HT_WOULD_BLOCK;
#ifdef __svr4__
/*
** In Solaris envirnoment, SIGPOLL is used to signal end
** of buffer for /dev/audio. If your process is also doing
** a socket read, it will cause an EINTR error. This
** error will cause the www library request to
** terminate prematurly.
*/
} else if (socerrno == EINTR) {
continue;
#endif /* __svr4__ */
#ifdef EPIPE
} else if (socerrno == EPIPE) {
HTTRACE(STREAM_TRACE, "Read Socket. got EPIPE\n" _ soc);
goto socketClosed;
#endif /* EPIPE */
#ifdef ECONNRESET
} else if (socerrno == ECONNRESET) {
HTTRACE(STREAM_TRACE, "Read Socket. got ECONNRESET\n" _ soc);
goto socketClosed;
#endif /* ECONNRESET */
#ifdef _WINSOCKAPI_ /* windows */
/*
** JK: added new tests here, based on the following text:
** Under BSD Unixes, if the remote peer closes its
** connection and your program is blocking on recv(), you
** will get a 0 back from recv(). Winsock behaves the same
** way, except that it can also return -1, with
** WSAGetLastError() returning WSAECONNRESET,
** WSAECONNABORTED or WSAESHUTDOWN, to signal the
** detectable flavors of abnormal disconnections.
** (from the Winsock Programmer's FAQ, Warren Young)
*/
} else if (socerrno == ECONNABORTED) {
HTTRACE(STREAM_TRACE, "Read Socket. got ECONNABORTED\n" _ soc);
goto socketClosed;
} else if (socerrno == ESHUTDOWN) {
HTTRACE(STREAM_TRACE, "Read Socket. got ESHUTDOWN\n" _ soc);
goto socketClosed;
#endif /* _WINSOCKAPI */
} else { /* We have a real error */
if (request)
HTRequest_addSystemError(request, ERR_FATAL, socerrno,
NO, "NETREAD");
return HT_ERROR;
}
} else if (!me->b_read) {
socketClosed:
HTTRACE(STREAM_TRACE, "Read Socket. FIN received on socket %d\n" _ soc);
HTHost_unregister(host, net, HTEvent_READ);
HTHost_register(host, net, HTEvent_CLOSE);
return HT_CLOSED;
}
/* Remember how much we have read from the input socket */
HTTRACEDATA(me->data, me->b_read, "Reading from socket %d" _ soc);
me->write = me->data;
me->read = me->data + me->b_read;
#ifdef FIND_SIGNATURES
{
char * ptr = me->data;
int len = me->b_read;
while ((ptr = strnstr(ptr, &len, "HTTP/1.1 200 OK")) != NULL) {
HTTRACE(STREAM_TRACE, "Read Socket. Signature found at 0x%x of 0x%x.\n" _ ptr - me->data _ me->b_read);
ptr++;
len--;
}
}
#endif /* FIND_SIGNATURES */
#ifdef NOT_ASCII
{
char *p = me->data;
while (p < me->read) {
*p = FROMASCII(*p);
p++;
}
}
#endif /* NOT_ASCII */
HTTRACE(STREAM_TRACE, "Read Socket. %d bytes read from socket %d\n" _
me->b_read _ soc);
if (request) {
HTAlertCallback * cbf = HTAlert_find(HT_PROG_READ);
if (HTNet_rawBytesCount(net))
HTNet_addBytesRead(net, me->b_read);
if (cbf) {
int tr = HTNet_bytesRead(net);
(*cbf)(request, HT_PROG_READ, HT_MSG_NULL, NULL, &tr, NULL);
}
}
}
/* Now push the data down the stream */
if ((status = (*net->readStream->isa->put_block)
(net->readStream, me->write, me->b_read)) != HT_OK) {
if (status == HT_WOULD_BLOCK) {
HTTRACE(STREAM_TRACE, "Read Socket. Target WOULD BLOCK\n");
HTHost_unregister(host, net, HTEvent_READ);
return HT_WOULD_BLOCK;
} else if (status == HT_PAUSE) {
HTTRACE(STREAM_TRACE, "Read Socket. Target PAUSED\n");
HTHost_unregister(host, net, HTEvent_READ);
return HT_PAUSE;
/* CONTINUE code or stream code means data was consumed */
} else if (status == HT_CONTINUE || status > 0) {
if (status == HT_CONTINUE) {
HTTRACE(STREAM_TRACE, "Read Socket. CONTINUE\n");
} else
HTTRACE(STREAM_TRACE, "Read Socket. Target returns %d\n" _ status);
/* me->write = me->read; */
return status;
} else { /* We have a real error */
HTTRACE(STREAM_TRACE, "Read Socket. Target ERROR %d\n" _ status);
return status;
}
}
me->write = me->read;
{
int remaining = HTHost_remainingRead(host);
if (remaining > 0) {
HTTRACE(STREAM_TRACE, "Read Socket. DIDN'T CONSUME %d BYTES: `%s\'\n" _
remaining _ me->read);
HTHost_setConsumed(host, remaining);
}
}
} while (net->preemptive);
HTHost_register(host, net, HTEvent_READ);
return HT_WOULD_BLOCK;
}
/*
** The difference between the close and the free method is that we don't
** close the connection in the free method - we only call the free method
** of the target stream. That way, we can keep the input stream as long
** as the channel itself.
*/
PRIVATE int HTReader_close (HTInputStream * me)
{
int status = HT_OK;
HTNet * net = HTHost_getReadNet(me->host);
if (net && net->readStream) {
if ((status = (*net->readStream->isa->_free)(net->readStream))==HT_WOULD_BLOCK)
return HT_WOULD_BLOCK;
net->readStream = NULL;
}
HTTRACE(STREAM_TRACE, "Socket read. FREEING....\n");
HT_FREE(me);
return status;
}
PUBLIC int HTReader_consumed (HTInputStream * me, size_t bytes)
{
me->write += bytes;
me->b_read -= bytes;
HTHost_setRemainingRead(me->host, me->b_read);
return HT_OK;
}
PRIVATE const HTInputStreamClass HTReader =
{
"SocketReader",
HTReader_flush,
HTReader_free,
HTReader_abort,
HTReader_read,
HTReader_close,
HTReader_consumed
};
/*
** Create a new input read stream. Before we actually create it we check
** to see whether we already have an input stream for this channel and if
** so we just return that. This means that we can reuse input streams
** in persistent connections, for example.
*/
PUBLIC HTInputStream * HTReader_new (HTHost * host, HTChannel * ch,
void * param, int mode)
{
if (host && ch) {
HTInputStream * me = HTChannel_input(ch);
if (me == NULL) {
if ((me=(HTInputStream *) HT_CALLOC(1, sizeof(HTInputStream))) == NULL)
HT_OUTOFMEM("HTReader_new");
me->isa = &HTReader;
me->ch = ch;
me->host = host;
HTTRACE(STREAM_TRACE, "Reader...... Created reader stream %p\n" _ me);
}
return me;
}
return NULL;
}
Webmaster