|
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 $errors = null; |
|
19 /** |
|
20 * constructor |
|
21 * |
|
22 * @param $arg mixed ingored argument |
|
23 */ |
|
24 function WP_Filesystem_Direct($arg) { |
|
25 $this->method = 'direct'; |
|
26 $this->errors = new WP_Error(); |
|
27 } |
|
28 /** |
|
29 * connect filesystem. |
|
30 * |
|
31 * @return bool Returns true on success or false on failure (always true for WP_Filesystem_Direct). |
|
32 */ |
|
33 function connect() { |
|
34 return true; |
|
35 } |
|
36 /** |
|
37 * Reads entire file into a string |
|
38 * |
|
39 * @param $file string Name of the file to read. |
|
40 * @return string|bool The function returns the read data or false on failure. |
|
41 */ |
|
42 function get_contents($file) { |
|
43 return @file_get_contents($file); |
|
44 } |
|
45 /** |
|
46 * Reads entire file into an array |
|
47 * |
|
48 * @param $file string Path to the file. |
|
49 * @return array|bool the file contents in an array or false on failure. |
|
50 */ |
|
51 function get_contents_array($file) { |
|
52 return @file($file); |
|
53 } |
|
54 /** |
|
55 * Write a string to a file |
|
56 * |
|
57 * @param $file string Path to the file where to write the data. |
|
58 * @param $contents string The data to write. |
|
59 * @param $mode int (optional) The file permissions as octal number, usually 0644. |
|
60 * @param $type string (optional) Specifies additional type of access you require to the file. |
|
61 * @return bool False upon failure. |
|
62 */ |
|
63 function put_contents($file, $contents, $mode = false, $type = '') { |
|
64 if ( ! ($fp = @fopen($file, 'w' . $type)) ) |
|
65 return false; |
|
66 @fwrite($fp, $contents); |
|
67 @fclose($fp); |
|
68 $this->chmod($file, $mode); |
|
69 return true; |
|
70 } |
|
71 /** |
|
72 * Gets the current working directory |
|
73 * |
|
74 * @return string|bool the current working directory on success, or false on failure. |
|
75 */ |
|
76 function cwd() { |
|
77 return @getcwd(); |
|
78 } |
|
79 /** |
|
80 * Change directory |
|
81 * |
|
82 * @param $dir string The new current directory. |
|
83 * @return bool Returns true on success or false on failure. |
|
84 */ |
|
85 function chdir($dir) { |
|
86 return @chdir($dir); |
|
87 } |
|
88 /** |
|
89 * Changes file group |
|
90 * |
|
91 * @param $file string Path to the file. |
|
92 * @param $group mixed A group name or number. |
|
93 * @param $recursive bool (optional) If set True changes file group recursivly. Defaults to False. |
|
94 * @return bool Returns true on success or false on failure. |
|
95 */ |
|
96 function chgrp($file, $group, $recursive = false) { |
|
97 if ( ! $this->exists($file) ) |
|
98 return false; |
|
99 if ( ! $recursive ) |
|
100 return @chgrp($file, $group); |
|
101 if ( ! $this->is_dir($file) ) |
|
102 return @chgrp($file, $group); |
|
103 //Is a directory, and we want recursive |
|
104 $file = trailingslashit($file); |
|
105 $filelist = $this->dirlist($file); |
|
106 foreach ($filelist as $filename) |
|
107 $this->chgrp($file . $filename, $group, $recursive); |
|
108 |
|
109 return true; |
|
110 } |
|
111 /** |
|
112 * Changes filesystem permissions |
|
113 * |
|
114 * @param $file string Path to the file. |
|
115 * @param $mode int (optional) The permissions as octal number, usually 0644 for files, 0755 for dirs. |
|
116 * @param $recursive bool (optional) If set True changes file group recursivly. Defaults to False. |
|
117 * @return bool Returns true on success or false on failure. |
|
118 */ |
|
119 function chmod($file, $mode = false, $recursive = false) { |
|
120 if ( ! $this->exists($file) ) |
|
121 return false; |
|
122 |
|
123 if ( ! $mode ) { |
|
124 if ( $this->is_file($file) ) |
|
125 $mode = FS_CHMOD_FILE; |
|
126 elseif ( $this->is_dir($file) ) |
|
127 $mode = FS_CHMOD_DIR; |
|
128 else |
|
129 return false; |
|
130 } |
|
131 |
|
132 if ( ! $recursive ) |
|
133 return @chmod($file, $mode); |
|
134 if ( ! $this->is_dir($file) ) |
|
135 return @chmod($file, $mode); |
|
136 //Is a directory, and we want recursive |
|
137 $file = trailingslashit($file); |
|
138 $filelist = $this->dirlist($file); |
|
139 foreach ($filelist as $filename) |
|
140 $this->chmod($file . $filename, $mode, $recursive); |
|
141 |
|
142 return true; |
|
143 } |
|
144 /** |
|
145 * Changes file owner |
|
146 * |
|
147 * @param $file string Path to the file. |
|
148 * @param $owner mixed A user name or number. |
|
149 * @param $recursive bool (optional) If set True changes file owner recursivly. Defaults to False. |
|
150 * @return bool Returns true on success or false on failure. |
|
151 */ |
|
152 function chown($file, $owner, $recursive = false) { |
|
153 if ( ! $this->exists($file) ) |
|
154 return false; |
|
155 if ( ! $recursive ) |
|
156 return @chown($file, $owner); |
|
157 if ( ! $this->is_dir($file) ) |
|
158 return @chown($file, $owner); |
|
159 //Is a directory, and we want recursive |
|
160 $filelist = $this->dirlist($file); |
|
161 foreach ($filelist as $filename) { |
|
162 $this->chown($file . '/' . $filename, $owner, $recursive); |
|
163 } |
|
164 return true; |
|
165 } |
|
166 /** |
|
167 * Gets file owner |
|
168 * |
|
169 * @param $file string Path to the file. |
|
170 * @return string Username of the user. |
|
171 */ |
|
172 function owner($file) { |
|
173 $owneruid = @fileowner($file); |
|
174 if ( ! $owneruid ) |
|
175 return false; |
|
176 if ( ! function_exists('posix_getpwuid') ) |
|
177 return $owneruid; |
|
178 $ownerarray = posix_getpwuid($owneruid); |
|
179 return $ownerarray['name']; |
|
180 } |
|
181 /** |
|
182 * Gets file permissions |
|
183 * |
|
184 * FIXME does not handle errors in fileperms() |
|
185 * |
|
186 * @param $file string Path to the file. |
|
187 * @return string Mode of the file (last 4 digits). |
|
188 */ |
|
189 function getchmod($file) { |
|
190 return substr(decoct(@fileperms($file)),3); |
|
191 } |
|
192 function group($file) { |
|
193 $gid = @filegroup($file); |
|
194 if ( ! $gid ) |
|
195 return false; |
|
196 if ( ! function_exists('posix_getgrgid') ) |
|
197 return $gid; |
|
198 $grouparray = posix_getgrgid($gid); |
|
199 return $grouparray['name']; |
|
200 } |
|
201 |
|
202 function copy($source, $destination, $overwrite = false) { |
|
203 if ( ! $overwrite && $this->exists($destination) ) |
|
204 return false; |
|
205 return copy($source, $destination); |
|
206 } |
|
207 |
|
208 function move($source, $destination, $overwrite = false) { |
|
209 //Possible to use rename()? |
|
210 if ( $this->copy($source, $destination, $overwrite) && $this->exists($destination) ) { |
|
211 $this->delete($source); |
|
212 return true; |
|
213 } else { |
|
214 return false; |
|
215 } |
|
216 } |
|
217 |
|
218 function delete($file, $recursive = false) { |
|
219 if ( empty($file) ) //Some filesystems report this as /, which can cause non-expected recursive deletion of all files in the filesystem. |
|
220 return false; |
|
221 $file = str_replace('\\', '/', $file); //for win32, occasional problems deleteing files otherwise |
|
222 |
|
223 if ( $this->is_file($file) ) |
|
224 return @unlink($file); |
|
225 if ( ! $recursive && $this->is_dir($file) ) |
|
226 return @rmdir($file); |
|
227 |
|
228 //At this point its a folder, and we're in recursive mode |
|
229 $file = trailingslashit($file); |
|
230 $filelist = $this->dirlist($file, true); |
|
231 |
|
232 $retval = true; |
|
233 if ( is_array($filelist) ) //false if no files, So check first. |
|
234 foreach ($filelist as $filename => $fileinfo) |
|
235 if ( ! $this->delete($file . $filename, $recursive) ) |
|
236 $retval = false; |
|
237 |
|
238 if ( file_exists($file) && ! @rmdir($file) ) |
|
239 $retval = false; |
|
240 return $retval; |
|
241 } |
|
242 |
|
243 function exists($file) { |
|
244 return @file_exists($file); |
|
245 } |
|
246 |
|
247 function is_file($file) { |
|
248 return @is_file($file); |
|
249 } |
|
250 |
|
251 function is_dir($path) { |
|
252 return @is_dir($path); |
|
253 } |
|
254 |
|
255 function is_readable($file) { |
|
256 return @is_readable($file); |
|
257 } |
|
258 |
|
259 function is_writable($file) { |
|
260 return @is_writable($file); |
|
261 } |
|
262 |
|
263 function atime($file) { |
|
264 return @fileatime($file); |
|
265 } |
|
266 |
|
267 function mtime($file) { |
|
268 return @filemtime($file); |
|
269 } |
|
270 function size($file) { |
|
271 return @filesize($file); |
|
272 } |
|
273 |
|
274 function touch($file, $time = 0, $atime = 0) { |
|
275 if ($time == 0) |
|
276 $time = time(); |
|
277 if ($atime == 0) |
|
278 $atime = time(); |
|
279 return @touch($file, $time, $atime); |
|
280 } |
|
281 |
|
282 function mkdir($path, $chmod = false, $chown = false, $chgrp = false) { |
|
283 if ( ! $chmod ) |
|
284 $chmod = FS_CHMOD_DIR; |
|
285 |
|
286 if ( ! @mkdir($path) ) |
|
287 return false; |
|
288 $this->chmod($path, $chmod); |
|
289 if ( $chown ) |
|
290 $this->chown($path, $chown); |
|
291 if ( $chgrp ) |
|
292 $this->chgrp($path, $chgrp); |
|
293 return true; |
|
294 } |
|
295 |
|
296 function rmdir($path, $recursive = false) { |
|
297 //Currently unused and untested, Use delete() instead. |
|
298 if ( ! $recursive ) |
|
299 return @rmdir($path); |
|
300 //recursive: |
|
301 $filelist = $this->dirlist($path); |
|
302 foreach ($filelist as $filename => $det) { |
|
303 if ( '/' == substr($filename, -1, 1) ) |
|
304 $this->rmdir($path . '/' . $filename, $recursive); |
|
305 @rmdir($filename); |
|
306 } |
|
307 return @rmdir($path); |
|
308 } |
|
309 |
|
310 function dirlist($path, $include_hidden = true, $recursive = false) { |
|
311 if ( $this->is_file($path) ) { |
|
312 $limit_file = basename($path); |
|
313 $path = dirname($path); |
|
314 } else { |
|
315 $limit_file = false; |
|
316 } |
|
317 |
|
318 if ( ! $this->is_dir($path) ) |
|
319 return false; |
|
320 |
|
321 $dir = @dir($path); |
|
322 if ( ! $dir ) |
|
323 return false; |
|
324 |
|
325 $ret = array(); |
|
326 |
|
327 while (false !== ($entry = $dir->read()) ) { |
|
328 $struc = array(); |
|
329 $struc['name'] = $entry; |
|
330 |
|
331 if ( '.' == $struc['name'] || '..' == $struc['name'] ) |
|
332 continue; |
|
333 |
|
334 if ( ! $include_hidden && '.' == $struc['name'][0] ) |
|
335 continue; |
|
336 |
|
337 if ( $limit_file && $struc['name'] != $limit_file) |
|
338 continue; |
|
339 |
|
340 $struc['perms'] = $this->gethchmod($path.'/'.$entry); |
|
341 $struc['permsn'] = $this->getnumchmodfromh($struc['perms']); |
|
342 $struc['number'] = false; |
|
343 $struc['owner'] = $this->owner($path.'/'.$entry); |
|
344 $struc['group'] = $this->group($path.'/'.$entry); |
|
345 $struc['size'] = $this->size($path.'/'.$entry); |
|
346 $struc['lastmodunix']= $this->mtime($path.'/'.$entry); |
|
347 $struc['lastmod'] = date('M j',$struc['lastmodunix']); |
|
348 $struc['time'] = date('h:i:s',$struc['lastmodunix']); |
|
349 $struc['type'] = $this->is_dir($path.'/'.$entry) ? 'd' : 'f'; |
|
350 |
|
351 if ( 'd' == $struc['type'] ) { |
|
352 if ( $recursive ) |
|
353 $struc['files'] = $this->dirlist($path . '/' . $struc['name'], $include_hidden, $recursive); |
|
354 else |
|
355 $struc['files'] = array(); |
|
356 } |
|
357 |
|
358 $ret[ $struc['name'] ] = $struc; |
|
359 } |
|
360 $dir->close(); |
|
361 unset($dir); |
|
362 return $ret; |
|
363 } |
|
364 } |
|
365 ?> |