fileperms
Returns the file’s permissions as a numeric mode. Lower bits of this mode are the same as the permissions expected by chmod() , however on most platforms the return value will also include information on the type of file given as filename . The examples below demonstrate how to test the return value for specific permissions and file types on POSIX systems, including Linux and macOS.
For local files, the specific return value is that of the st_mode member of the structure returned by the C library’s stat() function. Exactly which bits are set can vary from platform to platform, and looking up your specific platform’s documentation is recommended if parsing the non-permission bits of the return value is required.
Returns false on failure.
Errors/Exceptions
Upon failure, an E_WARNING is emitted.
Examples
Example #1 Display permissions as an octal value
echo substr ( sprintf ( ‘%o’ , fileperms ( ‘/tmp’ )), — 4 );
echo substr ( sprintf ( ‘%o’ , fileperms ( ‘/etc/passwd’ )), — 4 );
?>
The above example will output:
Example #2 Display full permissions
switch ( $perms & 0xF000 ) case 0xC000 : // socket
$info = ‘s’ ;
break;
case 0xA000 : // symbolic link
$info = ‘l’ ;
break;
case 0x8000 : // regular
$info = ‘r’ ;
break;
case 0x6000 : // block special
$info = ‘b’ ;
break;
case 0x4000 : // directory
$info = ‘d’ ;
break;
case 0x2000 : // character special
$info = ‘c’ ;
break;
case 0x1000 : // FIFO pipe
$info = ‘p’ ;
break;
default: // unknown
$info = ‘u’ ;
>
The above example will output:
Notes
Note: The results of this function are cached. See clearstatcache() for more details.
As of PHP 5.0.0, this function can also be used with some URL wrappers. Refer to Supported Protocols and Wrappers to determine which wrappers support stat() family of functionality.
See Also
- chmod() — Changes file mode
- is_readable() — Tells whether a file exists and is readable
- stat() — Gives information about a file
User Contributed Notes 9 notes
Don’t use substr, use bit operator
decoct ( fileperms ( $file ) & 0777 ); // return «755» for example
?>
If you want to compare permission
0755 === ( fileperms ( $file ) & 0777 );
?>
This may not be immediately apparent to some, but you can use octdec( $octal_value ) to match the permissions retrieved by file perms
//assumes file has 2770 permissions
$perm = fileperms ( __FILE__ );
$bit = «102770» ;
printf ( «%s\n» , octdec ( $bit ) );
printf ( «%s\n» , $perm );
An easy way to calculate fileperms to chmod is this:
Displays 666 or 777 (depends on chmod set).
Displays 0666 or 0777 and refers immediately to the number set with chmod();
Windows has a very different file permission model to Unix and integrates them only minimally.
Here’s how Windows calculates the bitmask.
u+w/g+w/o+w is set based on whether the file has the read only flag.
u+x/g+x/o+x is set based on whether $filename is an inherently executable file (e.g. bat) or a directory.
Windows isn’t integrating its ACLs at all.
Here is a small function I made : http://pastebin.com/iKky8Vtu
I was bored and I thought it could be useful.
mixed mkperms( string $perms [, bool return_as_string = false [, string $filename ] ] )
Returns permissions given a string in literal format and a filename.
If the file name is omitted, the permissions that the function will return are based on 000-permissions.
If return_as_string is set to true, the result will be output as a 644 format string. Otherwise it will return a string converted to base-10 for chmod.
echo mkperms ( ‘u+r’ , true ), «\n» ; // 400
echo mkperms ( ‘u+rwx,g+rw,o+x’ , true ), «\n» ; // 761
touch ( ‘myfile.txt’ ); // Create a file with any permissions
chmod ( ‘myfile.txt’ , mkperms ( ‘u=rwx,g=x,o=rw’ )); // myfile.txt is now at -rwx—xrw-
// Make a file and give it full permissions
touch ( ‘somefile.txt’ );
chmod ( ‘somefile.txt’ , 0777 );
echo mkperms ( ‘g-w,o-rw’ , true , ‘somefile.txt’ ); // 751
echo mkperms ( ‘u=rwx,g-r,o=-‘ , true , ‘somefile.txt’ ); // 730
// This way you can apply permissions to files
chmod ( ‘somefile.txt’ , mkperms ( ‘u=rwx,g-r,o=-‘ , false , ‘somefile.txt’ )); // somefile.txt is now at -rwx-wx—
?>
PS : sorry I had to put it on pastebin, or else it just made the note way too long.
A small function for the last 3 digits (777/755 ect.)
function getFilePermission ( $file ) $length = strlen ( decoct ( fileperms ( $file )))- 3 ;
return substr ( decoct ( fileperms ( $file )), $length );
>
?>
Since the output of decoct( fileperms(‘.’) ) is of the form: 40644
It seems the previous example is wrong, instead you should understand:
To get permissions formatted as «644»:
echo substr ( decoct ( fileperms ( ‘.’ ) ), 2 );
?>
To get permissions formatted as «0644»:
echo substr ( decoct ( fileperms ( ‘.’ ) ), 1 );
?>
On Linux (not tested on Windows), if you want a chmod-like permissions, you can use this function:
function file_perms ( $file , $octal = false )
if(! file_exists ( $file )) return false ;
return substr ( decoct ( $perms ), $cut );
>
?>
Using it:
$ touch foo.bar
$ chmod 0754 foo.bar
echo file_perms ( ‘foo.bar’ ); // prints: 754
echo file_perms ( ‘foo.bar’ , true ); // prints 0754
?>
PHP File Permissions
Summary: in this tutorial, you will learn how to deal with PHP file permissions, including checking and changing file permissions.
File permissions specify what a user can do with a file, e.g., reading, writing, or executing it. Notice that PHP automatically grants appropriate permissions behind the scenes.
For example, if you create a new file for writing, PHP automatically grants the read and write permissions.
PHP provides some useful functions for checking and changing the file permissions.
Checking file permissions
PHP has three handy functions that check file permissions:
- is_readable() function returns true if the file exists and is readable; otherwise, it returns false .
- is_writable() function returns true if the file exists and is writable; otherwise, it returns false .
- is_executable() function returns true if the file exists and executable; otherwise, it returns false .
Let’s take a look at the following example:
$filename = 'readme.txt'; $functions = [ 'is_readable', 'is_writable', 'is_executable' ]; foreach ($functions as $f) < echo $f($filename) ? 'The file ' . $filename . $f : ''; >Code language: HTML, XML (xml)Besides those functions, PHP also provides the fileperms() function that returns an integer, which represents the permissions set on a particular file. For example:
$permissions = fileperms('readme.txt'); echo substr(sprintf('%o', $permissions), -4); //0666Code language: HTML, XML (xml)Changing file permissions
To change the file permission or mode, you use the chmod() function:
chmod ( string $filename , int $permissions ) : boolCode language: PHP (php)The chmod() function has two parameters:
- $filename is the file that you want to change the permissions.
- $permissions parameter consists of three octal number components that specify access restrictions for the owner, the user group in which the owner is in, and everyone else in this sequence.
The chmod() function returns true on success or false on failure.
The permissions argument is represented by an octal number that contains three digits:
- The first digit specifies what the owner of the file can read, write, or execute the file.
- The second digit specifies what the user group in which the owner is in can read, write, or execute the file.
- The third digit specifies what everyone else can read, write, or execute the file.
The following table illustrates the value of each digit that represents the access permission for particular users ( owner, user group, or everyone else) :
| Value | Permission |
|---|---|
| 0 | cannot read, write or execute |
| 1 | can only execute |
| 2 | can only write |
| 3 | can write and execute |
| 4 | can only read |
| 5 | can read and execute |
| 6 | can read and write |
| 7 | can read, write and execute |
The following example sets permission that the only owner can read and write a file, everyone else only can read the file:
$filename = './readme.txt'; chmod($filename, 0644);Code language: HTML, XML (xml)Notice that we put 0 before 644 to instruct PHP to treat it as an octal number.
Summary
- Use the is_readable() , is_writable() , is_executable() to check if a file exists and readable, writable, and executable.
- Use the chmod() function to set permissions for a file.