Downloads

Documentation
Get Involved
Help

Search
ScotlandPHP Conference 2019

Getting Started
Introduction
A simple tutorial
Language Reference
Basic syntax
Types
Variables
Constants
Expressions
Operators
Control Structures
Functions
Classes and Objects
Namespaces
Errors
Exceptions
Generators
References Explained
Predefined Variables
Predefined Exceptions
Predefined Interfaces and Classes
Context options and parameters
Supported Protocols and Wrappers

Security
Introduction
General considerations
Installed as CGI binary
Installed as an Apache module
Session Security
Filesystem Security
Database Security
Error Reporting
Using Register Globals
User Submitted Data
Magic Quotes
Hiding PHP
Keeping Current
Features
HTTP authentication with PHP
Cookies
Sessions
 Dealing with XForms
Handling file uploads
Using remote files
Connection handling
Persistent Database Connections
Safe Mode
Command line usage
Garbage Collection
DTrace Dynamic Tracing

Function Reference
Affecting PHP's Behaviour
Audio Formats Manipulation
Authentication Services
Command Line Specific Extensions
Compression and Archive Extensions
Credit Card Processing
Cryptography Extensions
Database Extensions
Date and Time Related Extensions
File System Related Extensions
Human Language and Character Encoding Support
Image Processing and Generation
Mail Related Extensions
Mathematical Extensions
Non-Text MIME Output
Process Control Extensions
Other Basic Extensions
Other Services
Search Engine Extensions
Server Specific Extensions
Session Extensions
Text Processing
Variable and Type Related Extensions
Web Services
Windows Only Extensions
XML Manipulation
GUI Extensions

Keyboard Shortcuts
?
This help
j
Next menu item
k
Previous menu item
gp
Previous man page
gn
Next man page
G
Scroll to bottom
gg
Scroll to top
gh
Goto homepage
gs
Goto search
(current page)
/
Focus search box

fpassthru »
« fnmatch

Manual de PHP
Referencia de funciones
Extensiones relacionadas con el sistema de ficheros
Sistema de Ficheros
Funciones del Sistema de Archivos

Change language: Spanish

Edit Report a Bug

fopen
(PHP 4, PHP 5, PHP 7)

fopen — Abre un fichero o un URL

Descripción ¶

fopen ( string $filename , string $mode [, bool $use_include_path = FALSE [, resource $context ]] ) : resource

fopen() asocia un recurso con nombre, especificado por filename, a un flujo.

Parámetros ¶
filename

Si filename está en la forma "esquema://...", se asume que será un URL y PHP buscará un gestor de
protocolos (también conocido como envoltura) para ese protocolo. Si no está registrada ninguna envoltura
para ese protocolo, PHP emitirá un aviso para ayudar a rastrear problemas potenciales en el script y
continuará como si filename especificara un fichero normal.

Si PHP ha decidido que filename especifica un fichero local, intentará abrir un flujo para ese fichero. El
fichero debe ser accesible para PHP, por lo que es necesario asegurarse de que los permisos de acceso del
fichero permiten este acceso. Si está habilitado el modo seguro o open_basedir se pueden aplicar más
restricciones.

Si PHP ha decidido que filename especifica un protocolo registrado, y ese protocolo está registrado como
un URL de red, PHP se asegurará de que allow_url_fopen está habilitado. Si es desactivado, PHP emitirá
un aviso y la llamada a fopen fallará.

Nota:
 La lista de protocolos soportados se puede encontrar en Protocolos y Envolturas soportados.
Algunos protocolos (también descritos como envolturas) soportan contexto y/u opciones de
php.ini. Consulte la página específica del protocolo en uso para una lista de opciones que se
pueden establecer. (p.ej. el valor user_agent en php.ini usado por la envoltura http).

En la plataforma Windows, asegúrese de escapar cualquier barra invertida usada en la ruta de fichero, o
use barras hacia delante.

<?php
$gestor = fopen("c:\\folder\\resource.txt", "r");
?>
mode

El parámetro mode especifica el tipo de acceso que se necesita para el flujo. Puede ser cualquiera de los
siguientes:

Una lista de los modos posibles de fopen() usando mode

