?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'fixes' into main/rendor-staging
[ryzomcore.git] / web / public_php / ams / misc / elfinder-connector / elFinderVolumeDriver.class.php
blobbbb61f93aa017e3b73ea705d69d5f5ac27e4845b
1 <?php
2 /**
3 * Base class for elFinder volume.
4 * Provide 2 layers:
5 * 1. Public API (commands)
6 * 2. abstract fs API
7 *
8 * All abstract methods begin with "_"
9 *
10 * @author Dmitry (dio) Levashov
11 * @author Troex Nevelin
12 * @author Alexey Sukhotin
13 **/
14 abstract class elFinderVolumeDriver {
15
16 /**
17 * Driver id
18 * Must be started from letter and contains [a-z0-9]
19 * Used as part of volume id
20 *
21 * @var string
22 **/
23 protected $driverId = 'a';
24
25 /**
26 * Volume id - used as prefix for files hashes
27 *
28 * @var string
29 **/
30 protected $id = '';
31
32 /**
33 * Flag - volume "mounted" and available
34 *
35 * @var bool
36 **/
37 protected $mounted = false;
38
39 /**
40 * Root directory path
41 *
42 * @var string
43 **/
44 protected $root = '';
45
46 /**
47 * Root basename | alias
48 *
49 * @var string
50 **/
51 protected $rootName = '';
52
53 /**
54 * Default directory to open
55 *
56 * @var string
57 **/
58 protected $startPath = '';
59
60 /**
61 * Base URL
62 *
63 * @var string
64 **/
65 protected $URL = '';
66
67 /**
68 * Thumbnails dir path
69 *
70 * @var string
71 **/
72 protected $tmbPath = '';
73
74 /**
75 * Is thumbnails dir writable
76 *
77 * @var bool
78 **/
79 protected $tmbPathWritable = false;
80
81 /**
82 * Thumbnails base URL
83 *
84 * @var string
85 **/
86 protected $tmbURL = '';
87
88 /**
89 * Thumbnails size in px
90 *
91 * @var int
92 **/
93 protected $tmbSize = 48;
94
95 /**
96 * Image manipulation lib name
97 * auto|imagick|mogtify|gd
98 *
99 * @var string
100 **/
101 protected $imgLib = 'auto';
102
103 /**
104 * Library to crypt files name
105 *
106 * @var string
107 **/
108 protected $cryptLib = '';
109
110 /**
111 * Archivers config
112 *
113 * @var array
114 **/
115 protected $archivers = array(
116 'create' => array(),
117 'extract' => array()
118 );
119
120 /**
121 * How many subdirs levels return for tree
122 *
123 * @var int
124 **/
125 protected $treeDeep = 1;
126
127 /**
128 * Errors from last failed action
129 *
130 * @var array
131 **/
132 protected $error = array();
133
134 /**
135 * Today 24:00 timestamp
136 *
137 * @var int
138 **/
139 protected $today = 0;
140
141 /**
142 * Yesterday 24:00 timestamp
143 *
144 * @var int
145 **/
146 protected $yesterday = 0;
147
148 /**
149 * Object configuration
150 *
151 * @var array
152 **/
153 protected $options = array(
154 'id' => '',
155 // root directory path
156 'path' => '',
157 // open this path on initial request instead of root path
158 'startPath' => '',
159 // how many subdirs levels return per request
160 'treeDeep' => 1,
161 // root url, not set to disable sending URL to client (replacement for old "fileURL" option)
162 'URL' => '',
163 // directory separator. required by client to show paths correctly
164 'separator' => DIRECTORY_SEPARATOR,
165 // library to crypt/uncrypt files names (not implemented)
166 'cryptLib' => '',
167 // how to detect files mimetypes. (auto/internal/finfo/mime_content_type)
168 'mimeDetect' => 'auto',
169 // mime.types file path (for mimeDetect==internal)
170 'mimefile' => '',
171 // directory for thumbnails
172 'tmbPath' => '.tmb',
173 // mode to create thumbnails dir
174 'tmbPathMode' => 0777,
175 // thumbnails dir URL. Set it if store thumbnails outside root directory
176 'tmbURL' => '',
177 // thumbnails size (px)
178 'tmbSize' => 48,
179 // thumbnails crop (true - crop, false - scale image to fit thumbnail size)
180 'tmbCrop' => true,
181 // thumbnails background color (hex #rrggbb or 'transparent')
182 'tmbBgColor' => '#ffffff',
183 // image manipulations library
184 'imgLib' => 'auto',
185 // on paste file - if true - old file will be replaced with new one, if false new file get name - original_name-number.ext
186 'copyOverwrite' => true,
187 // if true - join new and old directories content on paste
188 'copyJoin' => true,
189 // on upload - if true - old file will be replaced with new one, if false new file get name - original_name-number.ext
190 'uploadOverwrite' => true,
191 // mimetypes allowed to upload
192 'uploadAllow' => array(),
193 // mimetypes not allowed to upload
194 'uploadDeny' => array(),
195 // order to proccess uploadAllow and uploadDeny options
196 'uploadOrder' => array('deny', 'allow'),
197 // maximum upload file size. NOTE - this is size for every uploaded files
198 'uploadMaxSize' => 0,
199 // files dates format
200 'dateFormat' => 'j M Y H:i',
201 // files time format
202 'timeFormat' => 'H:i',
203 // if true - every folder will be check for children folders, otherwise all folders will be marked as having subfolders
204 'checkSubfolders' => true,
205 // allow to copy from this volume to other ones?
206 'copyFrom' => true,
207 // allow to copy from other volumes to this one?
208 'copyTo' => true,
209 // list of commands disabled on this root
210 'disabled' => array(),
211 // regexp or function name to validate new file name
212 'acceptedName' => '/^\w[\w\s\.\%\-\(\)\[\]]*$/u',
213 // function/class method to control files permissions
214 'accessControl' => null,
215 // some data required by access control
216 'accessControlData' => null,
217 // default permissions. not set hidden/locked here - take no effect
218 'defaults' => array(
219 'read' => true,
220 'write' => true
221 ),
222 // files attributes
223 'attributes' => array(),
224 // Allowed archive's mimetypes to create. Leave empty for all available types.
225 'archiveMimes' => array(),
226 // Manual config for archivers. See example below. Leave empty for auto detect
227 'archivers' => array(),
228 // required to fix bug on macos
229 'utf8fix' => false,
230 // й ё Й Ё Ø Å
231 'utf8patterns' => array("\u0438\u0306", "\u0435\u0308", "\u0418\u0306", "\u0415\u0308", "\u00d8A", "\u030a"),
232 'utf8replace' => array("\u0439", "\u0451", "\u0419", "\u0401", "\u00d8", "\u00c5")
233 );
234
235 /**
236 * Defaults permissions
237 *
238 * @var array
239 **/
240 protected $defaults = array(
241 'read' => true,
242 'write' => true,
243 'locked' => false,
244 'hidden' => false
245 );
246
247 /**
248 * Access control function/class
249 *
250 * @var mixed
251 **/
252 protected $attributes = array();
253
254 /**
255 * Access control function/class
256 *
257 * @var mixed
258 **/
259 protected $access = null;
260
261 /**
262 * Mime types allowed to upload
263 *
264 * @var array
265 **/
266 protected $uploadAllow = array();
267
268 /**
269 * Mime types denied to upload
270 *
271 * @var array
272 **/
273 protected $uploadDeny = array();
274
275 /**
276 * Order to validate uploadAllow and uploadDeny
277 *
278 * @var array
279 **/
280 protected $uploadOrder = array();
281
282 /**
283 * Maximum allowed upload file size.
284 * Set as number or string with unit - "10M", "500K", "1G"
285 *
286 * @var int|string
287 **/
288 protected $uploadMaxSize = 0;
289
290 /**
291 * Mimetype detect method
292 *
293 * @var string
294 **/
295 protected $mimeDetect = 'auto';
296
297 /**
298 * Flag - mimetypes from externail file was loaded
299 *
300 * @var bool
301 **/
302 private static $mimetypesLoaded = false;
303
304 /**
305 * Finfo object for mimeDetect == 'finfo'
306 *
307 * @var object
308 **/
309 protected $finfo = null;
310
311 /**
312 * List of disabled client's commands
313 *
314 * @var array
315 **/
316 protected $diabled = array();
317
318 /**
319 * default extensions/mimetypes for mimeDetect == 'internal'
320 *
321 * @var array
322 **/
323 protected static $mimetypes = array(
324 // applications
325 'ai' => 'application/postscript',
326 'eps' => 'application/postscript',
327 'exe' => 'application/x-executable',
328 'doc' => 'application/vnd.ms-word',
329 'xls' => 'application/vnd.ms-excel',
330 'ppt' => 'application/vnd.ms-powerpoint',
331 'pps' => 'application/vnd.ms-powerpoint',
332 'pdf' => 'application/pdf',
333 'xml' => 'application/xml',
334 'odt' => 'application/vnd.oasis.opendocument.text',
335 'swf' => 'application/x-shockwave-flash',
336 'torrent' => 'application/x-bittorrent',
337 'jar' => 'application/x-jar',
338 // archives
339 'gz' => 'application/x-gzip',
340 'tgz' => 'application/x-gzip',
341 'bz' => 'application/x-bzip2',
342 'bz2' => 'application/x-bzip2',
343 'tbz' => 'application/x-bzip2',
344 'zip' => 'application/zip',
345 'rar' => 'application/x-rar',
346 'tar' => 'application/x-tar',
347 '7z' => 'application/x-7z-compressed',
348 // texts
349 'txt' => 'text/plain',
350 'php' => 'text/x-php',
351 'html' => 'text/html',
352 'htm' => 'text/html',
353 'js' => 'text/javascript',
354 'css' => 'text/css',
355 'rtf' => 'text/rtf',
356 'rtfd' => 'text/rtfd',
357 'py' => 'text/x-python',
358 'java' => 'text/x-java-source',
359 'rb' => 'text/x-ruby',
360 'sh' => 'text/x-shellscript',
361 'pl' => 'text/x-perl',
362 'xml' => 'text/xml',
363 'sql' => 'text/x-sql',
364 'c' => 'text/x-csrc',
365 'h' => 'text/x-chdr',
366 'cpp' => 'text/x-c++src',
367 'hh' => 'text/x-c++hdr',
368 'log' => 'text/plain',
369 'csv' => 'text/x-comma-separated-values',
370 // images
371 'bmp' => 'image/x-ms-bmp',
372 'jpg' => 'image/jpeg',
373 'jpeg' => 'image/jpeg',
374 'gif' => 'image/gif',
375 'png' => 'image/png',
376 'tif' => 'image/tiff',
377 'tiff' => 'image/tiff',
378 'tga' => 'image/x-targa',
379 'psd' => 'image/vnd.adobe.photoshop',
380 'ai' => 'image/vnd.adobe.photoshop',
381 'xbm' => 'image/xbm',
382 'pxm' => 'image/pxm',
383 //audio
384 'mp3' => 'audio/mpeg',
385 'mid' => 'audio/midi',
386 'ogg' => 'audio/ogg',
387 'oga' => 'audio/ogg',
388 'm4a' => 'audio/x-m4a',
389 'wav' => 'audio/wav',
390 'wma' => 'audio/x-ms-wma',
391 // video
392 'avi' => 'video/x-msvideo',
393 'dv' => 'video/x-dv',
394 'mp4' => 'video/mp4',
395 'mpeg' => 'video/mpeg',
396 'mpg' => 'video/mpeg',
397 'mov' => 'video/quicktime',
398 'wm' => 'video/x-ms-wmv',
399 'flv' => 'video/x-flv',
400 'mkv' => 'video/x-matroska',
401 'webm' => 'video/webm',
402 'ogv' => 'video/ogg',
403 'ogm' => 'video/ogg'
404 );
405
406 /**
407 * Directory separator - required by client
408 *
409 * @var string
410 **/
411 protected $separator = DIRECTORY_SEPARATOR;
412
413 /**
414 * Mimetypes allowed to display
415 *
416 * @var array
417 **/
418 protected $onlyMimes = array();
419
420 /**
421 * Store files moved or overwrited files info
422 *
423 * @var array
424 **/
425 protected $removed = array();
426
427 /**
428 * Cache storage
429 *
430 * @var array
431 **/
432 protected $cache = array();
433
434 /**
435 * Cache by folders
436 *
437 * @var array
438 **/
439 protected $dirsCache = array();
440
441 /*********************************************************************/
442 /* INITIALIZATION */
443 /*********************************************************************/
444
445 /**
446 * Prepare driver before mount volume.
447 * Return true if volume is ready.
448 *
449 * @return bool
450 * @author Dmitry (dio) Levashov
451 **/
452 protected function init() {
453 return true;
454 }
455
456 /**
457 * Configure after successfull mount.
458 * By default set thumbnails path and image manipulation library.
459 *
460 * @return void
461 * @author Dmitry (dio) Levashov
462 **/
463 protected function configure() {
464 // set thumbnails path
465 $path = $this->options['tmbPath'];
466 if ($path) {
467 if (!file_exists($path)) {
468 if (@mkdir($path)) {
469 chmod($path, $this->options['tmbPathMode']);
470 } else {
471 $path = '';
472 }
473 }
474
475 if (is_dir($path) && is_readable($path)) {
476 $this->tmbPath = $path;
477 $this->tmbPathWritable = is_writable($path);
478 }
479 }
480
481 // set image manipulation library
482 $type = preg_match('/^(imagick|gd|auto)$/i', $this->options['imgLib'])
483 ? strtolower($this->options['imgLib'])
484 : 'auto';
485
486 if (($type == 'imagick' || $type == 'auto') && extension_loaded('imagick')) {
487 $this->imgLib = 'imagick';
488 } else {
489 $this->imgLib = function_exists('gd_info') ? 'gd' : '';
490 }
491
492 }
493
494
495 /*********************************************************************/
496 /* PUBLIC API */
497 /*********************************************************************/
498
499 /**
500 * Return driver id. Used as a part of volume id.
501 *
502 * @return string
503 * @author Dmitry (dio) Levashov
504 **/
505 public function driverId() {
506 return $this->driverId;
507 }
508
509 /**
510 * Return volume id
511 *
512 * @return string
513 * @author Dmitry (dio) Levashov
514 **/
515 public function id() {
516 return $this->id;
517 }
518
519 /**
520 * Return debug info for client
521 *
522 * @return array
523 * @author Dmitry (dio) Levashov
524 **/
525 public function debug() {
526 return array(
527 'id' => $this->id(),
528 'name' => strtolower(substr(get_class($this), strlen('elfinderdriver'))),
529 'mimeDetect' => $this->mimeDetect,
530 'imgLib' => $this->imgLib
531 );
532 }
533
534 /**
535 * "Mount" volume.
536 * Return true if volume available for read or write,
537 * false - otherwise
538 *
539 * @return bool
540 * @author Dmitry (dio) Levashov
541 * @author Alexey Sukhotin
542 **/
543 public function mount(array $opts) {
544 if (!isset($opts['path']) || $opts['path'] === '') {
545 return false;
546 }
547
548 $this->options = array_merge($this->options, $opts);
549 $this->id = $this->driverId.(!empty($this->options['id']) ? $this->options['id'] : elFinder::$volumesCnt++).'_';
550 $this->root = $this->_normpath($this->options['path']);
551 $this->separator = isset($this->options['separator']) ? $this->options['separator'] : DIRECTORY_SEPARATOR;
552
553 // default file attribute
554 $this->defaults = array(
555 'read' => isset($this->options['defaults']['read']) ? !!$this->options['defaults']['read'] : true,
556 'write' => isset($this->options['defaults']['write']) ? !!$this->options['defaults']['write'] : true,
557 'locked' => false,
558 'hidden' => false
559 );
560
561 // root attributes
562 $this->attributes[] = array(
563 'pattern' => '~^'.preg_quote(DIRECTORY_SEPARATOR).'$~',
564 'locked' => true,
565 'hidden' => false
566 );
567 // set files attributes
568 if (!empty($this->options['attributes']) && is_array($this->options['attributes'])) {
569
570 foreach ($this->options['attributes'] as $a) {
571 // attributes must contain pattern and at least one rule
572 if (!empty($a['pattern']) || count($a) > 1) {
573 $this->attributes[] = $a;
574 }
575 }
576 }
577
578 if (!empty($this->options['accessControl'])) {
579 if (is_string($this->options['accessControl'])
580 && function_exists($this->options['accessControl'])) {
581 $this->access = $this->options['accessControl'];
582 } elseif (is_array($this->options['accessControl'])
583 && count($this->options['accessControl']) > 1
584 && is_object($this->options['accessControl'][0])
585 && method_exists($this->options['accessControl'][0], $this->options['accessControl'][1])) {
586 $this->access = array($this->options['accessControl'][0], $this->options['accessControl'][1]);
587 }
588 }
589
590 $this->today = mktime(0,0,0, date('m'), date('d'), date('Y'));
591 $this->yesterday = $this->today-86400;
592
593 // debug($this->attributes);
594 if (!$this->init()) {
595 return false;
596 }
597
598 // check some options is arrays
599 $this->uploadAllow = isset($this->options['uploadAllow']) && is_array($this->options['uploadAllow'])
600 ? $this->options['uploadAllow']
601 : array();
602
603 $this->uploadDeny = isset($this->options['uploadDeny']) && is_array($this->options['uploadDeny'])
604 ? $this->options['uploadDeny']
605 : array();
606
607 if (is_string($this->options['uploadOrder'])) { // telephat_mode on, compatibility with 1.x
608 $parts = explode(',', isset($this->options['uploadOrder']) ? $this->options['uploadOrder'] : 'deny,allow');
609 $this->uploadOrder = array(trim($parts[0]), trim($parts[1]));
610 } else { // telephat_mode off
611 $this->uploadOrder = $this->options['uploadOrder'];
612 }
613
614 if (!empty($this->options['uploadMaxSize'])) {
615 $size = ''.$this->options['uploadMaxSize'];
616 $unit = strtolower(substr($size, strlen($size) - 1));
617 $n = 1;
618 switch ($unit) {
619 case 'k':
620 $n = 1024;
621 break;
622 case 'm':
623 $n = 1048576;
624 break;
625 case 'g':
626 $n = 1073741824;
627 }
628 $this->uploadMaxSize = intval($size)*$n;
629 }
630
631 $this->disabled = isset($this->options['disabled']) && is_array($this->options['disabled'])
632 ? $this->options['disabled']
633 : array();
634
635 $this->cryptLib = $this->options['cryptLib'];
636 $this->mimeDetect = $this->options['mimeDetect'];
637
638 // find available mimetype detect method
639 $type = strtolower($this->options['mimeDetect']);
640 $type = preg_match('/^(finfo|mime_content_type|internal|auto)$/i', $type) ? $type : 'auto';
641 $regexp = '/text\/x\-(php|c\+\+)/';
642
643 if (($type == 'finfo' || $type == 'auto')
644 && class_exists('finfo')
645 && preg_match($regexp, array_shift(explode(';', @finfo_file(finfo_open(FILEINFO_MIME), __FILE__))))) {
646 $type = 'finfo';
647 $this->finfo = finfo_open(FILEINFO_MIME);
648 } elseif (($type == 'mime_content_type' || $type == 'auto')
649 && function_exists('mime_content_type')
650 && preg_match($regexp, array_shift(explode(';', mime_content_type(__FILE__))))) {
651 $type = 'mime_content_type';
652 } else {
653 $type = 'internal';
654 }
655 $this->mimeDetect = $type;
656
657 // load mimes from external file for mimeDetect == 'internal'
658 // based on Alexey Sukhotin idea and patch: http://elrte.org/redmine/issues/163
659 // file must be in file directory or in parent one
660 if ($this->mimeDetect == 'internal' && !self::$mimetypesLoaded) {
661 self::$mimetypesLoaded = true;
662 $this->mimeDetect = 'internal';
663 $file = false;
664 if (!empty($this->options['mimefile']) && file_exists($this->options['mimefile'])) {
665 $file = $this->options['mimefile'];
666 } elseif (file_exists(dirname(__FILE__).DIRECTORY_SEPARATOR.'mime.types')) {
667 $file = dirname(__FILE__).DIRECTORY_SEPARATOR.'mime.types';
668 } elseif (file_exists(dirname(dirname(__FILE__)).DIRECTORY_SEPARATOR.'mime.types')) {
669 $file = dirname(dirname(__FILE__)).DIRECTORY_SEPARATOR.'mime.types';
670 }
671
672 if ($file && file_exists($file)) {
673 $mimecf = file($file);
674
675 foreach ($mimecf as $line_num => $line) {
676 if (!preg_match('/^\s*#/', $line)) {
677 $mime = preg_split('/\s+/', $line, -1, PREG_SPLIT_NO_EMPTY);
678 for ($i = 1, $size = count($mime); $i < $size ; $i++) {
679 if (!isset(self::$mimetypes[$mime[$i]])) {
680 self::$mimetypes[$mime[$i]] = $mime[0];
681 }
682 }
683 }
684 }
685 }
686 }
687
688 $this->rootName = empty($this->options['alias']) ? $this->_basename($this->root) : $this->options['alias'];
689 $root = $this->stat($this->root);
690
691 if (!$root) {
692 return $this->setError('Root folder does not exists.');
693 }
694 if (!$root['read'] && !$root['write']) {
695 return $this->setError('Root folder has not read and write permissions.');
696 }
697
698 // debug($root);
699
700 if ($root['read']) {
701 // check startPath - path to open by default instead of root
702 if ($this->options['startPath']) {
703 $start = $this->stat($this->options['startPath']);
704 if (!empty($start)
705 && $start['mime'] == 'directory'
706 && $start['read']
707 && empty($start['hidden'])
708 && $this->_inpath($this->options['startPath'], $this->root)) {
709 $this->startPath = $this->options['startPath'];
710 if (substr($this->startPath, -1, 1) == $this->options['separator']) {
711 $this->startPath = substr($this->startPath, 0, -1);
712 }
713 }
714 }
715 } else {
716 $this->options['URL'] = '';
717 $this->options['tmbURL'] = '';
718 $this->options['tmbPath'] = '';
719 // read only volume
720 array_unshift($this->attributes, array(
721 'pattern' => '/.*/',
722 'read' => false
723 ));
724 }
725 $this->treeDeep = $this->options['treeDeep'] > 0 ? (int)$this->options['treeDeep'] : 1;
726 $this->tmbSize = $this->options['tmbSize'] > 0 ? (int)$this->options['tmbSize'] : 48;
727 $this->URL = $this->options['URL'];
728 if ($this->URL && preg_match("|[^/?&=]$|", $this->URL)) {
729 $this->URL .= '/';
730 }
731
732 $this->tmbURL = !empty($this->options['tmbURL']) ? $this->options['tmbURL'] : '';
733 if ($this->tmbURL && preg_match("|[^/?&=]$|", $this->tmbURL)) {
734 $this->tmbURL .= '/';
735 }
736
737 $this->nameValidator = is_string($this->options['acceptedName']) && !empty($this->options['acceptedName'])
738 ? $this->options['acceptedName']
739 : '';
740
741 $this->_checkArchivers();
742 // manual control archive types to create
743 if (!empty($this->options['archiveMimes']) && is_array($this->options['archiveMimes'])) {
744 foreach ($this->archivers['create'] as $mime => $v) {
745 if (!in_array($mime, $this->options['archiveMimes'])) {
746 unset($this->archivers['create'][$mime]);
747 }
748 }
749 }
750
751 // manualy add archivers
752 if (!empty($this->options['archivers']['create']) && is_array($this->options['archivers']['create'])) {
753 foreach ($this->options['archivers']['create'] as $mime => $conf) {
754 if (strpos($mime, 'application/') === 0
755 && !empty($conf['cmd'])
756 && isset($conf['argc'])
757 && !empty($conf['ext'])
758 && !isset($this->archivers['create'][$mime])) {
759 $this->archivers['create'][$mime] = $conf;
760 }
761 }
762 }
763
764 if (!empty($this->options['archivers']['extract']) && is_array($this->options['archivers']['extract'])) {
765 foreach ($this->options['archivers']['extract'] as $mime => $conf) {
766 if (substr($mime, 'application/') === 0
767 && !empty($cons['cmd'])
768 && isset($conf['argc'])
769 && !empty($conf['ext'])
770 && !isset($this->archivers['extract'][$mime])) {
771 $this->archivers['extract'][$mime] = $conf;
772 }
773 }
774 }
775
776 $this->configure();
777 // echo $this->uploadMaxSize;
778 // echo $this->options['uploadMaxSize'];
779 return $this->mounted = true;
780 }
781
782 /**
783 * Some "unmount" stuffs - may be required by virtual fs
784 *
785 * @return void
786 * @author Dmitry (dio) Levashov
787 **/
788 public function umount() {
789 }
790
791 /**
792 * Return error message from last failed action
793 *
794 * @return array
795 * @author Dmitry (dio) Levashov
796 **/
797 public function error() {
798 return $this->error;
799 }
800
801 /**
802 * Set mimetypes allowed to display to client
803 *
804 * @param array $mimes
805 * @return void
806 * @author Dmitry (dio) Levashov
807 **/
808 public function setMimesFilter($mimes) {
809 if (is_array($mimes)) {
810 $this->onlyMimes = $mimes;
811 }
812 }
813
814 /**
815 * Return root folder hash
816 *
817 * @return string
818 * @author Dmitry (dio) Levashov
819 **/
820 public function root() {
821 return $this->encode($this->root);
822 }
823
824 /**
825 * Return root or startPath hash
826 *
827 * @return string
828 * @author Dmitry (dio) Levashov
829 **/
830 public function defaultPath() {
831 return $this->encode($this->startPath ? $this->startPath : $this->root);
832 }
833
834 /**
835 * Return volume options required by client:
836 *
837 * @return array
838 * @author Dmitry (dio) Levashov
839 **/
840 public function options($hash) {
841 return array(
842 'path' => $this->_path($this->decode($hash)),
843 'url' => $this->URL,
844 'tmbUrl' => $this->tmbURL,
845 'disabled' => $this->disabled,
846 'separator' => $this->separator,
847 'copyOverwrite' => intval($this->options['copyOverwrite']),
848 'archivers' => array(
849 'create' => array_keys($this->archivers['create']),
850 'extract' => array_keys($this->archivers['extract'])
851 )
852 );
853 }
854
855 /**
856 * Return true if command disabled in options
857 *
858 * @param string $cmd command name
859 * @return bool
860 * @author Dmitry (dio) Levashov
861 **/
862 public function commandDisabled($cmd) {
863 return in_array($cmd, $this->disabled);
864 }
865
866 /**
867 * Return true if mime is required mimes list
868 *
869 * @param string $mime mime type to check
870 * @param array $mimes allowed mime types list or not set to use client mimes list
871 * @param bool|null $empty what to return on empty list
872 * @return bool|null
873 * @author Dmitry (dio) Levashov
874 * @author Troex Nevelin
875 **/
876 public function mimeAccepted($mime, $mimes = array(), $empty = true) {
877 $mimes = !empty($mimes) ? $mimes : $this->onlyMimes;
878 if (empty($mimes)) {
879 return $empty;
880 }
881 return $mime == 'directory'
882 || in_array('all', $mimes)
883 || in_array('All', $mimes)
884 || in_array($mime, $mimes)
885 || in_array(substr($mime, 0, strpos($mime, '/')), $mimes);
886 }
887
888 /**
889 * Return true if voume is readable.
890 *
891 * @return bool
892 * @author Dmitry (dio) Levashov
893 **/
894 public function isReadable() {
895 $stat = $this->stat($this->root);
896 return $stat['read'];
897 }
898
899 /**
900 * Return true if copy from this volume allowed
901 *
902 * @return bool
903 * @author Dmitry (dio) Levashov
904 **/
905 public function copyFromAllowed() {
906 return !!$this->options['copyFrom'];
907 }
908
909 /**
910 * Return file path related to root
911 *
912 * @param string $hash file hash
913 * @return string
914 * @author Dmitry (dio) Levashov
915 **/
916 public function path($hash) {
917 return $this->_path($this->decode($hash));
918 }
919
920 /**
921 * Return file real path if file exists
922 *
923 * @param string $hash file hash
924 * @return string
925 * @author Dmitry (dio) Levashov
926 **/
927 public function realpath($hash) {
928 $path = $this->decode($hash);
929 return $this->stat($path) ? $path : false;
930 }
931
932 /**
933 * Return list of moved/overwrited files
934 *
935 * @return array
936 * @author Dmitry (dio) Levashov
937 **/
938 public function removed() {
939 return $this->removed;
940 }
941
942 /**
943 * Clean removed files list
944 *
945 * @return void
946 * @author Dmitry (dio) Levashov
947 **/
948 public function resetRemoved() {
949 $this->removed = array();
950 }
951
952 /**
953 * Return file/dir hash or first founded child hash with required attr == $val
954 *
955 * @param string $hash file hash
956 * @param string $attr attribute name
957 * @param bool $val attribute value
958 * @return string|false
959 * @author Dmitry (dio) Levashov
960 **/
961 public function closest($hash, $attr, $val) {
962 return ($path = $this->closestByAttr($this->decode($hash), $attr, $val)) ? $this->encode($path) : false;
963 }
964
965 /**
966 * Return file info or false on error
967 *
968 * @param string $hash file hash
969 * @param bool $realpath add realpath field to file info
970 * @return array|false
971 * @author Dmitry (dio) Levashov
972 **/
973 public function file($hash) {
974 $path = $this->decode($hash);
975
976 return ($file = $this->stat($path)) ? $file : $this->setError(elFinder::ERROR_FILE_NOT_FOUND);
977
978 if (($file = $this->stat($path)) != false) {
979 if ($realpath) {
980 $file['realpath'] = $path;
981 }
982 return $file;
983 }
984 return $this->setError(elFinder::ERROR_FILE_NOT_FOUND);
985 }
986
987 /**
988 * Return folder info
989 *
990 * @param string $hash folder hash
991 * @param bool $hidden return hidden file info
992 * @return array|false
993 * @author Dmitry (dio) Levashov
994 **/
995 public function dir($hash, $resolveLink=false) {
996 if (($dir = $this->file($hash)) == false) {
997 return $this->setError(elFinder::ERROR_DIR_NOT_FOUND);
998 }
999
1000 if ($resolveLink && !empty($dir['thash'])) {
1001 $dir = $this->file($dir['thash']);
1002 }
1003
1004 return $dir && $dir['mime'] == 'directory' && empty($dir['hidden'])
1005 ? $dir
1006 : $this->setError(elFinder::ERROR_NOT_DIR);
1007 }
1008
1009 /**
1010 * Return directory content or false on error
1011 *
1012 * @param string $hash file hash
1013 * @return array|false
1014 * @author Dmitry (dio) Levashov
1015 **/
1016 public function scandir($hash) {
1017 if (($dir = $this->dir($hash)) == false) {
1018 return false;
1019 }
1020
1021 return $dir['read']
1022 ? $this->getScandir($this->decode($hash))
1023 : $this->setError(elFinder::ERROR_PERM_DENIED);
1024 }
1025
1026 /**
1027 * Return dir files names list
1028 *
1029 * @param string $hash file hash
1030 * @return array
1031 * @author Dmitry (dio) Levashov
1032 **/
1033 public function ls($hash) {
1034 if (($dir = $this->dir($hash)) == false || !$dir['read']) {
1035 return false;
1036 }
1037
1038 $list = array();
1039 $path = $this->decode($hash);
1040
1041 foreach ($this->getScandir($path) as $stat) {
1042 if (empty($stat['hidden']) && $this->mimeAccepted($stat['mime'])) {
1043 $list[] = $stat['name'];
1044 }
1045 }
1046
1047 return $list;
1048 }
1049
1050 /**
1051 * Return subfolders for required folder or false on error
1052 *
1053 * @param string $hash folder hash or empty string to get tree from root folder
1054 * @param int $deep subdir deep
1055 * @param string $exclude dir hash which subfolders must be exluded from result, required to not get stat twice on cwd subfolders
1056 * @return array|false
1057 * @author Dmitry (dio) Levashov
1058 **/
1059 public function tree($hash='', $deep=0, $exclude='') {
1060 $path = $hash ? $this->decode($hash) : $this->root;
1061
1062 if (($dir = $this->stat($path)) == false || $dir['mime'] != 'directory') {
1063 return false;
1064 }
1065
1066 $dirs = $this->gettree($path, $deep > 0 ? $deep -1 : $this->treeDeep-1, $this->decode($exclude));
1067 array_unshift($dirs, $dir);
1068 return $dirs;
1069 }
1070
1071 /**
1072 * Return part of dirs tree from required dir up to root dir
1073 *
1074 * @param string $hash directory hash
1075 * @return array
1076 * @author Dmitry (dio) Levashov
1077 **/
1078 public function parents($hash) {
1079 if (($current = $this->dir($hash)) == false) {
1080 return false;
1081 }
1082
1083 $path = $this->decode($hash);
1084 $tree = array();
1085
1086 while ($path && $path != $this->root) {
1087 $path = $this->_dirname($path);
1088 $stat = $this->stat($path);
1089 if (!empty($stat['hidden']) || !$stat['read']) {
1090 return false;
1091 }
1092
1093 array_unshift($tree, $stat);
1094 if ($path != $this->root) {
1095 foreach ($this->gettree($path, 0) as $dir) {
1096 if (!in_array($dir, $tree)) {
1097 $tree[] = $dir;
1098 }
1099 }
1100 }
1101 }
1102
1103 return $tree ? $tree : array($current);
1104 }
1105
1106 /**
1107 * Create thumbnail for required file and return its name of false on failed
1108 *
1109 * @return string|false
1110 * @author Dmitry (dio) Levashov
1111 **/
1112 public function tmb($hash) {
1113 $path = $this->decode($hash);
1114 $stat = $this->stat($path);
1115
1116 if (isset($stat['tmb'])) {
1117 return $stat['tmb'] == "1" ? $this->createTmb($path, $stat) : $stat['tmb'];
1118 }
1119 return false;
1120 }
1121
1122 /**
1123 * Return file size / total directory size
1124 *
1125 * @param string file hash
1126 * @return int
1127 * @author Dmitry (dio) Levashov
1128 **/
1129 public function size($hash) {
1130 return $this->countSize($this->decode($hash));
1131 }
1132
1133 /**
1134 * Open file for reading and return file pointer
1135 *
1136 * @param string file hash
1137 * @return Resource
1138 * @author Dmitry (dio) Levashov
1139 **/
1140 public function open($hash) {
1141 if (($file = $this->file($hash)) == false
1142 || $file['mime'] == 'directory') {
1143 return false;
1144 }
1145
1146 return $this->_fopen($this->decode($hash), 'rb');
1147 }
1148
1149 /**
1150 * Close file pointer
1151 *
1152 * @param Resource $fp file pointer
1153 * @param string $hash file hash
1154 * @return void
1155 * @author Dmitry (dio) Levashov
1156 **/
1157 public function close($fp, $hash) {
1158 $this->_fclose($fp, $this->decode($hash));
1159 }
1160
1161 /**
1162 * Create directory and return dir info
1163 *
1164 * @param string $dst destination directory
1165 * @param string $name directory name
1166 * @return array|false
1167 * @author Dmitry (dio) Levashov
1168 **/
1169 public function mkdir($dst, $name) {
1170 if ($this->commandDisabled('mkdir')) {
1171 return $this->setError(elFinder::ERROR_PERM_DENIED);
1172 }
1173
1174 if (!$this->nameAccepted($name)) {
1175 return $this->setError(elFinder::ERROR_INVALID_NAME);
1176 }
1177
1178 if (($dir = $this->dir($dst)) == false) {
1179 return $this->setError(elFinder::ERROR_TRGDIR_NOT_FOUND, '#'.$dst);
1180 }
1181
1182 if (!$dir['write']) {
1183 return $this->setError(elFinder::ERROR_PERM_DENIED);
1184 }
1185
1186 $path = $this->decode($dst);
1187 $dst = $this->_joinPath($path, $name);
1188 $stat = $this->stat($dst);
1189 if (!empty($stat)) {
1190 return $this->setError(elFinder::ERROR_EXISTS, $name);
1191 }
1192 $this->clearcache();
1193 return ($path = $this->_mkdir($path, $name)) ? $this->stat($path) : false;
1194 }
1195
1196 /**
1197 * Create empty file and return its info
1198 *
1199 * @param string $dst destination directory
1200 * @param string $name file name
1201 * @return array|false
1202 * @author Dmitry (dio) Levashov
1203 **/
1204 public function mkfile($dst, $name) {
1205 if ($this->commandDisabled('mkfile')) {
1206 return $this->setError(elFinder::ERROR_PERM_DENIED);
1207 }
1208
1209 if (!$this->nameAccepted($name)) {
1210 return $this->setError(elFinder::ERROR_INVALID_NAME);
1211 }
1212
1213 if (($dir = $this->dir($dst)) == false) {
1214 return $this->setError(elFinder::ERROR_TRGDIR_NOT_FOUND, '#'.$dst);
1215 }
1216
1217 if (!$dir['write']) {
1218 return $this->setError(elFinder::ERROR_PERM_DENIED);
1219 }
1220
1221 $path = $this->decode($dst);
1222
1223 if ($this->stat($this->_joinPath($path, $name))) {
1224 return $this->setError(elFinder::ERROR_EXISTS, $name);
1225 }
1226 $this->clearcache();
1227 return ($path = $this->_mkfile($path, $name)) ? $this->stat($path) : false;
1228 }
1229
1230 /**
1231 * Rename file and return file info
1232 *
1233 * @param string $hash file hash
1234 * @param string $name new file name
1235 * @return array|false
1236 * @author Dmitry (dio) Levashov
1237 **/
1238 public function rename($hash, $name) {
1239 if ($this->commandDisabled('rename')) {
1240 return $this->setError(elFinder::ERROR_PERM_DENIED);
1241 }
1242
1243 if (!$this->nameAccepted($name)) {
1244 return $this->setError(elFinder::ERROR_INVALID_NAME, $name);
1245 }
1246
1247 if (!($file = $this->file($hash))) {
1248 return $this->setError(elFinder::ERROR_FILE_NOT_FOUND);
1249 }
1250
1251 if ($name == $file['name']) {
1252 return $file;
1253 }
1254
1255 if (!empty($file['locked'])) {
1256 return $this->setError(elFinder::ERROR_LOCKED, $file['name']);
1257 }
1258
1259 $path = $this->decode($hash);
1260 $dir = $this->_dirname($path);
1261 $stat = $this->stat($this->_joinPath($dir, $name));
1262 if ($stat) {
1263 return $this->setError(elFinder::ERROR_EXISTS, $name);
1264 }
1265
1266 if (!$this->_move($path, $dir, $name)) {
1267 return false;
1268 }
1269
1270 if (!empty($stat['tmb']) && $stat['tmb'] != "1") {
1271 $this->rmTmb($stat['tmb']);
1272 }
1273
1274 $path = $this->_joinPath($dir, $name);
1275
1276 $this->clearcache();
1277 return $this->stat($path);
1278 }
1279
1280 /**
1281 * Create file copy with suffix "copy number" and return its info
1282 *
1283 * @param string $hash file hash
1284 * @param string $suffix suffix to add to file name
1285 * @return array|false
1286 * @author Dmitry (dio) Levashov
1287 **/
1288 public function duplicate($hash, $suffix='copy') {
1289 if ($this->commandDisabled('duplicate')) {
1290 return $this->setError(elFinder::ERROR_COPY, '#'.$hash, elFinder::ERROR_PERM_DENIED);
1291 }
1292
1293 if (($file = $this->file($hash)) == false) {
1294 return $this->setError(elFinder::ERROR_COPY, elFinder::ERROR_FILE_NOT_FOUND);
1295 }
1296
1297 $path = $this->decode($hash);
1298 $dir = $this->_dirname($path);
1299
1300 return ($path = $this->copy($path, $dir, $this->uniqueName($dir, $this->_basename($path), ' '.$suffix.' '))) == false
1301 ? false
1302 : $this->stat($path);
1303 }
1304
1305 /**
1306 * Save uploaded file.
1307 * On success return array with new file stat and with removed file hash (if existed file was replaced)
1308 *
1309 * @param Resource $fp file pointer
1310 * @param string $dst destination folder hash
1311 * @param string $src file name
1312 * @param string $tmpname file tmp name - required to detect mime type
1313 * @return array|false
1314 * @author Dmitry (dio) Levashov
1315 **/
1316 public function upload($fp, $dst, $name, $tmpname) {
1317 if ($this->commandDisabled('upload')) {
1318 return $this->setError(elFinder::ERROR_PERM_DENIED);
1319 }
1320
1321 if (($dir = $this->dir($dst)) == false) {
1322 return $this->setError(elFinder::ERROR_TRGDIR_NOT_FOUND, '#'.$dst);
1323 }
1324
1325 if (!$dir['write']) {
1326 return $this->setError(elFinder::ERROR_PERM_DENIED);
1327 }
1328
1329 if (!$this->nameAccepted($name)) {
1330 return $this->setError(elFinder::ERROR_INVALID_NAME);
1331 }
1332
1333 $mime = $this->mimetype($this->mimeDetect == 'internal' ? $name : $tmpname);
1334 if ($mime == 'unknown' && $this->mimeDetect == 'internal') {
1335 $mime = elFinderVolumeDriver::mimetypeInternalDetect($name);
1336 }
1337
1338 // logic based on http://httpd.apache.org/docs/2.2/mod/mod_authz_host.html#order
1339 $allow = $this->mimeAccepted($mime, $this->uploadAllow, null);
1340 $deny = $this->mimeAccepted($mime, $this->uploadDeny, null);
1341 $upload = true; // default to allow
1342 if (strtolower($this->uploadOrder[0]) == 'allow') { // array('allow', 'deny'), default is to 'deny'
1343 $upload = false; // default is deny
1344 if (!$deny && ($allow === true)) { // match only allow
1345 $upload = true;
1346 }// else (both match | no match | match only deny) { deny }
1347 } else { // array('deny', 'allow'), default is to 'allow' - this is the default rule
1348 $upload = true; // default is allow
1349 if (($deny === true) && !$allow) { // match only deny
1350 $upload = false;
1351 } // else (both match | no match | match only allow) { allow }
1352 }
1353 if (!$upload) {
1354 return $this->setError(elFinder::ERROR_UPLOAD_FILE_MIME);
1355 }
1356
1357 if ($this->uploadMaxSize > 0 && filesize($tmpname) > $this->uploadMaxSize) {
1358 return $this->setError(elFinder::ERROR_UPLOAD_FILE_SIZE);
1359 }
1360
1361 $dstpath = $this->decode($dst);
1362 $test = $this->_joinPath($dstpath, $name);
1363
1364 $file = $this->stat($test);
1365 $this->clearcache();
1366
1367 if ($file) { // file exists
1368 if ($this->options['uploadOverwrite']) {
1369 if (!$file['write']) {
1370 return $this->setError(elFinder::ERROR_PERM_DENIED);
1371 } elseif ($file['mime'] == 'directory') {
1372 return $this->setError(elFinder::ERROR_NOT_REPLACE, $name);
1373 }
1374 $this->remove($file);
1375 } else {
1376 $name = $this->uniqueName($dstpath, $name, '-', false);
1377 }
1378 }
1379
1380 $w = $h = 0;
1381 if (strpos($mime, 'image') === 0 && ($s = getimagesize($tmpname))) {
1382 $w = $s[0];
1383 $h = $s[1];
1384 }
1385 // $this->clearcache();
1386 if (($path = $this->_save($fp, $dstpath, $name, $mime, $w, $h)) == false) {
1387 return false;
1388 }
1389
1390
1391
1392 return $this->stat($path);
1393 }
1394
1395 /**
1396 * Paste files
1397 *
1398 * @param Object $volume source volume
1399 * @param string $source file hash
1400 * @param string $dst destination dir hash
1401 * @param bool $rmSrc remove source after copy?
1402 * @return array|false
1403 * @author Dmitry (dio) Levashov
1404 **/
1405 public function paste($volume, $src, $dst, $rmSrc = false) {
1406 $err = $rmSrc ? elFinder::ERROR_MOVE : elFinder::ERROR_COPY;
1407
1408 if ($this->commandDisabled('paste')) {
1409 return $this->setError($err, '#'.$src, elFinder::ERROR_PERM_DENIED);
1410 }
1411
1412 if (($file = $volume->file($src, $rmSrc)) == false) {
1413 return $this->setError($err, '#'.$src, elFinder::ERROR_FILE_NOT_FOUND);
1414 }
1415
1416 $name = $file['name'];
1417 $errpath = $volume->path($src);
1418
1419 if (($dir = $this->dir($dst)) == false) {
1420 return $this->setError($err, $errpath, elFinder::ERROR_TRGDIR_NOT_FOUND, '#'.$dst);
1421 }
1422
1423 if (!$dir['write'] || !$file['read']) {
1424 return $this->setError($err, $errpath, elFinder::ERROR_PERM_DENIED);
1425 }
1426
1427 $destination = $this->decode($dst);
1428
1429 if (($test = $volume->closest($src, $rmSrc ? 'locked' : 'read', $rmSrc))) {
1430 return $rmSrc
1431 ? $this->setError($err, $errpath, elFinder::ERROR_LOCKED, $volume->path($test))
1432 : $this->setError($err, $errpath, elFinder::ERROR_PERM_DENIED);
1433 }
1434
1435 $test = $this->_joinPath($destination, $name);
1436 $stat = $this->stat($test);
1437 $this->clearcache();
1438 if ($stat) {
1439 if ($this->options['copyOverwrite']) {
1440 // do not replace file with dir or dir with file
1441 if (!$this->isSameType($file['mime'], $stat['mime'])) {
1442 return $this->setError(elFinder::ERROR_NOT_REPLACE, $this->_path($test));
1443 }
1444 // existed file is not writable
1445 if (!$stat['write']) {
1446 return $this->setError($err, $errpath, elFinder::ERROR_PERM_DENIED);
1447 }
1448 // existed file locked or has locked child
1449 if (($locked = $this->closestByAttr($test, 'locked', true))) {
1450 return $this->setError(elFinder::ERROR_LOCKED, $this->_path($locked));
1451 }
1452 // remove existed file
1453 if (!$this->remove($test)) {
1454 return $this->setError(elFinder::ERROR_REPLACE, $this->_path($test));
1455 }
1456 } else {
1457 $name = $this->uniqueName($destination, $name, ' ', false);
1458 }
1459 }
1460
1461 // copy/move inside current volume
1462 if ($volume == $this) {
1463 $source = $this->decode($src);
1464 // do not copy into itself
1465 if ($this->_inpath($destination, $source)) {
1466 return $this->setError(elFinder::ERROR_COPY_INTO_ITSELF, $path);
1467 }
1468 $method = $rmSrc ? 'move' : 'copy';
1469
1470 return ($path = $this->$method($source, $destination, $name)) ? $this->stat($path) : false;
1471 }
1472
1473
1474 // copy/move from another volume
1475 if (!$this->options['copyTo'] || !$volume->copyFromAllowed()) {
1476 return $this->setError(elFinder::ERROR_COPY, $errpath, elFinder::ERROR_PERM_DENIED);
1477 }
1478
1479 if (($path = $this->copyFrom($volume, $src, $destination, $name)) == false) {
1480 return false;
1481 }
1482
1483 if ($rmSrc) {
1484 if ($volume->rm($src)) {
1485 $this->removed[] = $file;
1486 } else {
1487 return $this->setError(elFinder::ERROR_MOVE, $errpath, elFinder::ERROR_RM_SRC);
1488 }
1489 }
1490 return $this->stat($path);
1491 }
1492
1493 /**
1494 * Return file contents
1495 *
1496 * @param string $hash file hash
1497 * @return string|false
1498 * @author Dmitry (dio) Levashov
1499 **/
1500 public function getContents($hash) {
1501 $file = $this->file($hash);
1502
1503 if (!$file) {
1504 return $this->setError(elFinder::ERROR_FILE_NOT_FOUND);
1505 }
1506
1507 if ($file['mime'] == 'directory') {
1508 return $this->setError(elFinder::ERROR_NOT_FILE);
1509 }
1510
1511 if (!$file['read']) {
1512 return $this->setError(elFinder::ERROR_PERM_DENIED);
1513 }
1514
1515 return $this->_getContents($this->decode($hash));
1516 }
1517
1518 /**
1519 * Put content in text file and return file info.
1520 *
1521 * @param string $hash file hash
1522 * @param string $content new file content
1523 * @return array
1524 * @author Dmitry (dio) Levashov
1525 **/
1526 public function putContents($hash, $content) {
1527 if ($this->commandDisabled('edit')) {
1528 return $this->setError(elFinder::ERROR_PERM_DENIED);
1529 }
1530
1531 $path = $this->decode($hash);
1532
1533 if (!($file = $this->file($hash))) {
1534 return $this->setError(elFinder::ERROR_FILE_NOT_FOUND);
1535 }
1536
1537 if (!$file['write']) {
1538 return $this->setError(elFinder::ERROR_PERM_DENIED);
1539 }
1540 $this->clearcache();
1541 return $this->_filePutContents($path, $content) ? $this->stat($path) : false;
1542 }
1543
1544 /**
1545 * Extract files from archive
1546 *
1547 * @param string $hash archive hash
1548 * @return array|bool
1549 * @author Dmitry (dio) Levashov,
1550 * @author Alexey Sukhotin
1551 **/
1552 public function extract($hash) {
1553 if ($this->commandDisabled('extract')) {
1554 return $this->setError(elFinder::ERROR_PERM_DENIED);
1555 }
1556
1557 if (($file = $this->file($hash)) == false) {
1558 return $this->setError(elFinder::ERROR_FILE_NOT_FOUND);
1559 }
1560
1561 $archiver = isset($this->archivers['extract'][$file['mime']])
1562 ? $this->archivers['extract'][$file['mime']]
1563 : false;
1564
1565 if (!$archiver) {
1566 return $this->setError(elFinder::ERROR_NOT_ARCHIVE);
1567 }
1568
1569 $path = $this->decode($hash);
1570 $parent = $this->stat($this->_dirname($path));
1571
1572 if (!$file['read'] || !$parent['write']) {
1573 return $this->setError(elFinder::ERROR_PERM_DENIED);
1574 }
1575 $this->clearcache();
1576 return ($path = $this->_extract($path, $archiver)) ? $this->stat($path) : false;
1577 }
1578
1579 /**
1580 * Add files to archive
1581 *
1582 * @return void
1583 **/
1584 public function archive($hashes, $mime) {
1585 if ($this->commandDisabled('archive')) {
1586 return $this->setError(elFinder::ERROR_PERM_DENIED);
1587 }
1588
1589 $archiver = isset($this->archivers['create'][$mime])
1590 ? $this->archivers['create'][$mime]
1591 : false;
1592
1593 if (!$archiver) {
1594 return $this->setError(elFinder::ERROR_ARCHIVE_TYPE);
1595 }
1596
1597 $files = array();
1598
1599 foreach ($hashes as $hash) {
1600 if (($file = $this->file($hash)) == false) {
1601 return $this->error(elFinder::ERROR_FILE_NOT_FOUND, '#'+$hash);
1602 }
1603 if (!$file['read']) {
1604 return $this->error(elFinder::ERROR_PERM_DENIED);
1605 }
1606 $path = $this->decode($hash);
1607 if (!isset($dir)) {
1608 $dir = $this->_dirname($path);
1609 $stat = $this->stat($dir);
1610 if (!$stat['write']) {
1611 return $this->error(elFinder::ERROR_PERM_DENIED);
1612 }
1613 }
1614
1615 $files[] = $this->_basename($path);
1616 }
1617
1618 $name = (count($files) == 1 ? $files[0] : 'Archive').'.'.$archiver['ext'];
1619 $name = $this->uniqueName($dir, $name, '');
1620 $this->clearcache();
1621 return ($path = $this->_archive($dir, $files, $name, $archiver)) ? $this->stat($path) : false;
1622 }
1623
1624 /**
1625 * Resize image
1626 *
1627 * @param string $hash image file
1628 * @param int $width new width
1629 * @param int $height new height
1630 * @param int $x X start poistion for crop
1631 * @param int $y Y start poistion for crop
1632 * @param string $mode action how to mainpulate image
1633 * @return array|false
1634 * @author Dmitry (dio) Levashov
1635 * @author Alexey Sukhotin
1636 * @author nao-pon
1637 * @author Troex Nevelin
1638 **/
1639 public function resize($hash, $width, $height, $x, $y, $mode = 'resize', $bg = '', $degree = 0) {
1640 if ($this->commandDisabled('resize')) {
1641 return $this->setError(elFinder::ERROR_PERM_DENIED);
1642 }
1643
1644 if (($file = $this->file($hash)) == false) {
1645 return $this->setError(elFinder::ERROR_FILE_NOT_FOUND);
1646 }
1647
1648 if (!$file['write'] || !$file['read']) {
1649 return $this->setError(elFinder::ERROR_PERM_DENIED);
1650 }
1651
1652 $path = $this->decode($hash);
1653
1654 if (!$this->canResize($path, $file)) {
1655 return $this->setError(elFinder::ERROR_UNSUPPORT_TYPE);
1656 }
1657
1658 switch($mode) {
1659
1660 case 'propresize':
1661 $result = $this->imgResize($path, $width, $height, true, true);
1662 break;
1663
1664 case 'crop':
1665 $result = $this->imgCrop($path, $width, $height, $x, $y);
1666 break;
1667
1668 case 'fitsquare':
1669 $result = $this->imgSquareFit($path, $width, $height, 'center', 'middle', ($bg ? $bg : $this->options['tmbBgColor']));
1670 break;
1671
1672 case 'rotate':
1673 $result = $this->imgRotate($path, $degree, ($bg ? $bg : $this->options['tmbBgColor']));
1674 break;
1675
1676 default:
1677 $result = $this->imgResize($path, $width, $height, false, true);
1678 break;
1679 }
1680
1681 if ($result) {
1682 if (!empty($file['tmb']) && $file['tmb'] != "1") {
1683 $this->rmTmb($file['tmb']);
1684 }
1685 $this->clearcache();
1686 return $this->stat($path);
1687 }
1688
1689 return false;
1690 }
1691
1692 /**
1693 * Remove file/dir
1694 *
1695 * @param string $hash file hash
1696 * @return bool
1697 * @author Dmitry (dio) Levashov
1698 **/
1699 public function rm($hash) {
1700 return $this->commandDisabled('rm')
1701 ? array(elFinder::ERROR_ACCESS_DENIED)
1702 : $this->remove($this->decode($hash));
1703 }
1704
1705 /**
1706 * Search files
1707 *
1708 * @param string $q search string
1709 * @param array $mimes
1710 * @return array
1711 * @author Dmitry (dio) Levashov
1712 **/
1713 public function search($q, $mimes) {
1714 return $this->doSearch($this->root, $q, $mimes);
1715 }
1716
1717 /**
1718 * Return image dimensions
1719 *
1720 * @param string $hash file hash
1721 * @return array
1722 * @author Dmitry (dio) Levashov
1723 **/
1724 public function dimensions($hash) {
1725 if (($file = $this->file($hash)) == false) {
1726 return false;
1727 }
1728
1729 return $this->_dimensions($this->decode($hash), $file['mime']);
1730 }
1731
1732 /**
1733 * Save error message
1734 *
1735 * @param array error
1736 * @return false
1737 * @author Dmitry(dio) Levashov
1738 **/
1739 protected function setError($error) {
1740
1741 $this->error = array();
1742
1743 foreach (func_get_args() as $err) {
1744 if (is_array($err)) {
1745 $this->error = array_merge($this->error, $err);
1746 } else {
1747 $this->error[] = $err;
1748 }
1749 }
1750
1751 // $this->error = is_array($error) ? $error : func_get_args();
1752 return false;
1753 }
1754
1755 /*********************************************************************/
1756 /* FS API */
1757 /*********************************************************************/
1758
1759 /***************** paths *******************/
1760
1761 /**
1762 * Encode path into hash
1763 *
1764 * @param string file path
1765 * @return string
1766 * @author Dmitry (dio) Levashov
1767 * @author Troex Nevelin
1768 **/
1769 protected function encode($path) {
1770 if ($path !== '') {
1771
1772 // cut ROOT from $path for security reason, even if hacker decodes the path he will not know the root
1773 $p = $this->_relpath($path);
1774 // if reqesting root dir $path will be empty, then assign '/' as we cannot leave it blank for crypt
1775 if ($p === '') {
1776 $p = DIRECTORY_SEPARATOR;
1777 }
1778
1779 // TODO crypt path and return hash
1780 $hash = $this->crypt($p);
1781 // hash is used as id in HTML that means it must contain vaild chars
1782 // make base64 html safe and append prefix in begining
1783 $hash = strtr(base64_encode($hash), '+/=', '-_.');
1784 // remove dots '.' at the end, before it was '=' in base64
1785 $hash = rtrim($hash, '.');
1786 // append volume id to make hash unique
1787 return $this->id.$hash;
1788 }
1789 }
1790
1791 /**
1792 * Decode path from hash
1793 *
1794 * @param string file hash
1795 * @return string
1796 * @author Dmitry (dio) Levashov
1797 * @author Troex Nevelin
1798 **/
1799 protected function decode($hash) {
1800 if (strpos($hash, $this->id) === 0) {
1801 // cut volume id after it was prepended in encode
1802 $h = substr($hash, strlen($this->id));
1803 // replace HTML safe base64 to normal
1804 $h = base64_decode(strtr($h, '-_.', '+/='));
1805 // TODO uncrypt hash and return path
1806 $path = $this->uncrypt($h);
1807 // append ROOT to path after it was cut in encode
1808 return $this->_abspath($path);//$this->root.($path == DIRECTORY_SEPARATOR ? '' : DIRECTORY_SEPARATOR.$path);
1809 }
1810 }
1811
1812 /**
1813 * Return crypted path
1814 * Not implemented
1815 *
1816 * @param string path
1817 * @return mixed
1818 * @author Dmitry (dio) Levashov
1819 **/
1820 protected function crypt($path) {
1821 return $path;
1822 }
1823
1824 /**
1825 * Return uncrypted path
1826 * Not implemented
1827 *
1828 * @param mixed hash
1829 * @return mixed
1830 * @author Dmitry (dio) Levashov
1831 **/
1832 protected function uncrypt($hash) {
1833 return $hash;
1834 }
1835
1836 /**
1837 * Validate file name based on $this->options['acceptedName'] regexp
1838 *
1839 * @param string $name file name
1840 * @return bool
1841 * @author Dmitry (dio) Levashov
1842 **/
1843 protected function nameAccepted($name) {
1844 if ($this->nameValidator) {
1845 if (function_exists($this->nameValidator)) {
1846 $f = $this->nameValidator;
1847 return $f($name);
1848 }
1849 return preg_match($this->nameValidator, $name);
1850 }
1851 return true;
1852 }
1853
1854 /**
1855 * Return new unique name based on file name and suffix
1856 *
1857 * @param string $path file path
1858 * @param string $suffix suffix append to name
1859 * @return string
1860 * @author Dmitry (dio) Levashov
1861 **/
1862 public function uniqueName($dir, $name, $suffix = ' copy', $checkNum=true) {
1863 $ext = '';
1864
1865 if (preg_match('/\.((tar\.(gz|bz|bz2|z|lzo))|cpio\.gz|ps\.gz|xcf\.(gz|bz2)|[a-z0-9]{1,4})$/i', $name, $m)) {
1866 $ext = '.'.$m[1];
1867 $name = substr($name, 0, strlen($name)-strlen($m[0]));
1868 }
1869
1870 if ($checkNum && preg_match('/('.$suffix.')(\d*)$/i', $name, $m)) {
1871 $i = (int)$m[2];
1872 $name = substr($name, 0, strlen($name)-strlen($m[2]));
1873 } else {
1874 $i = 1;
1875 $name .= $suffix;
1876 }
1877 $max = $i+100000;
1878
1879 while ($i <= $max) {
1880 $n = $name.($i > 0 ? $i : '').$ext;
1881
1882 if (!$this->stat($this->_joinPath($dir, $n))) {
1883 $this->clearcache();
1884 return $n;
1885 }
1886 $i++;
1887 }
1888 return $name.md5($dir).$ext;
1889 }
1890
1891 /*********************** file stat *********************/
1892
1893 /**
1894 * Check file attribute
1895 *
1896 * @param string $path file path
1897 * @param string $name attribute name (read|write|locked|hidden)
1898 * @param bool $val attribute value returned by file system
1899 * @return bool
1900 * @author Dmitry (dio) Levashov
1901 **/
1902 protected function attr($path, $name, $val=false) {
1903 if (!isset($this->defaults[$name])) {
1904 return false;
1905 }
1906
1907
1908 $perm = null;
1909
1910 if ($this->access) {
1911 if (is_array($this->access)) {
1912 $obj = $this->access[0];
1913 $method = $this->access[1];
1914 $perm = $obj->{$method}($name, $path, $this->options['accessControlData'], $this);
1915 } else {
1916 $func = $this->access;
1917 $perm = $func($name, $path, $this->options['accessControlData'], $this);
1918 }
1919
1920 if ($perm !== null) {
1921 return !!$perm;
1922 }
1923 }
1924
1925 for ($i = 0, $c = count($this->attributes); $i < $c; $i++) {
1926 $attrs = $this->attributes[$i];
1927 $p = $this->separator.$this->_relpath($path);
1928 if (isset($attrs[$name]) && isset($attrs['pattern']) && preg_match($attrs['pattern'], $p)) {
1929 $perm = $attrs[$name];
1930 }
1931 }
1932
1933 return $perm === null ? $this->defaults[$name] : !!$perm;
1934 }
1935
1936 /**
1937 * Return fileinfo
1938 *
1939 * @param string $path file cache
1940 * @return array
1941 * @author Dmitry (dio) Levashov
1942 **/
1943 protected function stat($path) {
1944 return isset($this->cache[$path])
1945 ? $this->cache[$path]
1946 : $this->updateCache($path, $this->_stat($path));
1947 }
1948
1949 /**
1950 * Put file stat in cache and return it
1951 *
1952 * @param string $path file path
1953 * @param array $stat file stat
1954 * @return array
1955 * @author Dmitry (dio) Levashov
1956 **/
1957 protected function updateCache($path, $stat) {
1958 if (empty($stat) || !is_array($stat)) {
1959 return $this->cache[$path] = array();
1960 }
1961
1962 $stat['hash'] = $this->encode($path);
1963
1964 $root = $path == $this->root;
1965
1966 if ($root) {
1967 $stat['volumeid'] = $this->id;
1968 if ($this->rootName) {
1969 $stat['name'] = $this->rootName;
1970 }
1971 } else {
1972 if (empty($stat['name'])) {
1973 $stat['name'] = $this->_basename($path);
1974 }
1975 if (empty($stat['phash'])) {
1976 $stat['phash'] = $this->encode($this->_dirname($path));
1977 }
1978 }
1979
1980 // fix name if required
1981 if ($this->options['utf8fix'] && $this->options['utf8patterns'] && $this->options['utf8replace']) {
1982 $stat['name'] = json_decode(str_replace($this->options['utf8patterns'], $this->options['utf8replace'], json_encode($stat['name'])));
1983 }
1984
1985
1986 if (empty($stat['mime'])) {
1987 $stat['mime'] = $this->mimetype($stat['name']);
1988 }
1989
1990 // @todo move dateformat to client
1991 $stat['date'] = isset($stat['ts'])
1992 ? $this->formatDate($stat['ts'])
1993 : 'unknown';
1994
1995 if (!isset($stat['size'])) {
1996 $stat['size'] = 'unknown';
1997 }
1998
1999 $stat['read'] = intval($this->attr($path, 'read', isset($stat['read']) ? !!$stat['read'] : false));
2000 $stat['write'] = intval($this->attr($path, 'write', isset($stat['write']) ? !!$stat['write'] : false));
2001 if ($root) {
2002 $stat['locked'] = 1;
2003 } elseif ($this->attr($path, 'locked', !empty($stat['locked']))) {
2004 $stat['locked'] = 1;
2005 } else {
2006 unset($stat['locked']);
2007 }
2008
2009 if ($root) {
2010 unset($stat['hidden']);
2011 } elseif ($this->attr($path, 'hidden', !empty($stat['hidden']))
2012 || !$this->mimeAccepted($stat['mime'])) {
2013 $stat['hidden'] = $root ? 0 : 1;
2014 } else {
2015 unset($stat['hidden']);
2016 }
2017
2018 if ($stat['read'] && empty($stat['hidden'])) {
2019
2020 if ($stat['mime'] == 'directory') {
2021 // for dir - check for subdirs
2022
2023 if ($this->options['checkSubfolders']) {
2024 if (isset($stat['dirs'])) {
2025 if ($stat['dirs']) {
2026 $stat['dirs'] = 1;
2027 } else {
2028 unset($stat['dirs']);
2029 }
2030 } elseif (!empty($stat['alias']) && !empty($stat['target'])) {
2031 $stat['dirs'] = isset($this->cache[$stat['target']])
2032 ? intval(isset($this->cache[$stat['target']]['dirs']))
2033 : $this->_subdirs($stat['target']);
2034
2035 } elseif ($this->_subdirs($path)) {
2036 $stat['dirs'] = 1;
2037 }
2038 } else {
2039 $stat['dirs'] = 1;
2040 }
2041 } else {
2042 // for files - check for thumbnails
2043 $p = isset($stat['target']) ? $stat['target'] : $path;
2044 if ($this->tmbURL && !isset($stat['tmb']) && $this->canCreateTmb($p, $stat)) {
2045 $tmb = $this->gettmb($p, $stat);
2046 $stat['tmb'] = $tmb ? $tmb : 1;
2047 }
2048
2049 }
2050 }
2051
2052 if (!empty($stat['alias']) && !empty($stat['target'])) {
2053 $stat['thash'] = $this->encode($stat['target']);
2054 unset($stat['target']);
2055 }
2056
2057 return $this->cache[$path] = $stat;
2058 }
2059
2060 /**
2061 * Get stat for folder content and put in cache
2062 *
2063 * @param string $path
2064 * @return void
2065 * @author Dmitry (dio) Levashov
2066 **/
2067 protected function cacheDir($path) {
2068 $this->dirsCache[$path] = array();
2069
2070 foreach ($this->_scandir($path) as $p) {
2071 if (($stat = $this->stat($p)) && empty($stat['hidden'])) {
2072 $this->dirsCache[$path][] = $p;
2073 }
2074 }
2075 }
2076
2077 /**
2078 * Clean cache
2079 *
2080 * @return void
2081 * @author Dmitry (dio) Levashov
2082 **/
2083 protected function clearcache() {
2084 $this->cache = $this->dirsCache = array();
2085 }
2086
2087 /**
2088 * Return file mimetype
2089 *
2090 * @param string $path file path
2091 * @return string
2092 * @author Dmitry (dio) Levashov
2093 **/
2094 protected function mimetype($path) {
2095 $type = '';
2096
2097 if ($this->mimeDetect == 'finfo') {
2098 $type = @finfo_file($this->finfo, $path);
2099 } elseif ($type == 'mime_content_type') {
2100 $type = mime_content_type($path);
2101 } else {
2102 $type = elFinderVolumeDriver::mimetypeInternalDetect($path);
2103 }
2104
2105 $type = explode(';', $type);
2106 $type = trim($type[0]);
2107
2108 if ($type == 'application/x-empty') {
2109 // finfo return this mime for empty files
2110 $type = 'text/plain';
2111 } elseif ($type == 'application/x-zip') {
2112 // http://elrte.org/redmine/issues/163
2113 $type = 'application/zip';
2114 }
2115
2116 return $type == 'unknown' && $this->mimeDetect != 'internal'
2117 ? elFinderVolumeDriver::mimetypeInternalDetect($path)
2118 : $type;
2119
2120 }
2121
2122 /**
2123 * Detect file mimetype using "internal" method
2124 *
2125 * @param string $path file path
2126 * @return string
2127 * @author Dmitry (dio) Levashov
2128 **/
2129 static protected function mimetypeInternalDetect($path) {
2130 $pinfo = pathinfo($path);
2131 $ext = isset($pinfo['extension']) ? strtolower($pinfo['extension']) : '';
2132 return isset(elFinderVolumeDriver::$mimetypes[$ext]) ? elFinderVolumeDriver::$mimetypes[$ext] : 'unknown';
2133
2134 }
2135
2136 /**
2137 * Return file/total directory size
2138 *
2139 * @param string $path file path
2140 * @return int
2141 * @author Dmitry (dio) Levashov
2142 **/
2143 protected function countSize($path) {
2144 $stat = $this->stat($path);
2145
2146 if (empty($stat) || !$stat['read'] || !empty($stat['hidden'])) {
2147 return 'unknown';
2148 }
2149
2150 if ($stat['mime'] != 'directory') {
2151 return $stat['size'];
2152 }
2153
2154 $subdirs = $this->options['checkSubfolders'];
2155 $this->options['checkSubfolders'] = true;
2156 $result = 0;
2157 foreach ($this->getScandir($path) as $stat) {
2158 $size = $stat['mime'] == 'directory' && $stat['read']
2159 ? $this->countSize($this->_joinPath($path, $stat['name']))
2160 : $stat['size'];
2161 if ($size > 0) {
2162 $result += $size;
2163 }
2164 }
2165 $this->options['checkSubfolders'] = $subdirs;
2166 return $result;
2167 }
2168
2169 /**
2170 * Return true if all mimes is directory or files
2171 *
2172 * @param string $mime1 mimetype
2173 * @param string $mime2 mimetype
2174 * @return bool
2175 * @author Dmitry (dio) Levashov
2176 **/
2177 protected function isSameType($mime1, $mime2) {
2178 return ($mime1 == 'directory' && $mime1 == $mime2) || ($mime1 != 'directory' && $mime2 != 'directory');
2179 }
2180
2181 /**
2182 * If file has required attr == $val - return file path,
2183 * If dir has child with has required attr == $val - return child path
2184 *
2185 * @param string $path file path
2186 * @param string $attr attribute name
2187 * @param bool $val attribute value
2188 * @return string|false
2189 * @author Dmitry (dio) Levashov
2190 **/
2191 protected function closestByAttr($path, $attr, $val) {
2192 $stat = $this->stat($path);
2193
2194 if (empty($stat)) {
2195 return false;
2196 }
2197
2198 $v = isset($stat[$attr]) ? $stat[$attr] : false;
2199
2200 if ($v == $val) {
2201 return $path;
2202 }
2203
2204 return $stat['mime'] == 'directory'
2205 ? $this->childsByAttr($path, $attr, $val)
2206 : false;
2207 }
2208
2209 /**
2210 * Return first found children with required attr == $val
2211 *
2212 * @param string $path file path
2213 * @param string $attr attribute name
2214 * @param bool $val attribute value
2215 * @return string|false
2216 * @author Dmitry (dio) Levashov
2217 **/
2218 protected function childsByAttr($path, $attr, $val) {
2219 foreach ($this->_scandir($path) as $p) {
2220 if (($_p = $this->closestByAttr($p, $attr, $val)) != false) {
2221 return $_p;
2222 }
2223 }
2224 return false;
2225 }
2226
2227 /***************** get content *******************/
2228
2229 /**
2230 * Return required dir's files info.
2231 * If onlyMimes is set - return only dirs and files of required mimes
2232 *
2233 * @param string $path dir path
2234 * @return array
2235 * @author Dmitry (dio) Levashov
2236 **/
2237 protected function getScandir($path) {
2238 $files = array();
2239
2240 !isset($this->dirsCache[$path]) && $this->cacheDir($path);
2241
2242 foreach ($this->dirsCache[$path] as $p) {
2243 if (($stat = $this->stat($p)) && empty($stat['hidden'])) {
2244 $files[] = $stat;
2245 }
2246 }
2247
2248 return $files;
2249 }
2250
2251
2252 /**
2253 * Return subdirs tree
2254 *
2255 * @param string $path parent dir path
2256 * @param int $deep tree deep
2257 * @return array
2258 * @author Dmitry (dio) Levashov
2259 **/
2260 protected function gettree($path, $deep, $exclude='') {
2261 $dirs = array();
2262
2263 !isset($this->dirsCache[$path]) && $this->cacheDir($path);
2264
2265 foreach ($this->dirsCache[$path] as $p) {
2266 $stat = $this->stat($p);
2267
2268 if ($stat && empty($stat['hidden']) && $path != $exclude && $stat['mime'] == 'directory') {
2269 $dirs[] = $stat;
2270 if ($deep > 0 && !empty($stat['dirs'])) {
2271 $dirs = array_merge($dirs, $this->gettree($p, $deep-1));
2272 }
2273 }
2274 }
2275
2276 return $dirs;
2277 }
2278
2279 /**
2280 * Recursive files search
2281 *
2282 * @param string $path dir path
2283 * @param string $q search string
2284 * @param array $mimes
2285 * @return array
2286 * @author Dmitry (dio) Levashov
2287 **/
2288 protected function doSearch($path, $q, $mimes) {
2289 $result = array();
2290
2291 foreach($this->_scandir($path) as $p) {
2292 $stat = $this->stat($p);
2293
2294 if (!$stat) { // invalid links
2295 continue;
2296 }
2297
2298 if (!empty($stat['hidden']) || !$this->mimeAccepted($stat['mime'])) {
2299 continue;
2300 }
2301
2302 $name = $stat['name'];
2303
2304 if ($this->stripos($name, $q) !== false) {
2305 $stat['path'] = $this->_path($p);
2306 if ($this->URL && !isset($stat['url'])) {
2307 $stat['url'] = $this->URL . str_replace($this->separator, '/', substr($p, strlen($this->root) + 1));
2308 }
2309
2310 $result[] = $stat;
2311 }
2312 if ($stat['mime'] == 'directory' && $stat['read'] && !isset($stat['alias'])) {
2313 $result = array_merge($result, $this->doSearch($p, $q, $mimes));
2314 }
2315 }
2316
2317 return $result;
2318 }
2319
2320 /********************** manuipulations ******************/
2321
2322 /**
2323 * Copy file/recursive copy dir only in current volume.
2324 * Return new file path or false.
2325 *
2326 * @param string $src source path
2327 * @param string $dst destination dir path
2328 * @param string $name new file name (optionaly)
2329 * @return string|false
2330 * @author Dmitry (dio) Levashov
2331 **/
2332 protected function copy($src, $dst, $name) {
2333 $srcStat = $this->stat($src);
2334 $this->clearcache();
2335
2336 if (!empty($srcStat['thash'])) {
2337 $target = $this->decode($srcStat['thash']);
2338 $stat = $this->stat($target);
2339 $this->clearcache();
2340 return $stat && $this->_symlink($target, $dst, $name)
2341 ? $this->_joinPath($dst, $name)
2342 : $this->setError(elFinder::ERROR_COPY, $this->_path($src));
2343 }
2344
2345 if ($srcStat['mime'] == 'directory') {
2346 $test = $this->stat($this->_joinPath($dst, $name));
2347
2348 if (($test && $test['mime'] != 'directory') || !$this->_mkdir($dst, $name)) {
2349 return $this->setError(elFinder::ERROR_COPY, $this->_path($src));
2350 }
2351
2352 $dst = $this->_joinPath($dst, $name);
2353
2354 foreach ($this->getScandir($src) as $stat) {
2355 if (empty($stat['hidden'])) {
2356 $name = $stat['name'];
2357 if (!$this->copy($this->_joinPath($src, $name), $dst, $name)) {
2358 return false;
2359 }
2360 }
2361 }
2362 $this->clearcache();
2363 return $dst;
2364 }
2365
2366 return $this->_copy($src, $dst, $name)
2367 ? $this->_joinPath($dst, $name)
2368 : $this->setError(elFinder::ERROR_COPY, $this->_path($src));
2369 }
2370
2371 /**
2372 * Move file
2373 * Return new file path or false.
2374 *
2375 * @param string $src source path
2376 * @param string $dst destination dir path
2377 * @param string $name new file name
2378 * @return string|false
2379 * @author Dmitry (dio) Levashov
2380 **/
2381 protected function move($src, $dst, $name) {
2382 $stat = $this->stat($src);
2383 $stat['realpath'] = $src;
2384 $this->clearcache();
2385
2386 if ($this->_move($src, $dst, $name)) {
2387 $this->removed[] = $stat;
2388 return $this->_joinPath($dst, $name);
2389 }
2390
2391 return $this->setError(elFinder::ERROR_MOVE, $this->_path($src));
2392 }
2393
2394 /**
2395 * Copy file from another volume.
2396 * Return new file path or false.
2397 *
2398 * @param Object $volume source volume
2399 * @param string $src source file hash
2400 * @param string $destination destination dir path
2401 * @param string $name file name
2402 * @return string|false
2403 * @author Dmitry (dio) Levashov
2404 **/
2405 protected function copyFrom($volume, $src, $destination, $name) {
2406
2407 if (($source = $volume->file($src)) == false) {
2408 return $this->setError(elFinder::ERROR_COPY, '#'.$src, $volume->error());
2409 }
2410
2411 $errpath = $volume->path($src);
2412
2413 if (!$this->nameAccepted($source['name'])) {
2414 return $this->setError(elFinder::ERROR_COPY, $errpath, elFinder::ERROR_INVALID_NAME);
2415 }
2416
2417 if (!$source['read']) {
2418 return $this->setError(elFinder::ERROR_COPY, $errpath, elFinder::ERROR_PERM_DENIED);
2419 }
2420
2421 if ($source['mime'] == 'directory') {
2422 $stat = $this->stat($this->_joinPath($destination, $name));
2423 $this->clearcache();
2424 if ((!$stat || $stat['mime'] != 'directory') && !$this->_mkdir($destination, $name)) {
2425 return $this->setError(elFinder::ERROR_COPY, $errpath);
2426 }
2427
2428 $path = $this->_joinPath($destination, $name);
2429
2430 foreach ($volume->scandir($src) as $entr) {
2431 if (!$this->copyFrom($volume, $entr['hash'], $path, $entr['name'])) {
2432 return false;
2433 }
2434 }
2435
2436 } else {
2437 $mime = $source['mime'];
2438 $w = $h = 0;
2439 if (strpos($mime, 'image') === 0 && ($dim = $volume->dimensions($src))) {
2440 $s = explode('x', $dim);
2441 $w = $s[0];
2442 $h = $s[1];
2443 }
2444
2445 if (($fp = $volume->open($src)) == false
2446 || ($path = $this->_save($fp, $destination, $name, $mime, $w, $h)) == false) {
2447 $fp && $volume->close($fp, $src);
2448 return $this->setError(elFinder::ERROR_COPY, $errpath);
2449 }
2450 $volume->close($fp, $src);
2451 }
2452
2453 return $path;
2454 }
2455
2456 /**
2457 * Remove file/ recursive remove dir
2458 *
2459 * @param string $path file path
2460 * @param bool $force try to remove even if file locked
2461 * @return bool
2462 * @author Dmitry (dio) Levashov
2463 **/
2464 protected function remove($path, $force = false) {
2465 $stat = $this->stat($path);
2466 $stat['realpath'] = $path;
2467 if (!empty($stat['tmb']) && $stat['tmb'] != "1") {
2468 $this->rmTmb($stat['tmb']);
2469 }
2470 $this->clearcache();
2471
2472 if (empty($stat)) {
2473 return $this->setError(elFinder::ERROR_RM, $this->_path($path), elFinder::ERROR_FILE_NOT_FOUND);
2474 }
2475
2476 if (!$force && !empty($stat['locked'])) {
2477 return $this->setError(elFinder::ERROR_LOCKED, $this->_path($path));
2478 }
2479
2480 if ($stat['mime'] == 'directory') {
2481 foreach ($this->_scandir($path) as $p) {
2482 $name = $this->_basename($p);
2483 if ($name != '.' && $name != '..' && !$this->remove($p)) {
2484 return false;
2485 }
2486 }
2487 if (!$this->_rmdir($path)) {
2488 return $this->setError(elFinder::ERROR_RM, $this->_path($path));
2489 }
2490
2491 } else {
2492 if (!$this->_unlink($path)) {
2493 return $this->setError(elFinder::ERROR_RM, $this->_path($path));
2494 }
2495 }
2496
2497 $this->removed[] = $stat;
2498 return true;
2499 }
2500
2501
2502 /************************* thumbnails **************************/
2503
2504 /**
2505 * Return thumbnail file name for required file
2506 *
2507 * @param array $stat file stat
2508 * @return string
2509 * @author Dmitry (dio) Levashov
2510 **/
2511 protected function tmbname($stat) {
2512 return $stat['hash'].$stat['ts'].'.png';
2513 }
2514
2515 /**
2516 * Return thumnbnail name if exists
2517 *
2518 * @param string $path file path
2519 * @param array $stat file stat
2520 * @return string|false
2521 * @author Dmitry (dio) Levashov
2522 **/
2523 protected function gettmb($path, $stat) {
2524 if ($this->tmbURL && $this->tmbPath) {
2525 // file itself thumnbnail
2526 if (strpos($path, $this->tmbPath) === 0) {
2527 return basename($path);
2528 }
2529
2530 $name = $this->tmbname($stat);
2531 if (file_exists($this->tmbPath.DIRECTORY_SEPARATOR.$name)) {
2532 return $name;
2533 }
2534 }
2535 return false;
2536 }
2537
2538 /**
2539 * Return true if thumnbnail for required file can be created
2540 *
2541 * @param string $path thumnbnail path
2542 * @param array $stat file stat
2543 * @return string|bool
2544 * @author Dmitry (dio) Levashov
2545 **/
2546 protected function canCreateTmb($path, $stat) {
2547 return $this->tmbPathWritable
2548 && strpos($path, $this->tmbPath) === false // do not create thumnbnail for thumnbnail
2549 && $this->imgLib
2550 && strpos($stat['mime'], 'image') === 0
2551 && ($this->imgLib == 'gd' ? $stat['mime'] == 'image/jpeg' || $stat['mime'] == 'image/png' || $stat['mime'] == 'image/gif' : true);
2552 }
2553
2554 /**
2555 * Return true if required file can be resized.
2556 * By default - the same as canCreateTmb
2557 *
2558 * @param string $path thumnbnail path
2559 * @param array $stat file stat
2560 * @return string|bool
2561 * @author Dmitry (dio) Levashov
2562 **/
2563 protected function canResize($path, $stat) {
2564 return $this->canCreateTmb($path, $stat);
2565 }
2566
2567 /**
2568 * Create thumnbnail and return it's URL on success
2569 *
2570 * @param string $path file path
2571 * @param string $mime file mime type
2572 * @return string|false
2573 * @author Dmitry (dio) Levashov
2574 **/
2575 protected function createTmb($path, $stat) {
2576 if (!$stat || !$this->canCreateTmb($path, $stat)) {
2577 return false;
2578 }
2579
2580 $name = $this->tmbname($stat);
2581 $tmb = $this->tmbPath.DIRECTORY_SEPARATOR.$name;
2582
2583 // copy image into tmbPath so some drivers does not store files on local fs
2584 if (($src = $this->_fopen($path, 'rb')) == false) {
2585 return false;
2586 }
2587
2588 if (($trg = fopen($tmb, 'wb')) == false) {
2589 $this->_fclose($src, $path);
2590 return false;
2591 }
2592
2593 while (!feof($src)) {
2594 fwrite($trg, fread($src, 8192));
2595 }
2596
2597 $this->_fclose($src, $path);
2598 fclose($trg);
2599
2600 $result = false;
2601
2602 $tmbSize = $this->tmbSize;
2603
2604 if (($s = getimagesize($tmb)) == false) {
2605 return false;
2606 }
2607
2608 /* If image smaller or equal thumbnail size - just fitting to thumbnail square */
2609 if ($s[0] <= $tmbSize && $s[1] <= $tmbSize) {
2610 $result = $this->imgSquareFit($tmb, $tmbSize, $tmbSize, 'center', 'middle', $this->options['tmbBgColor'], 'png' );
2611
2612 } else {
2613
2614 if ($this->options['tmbCrop']) {
2615
2616 /* Resize and crop if image bigger than thumbnail */
2617 if (!(($s[0] > $tmbSize && $s[1] <= $tmbSize) || ($s[0] <= $tmbSize && $s[1] > $tmbSize) ) || ($s[0] > $tmbSize && $s[1] > $tmbSize)) {
2618 $result = $this->imgResize($tmb, $tmbSize, $tmbSize, true, false, 'png');
2619 }
2620
2621 if (($s = getimagesize($tmb)) != false) {
2622 $x = $s[0] > $tmbSize ? intval(($s[0] - $tmbSize)/2) : 0;
2623 $y = $s[1] > $tmbSize ? intval(($s[1] - $tmbSize)/2) : 0;
2624 $result = $this->imgCrop($tmb, $tmbSize, $tmbSize, $x, $y, 'png');
2625 }
2626
2627 } else {
2628 $result = $this->imgResize($tmb, $tmbSize, $tmbSize, true, true, $this->imgLib, 'png');
2629 $result = $this->imgSquareFit($tmb, $tmbSize, $tmbSize, 'center', 'middle', $this->options['tmbBgColor'], 'png' );
2630 }
2631
2632 }
2633 if (!$result) {
2634 unlink($tmb);
2635 return false;
2636 }
2637
2638 return $name;
2639 }
2640
2641 /**
2642 * Resize image
2643 *
2644 * @param string $path image file
2645 * @param int $width new width
2646 * @param int $height new height
2647 * @param bool $keepProportions crop image
2648 * @param bool $resizeByBiggerSide resize image based on bigger side if true
2649 * @param string $destformat image destination format
2650 * @return string|false
2651 * @author Dmitry (dio) Levashov
2652 * @author Alexey Sukhotin
2653 **/
2654 protected function imgResize($path, $width, $height, $keepProportions = false, $resizeByBiggerSide = true, $destformat = null) {
2655 if (($s = @getimagesize($path)) == false) {
2656 return false;
2657 }
2658
2659 $result = false;
2660
2661 list($size_w, $size_h) = array($width, $height);
2662
2663 if ($keepProportions == true) {
2664
2665 list($orig_w, $orig_h, $new_w, $new_h) = array($s[0], $s[1], $width, $height);
2666
2667 /* Calculating image scale width and height */
2668 $xscale = $orig_w / $new_w;
2669 $yscale = $orig_h / $new_h;
2670
2671 /* Resizing by biggest side */
2672
2673 if ($resizeByBiggerSide) {
2674
2675 if ($orig_w > $orig_h) {
2676 $size_h = $orig_h * $width / $orig_w;
2677 $size_w = $width;
2678 } else {
2679 $size_w = $orig_w * $height / $orig_h;
2680 $size_h = $height;
2681 }
2682
2683 } else {
2684 if ($orig_w > $orig_h) {
2685 $size_w = $orig_w * $height / $orig_h;
2686 $size_h = $height;
2687 } else {
2688 $size_h = $orig_h * $width / $orig_w;
2689 $size_w = $width;
2690 }
2691 }
2692 }
2693
2694 switch ($this->imgLib) {
2695 case 'imagick':
2696
2697 try {
2698 $img = new imagick($path);
2699 } catch (Exception $e) {
2700
2701 return false;
2702 }
2703
2704 $img->resizeImage($size_w, $size_h, Imagick::FILTER_LANCZOS, true);
2705
2706 $result = $img->writeImage($path);
2707
2708 return $result ? $path : false;
2709
2710 break;
2711
2712 case 'gd':
2713 if ($s['mime'] == 'image/jpeg') {
2714 $img = imagecreatefromjpeg($path);
2715 } elseif ($s['mime'] == 'image/png') {
2716 $img = imagecreatefrompng($path);
2717 } elseif ($s['mime'] == 'image/gif') {
2718 $img = imagecreatefromgif($path);
2719 } elseif ($s['mime'] == 'image/xbm') {
2720 $img = imagecreatefromxbm($path);
2721 }
2722
2723 if ($img && false != ($tmp = imagecreatetruecolor($size_w, $size_h))) {
2724 if (!imagecopyresampled($tmp, $img, 0, 0, 0, 0, $size_w, $size_h, $s[0], $s[1])) {
2725 return false;
2726 }
2727
2728 if ($destformat == 'jpg' || ($destformat == null && $s['mime'] == 'image/jpeg')) {
2729 $result = imagejpeg($tmp, $path, 100);
2730 } else if ($destformat == 'gif' || ($destformat == null && $s['mime'] == 'image/gif')) {
2731 $result = imagegif($tmp, $path, 7);
2732 } else {
2733 $result = imagepng($tmp, $path, 7);
2734 }
2735
2736 imagedestroy($img);
2737 imagedestroy($tmp);
2738
2739 return $result ? $path : false;
2740
2741 }
2742 break;
2743 }
2744
2745 return false;
2746 }
2747
2748 /**
2749 * Crop image
2750 *
2751 * @param string $path image file
2752 * @param int $width crop width
2753 * @param int $height crop height
2754 * @param bool $x crop left offset
2755 * @param bool $y crop top offset
2756 * @param string $destformat image destination format
2757 * @return string|false
2758 * @author Dmitry (dio) Levashov
2759 * @author Alexey Sukhotin
2760 **/
2761 protected function imgCrop($path, $width, $height, $x, $y, $destformat = null) {
2762 if (($s = @getimagesize($path)) == false) {
2763 return false;
2764 }
2765
2766 $result = false;
2767
2768 switch ($this->imgLib) {
2769 case 'imagick':
2770
2771 try {
2772 $img = new imagick($path);
2773 } catch (Exception $e) {
2774
2775 return false;
2776 }
2777
2778 $img->cropImage($width, $height, $x, $y);
2779
2780 $result = $img->writeImage($path);
2781
2782 return $result ? $path : false;
2783
2784 break;
2785
2786 case 'gd':
2787 if ($s['mime'] == 'image/jpeg') {
2788 $img = imagecreatefromjpeg($path);
2789 } elseif ($s['mime'] == 'image/png') {
2790 $img = imagecreatefrompng($path);
2791 } elseif ($s['mime'] == 'image/gif') {
2792 $img = imagecreatefromgif($path);
2793 } elseif ($s['mime'] == 'image/xbm') {
2794 $img = imagecreatefromxbm($path);
2795 }
2796
2797 if ($img && false != ($tmp = imagecreatetruecolor($width, $height))) {
2798
2799 if (!imagecopy($tmp, $img, 0, 0, $x, $y, $width, $height)) {
2800 return false;
2801 }
2802
2803 if ($destformat == 'jpg' || ($destformat == null && $s['mime'] == 'image/jpeg')) {
2804 $result = imagejpeg($tmp, $path, 100);
2805 } else if ($destformat == 'gif' || ($destformat == null && $s['mime'] == 'image/gif')) {
2806 $result = imagegif($tmp, $path, 7);
2807 } else {
2808 $result = imagepng($tmp, $path, 7);
2809 }
2810
2811 imagedestroy($img);
2812 imagedestroy($tmp);
2813
2814 return $result ? $path : false;
2815
2816 }
2817 break;
2818 }
2819
2820 return false;
2821 }
2822
2823 /**
2824 * Put image to square
2825 *
2826 * @param string $path image file
2827 * @param int $width square width
2828 * @param int $height square height
2829 * @param int $align reserved
2830 * @param int $valign reserved
2831 * @param string $bgcolor square background color in #rrggbb format
2832 * @param string $destformat image destination format
2833 * @return string|false
2834 * @author Dmitry (dio) Levashov
2835 * @author Alexey Sukhotin
2836 **/
2837 protected function imgSquareFit($path, $width, $height, $align = 'center', $valign = 'middle', $bgcolor = '#0000ff', $destformat = null) {
2838 if (($s = @getimagesize($path)) == false) {
2839 return false;
2840 }
2841
2842 $result = false;
2843
2844 /* Coordinates for image over square aligning */
2845 $y = ceil(abs($height - $s[1]) / 2);
2846 $x = ceil(abs($width - $s[0]) / 2);
2847
2848 switch ($this->imgLib) {
2849 case 'imagick':
2850 try {
2851 $img = new imagick($path);
2852 } catch (Exception $e) {
2853 return false;
2854 }
2855
2856 $img1 = new Imagick();
2857 $img1->newImage($width, $height, new ImagickPixel($bgcolor));
2858 $img1->setImageColorspace($img->getImageColorspace());
2859 $img1->setImageFormat($destformat != null ? $destformat : $img->getFormat());
2860 $img1->compositeImage( $img, imagick::COMPOSITE_OVER, $x, $y );
2861 $result = $img1->writeImage($path);
2862 return $result ? $path : false;
2863
2864 break;
2865
2866 case 'gd':
2867 if ($s['mime'] == 'image/jpeg') {
2868 $img = imagecreatefromjpeg($path);
2869 } elseif ($s['mime'] == 'image/png') {
2870 $img = imagecreatefrompng($path);
2871 } elseif ($s['mime'] == 'image/gif') {
2872 $img = imagecreatefromgif($path);
2873 } elseif ($s['mime'] == 'image/xbm') {
2874 $img = imagecreatefromxbm($path);
2875 }
2876
2877 if ($img && false != ($tmp = imagecreatetruecolor($width, $height))) {
2878
2879 if ($bgcolor == 'transparent') {
2880 list($r, $g, $b) = array(0, 0, 255);
2881 } else {
2882 list($r, $g, $b) = sscanf($bgcolor, "#%02x%02x%02x");
2883 }
2884
2885 $bgcolor1 = imagecolorallocate($tmp, $r, $g, $b);
2886
2887 if ($bgcolor == 'transparent') {
2888 $bgcolor1 = imagecolortransparent($tmp, $bgcolor1);
2889 }
2890
2891 imagefill($tmp, 0, 0, $bgcolor1);
2892
2893 if (!imagecopy($tmp, $img, $x, $y, 0, 0, $s[0], $s[1])) {
2894 return false;
2895 }
2896
2897 if ($destformat == 'jpg' || ($destformat == null && $s['mime'] == 'image/jpeg')) {
2898 $result = imagejpeg($tmp, $path, 100);
2899 } else if ($destformat == 'gif' || ($destformat == null && $s['mime'] == 'image/gif')) {
2900 $result = imagegif($tmp, $path, 7);
2901 } else {
2902 $result = imagepng($tmp, $path, 7);
2903 }
2904
2905 imagedestroy($img);
2906 imagedestroy($tmp);
2907
2908 return $result ? $path : false;
2909 }
2910 break;
2911 }
2912
2913 return false;
2914 }
2915
2916 /**
2917 * Rotate image
2918 *
2919 * @param string $path image file
2920 * @param int $degree rotete degrees
2921 * @param string $bgcolor square background color in #rrggbb format
2922 * @param string $destformat image destination format
2923 * @return string|false
2924 * @author nao-pon
2925 * @author Troex Nevelin
2926 **/
2927 protected function imgRotate($path, $degree, $bgcolor = '#ffffff', $destformat = null) {
2928 if (($s = @getimagesize($path)) == false) {
2929 return false;
2930 }
2931
2932 $result = false;
2933
2934 switch ($this->imgLib) {
2935 case 'imagick':
2936 try {
2937 $img = new imagick($path);
2938 } catch (Exception $e) {
2939 return false;
2940 }
2941
2942 $img->rotateImage(new ImagickPixel($bgcolor), $degree);
2943 $result = $img->writeImage($path);
2944 return $result ? $path : false;
2945
2946 break;
2947
2948 case 'gd':
2949 if ($s['mime'] == 'image/jpeg') {
2950 $img = imagecreatefromjpeg($path);
2951 } elseif ($s['mime'] == 'image/png') {
2952 $img = imagecreatefrompng($path);
2953 } elseif ($s['mime'] == 'image/gif') {
2954 $img = imagecreatefromgif($path);
2955 } elseif ($s['mime'] == 'image/xbm') {
2956 $img = imagecreatefromxbm($path);
2957 }
2958
2959 $degree = 360 - $degree;
2960 list($r, $g, $b) = sscanf($bgcolor, "#%02x%02x%02x");
2961 $bgcolor = imagecolorallocate($img, $r, $g, $b);
2962 $tmp = imageRotate($img, $degree, (int)$bgcolor);
2963
2964 if ($destformat == 'jpg' || ($destformat == null && $s['mime'] == 'image/jpeg')) {
2965 $result = imagejpeg($tmp, $path, 100);
2966 } else if ($destformat == 'gif' || ($destformat == null && $s['mime'] == 'image/gif')) {
2967 $result = imagegif($tmp, $path, 7);
2968 } else {
2969 $result = imagepng($tmp, $path, 7);
2970 }
2971
2972 imageDestroy($img);
2973 imageDestroy($tmp);
2974
2975 return $result ? $path : false;
2976
2977 break;
2978 }
2979
2980 return false;
2981 }
2982
2983 /**
2984 * Execute shell command
2985 *
2986 * @param string $command command line
2987 * @param array $output stdout strings
2988 * @param array $return_var process exit code
2989 * @param array $error_output stderr strings
2990 * @return int exit code
2991 * @author Alexey Sukhotin
2992 **/
2993 protected function procExec($command , array &$output = null, &$return_var = -1, array &$error_output = null) {
2994
2995 $descriptorspec = array(
2996 0 => array("pipe", "r"), // stdin
2997 1 => array("pipe", "w"), // stdout
2998 2 => array("pipe", "w") // stderr
2999 );
3000
3001 $process = proc_open($command, $descriptorspec, $pipes, null, null);
3002
3003 if (is_resource($process)) {
3004
3005 fclose($pipes[0]);
3006
3007 $tmpout = '';
3008 $tmperr = '';
3009
3010 $output = stream_get_contents($pipes[1]);
3011 $error_output = stream_get_contents($pipes[2]);
3012
3013 fclose($pipes[1]);
3014 fclose($pipes[2]);
3015 $return_var = proc_close($process);
3016
3017
3018 }
3019
3020 return $return_var;
3021
3022 }
3023
3024 /**
3025 * Remove thumbnail
3026 *
3027 * @param string $path file path
3028 * @return void
3029 * @author Dmitry (dio) Levashov
3030 **/
3031 protected function rmTmb($tmb) {
3032 $tmb = $this->tmbPath.DIRECTORY_SEPARATOR.$tmb;
3033 file_exists($tmb) && @unlink($tmb);
3034 clearstatcache();
3035 }
3036
3037 /*********************** misc *************************/
3038
3039 /**
3040 * Return smart formatted date
3041 *
3042 * @param int $ts file timestamp
3043 * @return string
3044 * @author Dmitry (dio) Levashov
3045 **/
3046 protected function formatDate($ts) {
3047 if ($ts > $this->today) {
3048 return 'Today '.date($this->options['timeFormat'], $ts);
3049 }
3050
3051 if ($ts > $this->yesterday) {
3052 return 'Yesterday '.date($this->options['timeFormat'], $ts);
3053 }
3054
3055 return date($this->options['dateFormat'], $ts);
3056 }
3057
3058 /**
3059 * Find position of first occurrence of string in a string with multibyte support
3060 *
3061 * @param string $haystack The string being checked.
3062 * @param string $needle The string to find in haystack.
3063 * @param int $offset The search offset. If it is not specified, 0 is used.
3064 * @return int|bool
3065 * @author Alexey Sukhotin
3066 **/
3067 protected function stripos($haystack , $needle , $offset = 0) {
3068 if (function_exists('mb_stripos')) {
3069 return mb_stripos($haystack , $needle , $offset);
3070 } else if (function_exists('mb_strtolower') && function_exists('mb_strpos')) {
3071 return mb_strpos(mb_strtolower($haystack), mb_strtolower($needle), $offset);
3072 }
3073 return stripos($haystack , $needle , $offset);
3074 }
3075
3076 /**==================================* abstract methods *====================================**/
3077
3078 /*********************** paths/urls *************************/
3079
3080 /**
3081 * Return parent directory path
3082 *
3083 * @param string $path file path
3084 * @return string
3085 * @author Dmitry (dio) Levashov
3086 **/
3087 abstract protected function _dirname($path);
3088
3089 /**
3090 * Return file name
3091 *
3092 * @param string $path file path
3093 * @return string
3094 * @author Dmitry (dio) Levashov
3095 **/
3096 abstract protected function _basename($path);
3097
3098 /**
3099 * Join dir name and file name and return full path.
3100 * Some drivers (db) use int as path - so we give to concat path to driver itself
3101 *
3102 * @param string $dir dir path
3103 * @param string $name file name
3104 * @return string
3105 * @author Dmitry (dio) Levashov
3106 **/
3107 abstract protected function _joinPath($dir, $name);
3108
3109 /**
3110 * Return normalized path
3111 *
3112 * @param string $path file path
3113 * @return string
3114 * @author Dmitry (dio) Levashov
3115 **/
3116 abstract protected function _normpath($path);
3117
3118 /**
3119 * Return file path related to root dir
3120 *
3121 * @param string $path file path
3122 * @return string
3123 * @author Dmitry (dio) Levashov
3124 **/
3125 abstract protected function _relpath($path);
3126
3127 /**
3128 * Convert path related to root dir into real path
3129 *
3130 * @param string $path rel file path
3131 * @return string
3132 * @author Dmitry (dio) Levashov
3133 **/
3134 abstract protected function _abspath($path);
3135
3136 /**
3137 * Return fake path started from root dir.
3138 * Required to show path on client side.
3139 *
3140 * @param string $path file path
3141 * @return string
3142 * @author Dmitry (dio) Levashov
3143 **/
3144 abstract protected function _path($path);
3145
3146 /**
3147 * Return true if $path is children of $parent
3148 *
3149 * @param string $path path to check
3150 * @param string $parent parent path
3151 * @return bool
3152 * @author Dmitry (dio) Levashov
3153 **/
3154 abstract protected function _inpath($path, $parent);
3155
3156 /**
3157 * Return stat for given path.
3158 * Stat contains following fields:
3159 * - (int) size file size in b. required
3160 * - (int) ts file modification time in unix time. required
3161 * - (string) mime mimetype. required for folders, others - optionally
3162 * - (bool) read read permissions. required
3163 * - (bool) write write permissions. required
3164 * - (bool) locked is object locked. optionally
3165 * - (bool) hidden is object hidden. optionally
3166 * - (string) alias for symlinks - link target path relative to root path. optionally
3167 * - (string) target for symlinks - link target path. optionally
3168 *
3169 * If file does not exists - returns empty array or false.
3170 *
3171 * @param string $path file path
3172 * @return array|false
3173 * @author Dmitry (dio) Levashov
3174 **/
3175 abstract protected function _stat($path);
3176
3177
3178 /***************** file stat ********************/
3179
3180
3181 /**
3182 * Return true if path is dir and has at least one childs directory
3183 *
3184 * @param string $path dir path
3185 * @return bool
3186 * @author Dmitry (dio) Levashov
3187 **/
3188 abstract protected function _subdirs($path);
3189
3190 /**
3191 * Return object width and height
3192 * Ususaly used for images, but can be realize for video etc...
3193 *
3194 * @param string $path file path
3195 * @param string $mime file mime type
3196 * @return string
3197 * @author Dmitry (dio) Levashov
3198 **/
3199 abstract protected function _dimensions($path, $mime);
3200
3201 /******************** file/dir content *********************/
3202
3203 /**
3204 * Return files list in directory
3205 *
3206 * @param string $path dir path
3207 * @return array
3208 * @author Dmitry (dio) Levashov
3209 **/
3210 abstract protected function _scandir($path);
3211
3212 /**
3213 * Open file and return file pointer
3214 *
3215 * @param string $path file path
3216 * @param bool $write open file for writing
3217 * @return resource|false
3218 * @author Dmitry (dio) Levashov
3219 **/
3220 abstract protected function _fopen($path, $mode="rb");
3221
3222 /**
3223 * Close opened file
3224 *
3225 * @param resource $fp file pointer
3226 * @param string $path file path
3227 * @return bool
3228 * @author Dmitry (dio) Levashov
3229 **/
3230 abstract protected function _fclose($fp, $path='');
3231
3232 /******************** file/dir manipulations *************************/
3233
3234 /**
3235 * Create dir and return created dir path or false on failed
3236 *
3237 * @param string $path parent dir path
3238 * @param string $name new directory name
3239 * @return string|bool
3240 * @author Dmitry (dio) Levashov
3241 **/
3242 abstract protected function _mkdir($path, $name);
3243
3244 /**
3245 * Create file and return it's path or false on failed
3246 *
3247 * @param string $path parent dir path
3248 * @param string $name new file name
3249 * @return string|bool
3250 * @author Dmitry (dio) Levashov
3251 **/
3252 abstract protected function _mkfile($path, $name);
3253
3254 /**
3255 * Create symlink
3256 *
3257 * @param string $source file to link to
3258 * @param string $targetDir folder to create link in
3259 * @param string $name symlink name
3260 * @return bool
3261 * @author Dmitry (dio) Levashov
3262 **/
3263 abstract protected function _symlink($source, $targetDir, $name);
3264
3265 /**
3266 * Copy file into another file (only inside one volume)
3267 *
3268 * @param string $source source file path
3269 * @param string $target target dir path
3270 * @param string $name file name
3271 * @return bool
3272 * @author Dmitry (dio) Levashov
3273 **/
3274 abstract protected function _copy($source, $targetDir, $name);
3275
3276 /**
3277 * Move file into another parent dir.
3278 * Return new file path or false.
3279 *
3280 * @param string $source source file path
3281 * @param string $target target dir path
3282 * @param string $name file name
3283 * @return string|bool
3284 * @author Dmitry (dio) Levashov
3285 **/
3286 abstract protected function _move($source, $targetDir, $name);
3287
3288 /**
3289 * Remove file
3290 *
3291 * @param string $path file path
3292 * @return bool
3293 * @author Dmitry (dio) Levashov
3294 **/
3295 abstract protected function _unlink($path);
3296
3297 /**
3298 * Remove dir
3299 *
3300 * @param string $path dir path
3301 * @return bool
3302 * @author Dmitry (dio) Levashov
3303 **/
3304 abstract protected function _rmdir($path);
3305
3306 /**
3307 * Create new file and write into it from file pointer.
3308 * Return new file path or false on error.
3309 *
3310 * @param resource $fp file pointer
3311 * @param string $dir target dir path
3312 * @param string $name file name
3313 * @return bool|string
3314 * @author Dmitry (dio) Levashov
3315 **/
3316 abstract protected function _save($fp, $dir, $name, $mime, $w, $h);
3317
3318 /**
3319 * Get file contents
3320 *
3321 * @param string $path file path
3322 * @return string|false
3323 * @author Dmitry (dio) Levashov
3324 **/
3325 abstract protected function _getContents($path);
3326
3327 /**
3328 * Write a string to a file
3329 *
3330 * @param string $path file path
3331 * @param string $content new file content
3332 * @return bool
3333 * @author Dmitry (dio) Levashov
3334 **/
3335 abstract protected function _filePutContents($path, $content);
3336
3337 /**
3338 * Extract files from archive
3339 *
3340 * @param string $path file path
3341 * @param array $arc archiver options
3342 * @return bool
3343 * @author Dmitry (dio) Levashov,
3344 * @author Alexey Sukhotin
3345 **/
3346 abstract protected function _extract($path, $arc);
3347
3348 /**
3349 * Create archive and return its path
3350 *
3351 * @param string $dir target dir
3352 * @param array $files files names list
3353 * @param string $name archive name
3354 * @param array $arc archiver options
3355 * @return string|bool
3356 * @author Dmitry (dio) Levashov,
3357 * @author Alexey Sukhotin
3358 **/
3359 abstract protected function _archive($dir, $files, $name, $arc);
3360
3361 /**
3362 * Detect available archivers
3363 *
3364 * @return void
3365 * @author Dmitry (dio) Levashov,
3366 * @author Alexey Sukhotin
3367 **/
3368 abstract protected function _checkArchivers();
3369
3370 } // END class