--- /dev/null
+/*
+ +----------------------------------------------------------------------+
+ | PHP version 4.0 |
+ +----------------------------------------------------------------------+
+ | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 2.02 of the PHP license, |
+ | that is bundled with this package in the file LICENSE, and is |
+ | available at through the world-wide-web at |
+ | http://www.php.net/license/2_02.txt. |
+ | If you did not receive a copy of the PHP license and are unable to |
+ | obtain it through the world-wide-web, please send a note to |
+ | license@php.net so we can mail you a copy immediately. |
+ +----------------------------------------------------------------------+
+ | Authors: |
+ | Wez Furlong (wez@thebrainroom.com) |
+ +----------------------------------------------------------------------+
+ */
+
+#ifndef PHP_STREAMS_H
+#define PHP_STREAMS_H
+
+#if HAVE_PHP_STREAM
+
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+
+
+typedef struct _php_stream php_stream;
+
+typedef struct _php_stream_ops {
+/* stdio like functions - these are mandatory! */
+ size_t (*write)(php_stream * stream, const char * buf, size_t count);
+ size_t (*read)(php_stream * stream, char * buf, size_t count);
+ int (*close)(php_stream * stream);
+ int (*flush)(php_stream * stream);
+/* these are optional */
+ int (*seek)(php_stream * stream, off_t offset, int whence);
+/* used only in unbuffered mode */
+ char * (*gets)(php_stream * stream, char * buf, size_t size);
+ int (*cast)(php_stream * stream, int castas, void ** ret);
+ const char * label; /* label for this ops structure */
+} php_stream_ops;
+
+typedef struct _php_stream_buffer {
+ char * buffer;
+ size_t buflen;
+
+ int dirty; /* 1 if we need to commit data */
+
+ off_t readpos;
+ off_t writepos;
+
+ size_t chunksize; /* amount to commit in one operation */
+ int persistent;
+} php_stream_buffer;
+
+PHPAPI int php_stream_buf_init(php_stream_buffer * buffer, int persistent, size_t chunksize);
+PHPAPI int php_stream_buf_cleanup(php_stream_buffer * buffer);
+/* add data into buffer, growing it if required */
+PHPAPI int php_stream_buf_append(php_stream_buffer * buffer, const char * buf, size_t size);
+/* read data out of buffer */
+PHPAPI size_t php_stream_buf_read(php_stream_buffer * buffer, char * buf, size_t size);
+PHPAPI int php_stream_buf_overwrite(php_stream_buffer * buffer, const char * buf, size_t size);
+
+struct _php_stream {
+ php_stream_ops * ops;
+ void * abstract; /* convenience pointer for abstraction */
+ int eof;
+
+ /* for convenience for sockets */
+ int is_blocked;
+ struct timeval timeout;
+ int timeout_event;
+
+ int readahead; /* number of chunks to read-ahead */
+
+ int is_persistent;
+ char mode[16]; /* "rwb" etc. ala stdio */
+ /* the stream can be buffered */
+ int is_buffered;
+ php_stream_buffer readbuf;
+
+ FILE * stdiocast; /* cache this, otherwise we might leak! */
+}; /* php_stream */
+
+/* allocate a new stream for a particular ops */
+PHPAPI php_stream * php_stream_alloc(php_stream_ops * ops, void * abstract, size_t bufsize, int persistent, const char * mode);
+
+PHPAPI int php_stream_free(php_stream * stream, int call_dtor);
+#define php_stream_close(stream) php_stream_free(stream, 1)
+
+/* seeking is only supported for reading! */
+PHPAPI int php_stream_seek(php_stream * stream, off_t offset, int whence);
+PHPAPI off_t php_stream_tell(php_stream * stream);
+PHPAPI size_t php_stream_read(php_stream * stream, char * buf, size_t count);
+PHPAPI size_t php_stream_write(php_stream * stream, const char * buf, size_t count);
+PHPAPI int php_stream_eof(php_stream * stream);
+PHPAPI int php_stream_getc(php_stream * stream);
+PHPAPI int php_stream_flush(php_stream * stream);
+PHPAPI char *php_stream_gets(php_stream * stream, char *buf, size_t maxlen);
+
+/* operations for a stdio FILE; the FILE * must be placed in stream->abstract */
+extern php_stream_ops php_stream_stdio_ops;
+/* like fopen, but returns a stream */
+PHPAPI php_stream * php_stream_fopen(const char * filename, const char * mode);
+
+/* coerce the stream into some other form */
+/* cast as a stdio FILE * */
+#define PHP_STREAM_AS_STDIO 0
+/* cast as a POSIX fd or socketd */
+#define PHP_STREAM_AS_FD 1
+/* cast as a socketd */
+#define PHP_STREAM_AS_SOCKETD 2
+
+/* warning: once you have cast a stream as a FILE*, you probably should not use
+ the php_stream_XXX api after that point, or you will confuse the buffering
+ in FILE* and/or php_stream *
+*/
+PHPAPI int php_stream_cast(php_stream * stream, int castas, void ** ret, int show_err);
+/* use this to check if a stream can be cast into another form */
+#define php_stream_can_cast(stream, as) php_stream_cast(stream, as, NULL, 0)
+
+#endif /* HAVE_PHP_STREAM */
+
+#endif
--- /dev/null
+/*
+ +----------------------------------------------------------------------+
+ | PHP version 4.0 |
+ +----------------------------------------------------------------------+
+ | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group |
+ +----------------------------------------------------------------------+
+ | This source file is subject to version 2.02 of the PHP license, |
+ | that is bundled with this package in the file LICENSE, and is |
+ | available at through the world-wide-web at |
+ | http://www.php.net/license/2_02.txt. |
+ | If you did not receive a copy of the PHP license and are unable to |
+ | obtain it through the world-wide-web, please send a note to |
+ | license@php.net so we can mail you a copy immediately. |
+ +----------------------------------------------------------------------+
+ | Authors: |
+ | Wez Furlong (wez@thebrainroom.com) |
+ +----------------------------------------------------------------------+
+ */
+
+#define _GNU_SOURCE
+#include "php.h"
+
+#if HAVE_PHP_STREAM
+
+#define MAX_CHUNK_SIZE 8192
+
+#define TOREAD(stream) ((stream)->readbuf.writepos - (stream)->readbuf.readpos)
+#define TOWRITE(stream) ((stream)->readbuf.writepos - (stream)->readbuf.readpos)
+
+#define READPTR(stream) ((stream)->readbuf.buffer + (stream)->readbuf.readpos)
+#define WRITEPTR(stream) ((stream)->readbuf.buffer + (stream)->readbuf.writepos)
+
+#define READ_MAX(stream, max) if (stream->is_blocked) stream_read_total(sock, max); else stream_readahead(sock)
+
+
+PHPAPI int php_stream_buf_init(php_stream_buffer * buffer, int persistent, size_t chunksize)
+{
+ memset(buffer, 0, sizeof(php_stream_buffer));
+
+ /* defer memory allocation until first use */
+ buffer->persistent = persistent;
+ buffer->chunksize = chunksize;
+
+ return SUCCESS;
+}
+
+PHPAPI int php_stream_buf_cleanup(php_stream_buffer * buffer)
+{
+ if (buffer->buffer) {
+ pefree(buffer->buffer, buffer->persistent);
+ buffer->buffer = NULL;
+ }
+ return SUCCESS;
+}
+
+/* append data to the buffer ready for reading */
+PHPAPI int php_stream_buf_append(php_stream_buffer * buffer, const char * buf, size_t size)
+{
+ if (!buffer->dirty && buffer->buffer && (buffer->writepos + size > buffer->buflen)) {
+ /* if a lot of memory is sitting idle, reclaim it, but only if we are "clean" */
+ if (buffer->readpos > 4 * buffer->chunksize) {
+ memmove(buffer->buffer + buffer->readpos, buffer->buffer, buffer->writepos - buffer->readpos);
+
+ buffer->writepos -= buffer->readpos;
+ buffer->readpos = 0;
+ }
+ }
+ while (buffer->writepos + size > buffer->buflen) {
+ /* grow it */
+ buffer->buflen += buffer->chunksize;
+ buffer->buffer = perealloc(buffer->buffer, buffer->buflen, buffer->persistent);
+ }
+ memcpy(buffer->buffer + buffer->writepos, buf, size);
+ buffer->writepos += size;
+ return SUCCESS;
+}
+
+/* write data into the buffer at the present read position.
+ When done, if we overlapped the writepos, move it to so that
+ it occurs just after the zone we wrote.
+*/
+PHPAPI int php_stream_buf_overwrite(php_stream_buffer * buffer, const char * buf, size_t size)
+{
+ /* ensure that there it enough memory */
+ while (buffer->readpos + size > buffer->buflen) {
+ buffer->buflen += buffer->chunksize;
+ buffer->buffer = perealloc(buffer->buffer, buffer->buflen, buffer->persistent);
+ }
+ memcpy(buffer->buffer + buffer->readpos, buf, size);
+ if (buffer->readpos + size > buffer->writepos)
+ buffer->writepos = buffer->readpos + size;
+
+ buffer->dirty = 1;
+
+ return SUCCESS;
+}
+
+/* read data out of buffer */
+PHPAPI size_t php_stream_buf_read(php_stream_buffer * buffer, char * buf, size_t size)
+{
+ size_t ret;
+
+ ret = MIN(size, buffer->writepos - buffer->readpos);
+
+ if (ret == 0) {
+ if (buf)
+ buf[0] = 0;
+ }
+ else {
+ if (buf)
+ memcpy(buf, buffer->buffer + buffer->readpos, ret);
+ buffer->readpos += ret;
+ }
+ return ret;
+}
+
+
+
+/* allocate a new stream for a particular ops */
+PHPAPI php_stream * php_stream_alloc(php_stream_ops * ops, void * abstract, size_t bufsize, int persistent, const char * mode)
+{
+ php_stream * ret;
+
+ ret = (php_stream*)pemalloc(sizeof(php_stream), persistent);
+
+ memset(ret, 0, sizeof(php_stream));
+
+ ret->ops = ops;
+ ret->abstract = abstract;
+ ret->is_persistent = persistent;
+
+ strncpy(ret->mode, mode, sizeof(ret->mode));
+
+ if (bufsize) {
+ ret->is_buffered = 1;
+ php_stream_buf_init(&ret->readbuf, persistent, bufsize);
+ }
+ return ret;
+}
+
+PHPAPI int php_stream_free(php_stream * stream, int call_dtor)
+{
+ int ret = 1;
+
+ if (call_dtor) {
+ ret = stream->ops->close(stream);
+ }
+ php_stream_buf_cleanup(&stream->readbuf);
+ pefree(stream, stream->is_persistent);
+
+ return ret;
+}
+
+/* get a chunk into the stream read buffer */
+static size_t stream_read_chunk(php_stream * stream)
+{
+ size_t nr, ret = 0;
+ char buf[MAX_CHUNK_SIZE];
+
+ /* do timeout check here ? */
+
+ nr = stream->ops->read(stream, buf, stream->readbuf.chunksize);
+
+ if (nr > 0) {
+ if (php_stream_buf_append(&stream->readbuf, buf, nr))
+ ret = nr;
+ }
+ else if (nr == 0 || (nr < 0 && errno != EWOULDBLOCK)) {
+ stream->eof = 1;
+ }
+ return ret;
+}
+
+
+/* read 1 + readahead chunks into buffer, if possible */
+static size_t stream_readahead(php_stream * stream)
+{
+ size_t nr_bytes;
+ size_t nr_read = 0;
+ int i;
+
+ for(i = 0; !stream->eof && i < (stream->readahead + 1); i++) {
+ nr_bytes = stream_read_chunk(stream);
+ if(nr_bytes == 0)
+ break;
+ nr_read += nr_bytes;
+ }
+ return nr_read;
+}
+
+static void stream_read_total(php_stream * stream, size_t size)
+{
+ while(!stream->eof && TOREAD(stream) < size && !stream->timeout_event) {
+ stream_readahead(stream);
+ }
+}
+
+
+PHPAPI size_t php_stream_read(php_stream * stream, char * buf, size_t size)
+{
+ size_t ret = 0;
+
+ if (stream->is_buffered) {
+ /* fill the buffer with enough bytes */
+ stream_read_total(stream, size);
+
+ if(size < 0)
+ return ret;
+
+ ret = php_stream_buf_read(&stream->readbuf, buf, size);
+ }
+ else
+ ret = stream->ops->read(stream, buf, size);
+
+ return ret;
+}
+
+PHPAPI int php_stream_eof(php_stream * stream)
+{
+ int ret = 0;
+
+ if (stream->is_buffered) {
+
+ if(!stream->is_blocked)
+ stream_read_chunk(stream);
+
+ if(!TOREAD(stream) && stream->eof)
+ ret = 1;
+ }
+ else {
+ /* we will define our stream reading function so that it
+ must return EOF when an EOF condition occurs, when
+ working in unbuffered mode and called with these args */
+ ret = stream->ops->read(stream, NULL, 0) == EOF ? 1 : 0;
+ }
+ return ret;
+}
+
+PHPAPI int php_stream_getc(php_stream * stream)
+{
+ char buf;
+
+ if (php_stream_read(stream, &buf, 1) > 0)
+ return buf;
+ return EOF;
+}
+
+
+#define SEARCHCR() p = memchr(READPTR(stream), '\n', MIN(TOREAD(stream), maxlen))
+
+PHPAPI char *php_stream_gets(php_stream * stream, char *buf, size_t maxlen)
+{
+
+ if (maxlen == 0) {
+ buf[0] = 0;
+ return buf;
+ }
+
+ if (stream->is_buffered) {
+ /* buffered fgets */
+ char * p = NULL;
+ size_t amount = 0;
+
+ SEARCHCR();
+
+ if (!p) {
+ if (stream->is_blocked) {
+ while (!p && !stream->eof && !stream->timeout_event && TOREAD(stream) < maxlen)
+ {
+ stream_read_chunk(stream);
+ SEARCHCR();
+ }
+ }
+ else {
+ stream_read_chunk(stream);
+ SEARCHCR();
+ }
+ }
+
+ if (p)
+ amount = (ptrdiff_t)p - (ptrdiff_t)READPTR(stream) + 1;
+ else
+ amount = TOREAD(stream);
+
+ amount = MIN(amount, maxlen);
+ php_stream_buf_read(&stream->readbuf, buf, amount);
+ buf[amount] = '\0';
+
+ /* signal error only if we don't return data from this call
+ and there is not data to read and if the eof flag is set */
+
+ if (amount || TOREAD(stream) || !stream->eof) {
+ return buf;
+ }
+
+ return NULL;
+ }
+ else if (stream->ops->gets) {
+ return stream->ops->gets(stream, buf, maxlen);
+ }
+ else {
+ /* unbuffered fgets - poor performance ! */
+ size_t n = 0;
+ char * c = buf;
+
+ /* TODO: look at error returns? */
+
+ while(n < maxlen && stream->ops->read(stream, c, 1) > 0) {
+ n++;
+ if (*c == '\n') {
+ c++;
+ break;
+ }
+ c++;
+ }
+ *c = 0;
+ return buf;
+ }
+}
+
+static int stream_commit(php_stream * stream)
+{
+ zend_error(E_WARNING, "buffered writes not yet implemented!");
+ return FAILURE;
+}
+
+PHPAPI int php_stream_flush(php_stream * stream)
+{
+ if (!stream->is_buffered && stream->ops->flush)
+ {
+ return stream->ops->flush(stream);
+ }
+ zend_error(E_WARNING, "php_stream_flush is not yet implemented on buffered streams!");
+ return EOF;
+}
+
+PHPAPI size_t php_stream_write(php_stream * stream, const char * buf, size_t count)
+{
+ size_t ret = 0;
+
+ if (strchr(stream->mode, 'w') == NULL) {
+ zend_error(E_WARNING, "%s(): stream was not opened for writing", get_active_function_name());
+ return 0;
+ }
+
+ if (stream->is_buffered) {
+ /* commit buffer before appending, to preserve memory */
+ stream_commit(stream);
+
+ /* dump it into the buffer */
+ php_stream_buf_overwrite(&stream->readbuf, buf, count);
+
+ /* commit if it makes sense */
+ stream_commit(stream);
+
+ ret = count;
+ }
+ else
+ ret = stream->ops->write(stream, buf, count);
+
+ return ret;
+}
+
+PHPAPI off_t php_stream_tell(php_stream * stream)
+{
+ off_t ret = -1;
+ if (stream->ops->seek) {
+ ret = stream->ops->seek(stream, 0, SEEK_CUR);
+ }
+ return ret;
+}
+
+PHPAPI int php_stream_seek(php_stream * stream, off_t offset, int whence)
+{
+ if (stream->is_buffered) {
+ /*TODO: implement!
+ stream_commit(stream);
+ stream->readbuf.readpos = 0;
+ stream->readbuf.writepos = 0;
+ if (stream->ops->seek)
+ return stream->ops->seek(stream, offset, whence);
+ */
+ goto cant_seek;
+ }
+ else if (stream->ops->seek) {
+ return stream->ops->seek(stream, offset, whence);
+ }
+
+cant_seek:
+ zend_error(E_ERROR, "streams of type %s do not support seeking", stream->ops->label);
+ return -1;
+}
+
+
+/*------- STDIO stream implementation -------*/
+
+static size_t php_stdiop_write(php_stream * stream, const char * buf, size_t count)
+{
+ return fwrite(buf, 1, count, (FILE*)stream->abstract);
+}
+
+static size_t php_stdiop_read(php_stream * stream, char * buf, size_t count)
+{
+ if (buf == NULL && count == 0) {
+ /* check for EOF condition */
+ if (feof((FILE*)stream->abstract)) {
+ return EOF;
+ }
+ return 0;
+ }
+ return fread(buf, 1, count, (FILE*)stream->abstract);
+}
+
+static int php_stdiop_close(php_stream * stream)
+{
+ return fclose((FILE*)stream->abstract);
+}
+
+static int php_stdiop_flush(php_stream * stream)
+{
+ return fflush((FILE*)stream->abstract);
+}
+
+static int php_stdiop_seek(php_stream * stream, off_t offset, int whence)
+{
+ return fseek((FILE*)stream->abstract, offset, whence);
+}
+
+static char * php_stdiop_gets(php_stream * stream, char * buf, size_t size)
+{
+ return fgets(buf, size, (FILE*)stream->abstract);
+}
+static int php_stdiop_cast(php_stream * stream, int castas, void ** ret)
+{
+ int fd;
+
+ switch (castas) {
+ case PHP_STREAM_AS_STDIO:
+ if (ret)
+ *ret = stream->abstract;
+ return SUCCESS;
+
+ case PHP_STREAM_AS_FD:
+ fd = fileno((FILE*)stream->abstract);
+ if (fd < 0)
+ return FAILURE;
+ if (ret)
+ *ret = (void*)fd;
+ return SUCCESS;
+ default:
+ return FAILURE;
+ }
+}
+
+php_stream_ops php_stream_stdio_ops = {
+ php_stdiop_write, php_stdiop_read,
+ php_stdiop_close, php_stdiop_flush, php_stdiop_seek,
+ php_stdiop_gets, php_stdiop_cast,
+ "STDIO"
+};
+
+PHPAPI php_stream * php_stream_fopen(const char * filename, const char * mode)
+{
+ FILE * fp = fopen(filename, mode);
+
+ if (fp) {
+ php_stream * ret = php_stream_alloc(&php_stream_stdio_ops, fp, 0, 0, mode);
+
+ if (ret)
+ return ret;
+
+ fclose(fp);
+ }
+ return NULL;
+}
+
+#if HAVE_FOPENCOOKIE
+static ssize_t stream_cookie_reader(void *cookie, char *buffer, size_t size)
+{
+ return php_stream_read(((php_stream *)cookie), buffer, size);
+}
+
+static ssize_t stream_cookie_writer(void *cookie, const char *buffer, size_t size) {
+ return php_stream_write(((php_stream *)cookie), (char *)buffer, size);
+}
+
+static int stream_cookie_seeker(void *cookie, off_t position, int whence) {
+ return php_stream_seek(((php_stream *)cookie), position, whence);
+}
+
+static int stream_cookie_closer(void *cookie) {
+ return php_stream_close(((php_stream *)cookie));
+}
+
+static COOKIE_IO_FUNCTIONS_T stream_cookie_functions =
+{
+ stream_cookie_reader, stream_cookie_writer,
+ stream_cookie_seeker, stream_cookie_closer
+};
+#endif
+
+PHPAPI int php_stream_cast(php_stream * stream, int castas, void ** ret, int show_err)
+{
+ if (castas == PHP_STREAM_AS_STDIO) {
+ if (stream->stdiocast) {
+ if (ret)
+ *ret = stream->stdiocast;
+ return SUCCESS;
+ }
+
+ if (stream->ops->cast && stream->ops->cast(stream, castas, ret) == SUCCESS)
+ goto exit_success;
+
+
+#if HAVE_FOPENCOOKIE
+ /* if just checking, say yes we can be a FILE*, but don't actually create it yet */
+ if (ret == NULL)
+ goto exit_success;
+
+ *ret = fopencookie(stream, stream->mode, stream_cookie_functions);
+
+ if (*ret != NULL)
+ goto exit_success;
+
+ /* must be either:
+ a) programmer error
+ b) no memory
+ -> lets bail
+ */
+ zend_error(E_ERROR, "%s(): fopencookie failed", get_active_function_name());
+ return FAILURE;
+#endif
+
+ goto exit_fail;
+ }
+ if (stream->ops->cast && stream->ops->cast(stream, castas, ret) == SUCCESS)
+ goto exit_success;
+
+
+exit_fail:
+ if (show_err) {
+ const char * cast_names[3] = { "STDIO FILE*", "File Descriptor", "Socket Descriptor" };
+ zend_error(E_WARNING, "%s(): cannot represent a stream of type %s as a %s",
+ get_active_function_name(),
+ stream->ops->label,
+ cast_names[castas]
+ );
+ }
+
+ return FAILURE;
+
+exit_success:
+ if (castas == PHP_STREAM_AS_STDIO && ret)
+ stream->stdiocast = *ret;
+
+ return SUCCESS;
+
+}
+
+#endif
projects / php / commitdiff