mode Descripción
'r' Apertura para sólo lectura; coloca el puntero al fichero al principio del fichero.
'r+' Apertura para lectura y escritura; coloca el puntero al fichero al principio del fichero.
Apertura para sólo escritura; coloca el puntero al fichero al principio del fichero y trunca el fichero a
'w'
longitud cero. Si el fichero no existe se intenta crear.
Apertura para lectura y escritura; coloca el puntero al fichero al principio del fichero y trunca el
'w+'
fichero a longitud cero. Si el fichero no existe se intenta crear.
Apertura para sólo escritura; coloca el puntero del fichero al final del mismo. Si el fichero no existe,
'a' se intenta crear. En este modo, fseek() solamente afecta a la posición de lectura; las lecturas siempre
son pospuestas.
Apertura para lectura y escritura; coloca el puntero del fichero al final del mismo. Si el fichero no
'a+'
existe, se intenta crear. En este modo, fseek() no tiene efecto, las escrituras siempre son pospuestas.
Creación y apertura para sólo escritura; coloca el puntero del fichero al principio del mismo. Si el
fichero ya existe, la llamada a fopen() fallará devolviendo FALSE y generando un error de nivel
'x'
E_WARNING. Si el fichero no existe se intenta crear. Esto es equivalente a especificar las banderas
O_EXCL|O_CREAT para la llamada al sistema de open(2) subyacente.
'x+' Creación y apertura para lectura y escritura; de otro modo tiene el mismo comportamiento que 'x'.
Abrir el fichero para sólo escritura. Si el fichero no existe, se crea. Si existe no es truncado (a
diferencia de 'w'), ni la llamada a esta función falla (como en el caso con 'x'). El puntero al fichero
se posiciona en el principio del fichero. Esto puede ser útil si se desea obtener un bloqueo asistido
'c'
(véase flock()) antes de intentar modificar el fichero, ya que al usar 'w' se podría truncar el fichero
antes de haber obtenido el bloqueo (si se desea truncar el fichero, se puede usar ftruncate() después
de solicitar el bloqueo).
'c+' Abrir el fichero para lectura y escritura; de otro modo tiene el mismo comportamiento que 'c'.
Establecer la bandera 'close-on-exec' en el descriptor de fichero abierto. Disponible solamente en
'e'
PHP compilado en sistemas que se ajustan a POSIX.1-2008.

Nota:

Diferentes familias de sistemas operativos tienen diferentes convenciones para el final de

línea. Cuando escribe un fichero de texto y quiere insertar un salto de línea, necesita usar el
carácter o caracteres correctos de final de línea para su sistema operativo. Los sistemas
basados en Unix usan \n como el carácter de final de línea, los sistemas basados en Windows
usan \r\n como caracteres de final de línea y los sistemas basados en Macintosh usan \r como
carácter de final de línea.
 Si usa los caracteres de final de línea erróneos cuando escribe sus ficheros, se podrá encontrar
con que otras aplicaciones que abran esos ficheros "parecerán raras".

Windows ofrece una bandera de traducción en modo texto ('t') que traducirá de manera
transparente \n a \r\n cuando se trabaja con el fichero. En contraste, puede usar 'b' para forzar
el modo binario, lo cual no traducirá su información. Para usar estas banderas, especifique 'b'
o 't' como el último carácter del parámetro mode.

El modo de traducción predeterminado depende de la SAPI y de la versión de PHP que esté

usando, por lo que se le anima a especificar siempre la bandera apropiada por razones de
portabilidad. Debería usar el modo 't' si está trabajando con ficheros de texto plano y usa \n
para delimitar los finales de línea es su script, pero confíe que sus ficheros serán legibles por
aplicaciones tales como notepad. Debería usar 'b' en los demás casos.

Si no especifica la bandera 'b' cuando está trabajando con ficheros binarios, puede
experimentar problemas extraños con su información, incluidos ficheros imagen rotos o
problemas extraños con los caracteres \r\n.

Nota:

Por portabilidad, se recomienda encarecidamente que siempre use la bandera 'b' cuando se
abran ficheros con fopen().

Nota:

De nuevo, por portabilidad, también se recomienda encarecidamente que reescriba el código

que usa o depende del modo 't' por lo que use los finales de línea correctos y el modo 'b' en su
lugar.

use_include_path

El tercer parámetro opcional use_include_path puede ser establecido a '1' o TRUE si se desea buscar un
fichero en include_path también.

context

Nota: Soporte para context fue añadido en PHP 5.0.0. Para una descripción de contexts,
refiérase a Flujos.

Valores devueltos ¶
Devuelve un recurso de puntero a fichero si tiene éxito, o FALSE si se produjo un error.

Errores/Excepciones ¶

Si la apertura falla, se generea un error de nivel E_WARNING. Se puede usar @ para suprimir esta advertencia.

Historial de cambios ¶

Versión Descripción
7.0.16, 7.1.2 Se añadió la opción 'e'.
5.2.6 Se añadieron las opciones 'c' y 'c+'
Ejemplos ¶

Ejemplo #1 Ejemplos de fopen()

<?php
$gestor = fopen("/home/rasmus/fichero.txt", "r");
$gestor = fopen("/home/rasmus/fichero.gif", "wb");
$gestor = fopen("http://www.example.com/", "r");
$gestor = fopen("ftp://user:password@example.com/fichero.txt", "w");
?>

Notas ¶

Advertencia

Cuando se usa SSL, Microsoft IIS violará el protocolo, cerrando la conexión sin mandar un indicador
close_notify. PHP avisará de esto con este mensaje "SSL: Fatal Protocol Error", cuando llegue al final de los
datos. Una solución a este problema es bajar el nivel de aviso de errores del sistema para que no incluya
advertencias. PHP pueden detectar servidores IIS con este problema cuando se abre un flujo usando https:// y
suprime la advertencia. Si usáis la función fsockopen() para crear un socket ssl://, tendréis que suprimir la
advertencia explicitamente.

Nota: Cuando el modo seguro está habilitado, PHP comprueba si el directorio en el cual el script
está operando tiene el mismo UID (propietario) que el script que está siendo ejecutado.

Nota:

Si está experimentando problemas al leer y escribir ficheros y está usando la versión de módulo de
servidor de PHP, asegúrese de que los ficheros y directorios que está usando sean accesibles por el
proceso del servidor.

Nota:

