Ошибка file put contents

<?php
function file_force_contents($dir, $contents){
$parts = explode('/', $dir);
$file = array_pop($parts);
$dir = '';
foreach($parts as $part)
if(!is_dir($dir .= "/$part")) mkdir($dir);
file_put_contents("$dir/$file", $contents);
}
?>

function path_put_contents($filePath, $contents, $flags = 0) {

if (! is_dir($dir = implode('/', explode('/', $filePath, -1))))
mkdir($dir, 0777, true);
file_put_contents($filePath, $contents, $flags);
}

Benchmark below:

file_put_contents() for 1,000,000 writes - average of 3 benchmarks:

real 0m3.932s
user 0m2.487s
sys 0m1.437s

fopen() fwrite() for 1,000,000 writes, fclose() - average of 3 benchmarks:

real 0m2.265s
user 0m1.819s
sys 0m0.445s

<?php
function file_force_contents( $fullPath, $contents, $flags = 0 ){
$parts = explode( '/', $fullPath );
array_pop( $parts );
$dir = implode( '/', $parts );

if( !

is_dir( $dir ) )
mkdir( $dir, 0777, true );file_put_contents( $fullPath, $contents, $flags );
}file_force_contents( ROOT.'/newpath/file.txt', 'message', LOCK_EX );
?>

<?php

/* set the FTP hostname */

$user = "test";

$pass = "myFTP";

$host = "example.com";

$file = "test.txt";

$hostname = $user . ":" . $pass . "@" . $host . "/" . $file;
/* the file content */

$content = "this is just a test.";
/* create a stream context telling PHP to overwrite the file */

$options = array('ftp' => array('overwrite' => true));

$stream = stream_context_create($options);
/* and finally, put the contents */

file_put_contents($hostname, $content, 0, $stream);

?>

i.e. in concurrent scenarios file_get_contents may return empty if you don't wrap it like this:

<?php
$myfile=fopen('test.txt','rt');
flock($myfile,LOCK_SH);
$read=file_get_contents('test.txt');
fclose($myfile);
?>

If you have code that does a file_get_contents on a file, changes the string, then re-saves using file_put_contents, you better be sure to do this correctly or your file will randomly wipe itself out.

<?phpfunction file_put_contents_atomically($filename, $data, $flags = 0, $context = null) {
if (file_put_contents($filename."~", $data, $flags, $context) === strlen($contents)) {
return rename($filename."~",$filename,$context);
}

@

unlink($filename."~", $context);
return FALSE;
}?>

If you want to emulate this function in PHP4, you need to return the bytes written as well as support for arrays, flags.

I can only figure out the FILE_APPEND flag and array support. If I could figure out "resource context" and the other flags, I would include those too.

<?

define('FILE_APPEND', 1);
function file_put_contents($n, $d, $flag = false) {
$mode = ($flag == FILE_APPEND || strtoupper($flag) == 'FILE_APPEND') ? 'a' : 'w';
$f = @fopen($n, $mode);
if ($f === false) {
return 0;
} else {
if (is_array($d)) $d = implode($d);
$bytes_written = fwrite($f, $d);
fclose($f);
return $bytes_written;
}
}

?>

if (strpos($dir, "../") === 0)
$dir = str_replace("..", substr(__DIR__, 0, strrpos(__DIR__, "/")), $dir);

More information about using this function without upgrading your version of PHP can be found on the below link:

http://pear.php.net/package/PHP_Compat

<?php

$host = '*****';

$usr = '*****';

$pwd = '**********';

$local_file = './orderXML/order200.xml';

$ftp_path = 'order200.xml';

$conn_id = ftp_connect($host, 21) or die ("Cannot connect to host");

ftp_pasv($resource, true);

ftp_login($conn_id, $usr, $pwd) or die("Cannot login");

// perform file upload

ftp_chdir($conn_id, '/public_html/abc/');

$upload = ftp_put($conn_id, $ftp_path, $local_file, FTP_ASCII);

if($upload) { $ftpsucc=1; } else { $ftpsucc=0; }

// check upload status:

print (!$upload) ? 'Cannot upload' : 'Upload complete';

print "\n";

// close the FTP stream

