Mercurial > hg > rc1

comparison vendor/pear/pear-core-minimal/src/System.php @ 0:1e000243b222

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
vanilla 1.3.3 distro, I hope
author Charlie Root
date Thu, 04 Jan 2018 15:50:29 -0500
parents
children 121a341ecb84
comparison
equal deleted inserted replaced
-1:000000000000 0:1e000243b222
1 <?php
2 /**
3 * File/Directory manipulation
4 *
5 * PHP versions 4 and 5
6 *
7 * @category pear
8 * @package System
9 * @author Tomas V.V.Cox <cox@idecnet.com>
10 * @copyright 1997-2009 The Authors
11 * @license http://opensource.org/licenses/bsd-license.php New BSD License
12 * @link http://pear.php.net/package/PEAR
13 * @since File available since Release 0.1
14 */
15
16 /**
17 * base class
18 */
19 require_once 'PEAR.php';
20 require_once 'Console/Getopt.php';
21
22 $GLOBALS['_System_temp_files'] = array();
23
24 /**
25 * System offers cross platform compatible system functions
26 *
27 * Static functions for different operations. Should work under
28 * Unix and Windows. The names and usage has been taken from its respectively
29 * GNU commands. The functions will return (bool) false on error and will
30 * trigger the error with the PHP trigger_error() function (you can silence
31 * the error by prefixing a '@' sign after the function call, but this
32 * is not recommended practice. Instead use an error handler with
33 * {@link set_error_handler()}).
34 *
35 * Documentation on this class you can find in:
36 * http://pear.php.net/manual/
37 *
38 * Example usage:
39 * if (!@System::rm('-r file1 dir1')) {
40 * print "could not delete file1 or dir1";
41 * }
42 *
43 * In case you need to to pass file names with spaces,
44 * pass the params as an array:
45 *
46 * System::rm(array('-r', $file1, $dir1));
47 *
48 * @category pear
49 * @package System
50 * @author Tomas V.V. Cox <cox@idecnet.com>
51 * @copyright 1997-2006 The PHP Group
52 * @license http://opensource.org/licenses/bsd-license.php New BSD License
53 * @version Release: @package_version@
54 * @link http://pear.php.net/package/PEAR
55 * @since Class available since Release 0.1
56 * @static
57 */
58 class System
59 {
60 /**
61 * returns the commandline arguments of a function
62 *
63 * @param string $argv the commandline
64 * @param string $short_options the allowed option short-tags
65 * @param string $long_options the allowed option long-tags
66 * @return array the given options and there values
67 */
68 public static function _parseArgs($argv, $short_options, $long_options = null)
69 {
70 if (!is_array($argv) && $argv !== null) {
71 /*
72 // Quote all items that are a short option
73 $av = preg_split('/(\A| )--?[a-z0-9]+[ =]?((?<!\\\\)((,\s*)|((?<!,)\s+))?)/i', $argv, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_OFFSET_CAPTURE);
74 $offset = 0;
75 foreach ($av as $a) {
76 $b = trim($a[0]);
77 if ($b{0} == '"' || $b{0} == "'") {
78 continue;
79 }
80
81 $escape = escapeshellarg($b);
82 $pos = $a[1] + $offset;
83 $argv = substr_replace($argv, $escape, $pos, strlen($b));
84 $offset += 2;
85 }
86 */
87
88 // Find all items, quoted or otherwise
89 preg_match_all("/(?:[\"'])(.*?)(?:['\"])|([^\s]+)/", $argv, $av);
90 $argv = $av[1];
91 foreach ($av[2] as $k => $a) {
92 if (empty($a)) {
93 continue;
94 }
95 $argv[$k] = trim($a) ;
96 }
97 }
98
99 return Console_Getopt::getopt2($argv, $short_options, $long_options);
100 }
101
102 /**
103 * Output errors with PHP trigger_error(). You can silence the errors
104 * with prefixing a "@" sign to the function call: @System::mkdir(..);
105 *
106 * @param mixed $error a PEAR error or a string with the error message
107 * @return bool false
108 */
109 protected static function raiseError($error)
110 {
111 if (PEAR::isError($error)) {
112 $error = $error->getMessage();
113 }
114 trigger_error($error, E_USER_WARNING);
115 return false;
116 }
117
118 /**
119 * Creates a nested array representing the structure of a directory
120 *
121 * System::_dirToStruct('dir1', 0) =>
122 * Array
123 * (
124 * [dirs] => Array
125 * (
126 * [0] => dir1
127 * )
128 *
129 * [files] => Array
130 * (
131 * [0] => dir1/file2
132 * [1] => dir1/file3
133 * )
134 * )
135 * @param string $sPath Name of the directory
136 * @param integer $maxinst max. deep of the lookup
137 * @param integer $aktinst starting deep of the lookup
138 * @param bool $silent if true, do not emit errors.
139 * @return array the structure of the dir
140 */
141 protected static function _dirToStruct($sPath, $maxinst, $aktinst = 0, $silent = false)
142 {
143 $struct = array('dirs' => array(), 'files' => array());
144 if (($dir = @opendir($sPath)) === false) {
145 if (!$silent) {
146 System::raiseError("Could not open dir $sPath");
147 }
148 return $struct; // XXX could not open error
149 }
150
151 $struct['dirs'][] = $sPath = realpath($sPath); // XXX don't add if '.' or '..' ?
152 $list = array();
153 while (false !== ($file = readdir($dir))) {
154 if ($file != '.' && $file != '..') {
155 $list[] = $file;
156 }
157 }
158
159 closedir($dir);
160 natsort($list);
161 if ($aktinst < $maxinst || $maxinst == 0) {
162 foreach ($list as $val) {
163 $path = $sPath . DIRECTORY_SEPARATOR . $val;
164 if (is_dir($path) && !is_link($path)) {
165 $tmp = System::_dirToStruct($path, $maxinst, $aktinst+1, $silent);
166 $struct = array_merge_recursive($struct, $tmp);
167 } else {
168 $struct['files'][] = $path;
169 }
170 }
171 }
172
173 return $struct;
174 }
175
176 /**
177 * Creates a nested array representing the structure of a directory and files
178 *
179 * @param array $files Array listing files and dirs
180 * @return array
181 * @static
182 * @see System::_dirToStruct()
183 */
184 protected static function _multipleToStruct($files)
185 {
186 $struct = array('dirs' => array(), 'files' => array());
187 settype($files, 'array');
188 foreach ($files as $file) {
189 if (is_dir($file) && !is_link($file)) {
190 $tmp = System::_dirToStruct($file, 0);
191 $struct = array_merge_recursive($tmp, $struct);
192 } else {
193 if (!in_array($file, $struct['files'])) {
194 $struct['files'][] = $file;
195 }
196 }
197 }
198 return $struct;
199 }
200
201 /**
202 * The rm command for removing files.
203 * Supports multiple files and dirs and also recursive deletes
204 *
205 * @param string $args the arguments for rm
206 * @return mixed PEAR_Error or true for success
207 * @static
208 * @access public
209 */
210 public static function rm($args)
211 {
212 $opts = System::_parseArgs($args, 'rf'); // "f" does nothing but I like it :-)
213 if (PEAR::isError($opts)) {
214 return System::raiseError($opts);
215 }
216 foreach ($opts[0] as $opt) {
217 if ($opt[0] == 'r') {
218 $do_recursive = true;
219 }
220 }
221 $ret = true;
222 if (isset($do_recursive)) {
223 $struct = System::_multipleToStruct($opts[1]);
224 foreach ($struct['files'] as $file) {
225 if (!@unlink($file)) {
226 $ret = false;
227 }
228 }
229
230 rsort($struct['dirs']);
231 foreach ($struct['dirs'] as $dir) {
232 if (!@rmdir($dir)) {
233 $ret = false;
234 }
235 }
236 } else {
237 foreach ($opts[1] as $file) {
238 $delete = (is_dir($file)) ? 'rmdir' : 'unlink';
239 if (!@$delete($file)) {
240 $ret = false;
241 }
242 }
243 }
244 return $ret;
245 }
246
247 /**
248 * Make directories.
249 *
250 * The -p option will create parent directories
251 * @param string $args the name of the director(y|ies) to create
252 * @return bool True for success
253 */
254 public static function mkDir($args)
255 {
256 $opts = System::_parseArgs($args, 'pm:');
257 if (PEAR::isError($opts)) {
258 return System::raiseError($opts);
259 }
260
261 $mode = 0777; // default mode
262 foreach ($opts[0] as $opt) {
263 if ($opt[0] == 'p') {
264 $create_parents = true;
265 } elseif ($opt[0] == 'm') {
266 // if the mode is clearly an octal number (starts with 0)
267 // convert it to decimal
268 if (strlen($opt[1]) && $opt[1]{0} == '0') {
269 $opt[1] = octdec($opt[1]);
270 } else {
271 // convert to int
272 $opt[1] += 0;
273 }
274 $mode = $opt[1];
275 }
276 }
277
278 $ret = true;
279 if (isset($create_parents)) {
280 foreach ($opts[1] as $dir) {
281 $dirstack = array();
282 while ((!file_exists($dir) || !is_dir($dir)) &&
283 $dir != DIRECTORY_SEPARATOR) {
284 array_unshift($dirstack, $dir);
285 $dir = dirname($dir);
286 }
287
288 while ($newdir = array_shift($dirstack)) {
289 if (!is_writeable(dirname($newdir))) {
290 $ret = false;
291 break;
292 }
293
294 if (!mkdir($newdir, $mode)) {
295 $ret = false;
296 }
297 }
298 }
299 } else {
300 foreach($opts[1] as $dir) {
301 if ((@file_exists($dir) || !is_dir($dir)) && !mkdir($dir, $mode)) {
302 $ret = false;
303 }
304 }
305 }
306
307 return $ret;
308 }
309
310 /**
311 * Concatenate files
312 *
313 * Usage:
314 * 1) $var = System::cat('sample.txt test.txt');
315 * 2) System::cat('sample.txt test.txt > final.txt');
316 * 3) System::cat('sample.txt test.txt >> final.txt');
317 *
318 * Note: as the class use fopen, urls should work also (test that)
319 *
320 * @param string $args the arguments
321 * @return boolean true on success
322 */
323 public static function &cat($args)
324 {
325 $ret = null;
326 $files = array();
327 if (!is_array($args)) {
328 $args = preg_split('/\s+/', $args, -1, PREG_SPLIT_NO_EMPTY);
329 }
330
331 $count_args = count($args);
332 for ($i = 0; $i < $count_args; $i++) {
333 if ($args[$i] == '>') {
334 $mode = 'wb';
335 $outputfile = $args[$i+1];
336 break;
337 } elseif ($args[$i] == '>>') {
338 $mode = 'ab+';
339 $outputfile = $args[$i+1];
340 break;
341 } else {
342 $files[] = $args[$i];
343 }
344 }
345 $outputfd = false;
346 if (isset($mode)) {
347 if (!$outputfd = fopen($outputfile, $mode)) {
348 $err = System::raiseError("Could not open $outputfile");
349 return $err;
350 }
351 $ret = true;
352 }
353 foreach ($files as $file) {
354 if (!$fd = fopen($file, 'r')) {
355 System::raiseError("Could not open $file");
356 continue;
357 }
358 while ($cont = fread($fd, 2048)) {
359 if (is_resource($outputfd)) {
360 fwrite($outputfd, $cont);
361 } else {
362 $ret .= $cont;
363 }
364 }
365 fclose($fd);
366 }
367 if (is_resource($outputfd)) {
368 fclose($outputfd);
369 }
370 return $ret;
371 }
372
373 /**
374 * Creates temporary files or directories. This function will remove
375 * the created files when the scripts finish its execution.
376 *
377 * Usage:
378 * 1) $tempfile = System::mktemp("prefix");
379 * 2) $tempdir = System::mktemp("-d prefix");
380 * 3) $tempfile = System::mktemp();
381 * 4) $tempfile = System::mktemp("-t /var/tmp prefix");
382 *
383 * prefix -> The string that will be prepended to the temp name
384 * (defaults to "tmp").
385 * -d -> A temporary dir will be created instead of a file.
386 * -t -> The target dir where the temporary (file|dir) will be created. If
387 * this param is missing by default the env vars TMP on Windows or
388 * TMPDIR in Unix will be used. If these vars are also missing
389 * c:\windows\temp or /tmp will be used.
390 *
391 * @param string $args The arguments
392 * @return mixed the full path of the created (file|dir) or false
393 * @see System::tmpdir()
394 */
395 public static function mktemp($args = null)
396 {
397 static $first_time = true;
398 $opts = System::_parseArgs($args, 't:d');
399 if (PEAR::isError($opts)) {
400 return System::raiseError($opts);
401 }
402
403 foreach ($opts[0] as $opt) {
404 if ($opt[0] == 'd') {
405 $tmp_is_dir = true;
406 } elseif ($opt[0] == 't') {
407 $tmpdir = $opt[1];
408 }
409 }
410
411 $prefix = (isset($opts[1][0])) ? $opts[1][0] : 'tmp';
412 if (!isset($tmpdir)) {
413 $tmpdir = System::tmpdir();
414 }
415
416 if (!System::mkDir(array('-p', $tmpdir))) {
417 return false;
418 }
419
420 $tmp = tempnam($tmpdir, $prefix);
421 if (isset($tmp_is_dir)) {
422 unlink($tmp); // be careful possible race condition here
423 if (!mkdir($tmp, 0700)) {
424 return System::raiseError("Unable to create temporary directory $tmpdir");
425 }
426 }
427
428 $GLOBALS['_System_temp_files'][] = $tmp;
429 if (isset($tmp_is_dir)) {
430 //$GLOBALS['_System_temp_files'][] = dirname($tmp);
431 }
432
433 if ($first_time) {
434 PEAR::registerShutdownFunc(array('System', '_removeTmpFiles'));
435 $first_time = false;
436 }
437
438 return $tmp;
439 }
440
441 /**
442 * Remove temporary files created my mkTemp. This function is executed
443 * at script shutdown time
444 */
445 public static function _removeTmpFiles()
446 {
447 if (count($GLOBALS['_System_temp_files'])) {
448 $delete = $GLOBALS['_System_temp_files'];
449 array_unshift($delete, '-r');
450 System::rm($delete);
451 $GLOBALS['_System_temp_files'] = array();
452 }
453 }
454
455 /**
456 * Get the path of the temporal directory set in the system
457 * by looking in its environments variables.
458 * Note: php.ini-recommended removes the "E" from the variables_order setting,
459 * making unavaible the $_ENV array, that s why we do tests with _ENV
460 *
461 * @return string The temporary directory on the system
462 */
463 public static function tmpdir()
464 {
465 if (OS_WINDOWS) {
466 if ($var = isset($_ENV['TMP']) ? $_ENV['TMP'] : getenv('TMP')) {
467 return $var;
468 }
469 if ($var = isset($_ENV['TEMP']) ? $_ENV['TEMP'] : getenv('TEMP')) {
470 return $var;
471 }
472 if ($var = isset($_ENV['USERPROFILE']) ? $_ENV['USERPROFILE'] : getenv('USERPROFILE')) {
473 return $var;
474 }
475 if ($var = isset($_ENV['windir']) ? $_ENV['windir'] : getenv('windir')) {
476 return $var;
477 }
478 return getenv('SystemRoot') . '\temp';
479 }
480 if ($var = isset($_ENV['TMPDIR']) ? $_ENV['TMPDIR'] : getenv('TMPDIR')) {
481 return $var;
482 }
483 return realpath('/tmp');
484 }
485
486 /**
487 * The "which" command (show the full path of a command)
488 *
489 * @param string $program The command to search for
490 * @param mixed $fallback Value to return if $program is not found
491 *
492 * @return mixed A string with the full path or false if not found
493 * @author Stig Bakken <ssb@php.net>
494 */
495 public static function which($program, $fallback = false)
496 {
497 // enforce API
498 if (!is_string($program) || '' == $program) {
499 return $fallback;
500 }
501
502 // full path given
503 if (basename($program) != $program) {
504 $path_elements[] = dirname($program);
505 $program = basename($program);
506 } else {
507 $path = getenv('PATH');
508 if (!$path) {
509 $path = getenv('Path'); // some OSes are just stupid enough to do this
510 }
511
512 $path_elements = explode(PATH_SEPARATOR, $path);
513 }
514
515 if (OS_WINDOWS) {
516 $exe_suffixes = getenv('PATHEXT')
517 ? explode(PATH_SEPARATOR, getenv('PATHEXT'))
518 : array('.exe','.bat','.cmd','.com');
519 // allow passing a command.exe param
520 if (strpos($program, '.') !== false) {
521 array_unshift($exe_suffixes, '');
522 }
523 } else {
524 $exe_suffixes = array('');
525 }
526
527 foreach ($exe_suffixes as $suff) {
528 foreach ($path_elements as $dir) {
529 $file = $dir . DIRECTORY_SEPARATOR . $program . $suff;
530 if (is_executable($file)) {
531 return $file;
532 }
533 }
534 }
535 return $fallback;
536 }
537
538 /**
539 * The "find" command
540 *
541 * Usage:
542 *
543 * System::find($dir);
544 * System::find("$dir -type d");
545 * System::find("$dir -type f");
546 * System::find("$dir -name *.php");
547 * System::find("$dir -name *.php -name *.htm*");
548 * System::find("$dir -maxdepth 1");
549 *
550 * Params implemented:
551 * $dir -> Start the search at this directory
552 * -type d -> return only directories
553 * -type f -> return only files
554 * -maxdepth <n> -> max depth of recursion
555 * -name <pattern> -> search pattern (bash style). Multiple -name param allowed
556 *
557 * @param mixed Either array or string with the command line
558 * @return array Array of found files
559 */
560 public static function find($args)
561 {
562 if (!is_array($args)) {
563 $args = preg_split('/\s+/', $args, -1, PREG_SPLIT_NO_EMPTY);
564 }
565 $dir = realpath(array_shift($args));
566 if (!$dir) {
567 return array();
568 }
569 $patterns = array();
570 $depth = 0;
571 $do_files = $do_dirs = true;
572 $args_count = count($args);
573 for ($i = 0; $i < $args_count; $i++) {
574 switch ($args[$i]) {
575 case '-type':
576 if (in_array($args[$i+1], array('d', 'f'))) {
577 if ($args[$i+1] == 'd') {
578 $do_files = false;
579 } else {
580 $do_dirs = false;
581 }
582 }
583 $i++;
584 break;
585 case '-name':
586 $name = preg_quote($args[$i+1], '#');
587 // our magic characters ? and * have just been escaped,
588 // so now we change the escaped versions to PCRE operators
589 $name = strtr($name, array('\?' => '.', '\*' => '.*'));
590 $patterns[] = '('.$name.')';
591 $i++;
592 break;
593 case '-maxdepth':
594 $depth = $args[$i+1];
595 break;
596 }
597 }
598 $path = System::_dirToStruct($dir, $depth, 0, true);
599 if ($do_files && $do_dirs) {
600 $files = array_merge($path['files'], $path['dirs']);
601 } elseif ($do_dirs) {
602 $files = $path['dirs'];
603 } else {
604 $files = $path['files'];
605 }
606 if (count($patterns)) {
607 $dsq = preg_quote(DIRECTORY_SEPARATOR, '#');
608 $pattern = '#(^|'.$dsq.')'.implode('|', $patterns).'($|'.$dsq.')#';
609 $ret = array();
610 $files_count = count($files);
611 for ($i = 0; $i < $files_count; $i++) {
612 // only search in the part of the file below the current directory
613 $filepart = basename($files[$i]);
614 if (preg_match($pattern, $filepart)) {
615 $ret[] = $files[$i];
616 }
617 }
618 return $ret;
619 }
620 return $files;
621 }
622 }