Esta función también podría tener éxito cuando filename es un directorio. Si no se está seguro de
que filename sea un fichero o un directorio, podría ser necesario utilzar la función is_dir() antes de
llamar a fopen().

Ver también ¶

Protocolos y Envolturas soportados

fclose() - Cierra un puntero a un archivo abierto
fgets() - Obtiene una línea desde el puntero a un fichero
fread() - Lectura de un fichero en modo binario seguro
fwrite() - Escritura de un archivo en modo binario seguro
fsockopen() - Abre una conexión vía sockets a Internet o a un dominio Unix
file() - Transfiere un fichero completo a un array
file_exists() - Comprueba si existe un fichero o directorio
is_readable() - Indica si un fichero existe y es legible
stream_set_timeout() - Establecer un perido de tiempo de espera en un flujo
popen() - Abre un proceso de un puntero a un fichero
stream_context_create() - Crear un contexto de flujo
umask() - Cambia la máscara de usuario actual
SplFileObject
 add a note

User Contributed Notes 42 notes

up
down
84
chapman at worldtakeoverindustries dot com ¶
7 years ago
Note - using fopen in 'w' mode will NOT update the modification time (filemtime) of a file like you
may expect. You may want to issue a touch() after writing and closing the file which update its
modification time. This may become critical in a caching situation, if you intend to keep your hair.
up
down
15
php at delhelsa dot com ¶
11 years ago
With php 5.2.5 on Apache 2.2.4, accessing files on an ftp server with fopen() or readfile() requires
an extra forwardslash if an absolute path is needed.

i.e., if a file called bullbes.txt is stored under /var/school/ on ftp server example.com and you're
trying to access it with user blossom and password buttercup, the url would be:

ftp://blossom:buttercup@example.com//var/school/bubbles.txt

Note the two forwardslashes. It looks like the second one is needed so the server won't interpret the
path as relative to blossom's home on townsville.
up
down
4
ideacode ¶
14 years ago
Note that whether you may open directories is operating system dependent. The following lines:

<?php
// Windows ($fh === false)
$fh = fopen('c:\\Temp', 'r');

// UNIX (is_resource($fh) === true)

$fh = fopen('/tmp', 'r');
?>

demonstrate that on Windows (2000, probably XP) you may not open a directory (the error is
"Permission Denied"), regardless of the security permissions on that directory.

On UNIX, you may happily read the directory format for the native filesystem.
up
down
0
k-gun at git dot io ¶
3 days ago
Seems not documented here but keep in mind, when $filename contains null byte (\0) then a TypeError
will be thrown with message such;
TypeError: fopen() expects parameter 1 to be a valid path, string given in ...
up
down
2
flobee ¶
13 years ago
download: i need a function to simulate a "wget url" and do not buffer the data in the memory to
avoid thouse problems on large files:
<?php
function download($file_source, $file_target) {
$rh = fopen($file_source, 'rb');
$wh = fopen($file_target, 'wb');
if ($rh===false || $wh===false) {
// error reading or opening file
return true;
}
while (!feof($rh)) {
if (fwrite($wh, fread($rh, 1024)) === FALSE) {
// 'Download error: Cannot write to file ('.$file_target.')';
return true;
}
}
fclose($rh);
fclose($wh);
// No error
return false;
}
?>
up
down
0
etters dot ayoub at gmail dot com ¶
1 year ago
This functions check recursive permissions and recursive existence parent folders, before creating a
folder. To avoid the generation of errors/warnings.

/**
* This functions check recursive permissions and recursive existence parent folders,
* before creating a folder. To avoid the generation of errors/warnings.
*
* @return bool
* true folder has been created or exist and writable.
* False folder not exist and cannot be created.
*/
function createWritableFolder($folder)
{
if (file_exists($folder)) {
// Folder exist.
return is_writable($folder);
}
// Folder not exit, check parent folder.
$folderParent = dirname($folder);
if($folderParent != '.' && $folderParent != '/' ) {
 if(!createWritableFolder(dirname($folder))) {
// Failed to create folder parent.
return false;
}
// Folder parent created.
}

if ( is_writable($folderParent) ) {
// Folder parent is writable.
if ( mkdir($folder, 0777, true) ) {
// Folder created.
return true;
}
// Failed to create folder.
}
// Folder parent is not writable.
return false;
}

/**
* This functions check recursive permissions and recursive existence parent folders,
* before creating a file/folder. To avoid the generation of errors/warnings.
*
* @return bool
* true has been created or file exist and writable.
* False file not exist and cannot be created.
*/
function createWritableFile($file)
{
// Check if conf file exist.
if (file_exists($file)) {
// check if conf file is writable.
return is_writable($file);
}

// Check if conf folder exist and try to create conf file.

if(createWritableFolder(dirname($file)) && ($handle = fopen($file, 'a'))) {
fclose($handle);
return true; // File conf created.
}
// Inaccessible conf file.
return false;
}
up
down
2
info at b1g dot de ¶
14 years ago
Simple class to fetch a HTTP URL. Supports "Location:"-redirections. Useful for servers with
allow_url_fopen=false. Works with SSL-secured hosts.

<?php
#usage:
$r = new HTTPRequest('http://www.example.com');
echo $r->DownloadToString();