ftp_close($conn_id);

?>

public static function file_force_contents($dir, $contents){
$parts = explode('/', $dir);
$file = array_pop($parts);
$dir = '';

foreach($parts as $part) {
if (! is_dir($dir .= "{$part}/")) mkdir($dir);
}

return file_put_contents("{$dir}{$file}", $contents);
}

i have updated code of "TrentTompkins at gmail dot com". thanks
<?php
/**
* @param string $filename <p>file name including folder.
* example :: /path/to/file/filename.ext or filename.ext</p>
* @param string $data <p> The data to write.
* </p>
* @param int $flags same flags used for file_put_contents.
* more info: http://php.net/manual/en/function.file-put-contents.php
* @return bool <b>TRUE</b> file created succesfully <br> <b>FALSE</b> failed to create file.
*/
function file_force_contents($filename, $data, $flags = 0){
if(!is_dir(dirname($filename)))
mkdir(dirname($filename).'/', 0777, TRUE);
return file_put_contents($filename, $data,$flags);
}
// usagefile_force_contents('test1.txt','test1 content'); // test1.txt createdfile_force_contents('test2/test2.txt','test2 content');
// test2/test2.txt created "test2" folder. file_force_contents('~/test3/test3.txt','test3 content');
// /path/to/user/directory/test3/test3.txt created "test3" folder in user directory (check on linux "ll ~/ | grep test3").
?>

__DIR__ is your friend.

If you really want an extra line ending at the end of a file when writing with file_put_contents(), you must append an extra PHP_EOL to the end of the line as follows.

<?php
$a_str = array("these","are","new","lines");
$contents = implode(PHP_EOL, $a_str);
$contents .= PHP_EOL . PHP_EOL;
file_put_contents("newfile.txt", $contents);
print("|$contents|");
?>

You can see that when you print $contents you get two extra line endings, but if you view the file newfile.txt, you only get one.

Keep in mind that they're not all that efficient. You must have a file called counter.txt with the initial value of 0.

For a text hit counter:
<?php
$counter = file_get_contents("counter.txt"); $counter++; file_put_contents("counter.txt", $counter); echo $counter;
?>

Or a graphic hit counter:
<?php
$counter = file_get_contents("counter.txt"); $counter++; file_put_contents("counter.txt", $counter); for($i = 0; $i < strlen($counter); $i++) echo "<img src=\"counter/".substr($counter, $i, 1).".gif\" alt=\"".substr($counter, $i, 1)."\" />";
?>

<?php
if ( !function_exists('file_put_contents') && !defined('FILE_APPEND') ) {
...
}
?>

Also, if the file could not be accessed for writing, the function should return boolean false, not 0. An error is different from 0 bytes written, in this case.

$from = 'Windows-1252';
$to = 'UTF-8';

$content = file_get_contents($this->path());

file_put_contents($this->path(), mb_convert_encoding($content, $to, $from));

where "$this->path()" has the path of the file... Using this the file is converted from Windows-1252 to UTF-8.

With this you can import it with mysqlimport with no problems.

A common situation is that the $filename argument is built from two variables:
file_put_contents($path . $file, $content);

Say that $path = 'path/to' and $file = 'file.txt': you see that $path lacks its ending "/", so the resulting full path is 'path/tofile.txt'.

Then you look at 'path/to' and don't see any 'file.txt', although no warning or notice was thrown!
And may be (like for me :D) it'll take time before you realize that a bad 'tofile.txt' was created in the *parent* directory of the one where you were looking for your file.

Usage from a Linux command line: ./scriptname specifieddirectory searchString replaceString

#!/usr/bin/php
<?php
$argc = $_SERVER['argc'];
$argv = $_SERVER['argv'];

if(

$argc != 4)
{
echo "This command replaces a search string with a replacement string\n for the contents of all files in a directory hierachy\n";
echo "command usage: $argv[0] directory searchString replaceString\n";
echo "\n";
exit;
}
?><?phpif (!function_exists('file_put_contents')) {
function file_put_contents($filename, $data) {
$f = @fopen($filename, 'w');
if (!$f) {
return false;
} else {
$bytes = fwrite($f, $data);
fclose($f);
return $bytes;
}
}
}

