and rename to php_connect_nonb().
Use php_connect_nonb() instead of connect() in php_hostconnect() -> timeouts
should now work in php_hostconnect().
sock streams abstraction now uses php_sockbuf as the "abstract" pointer.
#include "url.h"
#include "fsock.h"
+#include "php_network.h"
+
#ifdef ZTS
static int fsock_globals_id;
#else
return 0;
}
/* }}} */
-/* {{{ connect_nonb */
-PHPAPI int connect_nonb(int sockfd,
- struct sockaddr *addr,
- socklen_t addrlen,
- struct timeval *timeout)
-{
-/* probably won't work on Win32, someone else might try it (read: fix it ;) */
-
-#if (!defined(__BEOS__) && !defined(PHP_WIN32)) && (defined(O_NONBLOCK) || defined(O_NDELAY))
-
-#ifndef O_NONBLOCK
-#define O_NONBLOCK O_NDELAY
-#endif
-
- int flags;
- int n;
- int error = 0;
- socklen_t len;
- int ret = 0;
- fd_set rset;
- fd_set wset;
-
- flags = fcntl(sockfd, F_GETFL, 0);
- fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
-
- if ((n = connect(sockfd, addr, addrlen)) < 0) {
- if (errno != EINPROGRESS) {
- return -1;
- }
- }
-
- if (n == 0) {
- goto ok;
- }
-
- FD_ZERO(&rset);
- FD_SET(sockfd, &rset);
-
- wset = rset;
-
- if ((n = select(sockfd + 1, &rset, &wset, NULL, timeout)) == 0) {
- error = ETIMEDOUT;
- }
-
- if(FD_ISSET(sockfd, &rset) || FD_ISSET(sockfd, &wset)) {
- len = sizeof(error);
- /*
- BSD-derived systems set errno correctly
- Solaris returns -1 from getsockopt in case of error
- */
- if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
- ret = -1;
- }
- } else {
- /* whoops: sockfd has disappeared */
- ret = -1;
- }
-
- ok:
- fcntl(sockfd, F_SETFL, flags);
-
- if(error) {
- errno = error;
- ret = -1;
- }
- return ret;
-#else /* !defined(PHP_WIN32) && ... */
- return connect(sockfd, addr, addrlen);
-#endif
-}
-/* }}} */
/* {{{ php_fsockopen() */
/*
server.sin_port = htons(portno);
- if (connect_nonb(socketd, (struct sockaddr *)&server, sizeof(server), &timeout) == SOCK_CONN_ERR) {
+ if (php_connect_nonb(socketd, (struct sockaddr *)&server, sizeof(server), &timeout) == SOCK_CONN_ERR) {
CLOSE_SOCK(1);
if (arg_count>2) {
unix_addr.sun_family = AF_UNIX;
strlcpy(unix_addr.sun_path, (*args[0])->value.str.val, sizeof(unix_addr.sun_path));
- if (connect_nonb(socketd, (struct sockaddr *) &unix_addr, sizeof(unix_addr), &timeout) == SOCK_CONN_ERR) {
+ if (php_connect_nonb(socketd, (struct sockaddr *) &unix_addr, sizeof(unix_addr), &timeout) == SOCK_CONN_ERR) {
CLOSE_SOCK(1);
if (arg_count>2) {
zval_dtor(*args[2]);
/*
* FIXME: fgets depends on '\n' as line delimiter
*/
-PHPAPI char *php_sock_fgets(char *buf, size_t maxlen, int socket)
+static char * php_sock_fgets_internal(char * buf, size_t maxlen, php_sockbuf * sock)
{
char *p = NULL;
char *ret = NULL;
size_t amount = 0;
- SOCK_FIND(sock, socket);
if (maxlen==0) {
buf[0] = 0;
return ret;
}
+PHPAPI char *php_sock_fgets(char *buf, size_t maxlen, int socket)
+{
+ SOCK_FIND(sock, socket);
+ return php_sock_fgets_internal(buf, maxlen, sock);
+}
+
/* }}} */
return ret;
}
-/* {{{ php_sock_fread() */
-
-PHPAPI size_t php_sock_fread(char *ptr, size_t size, int socket)
-{
- size_t ret = 0;
- SOCK_FIND_AND_READ_MAX(size);
-
- if(size < 0)
- return ret;
-
- ret = MIN(TOREAD(sock), size);
- if(ret) {
- memcpy(ptr, READPTR(sock), ret);
- sock->readpos += ret;
- }
-
- return ret;
-}
-
-/* }}} */
-/* {{{ module start/shutdown functions */
-
- /* {{{ php_msock_destroy */
-PHPAPI void php_msock_destroy(int *data)
-{
- close(*data);
-}
-/* }}} */
-
-
/* {{{ stream abstraction */
#if HAVE_PHP_STREAM
static size_t php_sockop_write(php_stream * stream, const char * buf, size_t count)
{
- int socket = (int)stream->abstract;
- return send(socket, buf, count, 0);
+ php_sockbuf * sock = (php_sockbuf*)stream->abstract;
+ return send(sock->socket, buf, count, 0);
}
-static void php_stream_sockwait_for_data(php_stream * stream)
+static size_t php_sockop_read(php_stream * stream, char * buf, size_t count)
{
- fd_set fdr, tfdr;
- int retval, socket;
- struct timeval timeout, *ptimeout;
-
- socket = (int)stream->abstract;
-
- FD_ZERO(&fdr);
- FD_SET(socket, &fdr);
- stream->timeout_event = 0;
+ php_sockbuf * sock = (php_sockbuf*)stream->abstract;
+ size_t ret = 0;
- if (stream->timeout.tv_sec == -1)
- ptimeout = NULL;
+ if (sock->is_blocked)
+ php_sockread_total(sock, count);
else
- ptimeout = &timeout;
-
- while(1) {
- tfdr = fdr;
- timeout = stream->timeout;
-
- retval = select(socket + 1, &tfdr, NULL, NULL, ptimeout);
+ php_sockread(sock);
- if (retval == 0)
- stream->timeout_event = 1;
+ if(count < 0)
+ return ret;
- if (retval >= 0)
- break;
+ ret = MIN(TOREAD(sock), count);
+ if (ret) {
+ memcpy(buf, READPTR(sock), ret);
+ sock->readpos += ret;
}
-}
-static size_t php_sockop_read(php_stream * stream, char * buf, size_t count)
-{
- int socket = (int)stream->abstract;
-
- /* For blocking sockets, we wait until there is some
- data to read (real data or EOF)
-
- Otherwise, recv() may time out and return 0 and
- therefore sock->eof would be set errornously.
- */
-
- if (stream->is_blocked) {
- php_stream_sockwait_for_data(stream);
- if (stream->timeout_event)
- return 0;
- }
- return recv(socket, buf, count, 0);
+ return ret;
}
static int php_sockop_close(php_stream * stream)
{
- int socket = (int)stream->abstract;
- SOCK_CLOSE(socket);
+ php_sockbuf * sock = (php_sockbuf*)stream->abstract;
+
+ SOCK_CLOSE(sock->socket);
+ SOCK_DESTROY(sock);
+
return 0;
}
static int php_sockop_flush(php_stream * stream)
{
- int socket = (int)stream->abstract;
- return fsync(socket);
+ php_sockbuf * sock = (php_sockbuf*)stream->abstract;
+ return fsync(sock->socket);
}
static int php_sockop_cast(php_stream * stream, int castas, void ** ret)
{
- int socket = (int)stream->abstract;
+ php_sockbuf * sock = (php_sockbuf*)stream->abstract;
switch(castas) {
case PHP_STREAM_AS_STDIO:
if (ret) {
/* DANGER!: data buffered in stream->readbuf will be forgotten! */
- *ret = fdopen(socket, stream->mode);
+ if (TOREAD(sock) > 0)
+ zend_error(E_WARNING, "%s(): buffered data lost during conversion to FILE*!", get_active_function_name());
+ *ret = fdopen(sock->socket, stream->mode);
if (*ret)
return SUCCESS;
return FAILURE;
case PHP_STREAM_AS_FD:
case PHP_STREAM_AS_SOCKETD:
if (ret)
- *ret = (void*)socket;
+ *ret = (void*)sock->socket;
return SUCCESS;
default:
return FAILURE;
}
}
+static char * php_sockop_gets(php_stream * stream, char *buf, size_t size)
+{
+ php_sockbuf * sock = (php_sockbuf*)stream->abstract;
+ return php_sock_fgets_internal(buf, size, sock);
+}
+
php_stream_ops php_stream_socket_ops = {
php_sockop_write, php_sockop_read,
php_sockop_close, php_sockop_flush,
- NULL, NULL,
+ NULL, php_sockop_gets,
php_sockop_cast,
"socket"
};
#endif
+/* }}} */
+
+/* {{{ php_sock_fread() */
+
+PHPAPI size_t php_sock_fread(char *ptr, size_t size, int socket)
+{
+ size_t ret = 0;
+ SOCK_FIND_AND_READ_MAX(size);
+
+ if(size < 0)
+ return ret;
+
+ ret = MIN(TOREAD(sock), size);
+ if(ret) {
+ memcpy(ptr, READPTR(sock), ret);
+ sock->readpos += ret;
+ }
+
+ return ret;
+}
/* }}} */
+/* {{{ module start/shutdown functions */
+
+ /* {{{ php_msock_destroy */
+PHPAPI void php_msock_destroy(int *data)
+{
+ close(*data);
+}
+/* }}} */
+
+
PHP_RSHUTDOWN_FUNCTION(fsock)
{
php_cleanup_sockbuf(0 FLS_CC);
return SUCCESS;
}
-
+/* }}} */
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
+ * vim: sw=4 ts=4 tw=78
*/
+----------------------------------------------------------------------+
| Authors: Paul Panotzki - Bunyip Information Systems |
| Jim Winstead (jimw@php.net) |
+ | Wez Furlong |
+----------------------------------------------------------------------+
*/
extern php_stream_ops php_stream_socket_ops;
#endif
+/* stream->abstract points to an instance of this */
struct php_sockbuf {
int socket;
unsigned char *readbuf;
size_t chunk_size;
struct timeval timeout;
char timeout_event;
+#if HAVE_PHP_STREAM
+ php_stream * stream;
+#endif
};
typedef struct php_sockbuf php_sockbuf;
PHPAPI void php_msock_destroy(int *data);
PHPAPI void php_cleanup_sockbuf(int persistent FLS_DC);
-PHPAPI int connect_nonb(int sockfd, struct sockaddr *addr, socklen_t addrlen, struct timeval *timeout);
PHPAPI struct php_sockbuf *php_get_socket(int socket);
PHP_RSHUTDOWN_FUNCTION(fsock);
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim: sw=4 ts=4 tw=78
+ */
#endif /* FSOCK_H */
return 0;
}
+/* {{{ php_connect_nonb */
+PHPAPI int php_connect_nonb(int sockfd,
+ struct sockaddr *addr,
+ socklen_t addrlen,
+ struct timeval *timeout)
+{
+ /* probably won't work on Win32, someone else might try it (read: fix it ;) */
+
+#if (!defined(__BEOS__) && !defined(PHP_WIN32)) && (defined(O_NONBLOCK) || defined(O_NDELAY))
+
+#ifndef O_NONBLOCK
+#define O_NONBLOCK O_NDELAY
+#endif
+
+ int flags;
+ int n;
+ int error = 0;
+ socklen_t len;
+ int ret = 0;
+ fd_set rset;
+ fd_set wset;
+
+ if (timeout == NULL) {
+ /* blocking mode */
+ return connect(sockfd, addr, addrlen);
+ }
+
+ flags = fcntl(sockfd, F_GETFL, 0);
+ fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
+
+ if ((n = connect(sockfd, addr, addrlen)) < 0) {
+ if (errno != EINPROGRESS) {
+ return -1;
+ }
+ }
+
+ if (n == 0) {
+ goto ok;
+ }
+
+ FD_ZERO(&rset);
+ FD_SET(sockfd, &rset);
+
+ wset = rset;
+
+ if ((n = select(sockfd + 1, &rset, &wset, NULL, timeout)) == 0) {
+ error = ETIMEDOUT;
+ }
+
+ if(FD_ISSET(sockfd, &rset) || FD_ISSET(sockfd, &wset)) {
+ len = sizeof(error);
+ /*
+ BSD-derived systems set errno correctly
+ Solaris returns -1 from getsockopt in case of error
+ */
+ if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
+ ret = -1;
+ }
+ } else {
+ /* whoops: sockfd has disappeared */
+ ret = -1;
+ }
+
+ok:
+ fcntl(sockfd, F_SETFL, flags);
+
+ if(error) {
+ errno = error;
+ ret = -1;
+ }
+ return ret;
+#else /* !defined(PHP_WIN32) && ... */
+ return connect(sockfd, addr, addrlen);
+#endif
+}
+/* }}} */
+
/*
* Creates a socket of type socktype and connects to the given host and
* port, returns the created socket on success, else returns -1.
{
int s;
struct sockaddr **sal, **psal;
-
+ struct timeval timeoutval;
+
if (php_network_getaddresses(host, &sal))
return -1;
+ if (timeout) {
+ timeoutval.tv_sec = timeout;
+ timeoutval.tv_usec = 0;
+ }
+
psal = sal;
while (*sal != NULL) {
s = socket((*sal)->sa_family, socktype, 0);
if (s != SOCK_ERR) {
switch ((*sal)->sa_family) {
#if defined( HAVE_GETADDRINFO ) && defined( HAVE_IPV6 )
- case AF_INET6: {
- struct sockaddr_in6 *sa =
- (struct sockaddr_in6 *)*sal;
-
- sa->sin6_family = (*sal)->sa_family;
- sa->sin6_port = htons(port);
- if (connect(s, (struct sockaddr *) sa,
- sizeof(*sa)) != SOCK_CONN_ERR)
- goto ok;
- } break;
+ case AF_INET6:
+ {
+ struct sockaddr_in6 *sa =
+ (struct sockaddr_in6 *)*sal;
+
+ sa->sin6_family = (*sal)->sa_family;
+ sa->sin6_port = htons(port);
+ if (php_connect_nonb(s, (struct sockaddr *) sa,
+ sizeof(*sa), timeout ? &timeoutval : NULL) != SOCK_CONN_ERR)
+ goto ok;
+ }
+ break;
#endif
- case AF_INET: {
- struct sockaddr_in *sa =
- (struct sockaddr_in *)*sal;
+ case AF_INET:
+ {
+ struct sockaddr_in *sa =
+ (struct sockaddr_in *)*sal;
- sa->sin_family = (*sal)->sa_family;
- sa->sin_port = htons(port);
- if (connect(s, (struct sockaddr *) sa,
- sizeof(*sa)) != SOCK_CONN_ERR)
- goto ok;
+ sa->sin_family = (*sal)->sa_family;
+ sa->sin_port = htons(port);
+ if (php_connect_nonb(s, (struct sockaddr *) sa,
+ sizeof(*sa), timeout ? &timeoutval : NULL) != SOCK_CONN_ERR)
+ goto ok;
- } break;
+ }
+ break;
}
close (s);
}
* tab-width: 8
* c-basic-offset: 8
* End:
+ * vim: ts=4 sw=4 tw=78
*/
#ifndef _PHP_NETWORK_H
#define _PHP_NETWORK_H
+#ifdef PHP_WIN32
+# ifndef WINNT
+# define WINNT 1
+# endif
+# undef FD_SETSIZE
+# include "arpa/inet.h"
+# define socklen_t unsigned int
+#endif
+
+#ifdef HAVE_NETINET_IN_H
+# include <netinet/in.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+
+
+
int php_hostconnect(char *host, unsigned short port, int socktype, int timeout);
+PHPAPI int php_connect_nonb(int sockfd, struct sockaddr *addr, socklen_t addrlen, struct timeval *timeout);
#endif /* _PHP_NETWORK_H */
#include <sys/time.h>
#endif
+/* See README.STREAMS in php4 root dir for more info about this stuff */
typedef struct _php_stream php_stream;
typedef struct _php_stream_ops {
-/* stdio like functions - these are mandatory! */
+ /* 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 */
+ /* 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;
-
+ /* so we know how to clean it up correctly. This should be set to
+ * PHP_STREAM_FCLOSE_XXX as appropriate */
+ int fclose_stdiocast;
FILE * stdiocast; /* cache this, otherwise we might leak! */
}; /* php_stream */
+#define PHP_STREAM_FCLOSE_NONE 0
+#define PHP_STREAM_FCLOSE_FDOPEN 1
+#define PHP_STREAM_FCLOSE_FOPENCOOKIE 2
+
/* 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 php_stream * php_stream_alloc(php_stream_ops * ops, void * abstract, 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);
+#define php_stream_rewind(stream) php_stream_seek(stream, 0L, SEEK_SET)
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);
/* 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)
+/* use this to check if a stream is of a particular type:
+ * PHPAPI int php_stream_is(php_stream * stream, php_stream_ops * ops); */
+#define php_stream_is(stream, anops) (stream->ops == anops)
+
#endif /* HAVE_PHP_STREAM */
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim: sw=4 ts=4 tw=78
+ */
#endif
#if HAVE_PHP_STREAM
+#ifdef PHP_WIN32
+#define EWOULDBLOCK WSAEWOULDBLOCK
+#else
+#include "build-defs.h"
+#endif
+
#define MAX_CHUNK_SIZE 8192
#define TOREAD(stream) ((stream)->readbuf.writepos - (stream)->readbuf.readpos)
#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)
+PHPAPI php_stream * php_stream_alloc(php_stream_ops * ops, void * abstract, int persistent, const char * mode)
{
php_stream * ret;
strncpy(ret->mode, mode, sizeof(ret->mode));
- if (bufsize) {
- ret->is_buffered = 1;
- php_stream_buf_init(&ret->readbuf, persistent, bufsize);
- }
return ret;
}
int ret = 1;
if (call_dtor) {
+
+ if (stream->fclose_stdiocast == PHP_STREAM_FCLOSE_FOPENCOOKIE) {
+ /* calling fclose on an fopencookied stream will ultimately
+ call this very same function. If we were called via fclose,
+ the cookie_closer unsets the fclose_stdiocast flags, so
+ we can be sure that we only reach here when PHP code calls
+ php_stream_free.
+ Lets let the cookie code clean it all up.
+ */
+ return fclose(stream->stdiocast);
+ }
+
+ php_stream_flush(stream);
ret = stream->ops->close(stream);
+
+ /* tidy up any FILE* that might have been fdopened */
+ if (stream->fclose_stdiocast == PHP_STREAM_FCLOSE_FDOPEN && stream->stdiocast)
+ {
+ fclose(stream->stdiocast);
+ stream->stdiocast = NULL;
+ }
}
- 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;
+ return stream->ops->read(stream, buf, size);
}
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;
+ /* we 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 */
+ return stream->ops->read(stream, NULL, 0) == EOF ? 1 : 0;
}
PHPAPI int php_stream_getc(php_stream * stream)
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)
{
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) {
+ if (stream->ops->gets) {
return stream->ops->gets(stream, buf, maxlen);
}
else {
}
}
-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;
+ return stream->ops->flush(stream);
}
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;
+ return stream->ops->write(stream, buf, count);
}
PHPAPI off_t php_stream_tell(php_stream * stream)
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) {
+ 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);
+ zend_error(E_WARNING, "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)
FILE * fp = fopen(filename, mode);
if (fp) {
- php_stream * ret = php_stream_alloc(&php_stream_stdio_ops, fp, 0, 0, mode);
+ php_stream * ret = php_stream_alloc(&php_stream_stdio_ops, fp, 0, mode);
if (ret)
return ret;
}
static int stream_cookie_closer(void *cookie) {
- return php_stream_close(((php_stream *)cookie));
+ php_stream * stream = (php_stream*)cookie;
+ /* prevent recursion */
+ stream->fclose_stdiocast = PHP_STREAM_FCLOSE_NONE;
+ return php_stream_close(stream);
}
static COOKIE_IO_FUNCTIONS_T stream_cookie_functions =
stream_cookie_reader, stream_cookie_writer,
stream_cookie_seeker, stream_cookie_closer
};
+#else
+/* TODO: use socketpair() to emulate fopecookie, as suggested by Hartmut ? */
#endif
PHPAPI int php_stream_cast(php_stream * stream, int castas, void ** ret, int show_err)
*ret = fopencookie(stream, stream->mode, stream_cookie_functions);
- if (*ret != NULL)
+ if (*ret != NULL) {
+ stream->fclose_stdiocast = 1;
goto exit_success;
+ }
/* must be either:
a) programmer error
exit_fail:
if (show_err) {
- const char * cast_names[3] = { "STDIO FILE*", "File Descriptor", "Socket Descriptor" };
+ /* these names depend on the values of the PHP_STREAM_AS_XXX defines in php_streams.h */
+ static 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,
}
#endif
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim: tw=78 sw=4 ts=4
+ */
projects / php / commitdiff