+--- /dev/null
++++ b/ext/dio/config.m4
+@@ -0,0 +1,10 @@
++dnl
++dnl $Id: config.m4 291957 2009-12-10 17:13:14Z cyberspice $
++dnl
++
++PHP_ARG_ENABLE(dio, whether to enable direct I/O support,
++[ --enable-dio Enable direct I/O support])
++
++if test "$PHP_DIO" != "no"; then
++ PHP_NEW_EXTENSION(dio, dio.c dio_common.c dio_posix.c dio_stream_wrappers.c, $ext_shared)
++fi
+--- /dev/null
++++ b/ext/dio/dio.c
+@@ -0,0 +1,801 @@
++/*
++ +----------------------------------------------------------------------+
++ | PHP Version 5 |
++ +----------------------------------------------------------------------+
++ | Copyright (c) 1997-2009 The PHP Group |
++ +----------------------------------------------------------------------+
++ | This source file is subject to version 3.0 of the PHP license, |
++ | that is bundled with this package in the file LICENSE, and is |
++ | available through the world-wide-web at the following url: |
++ | http://www.php.net/license/3_0.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. |
++ +----------------------------------------------------------------------+
++ | Author: Sterling Hughes <sterling@php.net> |
++ | Author: Melanie Rhianna Lewis <cyberspice@php.net> |
++ +----------------------------------------------------------------------+
++ */
++
++#ifdef HAVE_CONFIG_H
++#include "config.h"
++#endif
++
++#include "php.h"
++#include "php_ini.h"
++#include "ext/standard/info.h"
++
++#include "php_dio.h"
++#include "php_dio_stream_wrappers.h"
++
++#include <sys/stat.h>
++#include <sys/types.h>
++
++#ifdef HAVE_UNISTD_H
++#include <unistd.h>
++#endif
++
++#include <fcntl.h>
++#ifndef PHP_WIN32
++#include <termios.h>
++#endif
++
++/* e.g. IRIX does not have CRTSCTS */
++#ifndef CRTSCTS
++# ifdef CNEW_RTSCTS
++# define CRTSCTS CNEW_RTSCTS
++# else
++# define CRTSCTS 0
++# endif /* CNEW_RTSCTS */
++#endif /* !CRTSCTS */
++
++/*
++ +----------------------------------------------------------------------+
++ | DEPRECATED FUNCTIONALITY |
++ +----------------------------------------------------------------------+
++ | The functions below are from the earlier DIO versions. They will |
++ | continue to be maintained but not extended. It is thoroughly |
++ | recommended that you should use either the stream wrappers or the |
++ | DIO classes in new code. - Melanie |
++ +----------------------------------------------------------------------+
++ */
++
++#define le_fd_name "Direct I/O File Descriptor"
++static int le_fd;
++
++static int new_php_fd(php_fd_t **f, int fd)
++{
++ if (!(*f = malloc(sizeof(php_fd_t)))) {
++ return 0;
++ }
++ (*f)->fd = fd;
++ return 1;
++}
++
++static void _dio_close_fd(zend_rsrc_list_entry *rsrc TSRMLS_DC)
++{
++ php_fd_t *f = (php_fd_t *) rsrc->ptr;
++ if (f) {
++ close(f->fd);
++ free(f);
++ }
++}
++
++/* {{{ proto resource dio_open(string filename, int flags[, int mode])
++ Open a new filename with specified permissions of flags and creation permissions of mode */
++PHP_FUNCTION(dio_open)
++{
++ php_fd_t *f;
++ char *file_name;
++ int file_name_length;
++ long flags;
++ long mode = 0;
++ int fd;
++
++ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|l", &file_name, &file_name_length, &flags, &mode) == FAILURE) {
++ return;
++ }
++
++ if (php_check_open_basedir(file_name TSRMLS_CC) || (PG(safe_mode) && !php_checkuid(file_name, "wb+", CHECKUID_CHECK_MODE_PARAM))) {
++ RETURN_FALSE;
++ }
++
++ if (ZEND_NUM_ARGS() == 3) {
++ fd = open(file_name, flags, mode);
++ } else {
++ fd = open(file_name, flags);
++ }
++
++ if (fd == -1) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot open file %s with flags %ld and permissions %ld: %s", file_name, flags, mode, strerror(errno));
++ RETURN_FALSE;
++ }
++
++
++ if (!new_php_fd(&f, fd)) {
++ RETURN_FALSE;
++ }
++ ZEND_REGISTER_RESOURCE(return_value, f, le_fd);
++}
++/* }}} */
++
++/* {{{ proto string dio_read(resource fd[, int n])
++ Read n bytes from fd and return them, if n is not specified, read 1k */
++PHP_FUNCTION(dio_read)
++{
++ zval *r_fd;
++ php_fd_t *f;
++ char *data;
++ long bytes = 1024;
++ ssize_t res;
++
++ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &r_fd, &bytes) == FAILURE) {
++ return;
++ }
++
++ ZEND_FETCH_RESOURCE(f, php_fd_t *, &r_fd, -1, le_fd_name, le_fd);
++
++ if (bytes <= 0) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length parameter must be greater than 0.");
++ RETURN_FALSE;
++ }
++
++ data = emalloc(bytes + 1);
++ res = read(f->fd, data, bytes);
++ if (res <= 0) {
++ efree(data);
++ RETURN_NULL();
++ }
++
++ data = erealloc(data, res + 1);
++ data[res] = 0;
++
++ RETURN_STRINGL(data, res, 0);
++}
++/* }}} */
++
++/* {{{ proto int dio_write(resource fd, string data[, int len])
++ Write data to fd with optional truncation at length */
++PHP_FUNCTION(dio_write)
++{
++ zval *r_fd;
++ php_fd_t *f;
++ char *data;
++ int data_len;
++ long trunc_len = 0;
++ ssize_t res;
++
++ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &r_fd, &data, &data_len, &trunc_len) == FAILURE) {
++ return;
++ }
++
++ if (trunc_len < 0 || trunc_len > data_len) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "length must be greater or equal to zero and less then the length of the specified string.");
++ RETURN_FALSE;
++ }
++
++ ZEND_FETCH_RESOURCE(f, php_fd_t *, &r_fd, -1, le_fd_name, le_fd);
++
++ res = write(f->fd, data, trunc_len ? trunc_len : data_len);
++ if (res == -1) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot write data to file descriptor %d, %s", f->fd, strerror(errno));
++ }
++
++ RETURN_LONG(res);
++}
++/* }}} */
++
++#ifndef PHP_WIN32
++
++/* {{{ proto bool dio_truncate(resource fd, int offset)
++ Truncate file descriptor fd to offset bytes */
++PHP_FUNCTION(dio_truncate)
++{
++ zval *r_fd;
++ php_fd_t *f;
++ long offset;
++
++ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &r_fd, &offset) == FAILURE) {
++ return;
++ }
++
++ ZEND_FETCH_RESOURCE(f, php_fd_t *, &r_fd, -1, le_fd_name, le_fd);
++
++ if (ftruncate(f->fd, offset) == -1) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "couldn't truncate %d to %ld bytes: %s", f->fd, offset, strerror(errno));
++ RETURN_FALSE;
++ }
++
++ RETURN_TRUE;
++}
++/* }}} */
++#endif
++
++#define ADD_FIELD(f, v) add_assoc_long_ex(return_value, (f), sizeof(f), v);
++
++/* {{{ proto array dio_stat(resource fd)
++ Get stat information about the file descriptor fd */
++PHP_FUNCTION(dio_stat)
++{
++ zval *r_fd;
++ php_fd_t *f;
++ struct stat s;
++
++ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &r_fd) == FAILURE) {
++ return;
++ }
++
++ ZEND_FETCH_RESOURCE(f, php_fd_t *, &r_fd, -1, le_fd_name, le_fd);
++
++ if (fstat(f->fd, &s) == -1) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot stat %d: %s", f->fd, strerror(errno));
++ RETURN_FALSE;
++ }
++
++ array_init(return_value);
++ ADD_FIELD("device", s.st_dev);
++ ADD_FIELD("inode", s.st_ino);
++ ADD_FIELD("mode", s.st_mode);
++ ADD_FIELD("nlink", s.st_nlink);
++ ADD_FIELD("uid", s.st_uid);
++ ADD_FIELD("gid", s.st_gid);
++ ADD_FIELD("device_type", s.st_rdev);
++ ADD_FIELD("size", s.st_size);
++#ifndef PHP_WIN32
++ ADD_FIELD("block_size", s.st_blksize);
++ ADD_FIELD("blocks", s.st_blocks);
++#endif
++ ADD_FIELD("atime", s.st_atime);
++ ADD_FIELD("mtime", s.st_mtime);
++ ADD_FIELD("ctime", s.st_ctime);
++}
++/* }}} */
++
++/* {{{ proto int dio_seek(resource fd, int pos, int whence)
++ Seek to pos on fd from whence */
++PHP_FUNCTION(dio_seek)
++{
++ zval *r_fd;
++ php_fd_t *f;
++ long offset;
++ long whence = SEEK_SET;
++
++ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|l", &r_fd, &offset, &whence) == FAILURE) {
++ return;
++ }
++
++ ZEND_FETCH_RESOURCE(f, php_fd_t *, &r_fd, -1, le_fd_name, le_fd);
++
++ RETURN_LONG(lseek(f->fd, offset, whence));
++}
++/* }}} */
++
++#ifndef PHP_WIN32
++
++/* {{{ proto mixed dio_fcntl(resource fd, int cmd[, mixed arg])
++ Perform a c library fcntl on fd */
++PHP_FUNCTION(dio_fcntl)
++{
++ zval *r_fd;
++ zval *arg = NULL;
++ php_fd_t *f;
++ long cmd;
++
++ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|z", &r_fd, &cmd, &arg) == FAILURE) {
++ return;
++ }
++
++ ZEND_FETCH_RESOURCE(f, php_fd_t *, &r_fd, -1, le_fd_name, le_fd);
++
++ switch (cmd) {
++ case F_SETLK:
++ case F_SETLKW: {
++ zval **element;
++ struct flock lk = {0};
++ HashTable *fh;
++
++ if (!arg) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "expects argument 3 to be array or int, none given");
++ RETURN_FALSE;
++ }
++ if (Z_TYPE_P(arg) == IS_ARRAY) {
++ fh = HASH_OF(arg);
++ if (zend_hash_find(fh, "start", sizeof("start"), (void **) &element) == FAILURE) {
++ lk.l_start = 0;
++ } else {
++ lk.l_start = Z_LVAL_PP(element);
++ }
++
++ if (zend_hash_find(fh, "length", sizeof("length"), (void **) &element) == FAILURE) {
++ lk.l_len = 0;
++ } else {
++ lk.l_len = Z_LVAL_PP(element);
++ }
++
++ if (zend_hash_find(fh, "whence", sizeof("whence"), (void **) &element) == FAILURE) {
++ lk.l_whence = 0;
++ } else {
++ lk.l_whence = Z_LVAL_PP(element);
++ }
++
++ if (zend_hash_find(fh, "type", sizeof("type"), (void **) &element) == FAILURE) {
++ lk.l_type = 0;
++ } else {
++ lk.l_type = Z_LVAL_PP(element);
++ }
++ } else if (Z_TYPE_P(arg) == IS_LONG) {
++ lk.l_start = 0;
++ lk.l_len = 0;
++ lk.l_whence = SEEK_SET;
++ lk.l_type = Z_LVAL_P(arg);
++ } else {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "expects argument 3 to be array or int, %s given", zend_zval_type_name(arg));
++ RETURN_FALSE;
++ }
++
++ RETURN_LONG(fcntl(f->fd, cmd, &lk));
++ break;
++ }
++ case F_GETLK: {
++ struct flock lk = {0};
++
++ fcntl(f->fd, cmd, &lk);
++
++ array_init(return_value);
++ add_assoc_long(return_value, "type", lk.l_type);
++ add_assoc_long(return_value, "whence", lk.l_whence);
++ add_assoc_long(return_value, "start", lk.l_start);
++ add_assoc_long(return_value, "length", lk.l_len);
++ add_assoc_long(return_value, "pid", lk.l_pid);
++
++ break;
++ }
++ case F_DUPFD: {
++ php_fd_t *new_f;
++
++ if (!arg || Z_TYPE_P(arg) != IS_LONG) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "expects argument 3 to be int");
++ RETURN_FALSE;
++ }
++
++ if (!new_php_fd(&new_f, fcntl(f->fd, cmd, Z_LVAL_P(arg)))) {
++ RETURN_FALSE;
++ }
++ ZEND_REGISTER_RESOURCE(return_value, new_f, le_fd);
++ break;
++ }
++ default:
++ if (!arg || Z_TYPE_P(arg) != IS_LONG) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "expects argument 3 to be int");
++ RETURN_FALSE;
++ }
++
++ RETURN_LONG(fcntl(f->fd, cmd, Z_LVAL_P(arg)));
++ }
++}
++/* }}} */
++#endif
++
++#ifndef PHP_WIN32
++
++/* {{{ proto mixed dio_tcsetattr(resource fd, array args )
++ Perform a c library tcsetattr on fd */
++PHP_FUNCTION(dio_tcsetattr)
++{
++ zval *r_fd;
++ zval *arg = NULL;
++ php_fd_t *f;
++ struct termios newtio;
++ int Baud_Rate, Data_Bits=8, Stop_Bits=1, Parity=0, Flow_Control=1, Is_Canonical=1;
++ long BAUD,DATABITS,STOPBITS,PARITYON,PARITY;
++ HashTable *fh;
++ zval **element;
++
++ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &r_fd, &arg) == FAILURE) {
++ return;
++ }
++
++ ZEND_FETCH_RESOURCE(f, php_fd_t *, &r_fd, -1, le_fd_name, le_fd);
++
++ if (Z_TYPE_P(arg) != IS_ARRAY) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING,"tcsetattr, third argument should be an associative array");
++ return;
++ }
++
++ fh = HASH_OF(arg);
++
++ if (zend_hash_find(fh, "baud", sizeof("baud"), (void **) &element) == FAILURE) {
++ Baud_Rate = 9600;
++ } else {
++ Baud_Rate = Z_LVAL_PP(element);
++ }
++
++ if (zend_hash_find(fh, "bits", sizeof("bits"), (void **) &element) == FAILURE) {
++ Data_Bits = 8;
++ } else {
++ Data_Bits = Z_LVAL_PP(element);
++ }
++
++ if (zend_hash_find(fh, "stop", sizeof("stop"), (void **) &element) == FAILURE) {
++ Stop_Bits = 1;
++ } else {
++ Stop_Bits = Z_LVAL_PP(element);
++ }
++
++ if (zend_hash_find(fh, "parity", sizeof("parity"), (void **) &element) == FAILURE) {
++ Parity = 0;
++ } else {
++ Parity = Z_LVAL_PP(element);
++ }
++
++ if (zend_hash_find(fh, "flow_control", sizeof("flow_control"), (void **) &element) == FAILURE) {
++ Flow_Control = 1;
++ } else {
++ Flow_Control = Z_LVAL_PP(element);
++ }
++
++ if (zend_hash_find(fh, "is_canonical", sizeof("is_canonical"), (void **) &element) == FAILURE) {
++ Is_Canonical = 1;
++ } else {
++ Is_Canonical = Z_LVAL_PP(element);
++ }
++
++ /* assign to correct values... */
++ switch (Baud_Rate) {
++ case 38400:
++ BAUD = B38400;
++ break;
++ case 19200:
++ BAUD = B19200;
++ break;
++ case 9600:
++ BAUD = B9600;
++ break;
++ case 4800:
++ BAUD = B4800;
++ break;
++ case 2400:
++ BAUD = B2400;
++ break;
++ case 1800:
++ BAUD = B1800;
++ break;
++ case 1200:
++ BAUD = B1200;
++ break;
++ case 600:
++ BAUD = B600;
++ break;
++ case 300:
++ BAUD = B300;
++ break;
++ case 200:
++ BAUD = B200;
++ break;
++ case 150:
++ BAUD = B150;
++ break;
++ case 134:
++ BAUD = B134;
++ break;
++ case 110:
++ BAUD = B110;
++ break;
++ case 75:
++ BAUD = B75;
++ break;
++ case 50:
++ BAUD = B50;
++ break;
++ default:
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid baud rate %d", Baud_Rate);
++ RETURN_FALSE;
++ }
++ switch (Data_Bits) {
++ case 8:
++ DATABITS = CS8;
++ break;
++ case 7:
++ DATABITS = CS7;
++ break;
++ case 6:
++ DATABITS = CS6;
++ break;
++ case 5:
++ DATABITS = CS5;
++ break;
++ default:
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid data bits %d", Data_Bits);
++ RETURN_FALSE;
++ }
++ switch (Stop_Bits) {
++ case 1:
++ STOPBITS = 0;
++ break;
++ case 2:
++ STOPBITS = CSTOPB;
++ break;
++ default:
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid stop bits %d", Stop_Bits);
++ RETURN_FALSE;
++ }
++
++ switch (Parity) {
++ case 0:
++ PARITYON = 0;
++ PARITY = 0;
++ break;
++ case 1:
++ PARITYON = PARENB;
++ PARITY = PARODD;
++ break;
++ case 2:
++ PARITYON = PARENB;
++ PARITY = 0;
++ break;
++ default:
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid parity %d", Parity);
++ RETURN_FALSE;
++ }
++
++ memset(&newtio, 0, sizeof(newtio));
++ tcgetattr(f->fd, &newtio);
++
++ if (Is_Canonical) {
++ newtio.c_iflag = IGNPAR | ICRNL;
++ newtio.c_oflag = 0;
++ newtio.c_lflag = ICANON;
++ } else {
++ cfmakeraw(&newtio);
++ }
++
++ newtio.c_cflag = BAUD | DATABITS | STOPBITS | PARITYON | PARITY | CLOCAL | CREAD;
++
++#ifdef CRTSCTS
++ if (Flow_Control) {
++ newtio.c_cflag |= CRTSCTS;
++ }
++#endif
++
++ if (Is_Canonical)
++
++ newtio.c_cc[VMIN] = 1;
++ newtio.c_cc[VTIME] = 0;
++ tcflush(f->fd, TCIFLUSH);
++ tcsetattr(f->fd,TCSANOW,&newtio);
++
++ RETURN_TRUE;
++}
++/* }}} */
++#endif
++
++/* {{{ proto void dio_close(resource fd)
++ Close the file descriptor given by fd */
++PHP_FUNCTION(dio_close)
++{
++ zval *r_fd;
++ php_fd_t *f;
++
++ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &r_fd) == FAILURE) {
++ return;
++ }
++
++ ZEND_FETCH_RESOURCE(f, php_fd_t *, &r_fd, -1, le_fd_name, le_fd);
++
++ zend_list_delete(Z_LVAL_P(r_fd));
++}
++/* }}} */
++
++#define RDIOC(c) REGISTER_LONG_CONSTANT(#c, c, CONST_CS | CONST_PERSISTENT)
++
++/* {{{ dio_init_legacy_defines
++ * Initialises the legacy PHP defines
++ */
++static void dio_init_legacy_defines(int module_number TSRMLS_DC) {
++ RDIOC(O_RDONLY);
++ RDIOC(O_WRONLY);
++ RDIOC(O_RDWR);
++ RDIOC(O_CREAT);
++ RDIOC(O_EXCL);
++ RDIOC(O_TRUNC);
++ RDIOC(O_APPEND);
++#ifdef O_NONBLOCK
++ RDIOC(O_NONBLOCK);
++#endif
++#ifdef O_NDELAY
++ RDIOC(O_NDELAY);
++#endif
++#ifdef O_SYNC
++ RDIOC(O_SYNC);
++#endif
++#ifdef O_ASYNC
++ RDIOC(O_ASYNC);
++#endif
++#ifdef O_NOCTTY
++ RDIOC(O_NOCTTY);
++#endif
++#ifndef PHP_WIN32
++ RDIOC(S_IRWXU);
++ RDIOC(S_IRUSR);
++ RDIOC(S_IWUSR);
++ RDIOC(S_IXUSR);
++ RDIOC(S_IRWXG);
++ RDIOC(S_IRGRP);
++ RDIOC(S_IWGRP);
++ RDIOC(S_IXGRP);
++ RDIOC(S_IRWXO);
++ RDIOC(S_IROTH);
++ RDIOC(S_IWOTH);
++ RDIOC(S_IXOTH);
++ RDIOC(F_DUPFD);
++ RDIOC(F_GETFD);
++ RDIOC(F_GETFL);
++ RDIOC(F_SETFL);
++ RDIOC(F_GETLK);
++ RDIOC(F_SETLK);
++ RDIOC(F_SETLKW);
++ RDIOC(F_SETOWN);
++ RDIOC(F_GETOWN);
++ RDIOC(F_UNLCK);
++ RDIOC(F_RDLCK);
++ RDIOC(F_WRLCK);
++#endif
++}
++
++ZEND_BEGIN_ARG_INFO_EX(dio_open_args, 0, 0, 2)
++ ZEND_ARG_INFO(0, filename)
++ ZEND_ARG_INFO(0, flags)
++ ZEND_ARG_INFO(0, mode)
++ZEND_END_ARG_INFO()
++
++ZEND_BEGIN_ARG_INFO_EX(dio_read_args, 0, 0, 1)
++ ZEND_ARG_INFO(0, fd)
++ ZEND_ARG_INFO(0, n)
++ZEND_END_ARG_INFO()
++
++ZEND_BEGIN_ARG_INFO_EX(dio_write_args, 0, 0, 2)
++ ZEND_ARG_INFO(0, fd)
++ ZEND_ARG_INFO(0, data)
++ ZEND_ARG_INFO(0, len)
++ZEND_END_ARG_INFO()
++
++ZEND_BEGIN_ARG_INFO_EX(dio_stat_args, 0, 0, 1)
++ ZEND_ARG_INFO(0, fd)
++ZEND_END_ARG_INFO()
++
++ZEND_BEGIN_ARG_INFO_EX(dio_truncate_args, 0, 0, 2)
++ ZEND_ARG_INFO(0, fd)
++ ZEND_ARG_INFO(0, offset)
++ZEND_END_ARG_INFO()
++
++ZEND_BEGIN_ARG_INFO_EX(dio_seek_args, 0, 0, 3)
++ ZEND_ARG_INFO(0, fd)
++ ZEND_ARG_INFO(0, pos)
++ ZEND_ARG_INFO(0, whence)
++ZEND_END_ARG_INFO()
++
++ZEND_BEGIN_ARG_INFO_EX(dio_fcntl_args, 0, 0, 2)
++ ZEND_ARG_INFO(0, fd)
++ ZEND_ARG_INFO(0, cmd)
++ ZEND_ARG_INFO(0, arg)
++ZEND_END_ARG_INFO()
++
++ZEND_BEGIN_ARG_INFO_EX(dio_tcsetattr_args, 0, 0, 2)
++ ZEND_ARG_INFO(0, fd)
++ ZEND_ARG_INFO(0, args)
++ZEND_END_ARG_INFO()
++
++ZEND_BEGIN_ARG_INFO_EX(dio_close_args, 0, 0, 1)
++ ZEND_ARG_INFO(0, fd)
++ZEND_END_ARG_INFO()
++
++/*
++ +----------------------------------------------------------------------+
++ | END OF DEPRECATED FUNCTIONALITY |
++ +----------------------------------------------------------------------+
++ */
++
++ZEND_BEGIN_ARG_INFO_EX(dio_raw_args, 0, 0, 2)
++ ZEND_ARG_INFO(0, filename)
++ ZEND_ARG_INFO(0, mode)
++ ZEND_ARG_INFO(0, options)
++ZEND_END_ARG_INFO()
++
++ZEND_BEGIN_ARG_INFO_EX(dio_serial_args, 0, 0, 2)
++ ZEND_ARG_INFO(0, filename)
++ ZEND_ARG_INFO(0, mode)
++ ZEND_ARG_INFO(0, options)
++ZEND_END_ARG_INFO()
++
++static zend_object_handlers dio_raw_object_handlers;
++
++static function_entry dio_functions[] = {
++ /* Class functions. */
++
++ /* Legacy functions (Deprecated - See dio_legacy.c) */
++ PHP_FE(dio_open, dio_open_args)
++#ifndef PHP_WIN32
++ PHP_FE(dio_truncate, dio_truncate_args)
++#endif
++ PHP_FE(dio_stat, dio_stat_args)
++ PHP_FE(dio_seek, dio_seek_args)
++#ifndef PHP_WIN32
++ PHP_FE(dio_fcntl, dio_fcntl_args)
++#endif
++ PHP_FE(dio_read, dio_read_args)
++ PHP_FE(dio_write, dio_write_args)
++ PHP_FE(dio_close, dio_close_args)
++#ifndef PHP_WIN32
++ PHP_FE(dio_tcsetattr, dio_tcsetattr_args)
++#endif
++
++ /* Stream functions */
++ PHP_FE(dio_raw, dio_raw_args)
++ PHP_FE(dio_serial, dio_serial_args)
++
++ /* End of functions */
++ {NULL, NULL, NULL}
++};
++
++zend_module_entry dio_module_entry = {
++ STANDARD_MODULE_HEADER,
++ "dio",
++ dio_functions,
++ PHP_MINIT(dio),
++ NULL,
++ NULL,
++ NULL,
++ PHP_MINFO(dio),
++ PHP_DIO_VERSION,
++ STANDARD_MODULE_PROPERTIES
++};
++
++#ifdef COMPILE_DL_DIO
++ZEND_GET_MODULE(dio)
++#endif
++
++#define DIO_UNDEF_CONST -1
++
++/* {{{ PHP_MINIT_FUNCTION
++ */
++PHP_MINIT_FUNCTION(dio)
++{
++ /* Legacy resource destructor. */
++ le_fd = zend_register_list_destructors_ex(_dio_close_fd, NULL, le_fd_name, module_number);
++
++ dio_init_legacy_defines(module_number TSRMLS_CC);
++
++ /* Register the stream wrappers */
++ return (php_register_url_stream_wrapper(DIO_RAW_STREAM_NAME, &php_dio_raw_stream_wrapper TSRMLS_CC) == SUCCESS &&
++ php_register_url_stream_wrapper(DIO_SERIAL_STREAM_NAME, &php_dio_serial_stream_wrapper TSRMLS_CC) == SUCCESS) ? SUCCESS : FAILURE;
++}
++/* }}} */
++
++/* {{{ PHP_MSHUTDOWN_FUNCTION
++ */
++PHP_MSHUTDOWN_FUNCTION(dio)
++{
++ return (php_unregister_url_stream_wrapper(DIO_RAW_STREAM_NAME TSRMLS_CC) == SUCCESS &&
++ php_unregister_url_stream_wrapper(DIO_SERIAL_STREAM_NAME TSRMLS_CC) == SUCCESS) ? SUCCESS : FAILURE;
++}
++/* }}} */
++
++/* {{{ PHP_MINFO_FUNCTION
++ */
++PHP_MINFO_FUNCTION(dio)
++{
++ php_info_print_table_start();
++ php_info_print_table_header(2, "dio support", "enabled");
++ php_info_print_table_row(2, "version", PHP_DIO_VERSION);
++ php_info_print_table_end();
++}
++/* }}} */
++
++/*
++ * Local variables:
++ * c-basic-offset: 4
++ * tab-width: 4
++ * End:
++ * vim600: fdm=marker
++ * vim: sw=4 ts=4 noet
++ */
+--- /dev/null
++++ b/ext/dio/dio_common.c
+@@ -0,0 +1,230 @@
++/*
++ +----------------------------------------------------------------------+
++ | PHP Version 5 |
++ +----------------------------------------------------------------------+
++ | Copyright (c) 2009 Melanie Rhianna Lewis |
++ +----------------------------------------------------------------------+
++ | This source file is subject to version 3.0 of the PHP license, |
++ | that is bundled with this package in the file LICENSE, and is |
++ | available through the world-wide-web at the following url: |
++ | http://www.php.net/license/3_0.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. |
++ +----------------------------------------------------------------------+
++ | Author: Melanie Rhianna Lewis <cyberspice@php.net> |
++ +----------------------------------------------------------------------+
++ */
++
++#ifdef HAVE_CONFIG_H
++#include "config.h"
++#endif
++
++#include "php.h"
++
++#include "php_dio.h"
++#include "php_dio_common.h"
++
++/* {{{ dio_init_stream_data
++ * Initialises the command parts of the stream data.
++ */
++void dio_init_stream_data(php_dio_stream_data *data) {
++ data->stream_type = DIO_STREAM_TYPE_NONE;
++ data->end_of_file = 0;
++#ifdef DIO_HAS_FILEPERMS
++ data->has_perms = 0;
++ data->perms = 0;
++#endif
++#ifdef DIO_NONBLOCK
++ data->is_blocking = 1;
++ data->has_timeout = 0;
++ data->timeout_sec = 0;
++ data->timeout_usec = 0;
++ data->timed_out = 0;
++#endif
++ /* Serial options */
++ data->data_rate = 9600;
++ data->data_bits = 8;
++ data->stop_bits = 1;
++ data->parity = 0;
++ data->flow_control = 1;
++ data->canonical = 1;
++}
++/* }}} */
++
++/* {{{ dio_convert_to_long
++ * Returns as a long, the value of the zval regardless of its type.
++ */
++long dio_convert_to_long(zval *val) {
++ zval *copyval;
++ long longval;
++
++ ALLOC_INIT_ZVAL(copyval);
++ *copyval = *val;
++ convert_to_long(copyval);
++ longval = Z_LVAL_P(copyval);
++ zval_ptr_dtor(©val);
++
++ return longval;
++}
++/* }}} */
++
++/* {{{ dio_assoc_array_get_basic_options
++ * Retrieves the basic open option values from an associative array
++ */
++void dio_assoc_array_get_basic_options(zval *options, php_dio_stream_data *data TSRMLS_DC) {
++#if defined(DIO_HAS_FILEPERMS) || defined(DIO_NONBLOCK)
++ zval **tmpzval;
++ HashTable *opthash;
++
++ opthash = HASH_OF(options);
++#endif
++
++#ifdef DIO_HAS_FILEPERMS
++ /* This is the file mode flags used by open(). */
++ if (zend_hash_find(opthash, "perms", sizeof("perms"), (void **)&tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->perms = (int)dio_convert_to_long(*tmpzval);
++ data->has_perms = 1;
++ }
++#endif
++
++#ifdef DIO_NONBLOCK
++ /* This sets the underlying stream to be blocking/non
++ block (i.e. O_NONBLOCK) */
++ if (zend_hash_find(opthash, "is_blocking", sizeof("is_blocking"), (void **)&tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->is_blocking = dio_convert_to_long(*tmpzval) ? 1 : 0;
++ }
++
++ /* This is the timeout value for reads in seconds. Only one of
++ timeout_secs or timeout_usecs need be defined to define a timeout. */
++ if (zend_hash_find(opthash, "timeout_secs", sizeof("timeout_secs"), (void **)&tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->timeout_sec = dio_convert_to_long(*tmpzval);
++ }
++
++ /* This is the timeout value for reads in microseconds. Only one of
++ timeout_secs or timeout_usecs need be defined to define a timeout. */
++ if (zend_hash_find(opthash, "timeout_usecs", sizeof("timeout_usecs"), (void **)&tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->timeout_usec = dio_convert_to_long(*tmpzval);
++ }
++
++ data->has_timeout = (data->timeout_sec | data->timeout_usec) ? 1 : 0;
++#endif
++}
++/* }}} */
++
++/* {{{ dio_assoc_array_get_serial_options
++ * Retrieves the serial open option values from an associative array
++ */
++void dio_assoc_array_get_serial_options(zval *options, php_dio_stream_data *data TSRMLS_DC) {
++ zval **tmpzval;
++ HashTable *opthash;
++
++ opthash = HASH_OF(options);
++
++ if (zend_hash_find(opthash, "data_rate", sizeof("data_rate"), (void **)&tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->data_rate = dio_convert_to_long(*tmpzval);
++ }
++
++ if (zend_hash_find(opthash, "data_bits", sizeof("data_bits"), (void **)&tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->data_bits = (int)dio_convert_to_long(*tmpzval);
++ }
++
++ if (zend_hash_find(opthash, "stop_bits", sizeof("stop_bits"), (void **)&tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->stop_bits = (int)dio_convert_to_long(*tmpzval);
++ }
++
++ if (zend_hash_find(opthash, "parity", sizeof("parity"), (void **)&tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->parity = (int)dio_convert_to_long(*tmpzval);
++ }
++
++ if (zend_hash_find(opthash, "flow_control", sizeof("flow_control"), (void **)&tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->flow_control = (int)(dio_convert_to_long(*tmpzval) ? 1 : 0);
++ }
++
++ if (zend_hash_find(opthash, "is_canonical", sizeof("is_canonical"), (void **)&tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->canonical = (int)(dio_convert_to_long(*tmpzval) ? 1 : 0);
++ }
++}
++/* }}} */
++
++/* {{{ dio_stream_context_get_raw_options
++ * Extracts the option values for dio.raw mode from a context
++ */
++void dio_stream_context_get_basic_options(php_stream_context *context, php_dio_stream_data *data TSRMLS_DC) {
++#if defined(DIO_HAS_FILEPERMS) || defined(DIO_NONBLOCK)
++ zval **tmpzval;
++#endif
++
++#ifdef DIO_HAS_FILEPERMS
++ /* This is the file mode flags used by open(). */
++ if (php_stream_context_get_option(context, "dio", "perms", &tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->perms = (int)dio_convert_to_long(*tmpzval);
++ data->has_perms = 1;
++ }
++#endif
++
++#ifdef DIO_NONBLOCK
++ /* This sets the underlying stream to be blocking/non
++ block (i.e. O_NONBLOCK) */
++ if (php_stream_context_get_option(context, "dio", "is_blocking", &tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->is_blocking = dio_convert_to_long(*tmpzval) ? 1 : 0;
++ }
++
++ /* This is the timeout value for reads in seconds. Only one of
++ timeout_secs or timeout_usecs need be defined to define a timeout. */
++ if (php_stream_context_get_option(context, "dio", "timeout_secs", &tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->timeout_sec = dio_convert_to_long(*tmpzval);
++ }
++
++ /* This is the timeout value for reads in microseconds. Only one of
++ timeout_secs or timeout_usecs need be defined to define a timeout. */
++ if (php_stream_context_get_option(context, "dio", "timeout_usecs", &tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->timeout_usec = dio_convert_to_long(*tmpzval);
++ }
++
++ data->has_timeout = (data->timeout_sec | data->timeout_usec) ? 1 : 0;
++#endif
++}
++/* }}} */
++
++/* {{{ dio_stream_context_get_serial_options
++ * Extracts the option values for dio.serial mode from a context
++ */
++void dio_stream_context_get_serial_options(php_stream_context *context, php_dio_stream_data *data TSRMLS_DC) {
++ zval **tmpzval;
++
++ if (php_stream_context_get_option(context, "dio", "data_rate", &tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->data_rate = dio_convert_to_long(*tmpzval);
++ }
++
++ if (php_stream_context_get_option(context, "dio", "data_bits", &tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->data_bits = (int)dio_convert_to_long(*tmpzval);
++ }
++
++ if (php_stream_context_get_option(context, "dio", "stop_bits", &tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->stop_bits = (int)dio_convert_to_long(*tmpzval);
++ }
++
++ if (php_stream_context_get_option(context, "dio", "parity", &tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->parity = (int)dio_convert_to_long(*tmpzval);
++ }
++
++ if (php_stream_context_get_option(context, "dio", "flow_control", &tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->flow_control = (int)(dio_convert_to_long(*tmpzval) ? 1 : 0);
++ }
++
++ if (php_stream_context_get_option(context, "dio", "is_canonical", &tmpzval) == SUCCESS && tmpzval && *tmpzval) {
++ data->canonical = (int)(dio_convert_to_long(*tmpzval) ? 1 : 0);
++ }
++}
++/* }}} */
++
++/*
++ * Local variables:
++ * c-basic-offset: 4
++ * tab-width: 4
++ * End:
++ * vim600: fdm=marker
++ * vim: sw=4 ts=4 noet
++ */
++
+--- /dev/null
++++ b/ext/dio/dio_posix.c
+@@ -0,0 +1,659 @@
++/*
++ +----------------------------------------------------------------------+
++ | PHP Version 5 |
++ +----------------------------------------------------------------------+
++ | Copyright (c) 2009 Melanie Rhianna Lewis |
++ +----------------------------------------------------------------------+
++ | This source file is subject to version 3.0 of the PHP license, |
++ | that is bundled with this package in the file LICENSE, and is |
++ | available through the world-wide-web at the following url: |
++ | http://www.php.net/license/3_0.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. |
++ +----------------------------------------------------------------------+
++ | Author: Melanie Rhianna Lewis <cyberspice@php.net> |
++ +----------------------------------------------------------------------+
++ */
++
++#ifdef HAVE_CONFIG_H
++#include "config.h"
++#endif
++
++#include "php.h"
++
++#include "php_dio_common.h"
++
++/* {{{ dio_stream_mode_to_flags
++ * Convert an fopen() mode string to open() flags
++ */
++static int dio_stream_mode_to_flags(const char *mode) {
++ int flags = 0, ch = 0, bin = 1;
++
++ switch(mode[ch++]) {
++ case 'r':
++ flags = 0;
++ break;
++ case 'w':
++ flags = O_TRUNC | O_CREAT;
++ break;
++ case 'a':
++ flags = O_APPEND | O_CREAT;
++ break;
++ case 'x':
++ flags = O_EXCL | O_CREAT;
++ break;
++ }
++
++ if (mode[ch] != '+') {
++ bin = (mode[ch++] == 'b');
++ }
++
++ if (mode[ch] == '+') {
++ flags |= O_RDWR;
++ } else if (flags) {
++ flags |= O_WRONLY;
++ } else {
++ flags |= O_RDONLY;
++ }
++
++#if defined(_O_TEXT) && defined(O_BINARY)
++ if (bin) {
++ flags |= O_BINARY;
++ } else {
++ flags |= _O_TEXT;
++ }
++#endif
++
++ return flags;
++}
++/* }}} */
++
++/* {{{ dio_data_rate_to_define
++ * Converts a numeric data rate to a termios define
++ */
++static int dio_data_rate_to_define(long rate, speed_t *def) {
++ speed_t val;
++
++ switch (rate) {
++ case 0:
++ val = 0;
++ break;
++ case 50:
++ val = B50;
++ break;
++ case 75:
++ val = B75;
++ break;
++ case 110:
++ val = B110;
++ break;
++ case 134:
++ val = B134;
++ break;
++ case 150:
++ val = B150;
++ break;
++ case 200:
++ val = B200;
++ break;
++ case 300:
++ val = B300;
++ break;
++ case 600:
++ val = B600;
++ break;
++ case 1200:
++ val = B1200;
++ break;
++ case 1800:
++ val = B1800;
++ break;
++ case 2400:
++ val = B2400;
++ break;
++ case 4800:
++ val = B4800;
++ break;
++ case 9600:
++ val = B9600;
++ break;
++ case 19200:
++ val = B19200;
++ break;
++ case 38400:
++ val = B38400;
++ break;
++#ifdef B57600
++ case 57600:
++ val = B57600;
++ break;
++#endif
++#ifdef B115200
++ case 115200:
++ val = B115200;
++ break;
++#endif
++#ifdef B230400
++ case 230400:
++ val = B230400;
++ break;
++#endif
++#ifdef B460800
++ case 460800:
++ val = B460800;
++ break;
++#endif
++ default:
++ return 0;
++ }
++
++ *def = val;
++ return 1;
++}
++
++/* {{{ dio_data_bits_to_define
++ * Converts a number of data bits to a termios define
++ */
++static int dio_data_bits_to_define(int data_bits, int *def) {
++ int val;
++
++ switch (data_bits) {
++ case 8:
++ val = CS8;
++ break;
++ case 7:
++ val = CS7;
++ break;
++ case 6:
++ val = CS6;
++ break;
++ case 5:
++ val = CS5;
++ break;
++ default:
++ return 0;
++ }
++
++ *def = val;
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_stop_bits_to_define
++ * Converts a number of stop bits to a termios define
++ */
++static int dio_stop_bits_to_define(int stop_bits, int *def) {
++ int val;
++
++ switch (stop_bits) {
++ case 1:
++ val = 0;
++ break;
++ case 2:
++ val = CSTOPB;
++ break;
++ default:
++ return 0;
++ }
++
++ *def = val;
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_parity_to_define
++ * Converts a parity type to a termios define
++ */
++static int dio_parity_to_define(int parity, int *def) {
++ int val;
++
++ switch (parity) {
++ case 0:
++ val = 0;
++ break;
++ case 1:
++ val = PARENB | PARODD;
++ break;
++ case 2:
++ val = PARENB;
++ break;
++ default:
++ return 0;
++ }
++
++ *def = val;
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_create_stream_data
++ * Creates an initialised stream data structure. Free with efree().
++ */
++php_dio_stream_data * dio_create_stream_data(void) {
++ php_dio_posix_stream_data * data = emalloc(sizeof(php_dio_posix_stream_data));
++ dio_init_stream_data(&(data->common));
++ data->fd = -1;
++ data->flags = 0;
++
++ return (php_dio_stream_data *)data;
++}
++/* }}} */
++
++/* {{{ dio_common_write
++ * Writes count chars from the buffer to the stream described by the stream data.
++ */
++size_t dio_common_write(php_dio_stream_data *data, const char *buf, size_t count) {
++ size_t ret;
++
++ /* Blocking writes can be interrupted by signals etc. If
++ * interrupted try again. Not sure about non-blocking
++ * writes but it doesn't hurt to check. */
++ do {
++ ret = write(((php_dio_posix_stream_data*)data)->fd, buf, count);
++ if (ret > 0) {
++ return ret;
++ }
++ } while (errno == EINTR);
++ return 0;
++}
++/* }}} */
++
++#ifdef DIO_NONBLOCK
++/* {{{ dio_timeval_subtract
++ * Calculates the difference between two timevals returning the result in the
++ * structure pointed to by diffptr. Returns -1 as error if late time is
++ * earlier than early time.
++ */
++static int dio_timeval_subtract(struct timeval *late, struct timeval *early, struct timeval *diff) {
++ struct timeval *tmp;
++
++ /* Handle negatives */
++ if (late->tv_sec < early->tv_sec) {
++ return 0;
++ }
++
++ if ((late->tv_sec == early->tv_sec) && (late->tv_usec < early->tv_usec)) {
++ return 0;
++ }
++
++ /* Handle any carry. If later usec is smaller than earlier usec simple
++ * subtraction will result in negative value. Since usec has a maximum
++ * of one second by adding another second before the subtraction the
++ * result will always be positive. */
++ if (late->tv_usec < early->tv_usec) {
++ late->tv_usec += 1000000;
++ late->tv_sec--;
++ }
++
++ /* Once adjusted can just subtract values. */
++ diff->tv_sec = late->tv_sec - early->tv_sec;
++ diff->tv_usec = late->tv_usec - early->tv_usec;
++
++ return 1;
++}
++#endif
++
++/* {{{ dio_common_read
++ * Reads count chars to the buffer to the stream described by the stream data.
++ */
++size_t dio_common_read(php_dio_stream_data *data, const char *buf, size_t count) {
++ int fd = ((php_dio_posix_stream_data*)data)->fd;
++ size_t ret, total = 0;
++ char *ptr = (char*)buf;
++
++ struct timeval timeout, timeouttmp, before, after, diff;
++ fd_set rfds;
++
++ if (!data->has_timeout) {
++ /* Blocking reads can be interrupted by signals etc. If
++ * interrupted try again. Not sure about non-blocking
++ * reads but it doesn't hurt to check. */
++ do {
++ ret = read(fd, (char*)ptr, count);
++ if (ret > 0) {
++ return ret;
++ } else if (!ret) {
++ data->end_of_file = 1;
++ }
++ } while ((errno == EINTR) && !data->end_of_file);
++ return 0;
++ }
++#ifdef DIO_NONBLOCK
++ else {
++ /* Clear timed out flag */
++ data->timed_out = 0;
++
++ /* The initial timeout value */
++ timeout.tv_sec = data->timeout_sec;
++ timeout.tv_usec = data->timeout_usec;
++
++ do {
++ /* The semantics of select() are that you cannot guarantee
++ * that the timeval structure passed in has not been changed by
++ * the select call. So you keep a copy. */
++ timeouttmp = timeout;
++
++ /* The time before we wait for data. */
++ (void) gettimeofday(&before, NULL);
++
++ /* Wait for an event on our file descriptor. */
++ FD_ZERO(&rfds);
++ FD_SET(fd, &rfds);
++
++ ret = select(fd + 1, &rfds, NULL, NULL, &timeouttmp);
++ /* An error. */
++ if ((ret < 0) && (errno != EINTR) && (errno != EAGAIN)) {
++ return 0;
++ }
++
++ /* We have data to read. */
++ if ((ret > 0) && FD_ISSET(fd, &rfds)) {
++ ret = read(fd, ptr, count);
++ /* Another error */
++ if ((ret < 0) && (errno != EINTR) && (errno != EAGAIN)) {
++ return 0;
++ }
++
++ if (ret > 0) {
++ /* Got data, add it to the buffer. */
++ ptr += ret;
++ total += ret;
++ count -= ret;
++ } else if (!ret) {
++ /* This should never happen since how can we have
++ * data to read at an end of file, but still
++ * just in case! */
++ data->end_of_file = 1;
++ break;
++ }
++ }
++
++ /* If not timed out and not end of file and not all data read
++ * calculate how long it took us and loop if we still have time
++ * out time left. */
++ if (count) {
++ (void) gettimeofday(&after, NULL);
++
++ /* Diff the timevals */
++ (void) dio_timeval_subtract(&after, &before, &diff);
++
++ /* Now adjust the timeout. */
++ if (!dio_timeval_subtract(&timeout, &diff, &timeout)) {
++ /* If it errors we've run out of time. */
++ data->timed_out = 1;
++ break;
++ } else if (!timeout.tv_sec && !(timeout.tv_usec / 1000)) {
++ /* Check for rounding issues (millisecond accuracy) */
++ data->timed_out = 1;
++ break;
++ }
++ }
++ } while (count); /* Until time out or end of file or all data read. */
++
++ return total;
++ }
++#endif
++}
++/* }}} */
++
++/* {{{ php_dio_stream_data
++ * Closes the php_stream.
++ */
++int dio_common_close(php_dio_stream_data *data) {
++ if (close(((php_dio_posix_stream_data*)data)->fd) < 0) {
++ return 0;
++ }
++
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_common_set_option
++ * Sets/gets stream options
++ */
++int dio_common_set_option(php_dio_stream_data *data, int option, int value, void *ptrparam) {
++ int fd = ((php_dio_posix_stream_data*)data)->fd;
++ int old_is_blocking;
++ int flags;
++
++ switch (option) {
++#ifdef DIO_NONBLOCK
++ case PHP_STREAM_OPTION_READ_TIMEOUT:
++ if (ptrparam) {
++ struct timeval *tv = (struct timeval*)ptrparam;
++
++ flags = fcntl(fd, F_GETFL, 0);
++
++ /* A timeout of zero seconds and zero microseconds disables
++ any existing timeout. */
++ if (tv->tv_sec || tv->tv_usec) {
++ data->timeout_sec = tv->tv_sec;
++ data->timeout_usec = tv->tv_usec;
++ data->has_timeout = -1;
++ (void) fcntl(fd, F_SETFL, flags & ~DIO_NONBLOCK);
++ } else {
++ data->timeout_sec = 0;
++ data->timeout_usec = 0;
++ data->has_timeout = 0;
++ data->timed_out = 0;
++ (void) fcntl(fd, F_SETFL, flags | DIO_NONBLOCK);
++ }
++
++ return PHP_STREAM_OPTION_RETURN_OK;
++ } else {
++ return PHP_STREAM_OPTION_RETURN_ERR;
++ }
++
++ case PHP_STREAM_OPTION_BLOCKING:
++ flags = fcntl(fd, F_GETFL, 0);
++ if (value) {
++ flags &= ~DIO_NONBLOCK;
++ } else {
++ flags |= DIO_NONBLOCK;
++ }
++ (void) fcntl(fd, F_SETFL, flags);
++
++ old_is_blocking = data->is_blocking;
++ data->is_blocking = value;
++ return old_is_blocking ? PHP_STREAM_OPTION_RETURN_OK : PHP_STREAM_OPTION_RETURN_ERR;
++#endif /* O_NONBLOCK */
++
++ default:
++ break;
++ }
++
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_raw_open_stream
++ * Opens the underlying stream.
++ */
++int dio_raw_open_stream(char *filename, char *mode, php_dio_stream_data *data TSRMLS_DC) {
++ php_dio_posix_stream_data *pdata = (php_dio_posix_stream_data*)data;
++ pdata->flags = dio_stream_mode_to_flags(mode);
++
++#ifdef DIO_NONBLOCK
++ if (!data->is_blocking || data->has_timeout) {
++ pdata->flags |= DIO_NONBLOCK;
++ }
++#endif
++
++ /* Open the file and handle any errors. */
++#ifdef DIO_HAS_FILEPERMS
++ if (data->has_perms) {
++ pdata->fd = open(filename, pdata->flags, (mode_t)data->perms);
++ } else {
++ pdata->fd = open(filename, pdata->flags);
++ }
++#else
++ pdata->fd = open(filename, pdata->flags);
++#endif
++
++ if (pdata->fd < 0) {
++ switch (errno) {
++ case EEXIST:
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "File exists!");
++ return 0;
++ default:
++ return 0;
++ }
++ }
++
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_serial_init
++ * Initialises the serial settings storing the original settings before hand.
++ */
++static int dio_serial_init(php_dio_stream_data *data TSRMLS_DC) {
++ php_dio_posix_stream_data *pdata = (php_dio_posix_stream_data*)data;
++ int ret = 0, data_bits_def, stop_bits_def, parity_def;
++ struct termios tio;
++ speed_t rate_def;
++
++ if (!dio_data_rate_to_define(data->data_rate, &rate_def)) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid data_rate value (%ld)", data->data_rate);
++ return 0;
++ }
++
++ if (!dio_data_bits_to_define(data->data_bits, &data_bits_def)) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid data_bits value (%d)", data->data_bits);
++ return 0;
++ }
++
++ if (!dio_stop_bits_to_define(data->stop_bits, &stop_bits_def)) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid stop_bits value (%d)", data->stop_bits);
++ return 0;
++ }
++
++ if (!dio_parity_to_define(data->parity, &parity_def)) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid parity value (%d)", data->parity);
++ return 0;
++ }
++
++ ret = tcgetattr(pdata->fd, &(pdata->oldtio));
++ if (ret < 0) {
++ if ((errno == ENOTTY) || (errno == ENODEV)) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a serial port or terminal!");
++ }
++ return 0;
++ }
++
++ ret = tcgetattr(pdata->fd, &tio);
++ if (ret < 0) {
++ return 0;
++ }
++
++ if (data->canonical) {
++ tio.c_iflag = IGNPAR | ICRNL;
++ tio.c_oflag = 0;
++ tio.c_lflag = ICANON;
++ } else {
++ cfmakeraw(&tio);
++ }
++
++ cfsetispeed(&tio, rate_def);
++ cfsetospeed(&tio, rate_def);
++
++ tio.c_cflag &= ~CSIZE;
++ tio.c_cflag |= data_bits_def;
++ tio.c_cflag &= ~CSTOPB;
++ tio.c_cflag |= stop_bits_def;
++ tio.c_cflag &= ~(PARENB|PARODD);
++ tio.c_cflag |= parity_def;
++
++#ifdef CRTSCTS
++ tio.c_cflag &= ~(CLOCAL | CRTSCTS);
++#else
++ tio.c_cflag &= ~CLOCAL;
++#endif
++ if (!data->flow_control) {
++ tio.c_cflag |= CLOCAL;
++#ifdef CRTSCTS
++ } else {
++ tio.c_cflag |= CRTSCTS;
++#endif
++ }
++
++ ret = tcsetattr(pdata->fd, TCSANOW, &tio);
++ if (ret < 0) {
++ return 0;
++ }
++
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_serial_uninit
++ * Restores the serial settings back to their original state.
++ */
++int dio_serial_uninit(php_dio_stream_data *data) {
++ php_dio_posix_stream_data *pdata = (php_dio_posix_stream_data*)data;
++ int ret;
++
++ do {
++ ret = tcsetattr(pdata->fd, TCSANOW, &(pdata->oldtio));
++ } while ((ret < 0) && (errno == EINTR));
++
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_serial_flush
++ * Purges the serial buffers of data.
++ */
++int dio_serial_purge(php_dio_stream_data *data) {
++ php_dio_posix_stream_data *pdata = (php_dio_posix_stream_data*)data;
++ int ret;
++
++ if ((pdata->flags & O_RDWR) == O_RDWR) {
++ ret = tcflush(pdata->fd, TCIOFLUSH);
++ } else if ((pdata->flags & O_WRONLY) == O_WRONLY) {
++ ret = tcflush(pdata->fd, TCOFLUSH);
++ } else if ((pdata->flags & O_RDONLY) == O_RDONLY) {
++ ret = tcflush(pdata->fd, TCIFLUSH);
++ }
++
++ if (ret < 0) {
++ return 0;
++ }
++
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_serial_open_stream
++ * Opens the underlying stream.
++ */
++int dio_serial_open_stream(char *filename, char *mode, php_dio_stream_data *data TSRMLS_DC) {
++ php_dio_posix_stream_data *pdata = (php_dio_posix_stream_data*)data;
++
++#ifdef O_NOCTTY
++ /* We don't want a controlling TTY */
++ pdata->flags |= O_NOCTTY;
++#endif
++
++ if (!dio_raw_open_stream(filename, mode, data TSRMLS_CC)) {
++ return 0;
++ }
++
++ if (!dio_serial_init(data TSRMLS_CC)) {
++ close(pdata->fd);
++ return 0;
++ }
++
++ return 1;
++}
++/* }}} */
++
++/*
++ * Local variables:
++ * c-basic-offset: 4
++ * tab-width: 4
++ * End:
++ * vim600: fdm=marker
++ * vim: sw=4 ts=4 noet
++ */
+--- /dev/null
++++ b/ext/dio/dio_stream_wrappers.c
+@@ -0,0 +1,410 @@
++/*
++ +----------------------------------------------------------------------+
++ | PHP Version 5 |
++ +----------------------------------------------------------------------+
++ | Copyright (c) 2009 Melanie Rhianna Lewis |
++ +----------------------------------------------------------------------+
++ | This source file is subject to version 3.0 of the PHP license, |
++ | that is bundled with this package in the file LICENSE, and is |
++ | available through the world-wide-web at the following url: |
++ | http://www.php.net/license/3_0.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. |
++ +----------------------------------------------------------------------+
++ | Author: Melanie Rhianna Lewis <cyberspice@php.net> |
++ +----------------------------------------------------------------------+
++ */
++
++#ifdef HAVE_CONFIG_H
++#include "config.h"
++#endif
++
++#include "php.h"
++#include "ext/standard/url.h"
++
++#include "php_dio.h"
++#include "php_dio_common.h"
++#include "php_dio_stream_wrappers.h"
++
++/*
++ +----------------------------------------------------------------------+
++ | Raw stream handling |
++ +----------------------------------------------------------------------+
++*/
++
++/* {{{ dio_stream_write
++ * Write to the stream
++ */
++static size_t dio_stream_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC)
++{
++ return dio_common_write((php_dio_stream_data*)stream->abstract, buf, count);
++}
++/* }}} */
++
++/* {{{ dio_stream_read
++ * Read from the stream
++ */
++static size_t dio_stream_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
++{
++ php_dio_stream_data* data = (php_dio_stream_data*)stream->abstract;
++ size_t bytes = dio_common_read(data, buf, count);
++ stream->eof = data->end_of_file;
++
++ return bytes;
++}
++/* }}} */
++
++/* {{{ dio_stream_flush
++ * Flush the stream. For raw streams this does nothing.
++ */
++static int dio_stream_flush(php_stream *stream TSRMLS_DC)
++{
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_stream_close
++ * Close the stream
++ */
++static int dio_stream_close(php_stream *stream, int close_handle TSRMLS_DC)
++{
++ php_dio_stream_data *abstract = (php_dio_stream_data*)stream->abstract;
++
++ if (!dio_common_close(abstract)) {
++ return 0;
++ }
++
++ efree(abstract);
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_stream_set_option
++ * Set the stream options.
++ */
++static int dio_stream_set_option(php_stream *stream, int option, int value, void *ptrparam TSRMLS_DC)
++{
++ php_dio_stream_data *abstract = (php_dio_stream_data*)stream->abstract;
++
++ switch (option) {
++ case PHP_STREAM_OPTION_META_DATA_API:
++#ifdef DIO_NONBLOCK
++ add_assoc_bool((zval *)ptrparam, "timed_out", abstract->timed_out);
++ add_assoc_bool((zval *)ptrparam, "blocked", abstract->is_blocking);
++#endif
++ add_assoc_bool((zval *)ptrparam, "eof", stream->eof);
++ return PHP_STREAM_OPTION_RETURN_OK;
++
++#if PHP_MAJOR_VERSION >= 5
++ case PHP_STREAM_OPTION_CHECK_LIVENESS:
++ stream->eof = abstract->end_of_file;
++ return PHP_STREAM_OPTION_RETURN_OK;
++#endif /* PHP_MAJOR_VERSION >= 5 */
++
++ default:
++ break;
++ }
++
++ return dio_common_set_option(abstract, option, value, ptrparam);
++}
++/* }}} */
++
++php_stream_ops dio_raw_stream_ops = {
++ dio_stream_write,
++ dio_stream_read,
++ dio_stream_close,
++ dio_stream_flush,
++ "dio",
++ NULL, /* seek */
++ NULL, /* cast */
++ NULL, /* stat */
++ dio_stream_set_option,
++};
++
++/* {{{ dio_raw_fopen_wrapper
++ * fopen for the dio.raw stream.
++ */
++static php_stream *dio_raw_fopen_wrapper(php_stream_wrapper *wrapper,
++ char *path, char *mode,
++ int options, char **opened_path,
++ php_stream_context *context STREAMS_DC TSRMLS_DC) {
++ php_dio_stream_data *data;
++ php_stream *stream;
++ char *filename;
++
++ /* Check it was actually for us (not a corrupted function pointer
++ somewhere!). */
++ if (strncmp(path, DIO_RAW_STREAM_PROTOCOL, sizeof(DIO_RAW_STREAM_PROTOCOL) - 1)) {
++ return NULL;
++ }
++
++ /* Get the actually file system name/path. */
++ filename = path + sizeof(DIO_RAW_STREAM_PROTOCOL) - 1;
++
++ /* Check we can actually access it. */
++ if (php_check_open_basedir(filename TSRMLS_CC) ||
++ (PG(safe_mode) && !php_checkuid(filename, mode, CHECKUID_CHECK_MODE_PARAM))) {
++ return NULL;
++ }
++
++ data = dio_create_stream_data();
++ data->stream_type = DIO_STREAM_TYPE_RAW;
++
++ /* Parse the context. */
++ if (context) {
++ dio_stream_context_get_basic_options(context, data TSRMLS_CC);
++ }
++
++ /* Try and open a raw stream. */
++ if (!dio_raw_open_stream(filename, mode, data TSRMLS_CC)) {
++ return NULL;
++ }
++
++ /* Create a PHP stream based on raw stream */
++ stream = php_stream_alloc(&dio_raw_stream_ops, data, 0, mode);
++ if (!stream) {
++ (void) dio_common_close(data);
++ efree(data);
++ }
++
++ return stream;
++}
++/* }}} */
++
++static php_stream_wrapper_ops dio_raw_stream_wops = {
++ dio_raw_fopen_wrapper,
++ NULL, /* stream_close */
++ NULL, /* stat */
++ NULL, /* stat_url */
++ NULL, /* opendir */
++ DIO_RAW_STREAM_NAME
++};
++
++php_stream_wrapper php_dio_raw_stream_wrapper = {
++ &dio_raw_stream_wops,
++ NULL,
++ 0
++};
++
++/* {{{ proto dio_raw(string filename, string mode[, array options])
++ * Opens a raw direct IO stream.
++ */
++PHP_FUNCTION(dio_raw) {
++ zval *options = NULL;
++ php_dio_stream_data *data;
++ php_stream *stream;
++
++ char *filename;
++ int filename_len;
++ char *mode;
++ int mode_len;
++
++ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|z", &filename, &filename_len, &mode, &mode_len, &options) == FAILURE) {
++ RETURN_FALSE;
++ }
++
++ /* Check the third argument is an array. */
++ if (options && (Z_TYPE_P(options) != IS_ARRAY)) {
++ RETURN_FALSE;
++ }
++
++ /* Check we can actually access the file. */
++ if (php_check_open_basedir(filename TSRMLS_CC) ||
++ (PG(safe_mode) && !php_checkuid(filename, mode, CHECKUID_CHECK_MODE_PARAM))) {
++ RETURN_FALSE;
++ }
++
++ data = dio_create_stream_data();
++ data->stream_type = DIO_STREAM_TYPE_RAW;
++
++ if (options) {
++ dio_assoc_array_get_basic_options(options, data TSRMLS_CC);
++ }
++
++ /* Try and open a raw stream. */
++ if (dio_raw_open_stream(filename, mode, data TSRMLS_CC)) {
++ stream = php_stream_alloc(&dio_raw_stream_ops, data, 0, mode);
++ if (!stream) {
++ (void) dio_common_close(data);
++ efree(data);
++ RETURN_FALSE;
++ }
++ }
++
++ php_stream_to_zval(stream, return_value);
++}
++/* }}} */
++
++/*
++ +----------------------------------------------------------------------+
++ | Serial stream handling |
++ +----------------------------------------------------------------------+
++*/
++
++/* {{{ dio_stream_flush
++ * Flush the stream. If the stream is read only, it flushes the read
++ * stream, if it is write only it flushes the write, otherwise it flushes
++ * both.
++ */
++static int dio_serial_stream_flush(php_stream *stream TSRMLS_DC)
++{
++ return dio_serial_purge((php_dio_stream_data*)stream->abstract);
++}
++/* }}} */
++
++/* {{{ dio_stream_close
++ * Close the stream. Restores the serial settings to their value before
++ * the stream was open.
++ */
++static int dio_serial_stream_close(php_stream *stream, int close_handle TSRMLS_DC)
++{
++ php_dio_stream_data *abstract = (php_dio_stream_data*)stream->abstract;
++
++ if (!dio_serial_uninit(abstract)) {
++ return 0;
++ }
++
++ if (!dio_common_close(abstract)) {
++ return 0;
++ }
++
++ efree(abstract);
++ return 1;
++}
++/* }}} */
++
++php_stream_ops dio_serial_stream_ops = {
++ dio_stream_write,
++ dio_stream_read,
++ dio_serial_stream_close,
++ dio_serial_stream_flush,
++ "dio",
++ NULL, /* seek */
++ NULL, /* cast */
++ NULL, /* stat */
++ dio_stream_set_option,
++};
++
++/* {{{ dio_raw_fopen_wrapper
++ * fopen for the dio.raw stream.
++ */
++static php_stream *dio_serial_fopen_wrapper(php_stream_wrapper *wrapper,
++ char *path, char *mode,
++ int options, char **opened_path,
++ php_stream_context *context STREAMS_DC TSRMLS_DC) {
++ php_dio_stream_data *data;
++ php_stream *stream;
++ char *filename;
++
++ /* Check it was actually for us (not a corrupted function pointer
++ somewhere!). */
++ if (strncmp(path, DIO_SERIAL_STREAM_PROTOCOL, sizeof(DIO_SERIAL_STREAM_PROTOCOL) - 1)) {
++ return NULL;
++ }
++
++ /* Get the actually file system name/path. */
++ filename = path + sizeof(DIO_SERIAL_STREAM_PROTOCOL) - 1;
++
++ /* Check we can actually access it. */
++ if (php_check_open_basedir(filename TSRMLS_CC) ||
++ (PG(safe_mode) && !php_checkuid(filename, mode, CHECKUID_CHECK_MODE_PARAM))) {
++ return NULL;
++ }
++
++ data = dio_create_stream_data();
++ data->stream_type = DIO_STREAM_TYPE_SERIAL;
++
++ /* Parse the context. */
++ if (context) {
++ dio_stream_context_get_basic_options(context, data TSRMLS_CC);
++ dio_stream_context_get_serial_options(context, data TSRMLS_CC);
++ }
++
++ /* Try and open a serial stream. */
++ if (!dio_serial_open_stream(filename, mode, data TSRMLS_CC)) {
++ return NULL;
++ }
++
++ stream = php_stream_alloc(&dio_serial_stream_ops, data, 0, mode);
++ if (!stream) {
++ efree(data);
++ }
++
++ return stream;
++}
++/* }}} */
++
++static php_stream_wrapper_ops dio_serial_stream_wops = {
++ dio_serial_fopen_wrapper,
++ NULL, /* stream_close */
++ NULL, /* stat */
++ NULL, /* stat_url */
++ NULL, /* opendir */
++ DIO_SERIAL_STREAM_NAME
++};
++
++php_stream_wrapper php_dio_serial_stream_wrapper = {
++ &dio_serial_stream_wops,
++ NULL,
++ 0
++};
++
++/* {{{ proto dio_serial(string filename, string mode[, array options])
++ * Opens a serial direct IO stream.
++ */
++PHP_FUNCTION(dio_serial) {
++ zval *options = NULL;
++ php_dio_stream_data *data;
++ php_stream *stream;
++
++ char *filename;
++ int filename_len;
++ char *mode;
++ int mode_len;
++
++ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|z", &filename, &filename_len, &mode, &mode_len, &options) == FAILURE) {
++ RETURN_FALSE;
++ }
++
++ /* Check the third argument is an array. */
++ if (options && (Z_TYPE_P(options) != IS_ARRAY)) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING,"dio_serial, the third argument should be an array of options");
++ RETURN_FALSE;
++ }
++
++ /* Check we can actually access the file. */
++ if (php_check_open_basedir(filename TSRMLS_CC) ||
++ (PG(safe_mode) && !php_checkuid(filename, mode, CHECKUID_CHECK_MODE_PARAM))) {
++ RETURN_FALSE;
++ }
++
++ data = dio_create_stream_data();
++ data->stream_type = DIO_STREAM_TYPE_SERIAL;
++
++ if (options) {
++ dio_assoc_array_get_basic_options(options, data TSRMLS_CC);
++ dio_assoc_array_get_serial_options(options, data TSRMLS_CC);
++ }
++
++ /* Try and open a serial stream. */
++ if (dio_serial_open_stream(filename, mode, data TSRMLS_CC)) {
++ stream = php_stream_alloc(&dio_serial_stream_ops, data, 0, mode);
++ if (!stream) {
++ efree(data);
++ RETURN_FALSE;
++ }
++ }
++
++ php_stream_to_zval(stream, return_value);
++}
++/* }}} */
++
++/*
++ * Local variables:
++ * c-basic-offset: 4
++ * tab-width: 4
++ * End:
++ * vim600: fdm=marker
++ * vim: sw=4 ts=4 noet
++ */
+--- /dev/null
++++ b/ext/dio/dio_win32.c
+@@ -0,0 +1,669 @@
++/*
++ +----------------------------------------------------------------------+
++ | PHP Version 5 |
++ +----------------------------------------------------------------------+
++ | Copyright (c) 2009 Melanie Rhianna Lewis |
++ +----------------------------------------------------------------------+
++ | This source file is subject to version 3.0 of the PHP license, |
++ | that is bundled with this package in the file LICENSE, and is |
++ | available through the world-wide-web at the following url: |
++ | http://www.php.net/license/3_0.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. |
++ +----------------------------------------------------------------------+
++ | Author: Melanie Rhianna Lewis <cyberspice@php.net> |
++ +----------------------------------------------------------------------+
++ */
++
++#ifdef HAVE_CONFIG_H
++#include "config.h"
++#endif
++
++#include "php.h"
++
++#include "php_dio_common.h"
++
++/* {{{ dio_data_rate_to_define
++ * Converts a numeric data rate to a termios define
++ */
++static int dio_data_rate_to_define(long rate, DWORD *def) {
++ switch (rate) {
++ case 75:
++ case 110:
++ case 134:
++ case 150:
++ case 300:
++ case 600:
++ case 1200:
++ case 1800:
++ case 2400:
++ case 4800:
++ case 7200:
++ case 9600:
++ case 14400:
++ case 19200:
++ case 38400:
++ case 57600:
++ case 115200:
++ case 56000:
++ case 128000:
++ break;
++ default:
++ return 0;
++ }
++
++ *def = (DWORD)rate;
++ return 1;
++}
++/* }}} */
++
++
++/* {{{ dio_data_bits_to_define
++ * Converts a number of data bits to a termios define
++ */
++static int dio_data_bits_to_define(int data_bits, DWORD *def) {
++ switch (data_bits) {
++ case 8:
++ case 7:
++ case 6:
++ case 5:
++ case 4:
++ break;
++ default:
++ return 0;
++ }
++
++ *def = (DWORD)data_bits;
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_stop_bits_to_define
++ * Converts a number of stop bits to a termios define
++ */
++static int dio_stop_bits_to_define(int stop_bits, DWORD *def) {
++ DWORD val;
++
++ switch (stop_bits) {
++ case 1:
++ val = 0;
++ break;
++ case 2:
++ val = 2;
++ break;
++ case 3:
++ val = 1;
++ break;
++ default:
++ return 0;
++ }
++
++ *def = val;
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_parity_to_define
++ * Converts a parity type to a termios define
++ */
++static int dio_parity_to_define(int parity, DWORD *def) {
++ switch (parity) {
++ case 0:
++ case 1:
++ case 2:
++ break;
++ default:
++ return 0;
++ }
++
++ *def = (DWORD)parity;
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_create_stream_data
++ * Creates an initialised stream data structure. Free with efree().
++ */
++php_dio_stream_data * dio_create_stream_data(void) {
++ php_dio_win32_stream_data * data = emalloc(sizeof(php_dio_win32_stream_data));
++ memset(data, 0, sizeof(php_dio_win32_stream_data));
++ dio_init_stream_data(&(data->common));
++ data->handle = INVALID_HANDLE_VALUE;
++ data->desired_access = 0;
++ data->creation_disposition = 0;
++ data->olddcb.DCBlength = sizeof(DCB);
++
++ return (php_dio_stream_data *)data;
++}
++/* }}} */
++
++/* {{{ dio_common_write
++ * Writes count chars from the buffer to the stream described by the stream data.
++ */
++size_t dio_common_write(php_dio_stream_data *data, const char *buf, size_t count) {
++ php_dio_win32_stream_data *wdata = (php_dio_win32_stream_data*)data;
++ DWORD total = 0;
++
++ if (WriteFile(wdata->handle, buf, (DWORD)count, &total, NULL)) {
++ return (size_t)total;
++ }
++
++ return 0;
++}
++/* }}} */
++
++/* {{{ dio_buffer_read
++ * Reads any available chars from the canonical buffer.
++ */
++static size_t dio_buffer_read(php_dio_win32_stream_data *wdata, const char *buf, size_t count) {
++ php_dio_win32_canon_data *canon_data = wdata->canon_data;
++ size_t total = 0;
++
++ /* Read always follows write. I.e. if read ptr > write ptr buffer has
++ wrapped and so we need to copy two blocks of data. */
++ if (canon_data->read_pos > canon_data->write_pos) {
++
++ /* Check we actually need to copy both blocks */
++ if ((canon_data->size - canon_data->read_pos) > count) {
++
++ /* No we don't. Just copy as much as we were asked for. */
++ memcpy((char*)buf,
++ &(canon_data->buf[canon_data->read_pos]),
++ count);
++ /* Update the read pointer. */
++ canon_data->read_pos += count;
++
++ /* Return the amount read. */
++ return count;
++ } else {
++
++ /* We need to copy both blocks so copy data up to the end of
++ the buffer. */
++ total = canon_data->size - canon_data->read_pos;
++ memcpy((char*)buf,
++ &(canon_data->buf[canon_data->read_pos]),
++ total);
++ canon_data->read_pos = 0;
++ count -= total;
++
++ /* Now copy the data from the start of the buffer either up
++ count or the number of bytes in the buffer. */
++
++ if (canon_data->write_pos > count) {
++ memcpy((char*)buf, canon_data->buf, count);
++ canon_data->read_pos = count;
++ total += count;
++
++ return total;
++ } else {
++ memcpy((char*)buf, canon_data->buf, canon_data->write_pos);
++ canon_data->read_pos = canon_data->write_pos;
++ total += canon_data->write_pos;
++
++ return total;
++ }
++ }
++
++ /* Else if write follows read. This is a simpler case. We just copy
++ either all the data buffered or count, which ever is smaller. */
++ } else if (canon_data->write_pos > canon_data->read_pos) {
++ if ((canon_data->write_pos - canon_data->read_pos) > count) {
++ memcpy((char*)buf,
++ &(canon_data->buf[canon_data->read_pos]),
++ count);
++ canon_data->read_pos += count;
++
++ return count;
++ } else {
++ total = canon_data->write_pos - canon_data->read_pos;
++ memcpy((char*)buf,
++ &(canon_data->buf[canon_data->read_pos]),
++ total);
++ canon_data->read_pos += total;
++
++ return total;
++ }
++ }
++
++ /* Else we need to read more data from the data port. */
++ return 0;
++}
++
++/* {{{ dio_com_read
++ * Read chars from the data port.
++ */
++static size_t dio_com_read(php_dio_stream_data *data, const char *buf, size_t count) {
++ php_dio_win32_stream_data *wdata = (php_dio_win32_stream_data*)data;
++ DWORD err, total = 0;
++
++ if (ReadFile(wdata->handle, (void*)buf, (DWORD)count, &total, NULL)) {
++
++ if (total) {
++ return (size_t)total;
++ }
++
++ data->end_of_file = 1;
++ }
++
++ if (!data->end_of_file) {
++ err = GetLastError();
++
++ if (ERROR_HANDLE_EOF == err) {
++ data->end_of_file = 1;
++ }
++ }
++
++ return 0;
++}
++
++/* {{{ dio_canonical_read
++ * Reads chars from the input stream until the internal buffer is full or a new
++ * line is reached.
++ */
++static size_t dio_canonical_read(php_dio_win32_stream_data *wdata, const char *buf, size_t count) {
++ php_dio_win32_canon_data *canon_data = wdata->canon_data;
++ size_t total = 0;
++ char ch;
++
++ /* See if there's any buffered data and copy it. */
++ total = dio_buffer_read(wdata, buf, count);
++ if (total) {
++ return total;
++ }
++
++ /* Need to read more data from the data port. Buffer should be empty(er)
++ by now. */
++ do {
++ /* Is the buffer full? */
++ if (((canon_data->write_pos + 1) % canon_data->size) ==
++ canon_data->read_pos) {
++ break;
++ }
++
++ /* Read a byte from the input checking for EOF. */
++ if (!dio_com_read((php_dio_stream_data*)wdata, &ch, 1)) {
++ break;
++ }
++
++ /* Translate CR to newlines (same as ICRNL in POSIX) */
++ ch = (ch != '\r') ? ch : '\n';
++
++ /* We read a character! So buffer it. */
++ canon_data->buf[canon_data->write_pos++] = ch;
++ if (canon_data->write_pos >= canon_data->size) {
++ canon_data->write_pos = 0;
++ }
++
++ /* End of line/input (^D)? */
++ } while ((ch != '\n') && (ch != 0x04));
++
++ return dio_buffer_read(wdata, buf, count);
++}
++/* }}} */
++
++/* {{{ dio_common_read
++ * Reads count chars to the buffer to the stream described by the stream data.
++ */
++size_t dio_common_read(php_dio_stream_data *data, const char *buf, size_t count) {
++
++ /* You ask for no bytes you'll get none :-) */
++ if (!count) {
++ return 0;
++ }
++
++ if (data->canonical) {
++ return dio_canonical_read((php_dio_win32_stream_data*)data, buf, count);
++ } else {
++ return dio_com_read(data, buf, count);
++ }
++}
++/* }}} */
++
++/* {{{ php_dio_stream_data
++ * Closes the php_stream.
++ */
++int dio_common_close(php_dio_stream_data *data) {
++ php_dio_win32_stream_data *wdata = (php_dio_win32_stream_data*)data;
++
++ if (data->canonical) {
++ efree(wdata->canon_data);
++ }
++
++ if (!CloseHandle(wdata->handle)) {
++ return 0;
++ }
++
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_common_set_option
++ * Sets/gets stream options
++ */
++int dio_common_set_option(php_dio_stream_data *data, int option, int value, void *ptrparam) {
++ COMMTIMEOUTS cto = { 0, 0, 0, 0, 0 };
++ int old_is_blocking = 0;
++
++ /* Can't do timeouts or non blocking with raw windows streams :-( */
++ if (DIO_STREAM_TYPE_SERIAL == data->stream_type) {
++ switch (option) {
++ case PHP_STREAM_OPTION_BLOCKING:
++ old_is_blocking = data->is_blocking;
++ data->is_blocking = value ? 1 : 0;
++
++ /* Only change values if we need to change them. */
++ if (data->is_blocking != old_is_blocking) {
++ /* If we're not blocking but don't have a timeout
++ set to return immediately */
++ if (!data->is_blocking && !data->has_timeout) {
++ cto.ReadIntervalTimeout = MAXDWORD;
++ }
++
++ /* If we have a timeout ignore the blocking and set
++ the total time in which to read the data */
++ if (data->has_timeout) {
++ cto.ReadIntervalTimeout = MAXDWORD;
++ cto.ReadTotalTimeoutMultiplier = MAXDWORD;
++ cto.ReadTotalTimeoutConstant = (data->timeout_usec / 1000) +
++ (data->timeout_sec * 1000);
++ }
++
++ if (!SetCommTimeouts(((php_dio_win32_stream_data*)data)->handle, &cto)) {
++ return PHP_STREAM_OPTION_RETURN_ERR;
++ }
++ }
++ return old_is_blocking ? PHP_STREAM_OPTION_RETURN_OK : PHP_STREAM_OPTION_RETURN_ERR;
++
++ case PHP_STREAM_OPTION_READ_TIMEOUT:
++ if (ptrparam) {
++ /* struct timeval is supported with PHP_WIN32 defined. */
++ struct timeval *tv = (struct timeval*)ptrparam;
++
++ /* A timeout of zero seconds and zero microseconds disables
++ any existing timeout. */
++ if (tv->tv_sec || tv->tv_usec) {
++ data->timeout_sec = tv->tv_sec;
++ data->timeout_usec = tv->tv_usec;
++ data->has_timeout = -1;
++
++ cto.ReadIntervalTimeout = MAXDWORD;
++ cto.ReadTotalTimeoutMultiplier = MAXDWORD;
++ cto.ReadTotalTimeoutConstant = (data->timeout_usec / 1000) +
++ (data->timeout_sec * 1000);
++ } else {
++ data->timeout_sec = 0;
++ data->timeout_usec = 0;
++ data->has_timeout = 0;
++ data->timed_out = 0;
++
++ /* If we're not blocking but don't have a timeout
++ set to return immediately */
++ if (!data->is_blocking) {
++ cto.ReadIntervalTimeout = MAXDWORD;
++ }
++ }
++
++ if (!SetCommTimeouts(((php_dio_win32_stream_data*)data)->handle, &cto)) {
++ return PHP_STREAM_OPTION_RETURN_ERR;
++ } else {
++ return PHP_STREAM_OPTION_RETURN_OK;
++ }
++ } else {
++ return PHP_STREAM_OPTION_RETURN_ERR;
++ }
++
++ default:
++ break;
++ }
++ }
++
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_raw_open_stream
++ * Opens the underlying stream.
++ */
++int dio_raw_open_stream(char *filename, char *mode, php_dio_stream_data *data TSRMLS_DC) {
++ php_dio_win32_stream_data *wdata = (php_dio_win32_stream_data*)data;
++ DWORD err;
++
++ switch(*mode) {
++ case 'r':
++ wdata->creation_disposition = OPEN_EXISTING;
++ break;
++ case 'w':
++ wdata->creation_disposition = TRUNCATE_EXISTING;
++ break;
++ case 'a':
++ wdata->creation_disposition = OPEN_ALWAYS;
++ break;
++ case 'x':
++ wdata->creation_disposition = CREATE_NEW;
++ break;
++ }
++ mode ++;
++
++ if (*mode && (*mode != '+')) {
++ mode++;
++ }
++
++ if (*mode && (*mode == '+')) {
++ wdata->desired_access = GENERIC_READ | GENERIC_WRITE;
++ } else if (OPEN_EXISTING == wdata->creation_disposition) {
++ wdata->desired_access = GENERIC_READ;
++ } else {
++ wdata->desired_access = GENERIC_WRITE;
++ }
++
++ wdata->handle = CreateFile(filename, wdata->desired_access, 0,
++ NULL, wdata->creation_disposition, FILE_ATTRIBUTE_NORMAL, NULL);
++ if (INVALID_HANDLE_VALUE == wdata->handle) {
++ err = GetLastError();
++ switch (err) {
++ case ERROR_FILE_EXISTS:
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "File exists!");
++ return 0;
++
++ case ERROR_FILE_NOT_FOUND:
++ /* ERROR_FILE_NOT_FOUND with TRUNCATE_EXISTING means that
++ * the file doesn't exist so now try to create it. */
++ if (TRUNCATE_EXISTING == wdata->creation_disposition) {
++ wdata->handle = CreateFile(filename, wdata->desired_access, 0,
++ NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
++ if (INVALID_HANDLE_VALUE == wdata->handle) {
++ err = GetLastError();
++ return 0;
++ }
++ } else {
++ return 0;
++ }
++ break;
++
++ default:
++ return 0;
++ }
++ }
++
++ /* If canonical allocate the canonical buffer. */
++ if (data->canonical) {
++ wdata->canon_data = emalloc(sizeof(php_dio_win32_canon_data));
++ memset(wdata->canon_data, 0, sizeof(php_dio_win32_canon_data));
++ wdata->canon_data->size = DIO_WIN32_CANON_BUF_SIZE;
++ }
++
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_serial_init
++ * Initialises the serial port
++ */
++static int dio_serial_init(php_dio_stream_data *data TSRMLS_DC) {
++ php_dio_win32_stream_data *wdata = (php_dio_win32_stream_data*)data;
++ DWORD err, rate_def, data_bits_def, stop_bits_def, parity_def;
++ DCB dcb;
++
++ if (!dio_data_rate_to_define(data->data_rate, &rate_def)) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid data_rate value (%d) (%d)", data->data_rate, __LINE__);
++ return 0;
++ }
++
++ if (!dio_data_bits_to_define(data->data_bits, &data_bits_def)) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid data_bits value (%d)", data->data_bits);
++ return 0;
++ }
++
++ if (!dio_stop_bits_to_define(data->stop_bits, &stop_bits_def)) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid stop_bits value (%d)", data->stop_bits);
++ return 0;
++ }
++
++ if (!dio_parity_to_define(data->parity, &parity_def)) {
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid parity value (%d)", data->parity);
++ return 0;
++ }
++
++ if (!GetCommState(wdata->handle, &(wdata->olddcb))) {
++ err = GetLastError();
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "GetCommState() failed! (%d)", err);
++ return 0;
++ }
++
++ /* Init the DCB structure */
++ memset(&dcb, 0, sizeof(DCB));
++ dcb.DCBlength = sizeof(DCB);
++
++ /* Set the communication parameters */
++ dcb.fBinary = 1;
++ dcb.BaudRate = rate_def;
++ dcb.ByteSize = (BYTE)data_bits_def;
++ dcb.StopBits = (BYTE)stop_bits_def;
++ dcb.Parity = (BYTE)parity_def;
++
++ /* Set the control line parameters */
++ dcb.fDtrControl = DTR_CONTROL_DISABLE;
++ dcb.fDsrSensitivity = FALSE;
++ dcb.fOutxDsrFlow = FALSE;
++ dcb.fTXContinueOnXoff = FALSE;
++ dcb.fOutX = FALSE;
++ dcb.fInX = FALSE;
++ dcb.fErrorChar = FALSE;
++ dcb.fNull = FALSE;
++ dcb.fAbortOnError = FALSE;
++
++ /* Hardware flow control */
++ if (data->flow_control) {
++ dcb.fOutxCtsFlow = TRUE;
++ dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
++ } else {
++ dcb.fOutxCtsFlow = FALSE;
++ dcb.fRtsControl = RTS_CONTROL_DISABLE;
++ }
++
++ if (!SetCommState(wdata->handle, &dcb)) {
++ return 0;
++ }
++
++ return 1;
++}
++/* }}} */
++
++
++/* {{{ dio_serial_uninit
++ * Restores the serial settings back to their original state.
++ */
++int dio_serial_uninit(php_dio_stream_data *data) {
++ php_dio_win32_stream_data *wdata = (php_dio_win32_stream_data*)data;
++
++ if (!SetCommState(wdata->handle, &(wdata->olddcb))) {
++ return 0;
++ }
++
++ return 1;
++}
++/* }}} */
++
++/* {{{ dio_serial_flush
++ * Purges the serial buffers of data.
++ */
++int dio_serial_purge(php_dio_stream_data *data) {
++ php_dio_win32_stream_data *wdata = (php_dio_win32_stream_data*)data;
++ BOOL ret;
++
++ /* Purge the canonical buffer if required */
++ if (data->canonical && ((wdata->desired_access & GENERIC_READ) == GENERIC_READ)) {
++ wdata->canon_data->read_pos = 0;
++ wdata->canon_data->write_pos = 0;
++ }
++
++ /* Purge the com port */
++ if ((wdata->desired_access & (GENERIC_READ|GENERIC_WRITE)) == (GENERIC_READ|GENERIC_WRITE)) {
++ ret = PurgeComm(wdata->handle, PURGE_RXCLEAR|PURGE_TXCLEAR);
++ } else if ((wdata->desired_access & GENERIC_WRITE) == GENERIC_WRITE) {
++ ret = PurgeComm(wdata->handle, PURGE_TXCLEAR);
++ } else if ((wdata->desired_access & GENERIC_READ) == GENERIC_READ) {
++ ret = PurgeComm(wdata->handle, PURGE_RXCLEAR);
++ }
++
++ return ret;
++}
++/* }}} */
++
++/* {{{ dio_serial_open_stream
++ * Opens the underlying stream.
++ */
++int dio_serial_open_stream(char *filename, char *mode, php_dio_stream_data *data TSRMLS_DC) {
++ php_dio_win32_stream_data *wdata = (php_dio_win32_stream_data*)data;
++ COMMTIMEOUTS cto = { 0, 0, 0, 0, 0 };
++ DWORD err;
++
++ if (!dio_raw_open_stream(filename, mode, data TSRMLS_CC)) {
++ return 0;
++ }
++
++ if (!GetCommTimeouts(wdata->handle, &(wdata->oldcto))) {
++ err = GetLastError();
++ php_error_docref(NULL TSRMLS_CC, E_WARNING, "SetCommTimeouts() failed! (%d) Not a comm port?", err);
++ CloseHandle(wdata->handle);
++ return 0;
++ }
++
++ /* If we're not blocking but don't have a timeout
++ set to return immediately */
++ if (!data->is_blocking && !data->has_timeout) {
++ cto.ReadIntervalTimeout = MAXDWORD;
++ }
++
++ /* If we have a timeout ignore the blocking and set
++ the total time in which to read the data */
++ if (data->has_timeout) {
++ cto.ReadIntervalTimeout = MAXDWORD;
++ cto.ReadTotalTimeoutMultiplier = MAXDWORD;
++ cto.ReadTotalTimeoutConstant = (data->timeout_usec / 1000) +
++ (data->timeout_sec * 1000);
++ }
++
++ if (!SetCommTimeouts(wdata->handle, &cto)) {
++ CloseHandle(wdata->handle);
++ return 0;
++ }
++
++ if (!dio_serial_init(data TSRMLS_CC)) {
++ CloseHandle(wdata->handle);
++ return 0;
++ }
++
++ return 1;
++}
++/* }}} */
++
++/*
++ * Local variables:
++ * c-basic-offset: 4
++ * tab-width: 4
++ * End:
++ * vim600: fdm=marker
++ * vim: sw=4 ts=4 noet
++ */
+--- /dev/null
++++ b/ext/dio/php_dio.h
+@@ -0,0 +1,60 @@
++/*
++ +----------------------------------------------------------------------+
++ | PHP Version 5 |
++ +----------------------------------------------------------------------+
++ | Copyright (c) 1997-2004 The PHP Group |
++ +----------------------------------------------------------------------+
++ | This source file is subject to version 3.0 of the PHP license, |
++ | that is bundled with this package in the file LICENSE, and is |
++ | available through the world-wide-web at the following url: |
++ | http://www.php.net/license/3_0.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. |
++ +----------------------------------------------------------------------+
++ */
++
++#ifndef PHP_DIO_H
++#define PHP_DIO_H
++
++#include "php.h"
++#include "php_dio_common.h"
++#include "php_dio_stream_wrappers.h"
++
++extern zend_module_entry dio_module_entry;
++#define phpext_dio_ptr &dio_module_entry
++
++#define PHP_DIO_VERSION "0.0.4RC4"
++
++/* Standard module functions. */
++PHP_MINIT_FUNCTION(dio);
++PHP_MSHUTDOWN_FUNCTION(dio);
++PHP_RINIT_FUNCTION(dio);
++PHP_RSHUTDOWN_FUNCTION(dio);
++PHP_MINFO_FUNCTION(dio);
++
++/* Legacy functions. */
++PHP_FUNCTION(dio_open);
++PHP_FUNCTION(dio_truncate);
++PHP_FUNCTION(dio_stat);
++PHP_FUNCTION(dio_seek);
++PHP_FUNCTION(dio_read);
++PHP_FUNCTION(dio_write);
++PHP_FUNCTION(dio_fcntl);
++PHP_FUNCTION(dio_close);
++PHP_FUNCTION(dio_tcsetattr);
++
++typedef struct {
++ int fd;
++} php_fd_t;
++
++#endif
++
++
++/*
++ * Local variables:
++ * tab-width: 4
++ * c-basic-offset: 4
++ * indent-tabs-mode: t
++ * End:
++ */
+--- /dev/null
++++ b/ext/dio/php_dio_common.h
+@@ -0,0 +1,77 @@
++/*
++ +----------------------------------------------------------------------+
++ | PHP Version 5 |
++ +----------------------------------------------------------------------+
++ | Copyright (c) 2009 Melanie Rhianna Lewis |
++ +----------------------------------------------------------------------+
++ | This source file is subject to version 3.0 of the PHP license, |
++ | that is bundled with this package in the file LICENSE, and is |
++ | available through the world-wide-web at the following url: |
++ | http://www.php.net/license/3_0.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. |
++ +----------------------------------------------------------------------+
++ | Author: Melanie Rhianna Lewis <cyberspice@php.net> |
++ +----------------------------------------------------------------------+
++ */
++
++#ifndef PHP_DIO_COMMON_H_
++#define PHP_DIO_COMMON_H_
++
++#ifdef PHP_WIN32
++#define PHP_DIO_API __declspec(dllexport)
++#else
++#define PHP_DIO_API
++#endif
++
++#ifdef PHP_WIN32
++#include "php_dio_win32.h"
++#else
++#include "php_dio_posix.h"
++#endif
++
++#define DIO_STREAM_TYPE_NONE 0
++#define DIO_STREAM_TYPE_RAW 1
++#define DIO_STREAM_TYPE_SERIAL 2
++
++long dio_convert_to_long(zval *val);
++
++php_dio_stream_data * dio_create_stream_data(void);
++
++void dio_init_stream_data(php_dio_stream_data *data);
++
++void dio_assoc_array_get_basic_options(zval *options, php_dio_stream_data *data TSRMLS_DC);
++
++void dio_assoc_array_get_serial_options(zval *options, php_dio_stream_data *data TSRMLS_DC);
++
++void dio_stream_context_get_basic_options(php_stream_context *context, php_dio_stream_data *data TSRMLS_DC);
++
++void dio_stream_context_get_serial_options(php_stream_context *context, php_dio_stream_data *data TSRMLS_DC);
++
++size_t dio_common_write(php_dio_stream_data *data, const char *buf, size_t count);
++
++size_t dio_common_read(php_dio_stream_data *data, const char *buf, size_t count);
++
++int dio_common_close(php_dio_stream_data *data);
++
++int dio_common_set_option(php_dio_stream_data *data, int option, int value, void *ptrparam);
++
++int dio_raw_open_stream(char *filename, char *mode, php_dio_stream_data *data TSRMLS_DC);
++
++int dio_serial_uninit(php_dio_stream_data *data);
++
++int dio_serial_purge(php_dio_stream_data *data);
++
++int dio_serial_open_stream(char *filename, char *mode, php_dio_stream_data *data TSRMLS_DC);
++
++#endif /* PHP_DIO_COMMON_H_ */
++
++/*
++ * Local variables:
++ * c-basic-offset: 4
++ * tab-width: 4
++ * End:
++ * vim600: fdm=marker
++ * vim: sw=4 ts=4 noet
++ */
+--- /dev/null
++++ b/ext/dio/php_dio_common_data.h
+@@ -0,0 +1,59 @@
++/*
++ +----------------------------------------------------------------------+
++ | PHP Version 5 |
++ +----------------------------------------------------------------------+
++ | Copyright (c) 2009 Melanie Rhianna Lewis |
++ +----------------------------------------------------------------------+
++ | This source file is subject to version 3.0 of the PHP license, |
++ | that is bundled with this package in the file LICENSE, and is |
++ | available through the world-wide-web at the following url: |
++ | http://www.php.net/license/3_0.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. |
++ +----------------------------------------------------------------------+
++ | Author: Melanie Rhianna Lewis <cyberspice@php.net> |
++ +----------------------------------------------------------------------+
++ */
++
++#ifndef PHP_DIO_COMMON_DATA_H_
++#define PHP_DIO_COMMON_DATA_H_
++
++/* This is the data structure 'base class'. It is common data fields used
++ * by all versions of DIO.
++ */
++typedef struct _php_dio_stream_data {
++ /* Stream type */
++ int stream_type;
++ /* Stream options */
++ int end_of_file;
++#ifdef DIO_HAS_FILEPERMS
++ int has_perms;
++ int perms;
++#endif
++#ifdef DIO_NONBLOCK
++ int is_blocking;
++ int has_timeout;
++ long timeout_sec;
++ long timeout_usec;
++ int timed_out;
++#endif
++ /* Serial options */
++ long data_rate;
++ int data_bits;
++ int stop_bits;
++ int parity;
++ int flow_control;
++ int canonical;
++} php_dio_stream_data ;
++
++#endif /* PHP_DIO_COMMON_DATA_H_ */
++
++/*
++ * Local variables:
++ * c-basic-offset: 4
++ * tab-width: 4
++ * End:
++ * vim600: fdm=marker
++ * vim: sw=4 ts=4 noet
++ */
+--- /dev/null
++++ b/ext/dio/php_dio_posix.h
+@@ -0,0 +1,70 @@
++/*
++ +----------------------------------------------------------------------+
++ | PHP Version 5 |
++ +----------------------------------------------------------------------+
++ | Copyright (c) 2009 Melanie Rhianna Lewis |
++ +----------------------------------------------------------------------+
++ | This source file is subject to version 3.0 of the PHP license, |
++ | that is bundled with this package in the file LICENSE, and is |
++ | available through the world-wide-web at the following url: |
++ | http://www.php.net/license/3_0.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. |
++ +----------------------------------------------------------------------+
++ | Author: Melanie Rhianna Lewis <cyberspice@php.net> |
++ +----------------------------------------------------------------------+
++ */
++
++#ifndef PHP_DIO_POSIX_H_
++#define PHP_DIO_POSIX_H_
++
++#include <sys/stat.h>
++#include <sys/types.h>
++#include <sys/select.h>
++#include <sys/time.h>
++
++#ifdef HAVE_UNISTD_H
++#include <unistd.h>
++#endif
++
++#include <fcntl.h>
++#include <termios.h>
++
++
++/**
++ * Detect if we can support non blocking IO.
++ */
++#ifdef O_NONBLOCK
++#define DIO_NONBLOCK O_NONBLOCK
++#else
++#ifdef O_NDELAY
++#define DIO_NONBLOCK O_NDELAY
++#endif
++#endif
++
++/**
++ * POSIXy platforms have file permissions
++ */
++#define DIO_HAS_FILEPERMS
++
++#include "php_dio_common_data.h"
++
++typedef struct _php_dio_posix_stream_data {
++ php_dio_stream_data common;
++ int fd;
++ int flags;
++ /* Serial options */
++ struct termios oldtio;
++} php_dio_posix_stream_data ;
++
++#endif /* PHP_DIO_POSIX_H_ */
++
++/*
++ * Local variables:
++ * c-basic-offset: 4
++ * tab-width: 4
++ * End:
++ * vim600: fdm=marker
++ * vim: sw=4 ts=4 noet
++ */
+--- /dev/null
++++ b/ext/dio/php_dio_stream_wrappers.h
+@@ -0,0 +1,44 @@
++/*
++ +----------------------------------------------------------------------+
++ | PHP Version 5 |
++ +----------------------------------------------------------------------+
++ | Copyright (c) 2009 Melanie Rhianna Lewis |
++ +----------------------------------------------------------------------+
++ | This source file is subject to version 3.0 of the PHP license, |
++ | that is bundled with this package in the file LICENSE, and is |
++ | available through the world-wide-web at the following url: |
++ | http://www.php.net/license/3_0.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. |
++ +----------------------------------------------------------------------+
++ | Author: Melanie Rhianna Lewis <cyberspice@php.net> |
++ +----------------------------------------------------------------------+
++ */
++
++#ifndef PHP_DIO_STREAM_WRAPPERS_H_
++#define PHP_DIO_STREAM_WRAPPERS_H_
++
++#define DIO_RAW_STREAM_NAME "dio.raw"
++#define DIO_RAW_STREAM_PROTOCOL "dio.raw://"
++#define DIO_SERIAL_STREAM_NAME "dio.serial"
++#define DIO_SERIAL_STREAM_PROTOCOL "dio.serial://"
++
++extern php_stream_wrapper php_dio_raw_stream_wrapper;
++
++PHP_FUNCTION(dio_raw);
++
++extern php_stream_wrapper php_dio_serial_stream_wrapper;
++
++PHP_FUNCTION(dio_serial);
++
++#endif /* PHP_DIO_STREAM_WRAPPERS_H_ */
++
++/*
++ * Local variables:
++ * c-basic-offset: 4
++ * tab-width: 4
++ * End:
++ * vim600: fdm=marker
++ * vim: sw=4 ts=4 noet
++ */
+--- /dev/null
++++ b/ext/dio/php_dio_win32.h
+@@ -0,0 +1,62 @@
++/*
++ +----------------------------------------------------------------------+
++ | PHP Version 5 |
++ +----------------------------------------------------------------------+
++ | Copyright (c) 2009 Melanie Rhianna Lewis |
++ +----------------------------------------------------------------------+
++ | This source file is subject to version 3.0 of the PHP license, |
++ | that is bundled with this package in the file LICENSE, and is |
++ | available through the world-wide-web at the following url: |
++ | http://www.php.net/license/3_0.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. |
++ +----------------------------------------------------------------------+
++ | Author: Melanie Rhianna Lewis <cyberspice@php.net> |
++ +----------------------------------------------------------------------+
++ */
++
++#ifndef PHP_DIO_WIN32_H_
++#define PHP_DIO_WIN32_H_
++
++#include <windows.h>
++
++/* Windows platform can do non blocking. */
++#define DIO_NONBLOCK
++
++#include "php_dio_common_data.h"
++
++#define DIO_WIN32_CANON_BUF_SIZE 8192
++
++/* This is the buffer information when reading in canonical mode. Data is
++ read right up to either buffer being full or a newline being read. Excess
++ data will be retained in the buffer until the next read. */
++typedef struct _php_dio_win32_canon_data {
++ size_t size;
++ size_t read_pos;
++ size_t write_pos;
++ char buf[DIO_WIN32_CANON_BUF_SIZE];
++
++} php_dio_win32_canon_data;
++
++typedef struct _php_dio_win32_stream_data {
++ php_dio_stream_data common;
++ HANDLE handle;
++ DWORD desired_access;
++ DWORD creation_disposition;
++ DCB olddcb;
++ COMMTIMEOUTS oldcto;
++ php_dio_win32_canon_data *canon_data;
++
++} php_dio_win32_stream_data ;
++
++#endif /* PHP_DIO_WIN32_H_ */
++
++/*
++ * Local variables:
++ * c-basic-offset: 4
++ * tab-width: 4
++ * End:
++ * vim600: fdm=marker
++ * vim: sw=4 ts=4 noet
++ */
+--- /dev/null
++++ b/ext/dio/tests/001.phpt
+@@ -0,0 +1,23 @@
++--TEST--
++Test dio legacy open
++--SKIPIF--
++<?php if (!extension_loaded("dio")) print "skip"; ?>
++--FILE--
++<?php
++ $iswin = (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN');
++
++ if (!$iswin) {
++ $filename = "/dev/null";
++ } else {
++ $filename = "NUL";
++ }
++
++ $f = dio_open($filename,O_RDONLY);
++ if ($f) {
++ echo "Legacy open passed";
++ } else {
++ echo "Legacy open failed";
++ }
++?>
++--EXPECT--
++Legacy open passed
+--- /dev/null
++++ b/ext/dio/tests/dio_raw_stream_001.phpt
+@@ -0,0 +1,24 @@
++--TEST--
++Test dio raw stream open
++--SKIPIF--
++<?php if (!extension_loaded("dio")) print "skip"; ?>
++--FILE--
++<?php
++ $iswin = (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN');
++
++ if (!$iswin) {
++ $filename = "dio.raw:///dev/null";
++ } else {
++ $filename = "dio.raw://NUL";
++ }
++
++ $f = fopen($filename, "r+");
++ if ($f) {
++ echo "Raw open passed";
++ fclose($f);
++ } else {
++ echo "Raw open failed";
++ }
++?>
++--EXPECT--
++Raw open passed
+--- /dev/null
++++ b/ext/dio/tests/dio_raw_stream_002.phpt
+@@ -0,0 +1,27 @@
++--TEST--
++Test dio raw stream close
++--SKIPIF--
++<?php if (!extension_loaded("dio")) print "skip"; ?>
++--FILE--
++<?php
++ $iswin = (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN');
++
++ if (!$iswin) {
++ $filename = "dio.raw:///dev/null";
++ } else {
++ $filename = "dio.raw://NUL";
++ }
++
++ $f = fopen($filename, "r+");
++ if ($f) {
++ if (fclose($f)) {
++ echo "Raw close passed";
++ } else {
++ echo "Raw close failed";
++ }
++ } else {
++ echo "Raw open failed";
++ }
++?>
++--EXPECT--
++Raw close passed
+--- /dev/null
++++ b/ext/dio/tests/dio_raw_stream_003.phpt
+@@ -0,0 +1,29 @@
++--TEST--
++Test dio raw stream write
++--SKIPIF--
++<?php if (!extension_loaded("dio")) print "skip"; ?>
++--FILE--
++<?php
++ $iswin = (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN');
++
++ if (!$iswin) {
++ $filename = "dio.raw:///dev/null";
++ } else {
++ $filename = "dio.raw://NUL";
++ }
++
++ $f = fopen($filename, "r+");
++ if ($f) {
++ $data = str_repeat("+", 2048);
++ if (fwrite($f, $data)) {
++ echo "Raw write passed";
++ } else {
++ echo "Raw write failed";
++ }
++ fclose($f);
++ } else {
++ echo "Raw open failed";
++ }
++?>
++--EXPECT--
++Raw write passed
+--- /dev/null
++++ b/ext/dio/tests/dio_raw_stream_004.phpt
+@@ -0,0 +1,46 @@
++--TEST--
++Test dio raw read
++--SKIPIF--
++<?php
++ if (!extension_loaded('dio')) print 'skip';
++?>
++--FILE--
++<?php
++ // Create a temp file with some content to read
++
++ // Create the temp file name
++ if (!function_exists('sys_get_temp_dir')) {
++ if (!($tmpdir = getenv('TEMP'))) {
++ $tmpdir = '';
++ }
++ } else {
++ $tmpdir = sys_get_temp_dir();
++ }
++ $filename = tempnam($tmpdir, 'dio_raw_stream_004.tmp');
++
++ // Create the temp file
++ $tf = fopen($filename, "w");
++ if ($tf) {
++ fwrite($tf, str_repeat('*', 2048));
++ fclose($tf);
++ } else {
++ echo "Can\'t create temp file";
++ }
++
++ $f = fopen('dio.raw://' . $filename, "r");
++ if ($f) {
++ $data = fread($f, 2048);
++ if ($data && (strlen($data) == 2048)) {
++ echo "Raw read passed";
++ } else {
++ echo "Raw read failed";
++ }
++ fclose($f);
++ } else {
++ echo "Raw open failed";
++ }
++
++ unlink($filename);
++?>
++--EXPECT--
++Raw read passed
+--- /dev/null
++++ b/ext/dio/tests/dio_raw_stream_005.phpt
+@@ -0,0 +1,45 @@
++--TEST--
++Test dio eof read
++--SKIPIF--
++<?php
++ if (!extension_loaded('dio')) print 'skip';
++?>
++--FILE--
++<?php
++ // Create a temp file with some content to read
++
++ // Create the temp file name
++ if (!function_exists('sys_get_temp_dir')) {
++ if (!($tmpdir = getenv('TEMP'))) {
++ $tmpdir = '';
++ }
++ } else {
++ $tmpdir = sys_get_temp_dir();
++ }
++ $filename = tempnam($tmpdir, 'dio_raw_stream_005.tmp');
++
++ // Create the temp file
++ $tf = fopen($filename, "w");
++ if ($tf) {
++ fclose($tf);
++ } else {
++ echo "Can\'t create temp file";
++ }
++
++ $f = fopen('dio.raw://' . $filename, "r");
++ if ($f) {
++ $data = fread($f, 2048);
++ if (feof($f)) {
++ echo "Raw feof passed";
++ } else {
++ echo "Raw feof failed";
++ }
++ fclose($f);
++ } else {
++ echo "Raw open failed";
++ }
++
++ unlink($filename);
++?>
++--EXPECT--
++Raw feof passed
+--- /dev/null
++++ b/ext/dio/tests/dio_raw_stream_006.phpt
+@@ -0,0 +1,46 @@
++--TEST--
++Test dio raw read
++--SKIPIF--
++<?php
++ if (!extension_loaded('dio')) print 'skip';
++?>
++--FILE--
++<?php
++ // Create a temp file with some content to read
++
++ // Create the temp file name
++ if (!function_exists('sys_get_temp_dir')) {
++ if (!($tmpdir = getenv('TEMP'))) {
++ $tmpdir = '';
++ }
++ } else {
++ $tmpdir = sys_get_temp_dir();
++ }
++ $filename = tempnam($tmpdir, 'diotest');
++
++ // Create the temp file
++ $tf = fopen($filename, "w");
++ if ($tf) {
++ fwrite($tf, str_repeat('*', 2048));
++ fclose($tf);
++ } else {
++ echo "Can\'t create temp file";
++ }
++
++ $f = fopen('dio.raw://' . $filename, "r");
++ if ($f) {
++ $data = fread($f, 1024);
++ if (stream_set_blocking($f, false)) {
++ echo "Raw set blocking passed";
++ } else {
++ echo "Raw set blocking failed";
++ }
++ fclose($f);
++ } else {
++ echo "Raw open failed";
++ }
++
++ unlink($filename);
++?>
++--EXPECT--
++Raw set blocking passed
+--- /dev/null
++++ b/ext/dio/tests/dio_raw_stream_007.phpt
+@@ -0,0 +1,22 @@
++--TEST--
++Test dio_raw() call
++--SKIPIF--
++<?php if (!extension_loaded("dio")) print "skip"; ?>
++--FILE--
++<?php
++ $iswin = (strtoupper(substr(PHP_OS, 0, 3)) == 'WIN');
++
++ if (!$iswin) {
++ $filename = "/dev/null";
++ } else {
++ $filename = "NUL";
++ }
++
++ $f = dio_raw($filename, "r+");
++ if ($f) {
++ echo "dio_raw passed";
++ fclose($f);
++ }
++?>
++--EXPECT--
++dio_raw passed
projects / openwrt / svn-archive / archive.git / commitdiff