function

get_file_contents($filename)/* Returns the contents of file name passed

*/

{
if (!function_exists('file_get_contents'))
{
$fhandle = fopen($filename, "r");
$fcontents = fread($fhandle, filesize($filename));
fclose($fhandle);
}
else
{
$fcontents = file_get_contents($filename);
}
return $fcontents;
}
?><?phpfunction openFileSearchAndReplace($parentDirectory, $searchFor, $replaceWith)
{
//echo "debug here- line 1a\n";
//echo "$parentDirectory\n";
//echo "$searchFor\n";
//echo "$replaceWith\n";if ($handle = opendir("$parentDirectory")) {
while (false !== ($file = readdir($handle))) {
if (($file != "." && $file != "..") && !is_dir($file)) {
chdir("$parentDirectory"); //to make sure you are always in right directory
// echo "$file\n";
$holdcontents = file_get_contents($file);
$holdcontents2 = str_replace($searchFor, $replaceWith, $holdcontents);
file_put_contents($file, $holdcontents2);
// echo "debug here- line 1\n";
// echo "$file\n";}
if(is_dir($file) && ($file != "." && $file != ".."))
{
$holdpwd = getcwd();
//echo "holdpwd = $holdpwd \n";
$newdir = "$holdpwd"."/$file";
//echo "newdir = $newdir \n"; //for recursive call
openFileSearchAndReplace($newdir, $searchFor, $replaceWith);
//echo "debug here- line 2\n";
//echo "$file\n";
}
}
closedir($handle);
}
}$parentDirectory2 = $argv[1];
$searchFor2 = $argv[2];
$replaceWith2 = $argv[3];//Please do not edit below to keep the rights to this script
//Free license, if contents below this line is not edited
echo "REPLACED\n'$searchFor2' with '$replaceWith2' recursively through directory listed below\nFor all files that current user has write permissions for\nDIRECTORY: '$parentDirectory2'\n";
echo "command written by Kolapo Akande :) all rights reserved :)\n";$holdpwd = getcwd();
//echo "$holdpwd\n";
chdir($parentDirectory2);
openFileSearchAndReplace($parentDirectory2, $searchFor2, $replaceWith2);
exit;
?>

hope you enjoy.

