Copy php ошибка

function file_win_copy( $src, $dst ) {
shell_exec( 'COPY "'.$src.'" "'.$dst.'"');
return file_exists($dest);
}

<?php
if(!@copy('http://someserver.com/somefile.zip','./somefile.zip'))
{
$errors= error_get_last();
echo "COPY ERROR: ".$errors['type'];
echo "<br />\n".$errors['message'];
} else {
echo "File copied from remote!";
}
?>

I am using these for managing folders and zip archives for my website plugins.

<?php// removes files and non-empty directories
function rrmdir($dir) {
if (is_dir($dir)) {
$files = scandir($dir);
foreach ($files as $file)
if ($file != "." && $file != "..") rrmdir("$dir/$file");
rmdir($dir);
}
else if (file_exists($dir)) unlink($dir);
} // copies files and non-empty directories
function rcopy($src, $dst) {
if (file_exists($dst)) rrmdir($dst);
if (is_dir($src)) {
mkdir($dst);
$files = scandir($src);
foreach ($files as $file)
if ($file != "." && $file != "..") rcopy("$src/$file", "$dst/$file");
}
else if (file_exists($src)) copy($src, $dst);
}
?>

Cheers!

<?php

$srcfile

='C:\File\Whatever\Path\Joe.txt';
$dstfile='G:\Shared\Reports\Joe.txt';
mkdir(dirname($dstfile), 0777, true);
copy($srcfile, $dstfile);?>

That simple.

It demonstrates useful customizations of the request (such as setting a User-Agent and Referrer, often required by web sites), and how to download only files if the copy on the web site is newer than the local copy.

It further demonstrates the processing of response headers (if set by server) to determine the timestamp and file name. The file type is checked because some servers return a 200 OK return code with a textual "not found" page, instead of a proper 404 return code.

<?php
// $fURI: URL to a file located on a web server
// $target_file: Path to a local file if ( file_exists( $target_file ) ) {
$ifmodhdr = 'If-Modified-Since: '.date( "r", filemtime( $target_file ) )."\r\n";
}
else {
$ifmodhdr = '';
}// set request header for GET with referrer for modified files, that follows redirects
$arrRequestHeaders = array(
'http'=>array(
'method' =>'GET',
'protocol_version' =>1.1,
'follow_location' =>1,
'header'=> "User-Agent: Anamera-Feed/1.0\r\n" .
"Referer: $source\r\n" .
$ifmodhdr
)
);
$rc = copy( $fURI, $target_file, stream_context_create($arrRequestHeaders) );// HTTP request completed, preserve system error, if any
if( $rc ) {
if ( fclose( $rc ) ) {
unset( $err );
}
else {
$err = error_get_last();
}
}
else {
$err = error_get_last();
}// Parse HTTP Response Headers for HTTP Status, as well filename, type, date information
// Need to start from rear, to get last set of headers after possible sets of redirection headers
if ( $http_response_header ) {
for ( $i = sizeof($http_response_header) - 1; $i >= 0; $i-- ) {
if ( preg_match('@^http/\S+ (\S{3,}) (.+)$@i', $http_response_header[$i], $http_status) > 0 ) {
// HTTP Status header means we have reached beginning of response headers for last request
break;
}
elseif ( preg_match('@^(\S+):\s*(.+)\s*$@', $http_response_header[$i], $arrHeader) > 0 ) {
switch ( $arrHeader[1] ) {
case 'Last-Modified':
if ( !isset($http_content_modtime) ) {
$http_content_modtime = strtotime( $arrHeader[2] );
}
break;
case 'Content-Type':
if ( !isset($http_content_image_type) ) {
if ( preg_match('@^image/(\w+)@ims', $arrHeader[2], $arrTokens) > 0 ) {
if ( in_array(strtolower($arrTokens[1]), $arrValidTypes)) {
$http_content_image_type = $arrTokens[1];
break;
}
}
throw new Exception( "Error accessing file $fURI; invalid content type: $arrHeader[2]", 2);
}
break;
case 'Content-Disposition':
if ( !isset($http_content_filename) && preg_match('@filename\\s*=\\s*(?|"([^"]+)"|([\\S]+));?@ims', $arrHeader[2], $arrTokens) > 0 ) {
$http_content_filename = basename($arrTokens[1]);
}
break;
}
}
}
}

