stream_socket_shutdown
Actually, I don't know if there's a better way to figure out if stream_read() was called by fgets() or e.g. fread() than this one:
public function stream_read($count)
{
$bt = debug_backtrace();
if(($bt[0]['function'] == 'stream_read') &&
($bt[1]['function'] == 'fgets'))
{
$pos = strpos($GLOBALS[$this->varname], "\n", $this->position);
$retval = substr($GLOBALS[$this->varname], $this->position, ($pos > $count) ? $count : $pos+1);
}
else
{
$retval = substr($GLOBALS[$this->varname], $this->position, $count);
}
$this->position += strlen($retval);
return (string)$retval;
}
stream_wrapper_register
(PHP 4 >= 4.3.2, PHP 5)
stream_wrapper_register — Registrar una envoltura URL implementada como una clase PHP
Descripción
bool stream_wrapper_register
( string $protocolo
, string $nombre_clase
)
stream_wrapper_register() le permite implementar sus propios gestores y secuencias de protocolo para su uso con todas las funciones de sistema de archivos (tales como fopen(), fread() etc.).
Para implementar una envoltura, necesita definir una clase con un número de funciones miembro, tal y como se define más adelante. Cuando alguien abre su secuencia mediante fopen, PHP creará una instancia de nombre_clase y luego llamará algunos métodos en esa instancia. Debe implementar los métodos exactamente como se describe a continuación - de no ser así, producirá comportamientos indefinidos.
Note: A partir de PHP 5.0.0, la instancia de nombre_clase será poblada con una propiedad contexto que hace referencia a un Recurso de Contexto, el cual puede obtenerse con stream_context_get_options(). Si no se ha pasado ningún contexto a la función de creación de secuencia, contexto será definido como NULL.
stream_wrapper_register() devolverá FALSE si el protocolo ya tiene un gestor.
bool stream_open
( string $ruta
, string $modo
, int $opciones
, string $ruta_abierta
)
Este método es llamado inmediatamente después de que su objeto de secuencia es creado. ruta especifica la URL pasada a fopen() y que éste objeto supuestamente debe recuperar. Puede usar parse_url() para separar la ruta.
modo es el modo usado para abrir el archivo, tal y como se proporciona en fopen(). Usted es responsable por el chequeo de la validez del modo para la ruta solicitada.
opciones contiene banderas adicionales definidas por la interfaz de programación de las secuencias. Puede contener uno o más de los siguientes valores, unidos mediante la operación lógica OR.
| Bandera | Descripción |
|---|---|
| STREAM_USE_PATH | Si ruta es relativa, buscar por el recurso usando include_path. |
| STREAM_REPORT_ERRORS | Si esta bandera está activa, usted se hace responsable por la generación de errores usando trigger_error() durante la apertura de la secuencia. Si esta bandera no está definida, no debe generar ningún error. |
Si la ruta es abierta satisfactoriamente, y STREAM_USE_PATH es definida en opciones , usted debe definir ruta_abierta como la ruta completa hacia el archivo/recurso que fue abierto en realidad.
Si el recurso solicitado fue abierto satisfactoriamente, debe devolver TRUE, o FALSE de lo contrario.
void stream_close
( void
)
Este método es llamado cuando la secuencia es cerrada, usando fclose(). Debe liberar cualquier recurso que haya sido bloqueado o reservado por la secuencia.
string stream_read
( int $conteo
)
Este método es llamado en respuesta a llamadas de fread() y fgets() en la secuencia. Usted debe devolver hasta conteo bytes de datos desde su posición actual de lectura/escritura como una cadena. Si hay menos de conteo bytes disponibles, devuelva tantos como pueda. Si no hay más datos disponibles, devuelva FALSE o una cadena vacía. También debe actualizar la posición de lectura/escritura de la secuencia en el número de bytes que fueron leídos con éxito.
int stream_write
( string $datos
)
Este método es llamado en respuesta a llamadas de fwrite() en el sistema. Debe guardar datos en el modelo de almacenamiento base usado por su secuencia. Si no hay suficiente espacio disponible, intente almacenar tantos bytes como le sea posible. Debe devolver el número de bytes que fueron almacenados satisfactoriamente en la secuencia, o 0 si no fue posible almacenar ninguno. También debe actualizar la posición de lectura/escritura de la secuencia en el número de bytes que fueron escritos con éxito.
bool stream_eof
( void
)
Este método es llamado en respuesta a llamados de feof() en la secuencia. Debe devolver TRUE si la posición de lectura/escritura se encuentra al final de la secuencia y no hay más datos disponibles para su lectura, o FALSE de lo contrario.
int stream_tell
( void
)
Este método es llamado en respuesta a llamados de ftell() en la secuencia. Debe devolver la posición actual de lectura/escritura en la secuencia.
bool stream_seek
( int $desplazamiento
, int $punto_partida
)
Este método es llamado en respuesta a llamadas de fseek() en la secuencia. Debe actualizar la posición de lectura/escritua en la secuencia de acuerdo a desplazamiento y punto_partida . Vea fseek() para más información sobre éstos parámetros. Devuelva TRUE si la posición fue actualizada, FALSE de lo contrario.
bool stream_flush
( void
)
Este método es llamado en respuesta a llamadas de fflush() en la secuencia. Si ha usado un caché con los datos de su secuencia, pero no los ha guardado aun en el modelo de almacenamiento base, debe hacerlo ahora. Devuelva TRUE si los datos en caché fueron almacenados satisfactoriamente (o si no habían datos a almacenar), o FALSE si los datos no pudieron ser almacenados.
array stream_stat
( void
)
Este método es llamado en respuesta a llamadas de fstat() en la secuencia y debe devolver una matriz que contenga los mismos valores que sean apropiados para la secuencia.
Este método es llamado en respuesta a llamadas de unlink() sobre rutas URL asociadas con la envoltura y debe intentar la eliminación del item especificado por ruta . Debe devolver TRUE de tener éxito o FALSE en caso de fallo. Para asegurarse de que el mensaje de error correcto sea devuelto, no defina éste método si su envoltura no soporta eliminaciones.
Note: El método de envoltura en espacio de usuario unlink no es soportado antes de PHP 5.0.0.
Este método es llamado en respuesta a llamadas de rename() en rutas URL asociadas con la envoltura y debe intentar renombrar el item especificado por ruta_fuente a la cadena dada por ruta_destino . Debe devolver TRUE en caso de éxito o FALSE en caso de fallo. Para asegurarse de que el mensaje de error correcto sea devuelto, no defina éste método si su envoltura no soporta el renombramiento de rutas.
Note: El método de envoltura en espacio de usuario rename no es soportado antes de PHP 5.0.0.
Este método es llamado en respuesta a llamadas de mkdir() en rutas URL asociadas con la envoltura y debe intentar crear el directorio especificado por ruta . Debe devolver TRUE de tener éxito o FALSE en caso de fallo. Para asegurarse de que el mensaje de error correcto sea devuelto, no defina éste método si su envoltura no soporta la creación de directorios. Valores posibles para opciones incluyen STREAM_REPORT_ERRORS y STREAM_MKDIR_RECURSIVE.
Note: El método de envoltura en espacio de usuario mkdir no es soportado antes de PHP 5.0.0.
Este método es llamado en respuesta a llamadas de rmdir() sobre rutas URL asociadas con la envoltura y debería intentar eliminar el directorio especificado por ruta . Debe devolver TRUE de tener éxito o FALSE en caso de fallo. Para asegurarse de que el mensaje de error correcto sea devuelto, no defina éste método si su envoltura no soporta la eliminación de directorios. Posibles valores para opciones incluyen STREAM_REPORT_ERRORS.
Note: El método de envoltura en espacio de usuario rmdir no es soportado antes de PHP 5.0.0.
bool dir_opendir
( string $ruta
, int $opciones
)
Este método es llamado inmediatamente cuando su objeto de secuencia es creado para examinar contenidos de directorio con opendir(). ruta especifica la URL que fue pasada a opendir() y que éste objeto supuestamente va a explorar. Puede usar parse_url() para separar ésta ruta.
array url_stat
( string $ruta
, int $banderas
)
Este método es llamado en respuesta a llamadas de stat() en rutas URL asociadas con la envoltura y debe devolver tantos elementos en común con la función del sistema como sea posible. Los valores desconocidos o no disponibles deben definirse con valores razonables (usualmente 0).
banderas contiene banderas adicionales definidas por la interfaz de programación de secuencias. Puede contener uno o más de los siguientes valores, unidos mediante la operación lógica OR.
| Bandera | Descripción |
|---|---|
| STREAM_URL_STAT_LINK | Para recursos con la habilidad de mantener un enlace con otro recurso (tales como una redirección HTTP Location:, o un enlace simbólico en el sistema de archivos). Esta bandera indica que solo se devolverá información sobre el enlace mismo, no sobre el recurso apuntado por el enlace. Esta bandera es definida en respuesta a llamadas de lstat(), is_link(), o filetype(). |
| STREAM_URL_STAT_QUIET | Si ésta bandera es definida, su envoltura no debe generar error alguno. Si esta bandera no está definida, usted es responsable por el reporte de errores usando la función trigger_error() durante la ejecución del proceso stat en la ruta. |
string dir_readdir
( void
)
Este método es llamado en respuesta a readdir() y debe devolver una cadena que represente el siguiente nombre de archivo en la ubicación abierta por dir_opendir().
bool dir_rewinddir
( void
)
Este método es llamado en respuesta a rewinddir() y debe restablecer la salida generada por dir_readdir(). Esto quiere decir, la siguiente llamada a dir_readdir() debe devolver la primera entrada en la ubicación devuelta por dir_opendir().
bool dir_closedir
( void
)
Este método es llamado en respuesta a closedir(). Debe liberar cualquier recurso que haya sido bloqueado o reservado durante la apertura y uso de la secuencia de directorio.
El siguiente ejemplo implementa un gestor del protocolo var:// que permite el acceso para lectura/escritura a una variable global con nombre, usando las funciones de secuencia de sistema de archivos, como fread(). El protocolo var:// implementado a continuación leerá/escribirá datos desde/hacia $GLOBALS["foo"] dada la URL "var://foo".
Example #1 Una Secuencia para la lectura/escritura de variables globales
<?php
class SecuenciaVariable {
var $posicion;
var $nombre_var;
function stream_open($ruta, $modo, $opciones, &$ruta_abierta)
{
$url = parse_url($ruta);
$this->nombre_var = $url["host"];
$this->posicion = 0;
return true;
}
function stream_read($conteo)
{
$ret = substr($GLOBALS[$this->nombre_var], $this->posicion, $conteo);
$this->posicion += strlen($ret);
return $ret;
}
function stream_write($datos)
{
$izq = substr($GLOBALS[$this->nombre_var], 0, $this->posicion);
$der = substr($GLOBALS[$this->nombre_var], $this->posicion + strlen($datos));
$GLOBALS[$this->nombre_var] = $izq . $datos . $der;
$this->posicion += strlen($datos);
return strlen($datos);
}
function stream_tell()
{
return $this->posicion;
}
function stream_eof()
{
return $this->posicion >= strlen($GLOBALS[$this->nombre_var]);
}
function stream_seek($desplazamiento, $partida)
{
switch ($partida) {
case SEEK_SET:
if ($desplazamiento < strlen($GLOBALS[$this->nombre_var]) && $desplazamiento >= 0) {
$this->posicion = $desplazamiento;
return true;
} else {
return false;
}
break;
case SEEK_CUR:
if ($desplazamiento >= 0) {
$this->posicion += $desplazamiento;
return true;
} else {
return false;
}
break;
case SEEK_END:
if (strlen($GLOBALS[$this->nombre_var]) + $desplazamiento >= 0) {
$this->posicion = strlen($GLOBALS[$this->nombre_var]) + $desplazamiento;
return true;
} else {
return false;
}
break;
default:
return false;
}
}
}
stream_wrapper_register("var", "SecuenciaVariable")
or die("Falló el registro del protocolo");
$mi_var = "";
$da = fopen("var://mi_var", "r+");
fwrite($da, "linea1\n");
fwrite($da, "linea2\n");
fwrite($da, "linea3\n");
rewind($da);
while (!feof($da)) {
echo fgets($da);
}
fclose($da);
var_dump($mi_var);
?>
add a note
User Contributed Notesstream_wrapper_register
phrank
17-Apr-2008 10:38
17-Apr-2008 10:38
Rick Hodger
20-Dec-2007 12:47
20-Dec-2007 12:47
I have created a POP3 stream wrapper, available at http://www.potato-people.com/code/pop3.stream/
yeiniel at gmail dot com
15-Oct-2007 04:30
15-Oct-2007 04:30
on using dir_opendir on PHP5 make sure you not return a resource object on success. A resource object is diferent from false but php make a cast to bool to dir_opendir return value and modify the value of your resource to 1.
example:
class myclass{
private $mysqlHandler;
public function dir_opendir(....)
{
$this->mysqlHandler = mysql_connect(....);
return $this->mysqlHandler; //this is wrong, next
//time you use
//$this->mysqlHandler
// the value is 1
}
}
vmvarela at gmail dot com
24-Sep-2007 06:34
24-Sep-2007 06:34
I have written a new SMB Stream Wrapper for Unix systems using smbclient (SAMBA project).
http://freshmeat.net/smb4php
fordiman at gmail dot com
13-Aug-2007 02:59
13-Aug-2007 02:59
Updated. I figured there's no need to store the variable name if we're dereferenceing; we can just store the pointer and not have to dereference in each function for brevity.
Also, I added the assertion that the stream is a string, since we're behaving basically like it has to be, and I changed the name to GlobalStream and global://, as that's a more descriptive moniker than VariableName/var://.
<?php
class GlobalStream {
private $pos;
private $stream;
public function stream_open($path, $mode, $options, &$opened_path) {
$url = parse_url($path);
$this->stream = &$GLOBALS[$url["host"]];
$this->pos = 0;
if (!is_string($this->stream)) return false;
return true;
}
public function stream_read($count) {
$p=&$this->pos;
$ret = substr($this->stream, $this->pos, $count);
$this->pos += strlen($ret);
return $ret;
}
public function stream_write($data){
$l=strlen($data);
$this->stream =
substr($this->stream, 0, $this->pos) .
$data .
substr($this->stream, $this->pos += $l);
return $l;
}
public function stream_tell() {
return $this->pos;
}
public function stream_eof() {
return $this->pos >= strlen($this->stream);
}
public function stream_seek($offset, $whence) {
$l=strlen($this->stream);
switch ($whence) {
case SEEK_SET: $newPos = $offset; break;
case SEEK_CUR: $newPos = $this->pos + $offset; break;
case SEEK_END: $newPos = $l + $offset; break;
default: return false;
}
$ret = ($newPos >=0 && $newPos <=$l);
if ($ret) $this->pos=$newPos;
return $ret;
}
}
stream_wrapper_register('global', 'GlobalStream') or die('Failed to register protocol global://');
$myvar = "";
$fp = fopen("global://myvar", "r+");
fwrite($fp, "line1\n");
fwrite($fp, "line2\n");
fwrite($fp, "line3\n");
rewind($fp);
while (!feof($fp)) {
echo fgets($fp);
}
fclose($fp);
var_dump($myvar);
?>
fordiman at gmail dot com
13-Aug-2007 02:32
13-Aug-2007 02:32
Updated for PHP 5, and optimized for readability, low line count, and minimum memory use:
<?php
class VariableStream {
private $position;
private $varname;
public function stream_open($path, $mode, $options, &$opened_path) {
$url = parse_url($path);
$this->varname = $url["host"];
$this->position = 0;
return true;
}
public function stream_read($count) {
$p=&$this->position;
$ret = substr($GLOBALS[$this->varname], $p, $count);
$p += strlen($ret);
return $ret;
}
public function stream_write($data){
$v=&$GLOBALS[$this->varname];
$l=strlen($data);
$p=&$this->position;
$v = substr($v, 0, $p) . $data . substr($v, $p += $l);
return $l;
}
public function stream_tell() {
return $this->position;
}
public function stream_eof() {
return $this->position >= strlen($GLOBALS[$this->varname]);
}
public function stream_seek($offset, $whence) {
$l=strlen(&$GLOBALS[$this->varname]);
$p=&$this->position;
switch ($whence) {
case SEEK_SET: $newPos = $offset; break;
case SEEK_CUR: $newPos = $p + $offset; break;
case SEEK_END: $newPos = $l + $offset; break;
default: return false;
}
$ret = ($newPos >=0 && $newPos <=$l);
if ($ret) $p=$newPos;
return $ret;
}
}
stream_wrapper_register("var", "VariableStream")
or die("Failed to register protocol");
$myvar = "";
$fp = fopen("var://myvar", "r+");
fwrite($fp, "line1\n");
fwrite($fp, "line2\n");
fwrite($fp, "line3\n");
rewind($fp);
while (!feof($fp)) {
echo fgets($fp);
}
fclose($fp);
var_dump($myvar);
?>
phpnet at povaddict dot com dot ar
10-Jun-2007 05:10
10-Jun-2007 05:10
In response to Anonymouse at Coward dot com:
The manual says "Reading stops when up to length bytes have been read, [...] or (after opening userspace stream) when 8192 bytes have been read whichever comes first."
I tested it and fread($filehandle, 4096) returns 4096 bytes, so it's working as the manual says it should. You're right when you say "8192 bytes is always passed to stream_read as count", but that doesn't mean fread will return 8192 bytes. If you call fread twice with length 4096, PHP calls stream_read passing 8192 as count on the first fread, and doesn't call it on second fread. On both cases, fread returns the correct amount of bytes.
<?php
class VariableStream {
var $position;
var $varname;
function stream_open($path, $mode, $options, &$opened_path)
{
$url = parse_url($path);
$this->varname = $url["host"];
$this->position = 0;
return true;
}
function stream_read($count)
{
echo "stream_read called asking for $count bytes\n";
$ret = substr($GLOBALS[$this->varname], $this->position, $count);
$this->position += strlen($ret);
return $ret;
}
function stream_eof()
{
return $this->position >= strlen($GLOBALS[$this->varname]);
}
}
stream_wrapper_register("var", "VariableStream")
or die("Failed to register protocol");
$myvar = "";
$l=range('a','z');
for($i=0;$i<65536;$i++) {
$myvar .= $l[array_rand($l)];
}
$fp = fopen("var://myvar", "r+");
while (!feof($fp)) {
$out = fread($fp,1000);
echo "fread returned ",strlen($out)," bytes\n";
}
fclose($fp);
?>
Anonymouse at Coward dot com
26-Apr-2007 06:18
26-Apr-2007 06:18
Use caution with writing code that may use stream wrappers with fread, as fread behaviour is 'inconsistent' with normal file operations because of the 8192 bytes internal buffer used by PHP ( >= 5.0.5 IIRC ).
ie:
fread($filehandle, filesize($filename))
will not work correctly if the file is larger than 8KB, it will only get you the first 8192 bytes. Also, it seems that:
fread($filehandle, 4096)
will still give you 8KB (if the file is larger than 8KB) as 8192 bytes is always passed to stream_read as count.
This makes it somewhat impossible to just 'drop in' a stream where normally a file would be used without taking special care.
Yes, it IS mentioned in the documentation here if you read it really well, but I for one spent some time scratching my head over it, and looking at the bug tracker, I am not the only one. The dev's say this inconsistancy is a feature though, even if it does make stream wrappers pretty much useless 'out of the box'.
file_get_contents and stream_get_contents seem to work ok though.
none at your dot biz
10-Nov-2006 01:35
10-Nov-2006 01:35
In case someone else starts scratching their head like I was, you should change the VariableStream::stream_eof() function to something like this:
function stream_eof()
{
$eof = ($this->position >= strlen($GLOBALS[$this->varname]));
if(version_compare(PHP_VERSION,'5.0','>=') && version_compare(PHP_VERSION,'5.1','<'))
{
$eof = !$eof;
}
return $eof;
}
PHP 5.0 introduced a bug that wasn't fixed until 5.1
jhannus at php dot net
21-Jun-2005 04:37
21-Jun-2005 04:37
It is worth noting that if your wrapper supports stream_flush() then when you flcose() your stream this function will be called prior to closing the stream.
cellog at php dot net
13-Apr-2005 04:45
13-Apr-2005 04:45
If you plan to use your wrapper in a require_once you need to define stream_stat(). If you plan to allow any other tests like is_file()/is_dir(), you have to define url_stat().
stream_stat() must define the size of the file, or it will never be included. url_stat() must define mode, or is_file()/is_dir()/is_executable(), and any of those functions affected by clearstatcache() simply won't work.
It's not documented, but directories must be a mode like 040777 (octal), and files a mode like 0100666. If you wish the file to be executable, use 7s instead of 6s. The last 3 digits are exactly the same thing as what you pass to chmod. 040000 defines a directory, and 0100000 defines a file. It would be really helpful to add this to the official manual!
Hayley Watson
04-Apr-2005 08:07
04-Apr-2005 08:07
The current URL standard is RFC 3986 - available at www.ietf.org/rfc/rfc3986.txt
simon at firepages dot org
13-Apr-2004 07:53
13-Apr-2004 07:53
using streams to use the ever useful fgetcsv() on a variable where explode() would not work (and would otherwise require regex(though that may be easier;)))
$explode_this="yak, llama, 'big llama', 'wobmat, with a comma in it', bandycoot";
<?php
class csvstream{
var $position;
var $varname;
function stream_open($path, $mode, $options, &$opened_path){
$url = parse_url($path);
$this->varname = $url['host'] ;
$this->position = 0;
return true;
}
function stream_read($count){
$ret = substr($GLOBALS[$this->varname], $this->position, $count);
$this->position += strlen($ret);
return $ret;
}
function stream_eof(){
return $this->position >= strlen($GLOBALS[$this->varname]);
}
function stream_tell(){
return $this->position;
}
}
stream_wrapper_register("csvstr", "csvstream") ;
$str="yak, llama, 'big llama', 'wobmat, with a comma in it', bandycoot";
$fp = fopen("csvstr://str", "r+");
print_r(fgetcsv($fp,100,",","'"));
?>