class HTTPRequest
{
var $_fp; // HTTP socket
var $_url; // full URL
var $_host; // HTTP host
var $_protocol; // protocol (HTTP/HTTPS)
var $_uri; // request URI
var $_port; // port

// scan url
function _scan_url()
{
$req = $this->_url;

$pos = strpos($req, '://');

$this->_protocol = strtolower(substr($req, 0, $pos));

$req = substr($req, $pos+3);

$pos = strpos($req, '/');
if($pos === false)
$pos = strlen($req);
$host = substr($req, 0, $pos);

if(strpos($host, ':') !== false)

{
list($this->_host, $this->_port) = explode(':', $host);
}
else
{
$this->_host = $host;
$this->_port = ($this->_protocol == 'https') ? 443 : 80;
}

$this->_uri = substr($req, $pos);

if($this->_uri == '')
$this->_uri = '/';
}

// constructor
function HTTPRequest($url)
{
$this->_url = $url;
$this->_scan_url();
}

// download URL to string

function DownloadToString()
{
$crlf = "\r\n";

// generate request
$req = 'GET ' . $this->_uri . ' HTTP/1.0' . $crlf
 . 'Host: ' . $this->_host . $crlf
. $crlf;

// fetch
$this->_fp = fsockopen(($this->_protocol == 'https' ? 'ssl://' : '') . $this->_host, $this-
>_port);
fwrite($this->_fp, $req);
while(is_resource($this->_fp) && $this->_fp && !feof($this->_fp))
$response .= fread($this->_fp, 1024);
fclose($this->_fp);

// split header and body

$pos = strpos($response, $crlf . $crlf);
if($pos === false)
return($response);
$header = substr($response, 0, $pos);
$body = substr($response, $pos + 2 * strlen($crlf));

// parse headers
$headers = array();
$lines = explode($crlf, $header);
foreach($lines as $line)
if(($pos = strpos($line, ':')) !== false)
$headers[strtolower(trim(substr($line, 0, $pos)))] = trim(substr($line, $pos+1));

// redirection?
if(isset($headers['location']))
{
$http = new HTTPRequest($headers['location']);
return($http->DownloadToString($http));
}
else
{
return($body);
}
}
}
?>
up
down
0
kasper at webmasteren dot eu ¶
7 years ago
"Do not use the following reserved device names for the name of a file:
CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1,
LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9. Also avoid these names
followed immediately by an extension; for example, NUL.txt is not recommended.
For more information, see Namespaces"
it is a windows limitation.
see:
http://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx
up
down
0
sean downey ¶
11 years ago
when using ssl / https on windows i would get the error:
"Warning: fopen(https://example.com): failed to open stream: Invalid argument in someSpecialFile.php
on line 4344534"

This was because I did not have the extension "php_openssl.dll" enabled.

So if you have the same problem, goto your php.ini file and enable it :)
up
down
-1
apathetic012 at gmail dot com ¶
7 years ago
a variable $http_response_header is available when doing the fopen(). Which contains an array of the
response header.
up
down
-1
splogamurugan at gmail dot com ¶
8 years ago
While opening a file with multibyte data (Ex: données multi-octets), faced some issues with the
encoding. Got to know that it uses windows-1250. Used iconv to convert it to UTF-8 and it resolved
the issue.

<?php
function utf8_fopen_read($fileName) {
$fc = iconv('windows-1250', 'utf-8', file_get_contents($fileName));
$handle=fopen("php://memory", "rw");
fwrite($handle, $fc);
fseek($handle, 0);
return $handle;
}
?>

Example usage:

<?php
$fh = utf8_fopen_read("./tpKpiBundle.csv");
while (($data = fgetcsv($fh, 1000, ",")) !== false) {
foreach ($data as $value) {
echo $value . "<br />\n";
}
}
?>

Hope it helps.
up
down
0
ken dot gregg at rwre dot com ¶
15 years ago
PHP will open a directory if a path with no file name is supplied. This just bit me. I was not
checking the filename part of a concatenated string.
For example:

<?php
$fd = fopen('/home/mydir/' . $somefile, 'r');
?>

Will open the directory if $somefile = ''

If you attempt to read using the file handle you will get the binary directory contents. I tried
append mode and it errors out so does not seem to be dangerous.

This is with FreeBSD 4.5 and PHP 4.3.1. Behaves the same on 4.1.1 and PHP 4.1.2. I have not tested
other version/os combinations.
up
down
0
keithm at aoeex dot NOSPAM dot com ¶
18 years ago
I was working on a consol script for win32 and noticed a few things about it. On win32 it appears
that you can't re-open the input stream for reading, but rather you have to open it once, and read
from there on. Also, i don't know if this is a bug or what but it appears that fgets() reads until
the new line anyway. The number of characters returned is ok, but it will not halt reading and
return to the script. I don't know of a work around for this right now, but i'll keep working on it.

This is some code to work around the close and re-open of stdin.

<?php
function read($length='255'){
if (!isset($GLOBALS['StdinPointer'])){
$GLOBALS['StdinPointer']=fopen("php://stdin","r");
}
$line=fgets($GLOBALS['StdinPointer'],$length);
return trim($line);
}
echo "Enter your name: ";
$name=read();
echo "Enter your age: ";
$age=read();
echo "Hi $name, Isn't it Great to be $age years old?";
@fclose($StdinPointer);
?>
up
down
-1
owltech at larkandowl dot net ¶
8 years ago
[fopen note]