if (

$http_status ) {
// Make sure we have good HTTP Status
switch ( $http_status[1] ) {
case '200':
// SUCCESS: HTTP Status is "200 OK"
break;
case '304':
throw new Exception( "Remote file not newer: $fURI", $http_status[1] );
break;
case '404':
throw new Exception( "Remote file not found: $fURI", $http_status[1] );
break;
default:
throw new Exception( "HTTP Error, $http_status[2], accessing $fURI", $http_status[1] );
break;
}
}
elseif ( $err ) {
// Protocol / Communication error
throw new Exception( $err['message']/*."; Remote file: $fURI"*/, $err['type'] );
}
else {
// No HTTP status and no error
throw new customException( "Unknown HTTP response accessing $fURI: $http_response_header[0]", -1 );
}
?>

Notes:
1. Currently copy() does NOT appropriately handle the 304 response code. Instead of NOT performing a copy (possibly setting the RC), it will overwrite the target file with an zero length file.
2. There may be a problem accessing a list of remote files when HTTP 1.1 protocol is used. If you experience time-out errors, try the default 1.0 protocol version.

So, if you think to have files larger than 4 GiB, instead of doing:
copy($source,$destination);
it is much better to do something like:
exec("xcopy $source $destination");

I will check to see if this issue is valid also under Linux.
It depends on PHP not being compiled in 64 bit mode?

Note to do your own check to make sure the directory exists that you first call it on.

<?php

function recurse_copy($src,$dst) {

$dir = opendir($src);

@mkdir($dst);

while(false !== ( $file = readdir($dir)) ) {

if (( $file != '.' ) && ( $file != '..' )) {

if ( is_dir($src . '/' . $file) ) {

recurse_copy($src . '/' . $file,$dst . '/' . $file);

}

else {

copy($src . '/' . $file,$dst . '/' . $file);

}

}

}

closedir($dir);

}

?>

and for some copy is important so this is and simple function that do same as copy function effect

how smart php can help us l like php

<?php

function copyemz($file1,$file2){

$contentx =@file_get_contents($file1);

$openedfile = fopen($file2, "w");

fwrite($openedfile, $contentx);

fclose($openedfile);

if ($contentx === FALSE) {

$status=false;

}else $status=true;

return

$status;

}

?>

<?PHPfunction convertPath($path)
{
//split networkpath into parts
$parts = explode('\\',$path);
// convert each part to SJIS
foreach($parts as $index => $part)
{
$parts[$index] = iconv('UTF-8','SJIS//IGNORE',$part);
}
// put the network path back together
return implode('\\',$parts);
}$oldname = convertPath('c:/Temp/ほげほげ.pdf');
$newname = convertPath('\\\\PFSV0100\\DATA\\06：個人別\\333328_ほげほげ\\test_あいうえお.pdf');copy($oldname, $newname);
?>

There are however a number of characters that cannot be converted correctly like '②' and '﨑' because there are no SJIS equivalents.

In other words if I have a file named "Myfile.txt" and I overwrite it using copy with a file named "MyFile.txt" it will overwrite it but the filename will remain "Myfile.txt".

If this is a problem (as it was for me) use unlink to delete the existing file first.

<?php

exec('xcopy c:\\myfolder d:\\myfolder /e/i', $a, $a1);

?>



by executing this command, it will move folder along with all contents to destination.

-adnan

PS : It was very useful for me, hope you find it useful as well.

<?php

