Wordpress 2.7.1
[autoinstalls/wordpress.git] / wp-admin / includes / class-wp-filesystem-direct.php
1 <?php
2 /**
3  * WordPress Direct Filesystem.
4  *
5  * @package WordPress
6  * @subpackage Filesystem
7  */
8
9 /**
10  * WordPress Filesystem Class for direct PHP file and folder manipulation.
11  *
12  * @since 2.5
13  * @package WordPress
14  * @subpackage Filesystem
15  * @uses WP_Filesystem_Base Extends class
16  */
17 class WP_Filesystem_Direct  extends WP_Filesystem_Base {
18         var $permission = null;
19         var $errors = array();
20         function WP_Filesystem_Direct($arg) {
21                 $this->method = 'direct';
22                 $this->errors = new WP_Error();
23                 $this->permission = umask();
24         }
25         function connect() {
26                 return true;
27         }
28         function setDefaultPermissions($perm) {
29                 $this->permission = $perm;
30         }
31         function get_contents($file) {
32                 return @file_get_contents($file);
33         }
34         function get_contents_array($file) {
35                 return @file($file);
36         }
37         function put_contents($file, $contents, $mode = false, $type = '') {
38                 if ( ! ($fp = @fopen($file, 'w' . $type)) )
39                         return false;
40                 @fwrite($fp, $contents);
41                 @fclose($fp);
42                 $this->chmod($file,$mode);
43                 return true;
44         }
45         function cwd() {
46                 return @getcwd();
47         }
48         function chdir($dir) {
49                 return @chdir($dir);
50         }
51         function chgrp($file, $group, $recursive = false) {
52                 if( ! $this->exists($file) )
53                         return false;
54                 if( ! $recursive )
55                         return @chgrp($file, $group);
56                 if( ! $this->is_dir($file) )
57                         return @chgrp($file, $group);
58                 //Is a directory, and we want recursive
59                 $file = trailingslashit($file);
60                 $filelist = $this->dirlist($file);
61                 foreach($filelist as $filename)
62                         $this->chgrp($file . $filename, $group, $recursive);
63
64                 return true;
65         }
66         function chmod($file, $mode = false, $recursive = false) {
67                 if( ! $mode )
68                         $mode = $this->permission;
69                 if( ! $this->exists($file) )
70                         return false;
71                 if( ! $recursive )
72                         return @chmod($file,$mode);
73                 if( ! $this->is_dir($file) )
74                         return @chmod($file, $mode);
75                 //Is a directory, and we want recursive
76                 $file = trailingslashit($file);
77                 $filelist = $this->dirlist($file);
78                 foreach($filelist as $filename)
79                         $this->chmod($file . $filename, $mode, $recursive);
80
81                 return true;
82         }
83         function chown($file, $owner, $recursive = false) {
84                 if( ! $this->exists($file) )
85                         return false;
86                 if( ! $recursive )
87                         return @chown($file, $owner);
88                 if( ! $this->is_dir($file) )
89                         return @chown($file, $owner);
90                 //Is a directory, and we want recursive
91                 $filelist = $this->dirlist($file);
92                 foreach($filelist as $filename){
93                         $this->chown($file . '/' . $filename, $owner, $recursive);
94                 }
95                 return true;
96         }
97         function owner($file) {
98                 $owneruid = @fileowner($file);
99                 if( ! $owneruid )
100                         return false;
101                 if( ! function_exists('posix_getpwuid') )
102                         return $owneruid;
103                 $ownerarray = posix_getpwuid($owneruid);
104                 return $ownerarray['name'];
105         }
106         function getchmod($file) {
107                 return @fileperms($file);
108         }
109         function group($file) {
110                 $gid = @filegroup($file);
111                 if( ! $gid )
112                         return false;
113                 if( ! function_exists('posix_getgrgid') )
114                         return $gid;
115                 $grouparray = posix_getgrgid($gid);
116                 return $grouparray['name'];
117         }
118
119         function copy($source, $destination, $overwrite = false) {
120                 if( ! $overwrite && $this->exists($destination) )
121                         return false;
122                 return copy($source, $destination);
123         }
124
125         function move($source, $destination, $overwrite = false) {
126                 //Possible to use rename()?
127                 if( $this->copy($source, $destination, $overwrite) && $this->exists($destination) ){
128                         $this->delete($source);
129                         return true;
130                 } else {
131                         return false;
132                 }
133         }
134
135         function delete($file, $recursive = false) {
136                 $file = str_replace('\\', '/', $file); //for win32, occasional problems deleteing files otherwise
137
138                 if( $this->is_file($file) )
139                         return @unlink($file);
140                 if( ! $recursive && $this->is_dir($file) )
141                         return @rmdir($file);
142
143                 //At this point its a folder, and we're in recursive mode
144                 $file = trailingslashit($file);
145                 $filelist = $this->dirlist($file, true);
146
147                 $retval = true;
148                 if( is_array($filelist) ) //false if no files, So check first.
149                         foreach($filelist as $filename => $fileinfo)
150                                 if( ! $this->delete($file . $filename, $recursive) )
151                                         $retval = false;
152
153                 if( ! @rmdir($file) )
154                         return false;
155                 return $retval;
156         }
157
158         function exists($file) {
159                 return @file_exists($file);
160         }
161
162         function is_file($file) {
163                 return @is_file($file);
164         }
165
166         function is_dir($path) {
167                 return @is_dir($path);
168         }
169
170         function is_readable($file) {
171                 return @is_readable($file);
172         }
173
174         function is_writable($file) {
175                 return @is_writable($file);
176         }
177
178         function atime($file) {
179                 return @fileatime($file);
180         }
181
182         function mtime($file) {
183                 return @filemtime($file);
184         }
185         function size($file) {
186                 return @filesize($file);
187         }
188
189         function touch($file, $time = 0, $atime = 0){
190                 if($time == 0)
191                         $time = time();
192                 if($atime == 0)
193                         $atime = time();
194                 return @touch($file, $time, $atime);
195         }
196
197         function mkdir($path, $chmod = false, $chown = false, $chgrp = false){
198                 if( ! $chmod)
199                         $chmod = $this->permission;
200
201                 if( ! @mkdir($path, $chmod) )
202                         return false;
203                 if( $chown )
204                         $this->chown($path, $chown);
205                 if( $chgrp )
206                         $this->chgrp($path, $chgrp);
207                 return true;
208         }
209
210         function rmdir($path, $recursive = false) {
211                 //Currently unused and untested, Use delete() instead.
212                 if( ! $recursive )
213                         return @rmdir($path);
214                 //recursive:
215                 $filelist = $this->dirlist($path);
216                 foreach($filelist as $filename => $det) {
217                         if ( '/' == substr($filename, -1, 1) )
218                                 $this->rmdir($path . '/' . $filename, $recursive);
219                         @rmdir($filename);
220                 }
221                 return @rmdir($path);
222         }
223
224         function dirlist($path, $incdot = false, $recursive = false) {
225                 if( $this->is_file($path) ) {
226                         $limitFile = basename($path);
227                         $path = dirname($path);
228                 } else {
229                         $limitFile = false;
230                 }
231                 if( ! $this->is_dir($path) )
232                         return false;
233
234                 $ret = array();
235                 $dir = @dir($path);
236                 if ( ! $dir )
237                         return false;
238                 while (false !== ($entry = $dir->read()) ) {
239                         $struc = array();
240                         $struc['name'] = $entry;
241
242                         if( '.' == $struc['name'] || '..' == $struc['name'] )
243                                 continue; //Do not care about these folders.
244                         if( '.' == $struc['name'][0] && !$incdot)
245                                 continue;
246                         if( $limitFile && $struc['name'] != $limitFile)
247                                 continue;
248
249                         $struc['perms']         = $this->gethchmod($path.'/'.$entry);
250                         $struc['permsn']        = $this->getnumchmodfromh($struc['perms']);
251                         $struc['number']        = false;
252                         $struc['owner']         = $this->owner($path.'/'.$entry);
253                         $struc['group']         = $this->group($path.'/'.$entry);
254                         $struc['size']          = $this->size($path.'/'.$entry);
255                         $struc['lastmodunix']= $this->mtime($path.'/'.$entry);
256                         $struc['lastmod']   = date('M j',$struc['lastmodunix']);
257                         $struc['time']          = date('h:i:s',$struc['lastmodunix']);
258                         $struc['type']          = $this->is_dir($path.'/'.$entry) ? 'd' : 'f';
259
260                         if ( 'd' == $struc['type'] ) {
261                                 if( $recursive )
262                                         $struc['files'] = $this->dirlist($path . '/' . $struc['name'], $incdot, $recursive);
263                                 else
264                                         $struc['files'] = array();
265                         }
266
267                         $ret[ $struc['name'] ] = $struc;
268                 }
269                 $dir->close();
270                 unset($dir);
271                 return $ret;
272         }
273 }
274 ?>