<?phpfunction ftp_put_contents($fpc_path_and_name, $fpc_content) {//Temporary folder in the server
$cfg_temp_folder = str_replace("//", "/", $_SERVER['DOCUMENT_ROOT']."/_temp/");//Link to FTP
$cfg_ftp_server = "ftp://ftp.com";//FTP username
$cfg_user = "user";//FTP password
$cfg_pass = "password";//Document Root of FTP
$cfg_document_root = "DOCUMENT ROOT OF FTP";//Link to the website
$cfg_site_link = "Link to the website";//Check if conteins slash on the path of the file
$cotains_slash = strstr($fpc_path_and_name, "/");//Get filename and paths
if ($cotains_slash) {
$fpc_path_and_name_array = explode("/", $fpc_path_and_name);
$fpc_file_name = end($fpc_path_and_name_array);
}
else {
$fpc_file_name = $fpc_path_and_name;
}//Create local temp dir
if (!file_exists($cfg_temp_folder)) {
if (!mkdir($cfg_temp_folder, 0777)) {
echo "Unable to generate a temporary folder on the local server - $cfg_temp_folder.<br />";
die();
}
}//Create local file in temp dir
if (!file_put_contents(str_replace("//", "/", $cfg_temp_folder.$fpc_file_name), $fpc_content)) {
echo "Unable to generate the file in the temporary location - ".str_replace("//", "/", $cfg_temp_folder.$fpc_file_name).".<br />";
die();
}//Connection to the FTP Server
$fpc_ftp_conn = ftp_connect("$cfg_ftp_server");//Check connection
if (!$fpc_ftp_conn) {
echo "Could not connect to server <b>$cfg_ftp_server</b>.<br />";
die();
}
else {// login
// check username and password
if (!ftp_login($fpc_ftp_conn, "$cfg_user", "$cfg_pass")) {
echo "User or password.<br />";
die();
}
else {//Document Root
if (!ftp_chdir($fpc_ftp_conn, $cfg_document_root)) {
echo "Error to set Document Root.<br />";
die();
}//Check if there are folders to create
if ($cotains_slash) {//Check if have folders and is not just the file name
if (count($fpc_path_and_name_array) > 1) {//Remove last array
$fpc_remove_last_array = array_pop($fpc_path_and_name_array);//Checks if there slashs on the path
if (substr($fpc_path_and_name,0,1) == "/") {
$fpc_remove_first_array = array_shift($fpc_path_and_name_array);
}//Create each folder on ftp
foreach ($fpc_path_and_name_array as $fpc_ftp_path) {
if (!@ftp_chdir($fpc_ftp_conn, $fpc_ftp_path)) {
if (!ftp_mkdir($fpc_ftp_conn, $fpc_ftp_path)) {
echo "Error creating directory $fpc_ftp_path.<br />";
}
else {
if (!ftp_chdir($fpc_ftp_conn, $fpc_ftp_path)) {
echo "Error go to the directory $fpc_ftp_path.<br />";
}
}
}
}
}
else {

}
}

//Check upload file
if (!ftp_put($fpc_ftp_conn, $fpc_file_name, str_replace("//", "/", $cfg_temp_folder.$fpc_file_name), FTP_ASCII)) {
echo "File upload <b>$fpc_path_and_name</b> failed!<br />";
die();
}
else {
if (!unlink(str_replace("//", "/", $cfg_temp_folder.$fpc_file_name))) {
echo "Error deleting temporary file.<br />";
die();
}
else {
echo "File upload <a href='$cfg_site_link".str_replace("//", "/", "/$fpc_path_and_name")."'><b>$cfg_site_link".str_replace("//", "/", "/$fpc_path_and_name")."</a></b> successfully performed.<br />";
}
}//Close connection to FTP server
ftp_close($fpc_ftp_conn);
}
}
}#Sample$content_file = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">
<html xmlns=\"http://www.w3.org/1999/xhtml\">
<head>
<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />
<title>Title</title>
</head>
<body>
<p>Test</p>
</body>
</html>";ftp_put_contents("test.php", $content_file);
?>

There are still obvious security holes here, but for most applications it should be reasonably safe if implemented for brief periods in a counterintuitive spot. (Nobody says you have to make a PHP file for that purpose; you can tack it on anywhere, so long as it is at the beginning of a file.)

<?php
$random1 = 'randomly_generated_string';
$random2 = 'another_randomly_generated_string';
$target_file = 'file_to_edit.php';
$this_file = 'the_current_file.php';