I have been trying unsuccessfully to upload and read a Mac OS file on a Linux server. Lots of records
show up a just one big using only the following:

<?php $fhandle = fopen($file, 'r'); ?>

or
<?php $fhandle = fopen($file, 'rb'); ?>

It does work, however, this way:

<?php
ini_set('auto_detect_line_endings', TRUE);
$fhandle = fopen($file, 'r');
?>
up
down
-1
php at richardneill dot org ¶
8 years ago
fopen() will block if the file to be opened is a fifo. This is true whether it's opened in "r" or "w"
mode. (See man 7 fifo: this is the correct, default behaviour; although Linux supports non-blocking
fopen() of a fifo, PHP doesn't).
The consequence of this is that you can't discover whether an initial fifo read/write would block
because to do that you need stream_select(), which in turn requires that fopen() has happened!
up
down
-1
anfragen at tsgames dot de ¶
9 years ago
Since the http-wrapper doesn't support stat() and so you can't use file_exists() for url's, you can
simply use a function like this:

<?php
function http_file_exists($url)
{
$f=@fopen($url,"r");
if($f)
{
fclose($f);
return true;
}
return false;
}
?>
up
down
-1
Luiz Miguel Axcar (lmaxcar at yahoo dot com dot br) ¶
14 years ago
If you are getting message "Warning: fopen(): URL file-access is disabled in the server
configuration", you can use function below to get the content from a local or remote file.

Function uses CURL lib, follow the link to get help: http://www.php.net/curl

<?php
/*
* @return string
* @param string $url
* @desc Return string content from a remote file
* @author Luiz Miguel Axcar (lmaxcar@yahoo.com.br)
*/

function get_content($url)
{
$ch = curl_init();

curl_setopt ($ch, CURLOPT_URL, $url);

curl_setopt ($ch, CURLOPT_HEADER, 0);

ob_start();

curl_exec ($ch);
curl_close ($ch);
$string = ob_get_contents();

ob_end_clean();

return $string;
}

#usage:
$content = get_content ("http://www.php.net");
var_dump ($content);
?>
up
down
-1
info at NOSPAMPLEASE dot c-eagle dot com ¶
12 years ago
If there is a file that´s excessively being rewritten by many different users, you´ll note that two
almost-simultaneously accesses on that file could interfere with each other. For example if there´s a
chat history containing only the last 25 chat lines. Now adding a line also means deleting the very
first one. So while that whole writing is happening, another user might also add a line, reading the
file, which, at this point, is incomplete, because it´s just being rewritten. The second user would
then rewrite an incomplete file and add its line to it, meaning: you just got yourself some data
loss!

If flock() was working at all, that might be the key to not let those interferences happen - but
flock() mostly won´t work as expected (at least that´s my experience on any linux webserver I´ve
tried), and writing own file-locking-functions comes with a lot of possible issues that would finally
result in corrupted files. Even though it´s very unlikely, it´s not impossible and has happened to me
already.

So I came up with another solution for the file-interference-problem:

1. A file that´s to be accessed will first be copied to a temp-file directory and its last
filemtime() is being stored in a PHP-variable. The temp-file gets a random filename, ensuring no
other process is able to interfere with this particular temp-file.
2. When the temp-file has been changed/rewritten/whatever, there´ll be a check whether the
filemtime() of the original file has been changed since we copied it into our temp-directory.
2.1. If filemtime() is still the same, the temp-file will just be renamed/moved to the original
filename, ensuring the original file is never in a temporary state - only the complete previous state
or the complete new state.
2.2. But if filemtime() has been changed while our PHP-process wanted to change its file, the temp-
file will just be deleted and our new PHP-fileclose-function will return a FALSE, enabling whatever
called that function to do it again (ie. upto 5 times, until it returns TRUE).

These are the functions I´ve written for that purpose:

<?php
$dir_fileopen = "../AN/INTERNAL/DIRECTORY/fileopen";

function randomid() {
return time().substr(md5(microtime()), 0, rand(5, 12));
}

function cfopen($filename, $mode, $overwriteanyway = false) {

global $dir_fileopen;
clearstatcache();
do {
$id = md5(randomid(rand(), TRUE));
$tempfilename = $dir_fileopen."/".$id.md5($filename);
} while(file_exists($tempfilename));
if (file_exists($filename)) {
$newfile = false;
copy($filename, $tempfilename);
}else{
$newfile = true;
}
$fp = fopen($tempfilename, $mode);
return $fp ? array($fp, $filename, $id, @filemtime($filename), $newfile, $overwriteanyway) :
false;
}

function cfwrite($fp,$string) { return fwrite($fp[0], $string); }

function cfclose($fp, $debug = "off") {

global $dir_fileopen;
$success = fclose($fp[0]);
clearstatcache();
$tempfilename = $dir_fileopen."/".$fp[2].md5($fp[1]);
if ((@filemtime($fp[1]) == $fp[3]) or ($fp[4]==true and !file_exists($fp[1])) or $fp[5]==true) {
rename($tempfilename, $fp[1]);
}else{
unlink($tempfilename);
if ($debug != "off") echo "While writing, another process accessed $fp[1]. To ensure file-
integrity, your changes were rejected.";
$success = false;
}
return $success;
}
?>

$overwriteanyway, one of the parameters for cfopen(), means: If cfclose() is used and the original
file has changed, this script won´t care and still overwrite the original file with the new temp
file. Anyway there won´t be any writing-interference between two PHP processes, assuming there can be
no absolute simultaneousness between two (or more) processes.
up
down
-1
dan at cleandns dot com ¶
15 years ago
<?php
#going to update last users counter script since
#aborting a write because a file is locked is not correct.

$counter_file = '/tmp/counter.txt';
clearstatcache();
ignore_user_abort(true); ## prevent refresh from aborting file operations and hosing file
if (file_exists($counter_file)) {
$fh = fopen($counter_file, 'r+');
while(1) {
if (flock($fh, LOCK_EX)) {
#$buffer = chop(fgets($fh, 2));
$buffer = chop(fread($fh, filesize($counter_file)));
$buffer++;
rewind($fh);
fwrite($fh, $buffer);
fflush($fh);
ftruncate($fh, ftell($fh));
flock($fh, LOCK_UN);
break;
}
}
}
else {
$fh = fopen($counter_file, 'w+');
fwrite($fh, "1");
$buffer="1";
}
fclose($fh);

print "Count is $buffer";

?>
up
down
-1
ceo at l-i-e dot com ¶
13 years ago
If you need fopen() on a URL to timeout, you can do like:
<?php
$timeout = 3;
$old = ini_set('default_socket_timeout', $timeout);
$file = fopen('http://example.com', 'r');
ini_set('default_socket_timeout', $old);
stream_set_timeout($file, $timeout);
stream_set_blocking($file, 0);
//the rest is standard
?>
up
down
-1
durwood at speakeasy dot NOSPAM dot net ¶
14 years ago
I couldn't for the life of me get a certain php script working when i moved my server to a new Fedora
4 installation. The problem was that fopen() was failing when trying to access a file as a URL
through apache -- even though it worked fine when run from the shell and even though the file was
readily readable from any browser. After trying to place blame on Apache, RedHat, and even my cat
and dog, I finally ran across this bug report on Redhat's website:

https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=164700

Basically the problem was SELinux (which I knew nothing about) -- you have to run the following
command in order for SELinux to allow php to open a web file:

/usr/sbin/setsebool httpd_can_network_connect=1

To make the change permanent, run it with the -P option:

/usr/sbin/setsebool -P httpd_can_network_connect=1

Hope this helps others out -- it sure took me a long time to track down the problem.
up
down
-2
Jem Tallon ¶
15 years ago
If you're using fopen to open a URL that requires authorization, you might need to force a HTTP/1.0
request for it since fopen won't support HTTP/1.1 requests. You can do that by setting your
user_agent to one that is known only to support HTTP/1.0 (most webservers will be configured to force
HTTP/1.0 for some browsers). Here's what worked for me:

<?php
$returned=URLopen("http://$username:$password@example.com");

function URLopen($url)
{
// Fake the browser type
ini_set('user_agent','MSIE 4\.0b2;');

$dh = fopen("$url",'r');
$result = fread($dh,8192);

return $result;
}
?>
up
down
-2
Pastix ¶
9 years ago
If fopen() has been disabled for security reasons, is possible a porting FROM:

<?php
$f=fopen($file,'rb');
$data='';
while(!feof($f))
$data.=fread($f,$size);
fclose($f);
?>

TO:

<?php
$data = file_get_contents($file); // (PHP 4 >= 4.3.0, PHP 5)
?>

and also a porting FROM:

<?php
$f = fopen($file,'wb');
fwrite($f,$content,strlen($content));
fclose($f);
?>

TO:

<?php
$f=file_put_contents($file, $content); // (PHP 5)
?>

For detail read the php manual.

up
down
-4
simon dot riget at gamil dot com ¶
6 years ago
Writing and reading on a serial port.

If you are unable or unwilling to install the serial device library for PHP, its still possible to
communicate through a serial port or USB device.

There are two issues to note:

- you must use a system call to set the port control options
- you must use NON blocking stream mode for reading (not for writing unless you use flow control)

<?php
// Set timeout to 500 ms
$timeout=microtime(true)+0.5;

// Set device controle options (See man page for stty)

exec("/bin/stty -F /dev/ttyS0 19200 sane raw cs8 hupcl cread clocal -echo -onlcr ");

// Open serial port

$fp=fopen("/dev/ttyS0","c+");
if(!$fp) die("Can't open device");

// Set blocking mode for writing

stream_set_blocking($fp,1);
fwrite($fp,"foo\n");

// Set non blocking mode for reading

stream_set_blocking($fp,0);
do{
// Try to read one character from the device
$c=fgetc($fp);

// Wait for data to arive

if($c === false){
usleep(50000);
continue;
}

$line.=$c;

}while($c!="\n" && microtime(true)<$timeout);

echo "Responce: $line";

?>
up
down
-2
lp dot soni at yahoo dot co dot in ¶
4 years ago
For the directory separators use the PHP constant DIRECTORY_SEPARATOR.
up
down
-1
petepostma-deletethis at gmail dot com ¶
2 years ago
The verbal descriptions take a while to read through to get a feel for the expected results for fopen
modes. This csv table can help break it down for quicker understanding to find which mode you are
looking for:

Mode,Creates,Reads,Writes,Pointer Starts,Truncates File,Notes,Purpose

r,,y,,beginning,,fails if file doesn't exist,basic read existing file
r+,,y,y,beginning,,fails if file doesn't exist,basic r/w existing file
w,y,,y,beginning+end,y,,"create, erase, write file"
w+,y,y,y,beginning+end,y,,"create, erase, write file with read option"
a,y,,y,end,,,"write from end of file, create if needed"
a+,y,y,y,end,,,"write from end of file, create if needed, with read options"
x,y,,y,beginning,,fails if file exists,"like w, but prevents over-writing an existing file"
x+,y,y,y,beginning,,fails if file exists,"like w+, but prevents over writing an existing file"
c,y,,y,beginning,,,open/create a file for writing without deleting current content
c+,y,y,y,beginning,,,"open/create a file that is read, and then written back down"
up
down
-2
nefertari at nefertari dot be ¶
14 years ago
Important note:
You have always to use the real path name for a file with the command fopen [for example:
fopen($filename, 'w')], never use a symbolic link, it will not work (unable to open $filename).
up
down
-2
Brad G ¶
9 years ago
While adding CFLAGS="-D_FILE_OFFSET_BITS=64" immediately before calling "./configure" on the PHP
source will enable support for using fopen() on large files (greater than 2 GB), note that -- if such
an installation of PHP is used in conjunction with Apache HTTPD [2.x], Apache will become completely
unresponsive even when not serving output from a PHP application.

In order to gain large file support for non-web applications while maintaining the operability of
Apache, consider making two distinct PHP installations: one with the above CFLAGS specified during
configuration (for non-web uses), and the other without this flag (for use with Apache).
up
down
-3
Antoine ¶
5 years ago
On a Windows webserver, when using fopen with a file path stored in a variable, PHP will return an
error if the variable isn't encoded in ASCII, which may be the case if the file file path is
retrieved from a database.

Possible workaround :
<?
$encoding = mb_detect_encoding($filePath);
$filePath = mb_convert_encoding($filePath, "ASCII", $encoding);
$filePath = str_replace("?", "", $filePath);
$filePath = addslashes($filePath);

if(file_exists($filePath)) {
echo "File Found.";
$handle = fopen($filePath, "r");
$fileContents = fread($handle, filesize($filePath));
fclose($handle);
if(!empty($fileContents)) {
echo "<pre>".$fileContents."</pre>";
}
}
else {
echo "File Not Found.";
}
?>
up
down
-2
RobNar ¶
16 years ago
This is an addendum to ibetyouare at home dot com's note about Apache directory permissions. If you
are on a shared host and cannot tweak Apache's permissions directives then you might try setting the
same thing in a .htaccess file. Failing that, if you are having trouble just creating files then
set the directory permissions to allow writing (for whatever directory the file is supposed to be in)
and include the following before fopen():
`touch /path/to/myfile/myfile.txt`;

That will usually create a new empty file that you can write to even when fopen fails. - PHP 4.3.0
up
down
-4
eyrie88 at gmail dot com ¶
9 years ago
Be aware that fopen($url) also respects HTTP status headers. If the URL responds with a 1xx, 4xx, or
5xx status code, you will get a "failed to open stream: HTTP request failed!", followed by the HTTP
status response. Same goes for file_get_contents($url)...
up
down
-4
rene ¶
9 years ago
if fopen() throws a E_WARNING "failed to open stream: HTTP request failed!" at you when opening a
valid URL that you know returns data, i advise you to do the following before calling
fopen($url,'r'):

<?php
ini_set ('user_agent', $_SERVER['HTTP_USER_AGENT']);
?>

or anyways, set that 'user_agent' with ini_set() to something valid.

thanks, pollita|at|php.net @ http://bugs.php.net/bug.php?id=22937#c64196 , for the clue to this

up
down
-4
admin at sellchain dot com ¶
14 years ago
TIP: If you are using fopen and fread to read HTTP or FTP or Remote Files, and experiencing some
performance issues such as stalling, slowing down and otherwise, then it's time you learned a thing
called cURL.

Performance Comparison:

10 per minute for fopen/fread for 100 HTTP files

2000 per minute for cURL for 2000 HTTP files

cURL should be used for opening HTTP and FTP files, it is EXTREMELY reliable, even when it comes to
performance.

I noticed when using too many scripts at the same time to download the data from the site I was
harvesting from, fopen and fread would go into deadlock. When using cURL i can open 50 windows,
running 10 URL's from each window, and getting the best performance possible.

Just a Tip :)
up
down
-3
marcovtwout ¶
3 years ago
If you are getting a "HTTP request failed!" without further details, the socket timeout could be
expired. This default to 60 seconds. See stream_set_timeout().
up
down
-2
etters dot ayoub at gmail dot com ¶
1 year ago
function checks if file exist, if not it will be created, if we have permission, without generate a
warning
/**
* Check if folder exist and writable.
* If not exist try to create it one writable.
*
* @return bool
* true folder has been created or exist and writable.
* False folder not exist and cannot be created.
*/
function createWritableFolder($folder)
{
if($folder != '.' && $folder != '/' ) {
createWritableFolder(dirname($folder));
}
if (file_exists($folder)) {
return is_writable($folder);
}

return is_writable($folder) && mkdir($folder, 0777, true);

}