/**

* Copy file or folder from source to destination, it can do

* recursive copy as well and is very smart

* It recursively creates the dest file or directory path if there weren't exists

* Situtaions :

* - Src:/home/test/file.txt ,Dst:/home/test/b ,Result:/home/test/b -> If source was file copy file.txt name with b as name to destination

* - Src:/home/test/file.txt ,Dst:/home/test/b/ ,Result:/home/test/b/file.txt -> If source was file Creates b directory if does not exsits and copy file.txt into it

* - Src:/home/test ,Dst:/home/ ,Result:/home/test/** -> If source was directory copy test directory and all of its content into dest

* - Src:/home/test/ ,Dst:/home/ ,Result:/home/**-> if source was direcotry copy its content to dest

* - Src:/home/test ,Dst:/home/test2 ,Result:/home/test2/** -> if source was directoy copy it and its content to dest with test2 as name

* - Src:/home/test/ ,Dst:/home/test2 ,Result:->/home/test2/** if source was directoy copy it and its content to dest with test2 as name

* @todo

* - Should have rollback technique so it can undo the copy when it wasn't successful

* - Auto destination technique should be possible to turn off

* - Supporting callback function

* - May prevent some issues on shared enviroments : http://us3.php.net/umask

* @param $source //file or folder

* @param $dest ///file or folder

* @param $options //folderPermission,filePermission

* @return boolean

*/

function smartCopy($source, $dest, $options=array('folderPermission'=>0755,'filePermission'=>0755))

{

$result=false;

if (

is_file($source)) {

if ($dest[strlen($dest)-1]=='/') {

if (!file_exists($dest)) {

cmfcDirectory::makeAll($dest,$options['folderPermission'],true);

}

$__dest=$dest."/".basename($source);

} else {

$__dest=$dest;

}

$result=copy($source, $__dest);

chmod($__dest,$options['filePermission']);

} elseif(

is_dir($source)) {

if ($dest[strlen($dest)-1]=='/') {

if ($source[strlen($source)-1]=='/') {

//Copy only contents

} else {

//Change parent itself and its contents

$dest=$dest.basename($source);

@mkdir($dest);

chmod($dest,$options['filePermission']);

}

} else {

if ($source[strlen($source)-1]=='/') {

//Copy parent directory with new name and all its content

@mkdir($dest,$options['folderPermission']);

chmod($dest,$options['filePermission']);

} else {

//Copy parent directory with new name and all its content

@mkdir($dest,$options['folderPermission']);

chmod($dest,$options['filePermission']);

}

}
$dirHandle=opendir($source);

while($file=readdir($dirHandle))

{

if($file!="." && $file!="..")

{

if(!is_dir($source."/".$file)) {

$__dest=$dest."/".$file;

} else {

$__dest=$dest."/".$file;

}

//echo "$source/$file ||| $__dest<br />";

$result=smartCopy($source."/".$file, $__dest, $options);

}

}

closedir($dirHandle);

} else {

$result=false;

}

return $result;

}

?>

Attempting to use the function again in the same PHP script will return false and not move the file.

I ran into this when an image that was uploaded did not need resizing (smaller than a size threshold) and after moving the temporary upload to the "originals" directory, an attempt was made to again move the temporary file to another folder.

This behavior is understandable, but be careful - in this instance, I simply used copy() on the file that was already uploaded.

<?php
$output = shell_exec( " cp -r -a dir_source/* dir_dest 2>&1 " )
echo $output
?>

Of course you need to get all your permissions clear. You can do the necessary stuff to use variables.

You could also do this to create the destination directory:

<?php
shell_exec( " cp -r -a dir_source dir_dest 2>&1 " )
?>

This will create a new directory called "dir_dest" if it does not already exist. This is a bit risky though if your situation is ambiguous, and you want to continue to make backups etc, 'cause if you do it twice you end up with:

dir_destination/dir_source

to avoid that one could do something like:

<?php
shell_exec( " mkdir dir_dest; cp -r -a dir_source/* dir_dest 2>&1 " )
?>

Maybe someone can tell me when or why it would be better to use all that PHP code I see here.

Check if the user that PHP runs under have "X" permission on every directory of the file path.
It will need it to access the file