if (

$_REQUEST[$random1] === $random2) {
if (isset($_POST['content']))
file_put_contents($target_file, get_magic_quotes_qpc() ? stripslashes($_POST['content']) : $_POST['content']);

die(

'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<title>Editing...</title>
</head>
<body>
<form method="post" action="' . $this_file . '" />
<input type="hidden" name="' . $random1 . '" value="' . $random2 . '" />
<textarea name="content" rows="50" cols="100">' . file_get_contents($target_file) . '</textarea><br />
<input type="submit" value="Save Changes" />
</form>
</body>
</html>');
}
?>

Then simply browse to hxxp://www.example.com/{$this_file}?{$random1}={$random2}, with the appropriate values substituted for each bracketed variable. Please note that this code assumes the target file to be world writable (-rw-rw-rw- or 666) and will fail to save properly without error if it is not.

Once again, this is by no means secure or permanent, but as a quick fix for brief edits to noncritical files it should be sufficient, and its small size is a definite bonus.

if (!

function file_force_contents($filename, $data, $per = 0755, $flags = 0) {
$fn = "";
if(substr($filename, 0, 1) === "/") $fn .= "/";
$parts = explode("/", $filename);
$file = array_pop($parts);

foreach($parts as $part) {
if(!is_dir($fn .= "$part")) mkdir($fn, $per, true);
$fn .= "/";
}

file_put_contents($fn.$file, $data, $flags);
}

Since you're not adding anything to the file,

<?php
function updateFile($filename) {
if (!file_exists($filename)) return;
touch($filename);
}
?>

<?phpclass Logger{

protected

$file;

protected

$content;

protected

$writeFlag;

protected

$endRow;

public function

__construct($file,$endRow="\n",$writeFlag=FILE_APPEND) { $this->file=$file;$this->writeFlag=$writeFlag;$this->endRow=$endRow;

}

public function

AddRow($content="",$newLines=1){

for (

$m=0;$m<$newLines;$m++)
{$newRow .= $this->endRow;

}

$this->content .= $content . $newRow;

}

public function

Commit(){

return

file_put_contents($this->file,$this->content,$this->writeFlag);

}

public function

LogError($error,$newLines=1)
{
if ($error!=""){$this->AddRow($error,$newLines);
echo $error;

}

}

}

$logFileDirectoryAndName="/yourDirectory/yourFileName.xxx";$logger = new Logger($logFileDirectoryAndName);$logger->AddRow("Your Log Message");#log a system error and echo a message
$logger->LogError(mysql_error($conn));$logger->Commit();
?>

As a work around, you can consider trying the following code to do a file write (fwrite) inside of a file lock.

Play with the $overwriting= setting to switch from simply appending to completely overwriting.

<?php
// Tested in PHP7.0.18$trackErrors = ini_get('track_errors');
ini_set('track_errors', 1);$filename="c:/temp/test.txt";

if ( !

file_exists($filename) ) {
touch($filename);
}$mode="r+";
$fh=fopen($filename, $mode);
if ( ! $fh ) {
echo "<LI style='color:red'>Failed to open $filename in $mode";
die();
}

if (

1==1 ) {
flock($fh, LOCK_EX);

if (

1==1 ) {
if (filesize($filename) > 0) {
$txt = fread($fh, filesize($filename));
echo "BEFORE:<OL>$txt</OL>";
}
else {
$txt = "empty";
}$txt = "<LI>Date is now " . gmdate("Y-m-d H:i:s", time());

echo

"<HR>WRITING:<OL>";
if ( 1==1 ) {$overwrite = false;
if ($overwrite) {
echo "(Overwrite)<BR><BR>";
ftruncate($fh, 0);
// ftruncate is here as rewind will move the pointer
// to the beginning of the file and allow overwrite,
// but it will not remove existing content that
// extends beyond the length of the new write
rewind($fh);
}
else {
echo "(Appending)<BR><BR>";
}

if (

fwrite($fh, $txt) == FALSE) {
echo "<LI style='color:red'>Failed to write to $filename";
die();
}
else {
echo "$txt";
}
fflush($fh);

}
echo

"</OL>";
}
flock($fh, LOCK_UN);
}
fclose($fh);// -------------------------------------------------------------------echo "<HR>AFTER:<OL>";
if ( 1==2 ) {
// I've noticed that this block fails to pick up the newly
// written content when run with fread, but does work with
// the fgets logic below - possibly there is caching going on.
$mode = "r";
$fh2 = fopen($filename, $mode);
$contents = fread($fh2, filesize($filename));
echo "$contents";
fclose($fh2);
}
else {
$fh3 = fopen($filename, "r");
while (!feof($fh3)) {
$line = fgets($fh3);
echo $line;
}
fclose($fh3);
}
echo "</OL>";

echo

"<HR>Fin";
?>

<?php
$myFile = 'test.txt';
$myContent = 'I love PHP'; file_put_contents($myFile, utf8_encode($myContent));
?>

You must check yourself using return value.
<?php
$url = 'https://monsite.fr/image.png';
$size = filesize($url);
$written = file_put_contents('image.png', fopen($url, 'r'));
if ($size === false || $size != $written) {
die('Download failed');
}
?>

<?php

$myFile = 'test.txt';

$myContent = 'I love PHP';
file_put_contents($myFile, "\xEF\xBB\xBF".$myContent);

?>

$data = ''
$size = file_put_contents($filename, $data, FILE_APPEND);
if ($size == FALSE)
{
echo "error writing file"
}

Code will give error when $data is an empty string even using == operator.

Hope it helps somebody...

<?php

$error

[] = 'some error';
$error[] = 'some error 2';

@

file_put_contents('log.txt',date('c')."\n".implode("\n", $error),FILE_APPEND);?>