/**
* Check if the file existe and writable.
* if is exist try to create it.
*
* @return bool
* true has been created or file exist and writable.
* False file not exist and cannot be created.
*/
function createWritableFile($file)
{
// Check if conf file exist.
if (file_exists($file)) {
// check if conf file is writable.
return is_writable($file);
}

// Check if conf folder exist and try to create conf file.

if(createWritableFolder(dirname($file)) && ($handle = fopen($file, 'a'))) {
fclose($handle);
return true; // File conf created.
}
// Inaccessible conf file.
return false;
}
up
down
-4
php at themastermind1 dot com ¶
18 years ago
I have found that I can do fopen("COM1:", "r+"); to open the comport in windows. You have to make
sure the comport isn't already open or you will get a permission denied.

I am still playing around with this but you have to somehow flush what you send to the comport if you
are trying to communicate realtime with a device.
up
down
-5
sergiopaternoster at tiscali dot it ¶
15 years ago
If you want to open large files (more than 2GB) that's what I did and it works: you should recompile
your php with the CFLAGS="-D_FILE_OFFSET_BITS=64" ./configure etc... This tells to your compiler (I
tested only gcc on PHP-4.3.4 binary on Linux and Solaris) to make the PHP parser binary large file
aware. This way fopen() will not give you the "Value too large for defined data type" error message.
God bless PHP
ciao
Sergio Paternoster
up
down
-4
Anonymous ¶
17 years ago
Note that if specifying the optional 'b' (binary) mode, it appears that it cannot be the first letter
for some unaccountable reason. In other words, "br" doesn't work, while "rb" is ok!
up
down
-6
Thomas Candrian tc_ at gmx dot ch ¶
14 years ago
With this it isn't possible to get data from another port than 80 (and 443) - at least for me.
Because of that I've made this function who gets data from every port you want using HTTP:

<?php;
function getcontent($server, $port, $file)
{
$cont = "";
$ip = gethostbyname($server);
$fp = fsockopen($ip, $port);
if (!$fp)
{
return "Unknown";
}
else
{
$com = "GET $file HTTP/1.1\r\nAccept: */*\r\nAccept-Language: de-ch\r\nAccept-Encoding: gzip,
deflate\r\nUser-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0)\r\nHost:
$server:$port\r\nConnection: Keep-Alive\r\n\r\n";
fputs($fp, $com);
while (!feof($fp))
 {
$cont .= fread($fp, 500);
}
fclose($fp);
$cont = substr($cont, strpos($cont, "\r\n\r\n") + 4);
return $cont;
}
}
echo getcontent("www.myhost.com", "81", "/"));
?>

Works fine for me. Had to do this especially for a shoutcast server, which only delivered the HTML-
file if the user-agent was given.
up
down
-4
richard dot quadling at carval dot co dot uk ¶
15 years ago
The issue involving some sites requiring a valid user-agent string when using fopen can easily be
resolved by setting the user_agent string in the PHP.INI file.

If you do not have access to the PHP.INI file, then the use of

ini_set('user_agent','Mozilla: (compatible; Windows XP)');

should also work.

The actual agent string is up to you. If you want to identify to the sites that you are using PHP ...