If your file is: /path/to/test-in.txt
You should have X permission on:

/path
/path/to
and read permission on /path/to/test-in.txt

Surprisingly stream_copy seamed to be slightly faster (at least in this specific context).

<?php

function stream_copy($src, $dest)

{

$fsrc = fopen($src,'r');

$fdest = fopen($dest,'w+');

$len = stream_copy_to_stream($fsrc,$fdest);

fclose($fsrc);

fclose($fdest);

return $len;

}

?>

Hopefully it will work for your situation. I'm using it in a web based file manager for my CMS.

<?php

define

('DS', DIRECTORY_SEPARATOR); // I always use this short form in my code.function copy_r( $path, $dest )
{
if( is_dir($path) )
{
@mkdir( $dest );
$objects = scandir($path);
if( sizeof($objects) > 0 )
{
foreach( $objects as $file )
{
if( $file == "." || $file == ".." )
continue;
// go on
if( is_dir( $path.DS.$file ) )
{
copy_r( $path.DS.$file, $dest.DS.$file );
}
else
{
copy( $path.DS.$file, $dest.DS.$file );
}
}
}
return true;
}
elseif( is_file($path) )
{
return copy($path, $dest);
}
else
{
return false;
}
}?>

It also tries to match the current name as neatly as possible:

foo.txt -> foo copy.txt -> foo copy 1.txt -> foo copy 2.txt [etc]

foo.bar.baz.jpg -> foo.bar.baz copy.jpg

foobar -> foobar copy -> foobar copy 1 [etc]

".txt" -> .txt copy, and "txt." -> txt. copy

file.longextension -> file.longextension copy

It keeps trying until it finds a name that is not yet taken in $list, or until it looped 500 times (change as needed).

If the renamed file becomes longer than max filename length, it starts chopping away at the end of the part before where it adds " copy": reallylong...filename.txt -> reallylong...filena copy.txt

<?php
// $orig = current name, of course

// $list = array of filenames in the target directory (if none given, it will still return a new name)

// $max = max length of filename

function duplicate_name($orig, $list = array(), $max = 64) {

$ext = '';

$counter = 0;

$list = (array) $list;

$max = (int) $max;

$newname = $orig;

do {

$name = $newname; # name in, newname out

if (preg_match('/ copy$| copy \d+$/', $name, $matches)) {

// don't even check for extension, name ends with " copy[ digits]"

// preg hereunder matches anything with at least one period in the middle and an extension of 1-5 characters

}elseif (preg_match('/(.+)\.([^.]{1,5})$/', $name, $parts)) {

// split to name & extension

list($name, $ext) = array($parts[1], $parts[2]);

}

if (preg_match('/ copy (\d+)$/', $name, $digits)) {

$newname = substr($name, 0, - strlen($digits[1])) . ($digits[1] + 1);

# $cutlen is only used for the bit at the end where it checks on max filename length

$cutlen = 6 + strlen($digits[1]+1); // ' copy ' + digits

}elseif(preg_match('/ copy$/', $name, $digits)) {

$newname = $name . ' 1';

$cutlen = 7; // ' copy' + ' 1'

}else{

$newname = $name . ' copy';

$cutlen = 5; // ' copy'

}

if ($ext) {

$newname .= '.' . $ext;

$cutlen += strlen($ext) + 1;

}

if ($max > 0) {

if (strlen($newname) > $max) {

$newname = substr($newname, 0, max($max - $cutlen, 0)) . substr($newname, -$cutlen);

if (strlen($newname) > $max) {echo "duplicate_name() error: Can't keep the new name under given max length.\n"; return false;}

}

}

if ($counter++ > 500) {echo "duplicate_name() error: Too many similarly named files or infinite while loop.\n"; return false;}

} while (in_array($newname, $list));

return $newname;

}
?>



*1) The Finder seems to check the extension vs a list of known extensions, this function considers it valid if it's 5 or fewer characters long.

ps. sorry for taking up so much space! :-)