ini_set('user_agent','PHP');

would do.

Regards,

Richard Quadling.
up
down
-6
unshift at yahoo dot com ¶
16 years ago
It seems that fopen() errors when you attempt opening a url starting with HTTP:// as opposed to
http:// - it is case sensitive. In 4.3.1 anyway..."HTTP://", by not matching "http://" will tell the
wrapper to look locally. From the looks of the source, the same goes for HTTPS vs https, etc.
up
down
-4
David Spector ¶
1 year ago
The manual doesn't make it crystal-clear that fopen in write mode will not create a new file in the
Include Path, even if there is only one directory in the Include Path. The Include Path is for
searching, which means for reading files only.
add a note
Funciones del Sistema de Archivos
basename
chgrp
chmod
chown
clearstatcache
copy
delete
dirname
disk_free_space
disk_total_space
diskfreespace
fclose
feof
fflush
fgetc
fgetcsv
fgets
fgetss
file_exists
file_get_contents
file_put_contents
file
fileatime
filectime
filegroup
fileinode
filemtime
fileowner
fileperms
filesize
filetype
flock
fnmatch
fopen
fpassthru
fputcsv
fputs
fread
fscanf
fseek
fstat
ftell
ftruncate
fwrite
glob
is_dir
is_executable
is_file
is_link
is_readable
is_uploaded_file
is_writable
is_writeable
 lchgrp
lchown
link
linkinfo
lstat
mkdir
move_uploaded_file
parse_ini_file
parse_ini_string
pathinfo
pclose
popen
readfile
readlink
realpath_cache_get
realpath_cache_size
realpath
rename
rewind
rmdir
set_file_buffer
stat
symlink
tempnam
tmpfile
touch
umask
unlink

Copyright © 2001-2019 The PHP Group

My PHP.net
Contact
Other PHP.net sites
Privacy policy