1 <?php
  2 /**
  3  * @package     Joomla.Libraries
  4  * @subpackage  Installer
  5  *
  6  * @copyright   Copyright (C) 2005 - 2017 Open Source Matters, Inc. All rights reserved.
  7  * @license     GNU General Public License version 2 or later; see LICENSE.txt
  8  */
  9 
 10 defined('JPATH_PLATFORM') or die;
 11 
 12 jimport('joomla.filesystem.folder');
 13 
 14 /**
 15  * File installer
 16  *
 17  * @since  3.1
 18  */
 19 class JInstallerAdapterFile extends JInstallerAdapter
 20 {
 21     /**
 22      * `<scriptfile>` element of the extension manifest
 23      *
 24      * @var    object
 25      * @since  3.1
 26      */
 27     protected $scriptElement = null;
 28 
 29     /**
 30      * Flag if the adapter supports discover installs
 31      *
 32      * Adapters should override this and set to false if discover install is unsupported
 33      *
 34      * @var    boolean
 35      * @since  3.4
 36      */
 37     protected $supportsDiscoverInstall = false;
 38 
 39     /**
 40      * Method to copy the extension's base files from the `<files>` tag(s) and the manifest file
 41      *
 42      * @return  void
 43      *
 44      * @since   3.4
 45      * @throws  RuntimeException
 46      */
 47     protected function copyBaseFiles()
 48     {
 49         // Populate File and Folder List to copy
 50         $this->populateFilesAndFolderList();
 51 
 52         // Now that we have folder list, lets start creating them
 53         foreach ($this->folderList as $folder)
 54         {
 55             if (!JFolder::exists($folder))
 56             {
 57                 if (!$created = JFolder::create($folder))
 58                 {
 59                     throw new RuntimeException(
 60                         JText::sprintf('JLIB_INSTALLER_ABORT_FILE_INSTALL_FAIL_SOURCE_DIRECTORY', $folder)
 61                     );
 62                 }
 63 
 64                 // Since we created a directory and will want to remove it if we have to roll back.
 65                 // The installation due to some errors, let's add it to the installation step stack.
 66                 if ($created)
 67                 {
 68                     $this->parent->pushStep(array('type' => 'folder', 'path' => $folder));
 69                 }
 70             }
 71         }
 72 
 73         // Now that we have file list, let's start copying them
 74         $this->parent->copyFiles($this->fileList);
 75     }
 76 
 77     /**
 78      * Method to finalise the installation processing
 79      *
 80      * @return  void
 81      *
 82      * @since   3.4
 83      * @throws  RuntimeException
 84      */
 85     protected function finaliseInstall()
 86     {
 87         // Clobber any possible pending updates
 88         $update = JTable::getInstance('update');
 89 
 90         $uid = $update->find(
 91             array(
 92                 'element' => $this->element,
 93                 'type' => $this->type,
 94             )
 95         );
 96 
 97         if ($uid)
 98         {
 99             $update->delete($uid);
100         }
101 
102         // Lastly, we will copy the manifest file to its appropriate place.
103         $manifest = array();
104         $manifest['src'] = $this->parent->getPath('manifest');
105         $manifest['dest'] = JPATH_MANIFESTS . '/files/' . basename($this->parent->getPath('manifest'));
106 
107         if (!$this->parent->copyFiles(array($manifest), true))
108         {
109             // Install failed, rollback changes
110             throw new RuntimeException(JText::_('JLIB_INSTALLER_ABORT_FILE_INSTALL_COPY_SETUP'));
111         }
112 
113         // If there is a manifest script, let's copy it.
114         if ($this->manifest_script)
115         {
116             // First, we have to create a folder for the script if one isn't present
117             if (!file_exists($this->parent->getPath('extension_root')))
118             {
119                 JFolder::create($this->parent->getPath('extension_root'));
120             }
121 
122             $path['src'] = $this->parent->getPath('source') . '/' . $this->manifest_script;
123             $path['dest'] = $this->parent->getPath('extension_root') . '/' . $this->manifest_script;
124 
125             if ($this->parent->isOverwrite() || !file_exists($path['dest']))
126             {
127                 if (!$this->parent->copyFiles(array($path)))
128                 {
129                     // Install failed, rollback changes
130                     throw new RuntimeException(
131                         JText::sprintf(
132                             'JLIB_INSTALLER_ABORT_MANIFEST',
133                             JText::_('JLIB_INSTALLER_' . strtoupper($this->route))
134                         )
135                     );
136                 }
137             }
138         }
139     }
140 
141     /**
142      * Get the filtered extension element from the manifest
143      *
144      * @param   string  $element  Optional element name to be converted
145      *
146      * @return  string  The filtered element
147      *
148      * @since   3.4
149      */
150     public function getElement($element = null)
151     {
152         if (!$element)
153         {
154             $manifestPath = JPath::clean($this->parent->getPath('manifest'));
155             $element = preg_replace('/\.xml/', '', basename($manifestPath));
156         }
157 
158         return $element;
159     }
160 
161     /**
162      * Custom loadLanguage method
163      *
164      * @param   string  $path  The path on which to find language files.
165      *
166      * @return  void
167      *
168      * @since   3.1
169      */
170     public function loadLanguage($path)
171     {
172         $extension = 'files_' . strtolower(str_replace('files_', '', $this->getElement()));
173 
174         $this->doLoadLanguage($extension, $path, JPATH_SITE);
175     }
176 
177     /**
178      * Method to parse optional tags in the manifest
179      *
180      * @return  void
181      *
182      * @since   3.4
183      */
184     protected function parseOptionalTags()
185     {
186         // Parse optional tags
187         $this->parent->parseLanguages($this->getManifest()->languages);
188     }
189 
190     /**
191      * Method to do any prechecks and setup the install paths for the extension
192      *
193      * @return  void
194      *
195      * @since   3.4
196      */
197     protected function setupInstallPaths()
198     {
199         // Set the file root path
200         if ($this->name === 'files_joomla')
201         {
202             // If we are updating the Joomla core, set the root path to the root of Joomla
203             $this->parent->setPath('extension_root', JPATH_ROOT);
204         }
205         else
206         {
207             $this->parent->setPath('extension_root', JPATH_MANIFESTS . '/files/' . $this->element);
208         }
209     }
210 
211     /**
212      * Method to store the extension to the database
213      *
214      * @return  void
215      *
216      * @since   3.4
217      * @throws  RuntimeException
218      */
219     protected function storeExtension()
220     {
221         if ($this->currentExtensionId)
222         {
223             // Load the entry and update the manifest_cache
224             $this->extension->load($this->currentExtensionId);
225 
226             // Update name
227             $this->extension->name = $this->name;
228 
229             // Update manifest
230             $this->extension->manifest_cache = $this->parent->generateManifestCache();
231 
232             if (!$this->extension->store())
233             {
234                 // Install failed, roll back changes
235                 throw new RuntimeException(
236                     JText::sprintf(
237                         'JLIB_INSTALLER_ABORT_ROLLBACK',
238                         JText::_('JLIB_INSTALLER_' . strtoupper($this->route)),
239                         $this->extension->getError()
240                     )
241                 );
242             }
243         }
244         else
245         {
246             // Add an entry to the extension table with a whole heap of defaults
247             $this->extension->name = $this->name;
248             $this->extension->type = 'file';
249             $this->extension->element = $this->element;
250 
251             // There is no folder for files so leave it blank
252             $this->extension->folder = '';
253             $this->extension->enabled = 1;
254             $this->extension->protected = 0;
255             $this->extension->access = 0;
256             $this->extension->client_id = 0;
257             $this->extension->params = '';
258             $this->extension->system_data = '';
259             $this->extension->manifest_cache = $this->parent->generateManifestCache();
260             $this->extension->custom_data = '';
261 
262             if (!$this->extension->store())
263             {
264                 // Install failed, roll back changes
265                 throw new RuntimeException(
266                     JText::sprintf(
267                         'JLIB_INSTALLER_ABORT_ROLLBACK',
268                         JText::_('JLIB_INSTALLER_' . strtoupper($this->route)),
269                         $this->extension->getError()
270                     )
271                 );
272             }
273 
274             // Since we have created a module item, we add it to the installation step stack
275             // so that if we have to rollback the changes we can undo it.
276             $this->parent->pushStep(array('type' => 'extension', 'extension_id' => $this->extension->extension_id));
277         }
278     }
279 
280     /**
281      * Custom uninstall method
282      *
283      * @param   string  $id  The id of the file to uninstall
284      *
285      * @return  boolean  True on success
286      *
287      * @since   3.1
288      */
289     public function uninstall($id)
290     {
291         $row = JTable::getInstance('extension');
292 
293         if (!$row->load($id))
294         {
295             JLog::add(JText::_('JLIB_INSTALLER_ERROR_FILE_UNINSTALL_LOAD_ENTRY'), JLog::WARNING, 'jerror');
296 
297             return false;
298         }
299 
300         if ($row->protected)
301         {
302             JLog::add(JText::_('JLIB_INSTALLER_ERROR_FILE_UNINSTALL_WARNCOREFILE'), JLog::WARNING, 'jerror');
303 
304             return false;
305         }
306 
307         /*
308          * Does this extension have a parent package?
309          * If so, check if the package disallows individual extensions being uninstalled if the package is not being uninstalled
310          */
311         if ($row->package_id && !$this->parent->isPackageUninstall() && !$this->canUninstallPackageChild($row->package_id))
312         {
313             JLog::add(JText::sprintf('JLIB_INSTALLER_ERROR_CANNOT_UNINSTALL_CHILD_OF_PACKAGE', $row->name), JLog::WARNING, 'jerror');
314 
315             return false;
316         }
317 
318         $retval = true;
319         $manifestFile = JPATH_MANIFESTS . '/files/' . $row->element . '.xml';
320 
321         // Because files may not have their own folders we cannot use the standard method of finding an installation manifest
322         if (file_exists($manifestFile))
323         {
324             // Set the files root path
325             $this->parent->setPath('extension_root', JPATH_MANIFESTS . '/files/' . $row->element);
326 
327             $xml = simplexml_load_file($manifestFile);
328 
329             // If we cannot load the XML file return null
330             if (!$xml)
331             {
332                 JLog::add(JText::_('JLIB_INSTALLER_ERROR_FILE_UNINSTALL_LOAD_MANIFEST'), JLog::WARNING, 'jerror');
333 
334                 return false;
335             }
336 
337             // Check for a valid XML root tag.
338             if ($xml->getName() !== 'extension')
339             {
340                 JLog::add(JText::_('JLIB_INSTALLER_ERROR_FILE_UNINSTALL_INVALID_MANIFEST'), JLog::WARNING, 'jerror');
341 
342                 return false;
343             }
344 
345             $this->setManifest($xml);
346 
347             // If there is an manifest class file, let's load it
348             $this->scriptElement = $this->getManifest()->scriptfile;
349             $manifestScript = (string) $this->getManifest()->scriptfile;
350 
351             if ($manifestScript)
352             {
353                 $manifestScriptFile = $this->parent->getPath('extension_root') . '/' . $manifestScript;
354 
355                 // Set the class name
356                 $classname = $row->element . 'InstallerScript';
357 
358                 JLoader::register($classname, $manifestScriptFile);
359 
360                 if (class_exists($classname))
361                 {
362                     // Create a new instance
363                     $this->parent->manifestClass = new $classname($this);
364 
365                     // And set this so we can copy it later
366                     $this->set('manifest_script', $manifestScript);
367                 }
368             }
369 
370             ob_start();
371             ob_implicit_flush(false);
372 
373             // Run uninstall if possible
374             if ($this->parent->manifestClass && method_exists($this->parent->manifestClass, 'uninstall'))
375             {
376                 $this->parent->manifestClass->uninstall($this);
377             }
378 
379             $msg = ob_get_contents();
380             ob_end_clean();
381 
382             if ($msg != '')
383             {
384                 $this->parent->set('extension_message', $msg);
385             }
386 
387             $db = JFactory::getDbo();
388 
389             // Let's run the uninstall queries for the extension
390             $result = $this->parent->parseSQLFiles($this->getManifest()->uninstall->sql);
391 
392             if ($result === false)
393             {
394                 // Install failed, rollback changes
395                 JLog::add(JText::sprintf('JLIB_INSTALLER_ERROR_FILE_UNINSTALL_SQL_ERROR', $db->stderr(true)), JLog::WARNING, 'jerror');
396                 $retval = false;
397             }
398 
399             // Remove the schema version
400             $query = $db->getQuery(true)
401                 ->delete('#__schemas')
402                 ->where('extension_id = ' . $row->extension_id);
403             $db->setQuery($query);
404             $db->execute();
405 
406             // Loop through all elements and get list of files and folders
407             foreach ($xml->fileset->files as $eFiles)
408             {
409                 $target = (string) $eFiles->attributes()->target;
410 
411                 // Create folder path
412                 if (empty($target))
413                 {
414                     $targetFolder = JPATH_ROOT;
415                 }
416                 else
417                 {
418                     $targetFolder = JPATH_ROOT . '/' . $target;
419                 }
420 
421                 $folderList = array();
422 
423                 // Check if all children exists
424                 if (count($eFiles->children()) > 0)
425                 {
426                     // Loop through all filenames elements
427                     foreach ($eFiles->children() as $eFileName)
428                     {
429                         if ($eFileName->getName() === 'folder')
430                         {
431                             $folderList[] = $targetFolder . '/' . $eFileName;
432                         }
433                         else
434                         {
435                             $fileName = $targetFolder . '/' . $eFileName;
436                             JFile::delete($fileName);
437                         }
438                     }
439                 }
440 
441                 // Delete any folders that don't have any content in them.
442                 foreach ($folderList as $folder)
443                 {
444                     $files = JFolder::files($folder);
445 
446                     if (!count($files))
447                     {
448                         JFolder::delete($folder);
449                     }
450                 }
451             }
452 
453             JFile::delete($manifestFile);
454 
455             // Lastly, remove the extension_root
456             $folder = $this->parent->getPath('extension_root');
457 
458             if (JFolder::exists($folder))
459             {
460                 JFolder::delete($folder);
461             }
462         }
463         else
464         {
465             JLog::add(JText::_('JLIB_INSTALLER_ERROR_FILE_UNINSTALL_INVALID_NOTFOUND_MANIFEST'), JLog::WARNING, 'jerror');
466 
467             // Delete the row because its broken
468             $row->delete();
469 
470             return false;
471         }
472 
473         $this->parent->removeFiles($xml->languages);
474 
475         $row->delete();
476 
477         return $retval;
478     }
479 
480     /**
481      * Function used to check if extension is already installed
482      *
483      * @param   string  $extension  The element name of the extension to install
484      *
485      * @return  boolean  True if extension exists
486      *
487      * @since   3.1
488      */
489     protected function extensionExistsInSystem($extension = null)
490     {
491         // Get a database connector object
492         $db = $this->parent->getDbo();
493 
494         $query = $db->getQuery(true)
495             ->select($db->quoteName('extension_id'))
496             ->from($db->quoteName('#__extensions'))
497             ->where($db->quoteName('type') . ' = ' . $db->quote('file'))
498             ->where($db->quoteName('element') . ' = ' . $db->quote($extension));
499         $db->setQuery($query);
500 
501         try
502         {
503             $db->execute();
504         }
505         catch (RuntimeException $e)
506         {
507             // Install failed, roll back changes
508             $this->parent->abort(JText::sprintf('JLIB_INSTALLER_ABORT_FILE_ROLLBACK', $db->stderr(true)));
509 
510             return false;
511         }
512         $id = $db->loadResult();
513 
514         if (empty($id))
515         {
516             return false;
517         }
518 
519         return true;
520     }
521 
522     /**
523      * Function used to populate files and folder list
524      *
525      * @return  boolean  none
526      *
527      * @since   3.1
528      */
529     protected function populateFilesAndFolderList()
530     {
531         // Initialise variable
532         $this->folderList = array();
533         $this->fileList = array();
534 
535         // Set root folder names
536         $packagePath = $this->parent->getPath('source');
537         $jRootPath = JPath::clean(JPATH_ROOT);
538 
539         // Loop through all elements and get list of files and folders
540         foreach ($this->getManifest()->fileset->files as $eFiles)
541         {
542             // Check if the element is files element
543             $folder = (string) $eFiles->attributes()->folder;
544             $target = (string) $eFiles->attributes()->target;
545 
546             // Split folder names into array to get folder names. This will help in creating folders
547             $arrList = preg_split("#/|\\/#", $target);
548 
549             $folderName = $jRootPath;
550 
551             foreach ($arrList as $dir)
552             {
553                 if (empty($dir))
554                 {
555                     continue;
556                 }
557 
558                 $folderName .= '/' . $dir;
559 
560                 // Check if folder exists, if not then add to the array for folder creation
561                 if (!JFolder::exists($folderName))
562                 {
563                     $this->folderList[] = $folderName;
564                 }
565             }
566 
567             // Create folder path
568             $sourceFolder = empty($folder) ? $packagePath : $packagePath . '/' . $folder;
569             $targetFolder = empty($target) ? $jRootPath : $jRootPath . '/' . $target;
570 
571             // Check if source folder exists
572             if (!JFolder::exists($sourceFolder))
573             {
574                 JLog::add(JText::sprintf('JLIB_INSTALLER_ABORT_FILE_INSTALL_FAIL_SOURCE_DIRECTORY', $sourceFolder), JLog::WARNING, 'jerror');
575 
576                 // If installation fails, rollback
577                 $this->parent->abort();
578 
579                 return false;
580             }
581 
582             // Check if all children exists
583             if (count($eFiles->children()))
584             {
585                 // Loop through all filenames elements
586                 foreach ($eFiles->children() as $eFileName)
587                 {
588                     $path['src'] = $sourceFolder . '/' . $eFileName;
589                     $path['dest'] = $targetFolder . '/' . $eFileName;
590                     $path['type'] = 'file';
591 
592                     if ($eFileName->getName() === 'folder')
593                     {
594                         $folderName         = $targetFolder . '/' . $eFileName;
595                         $this->folderList[] = $folderName;
596                         $path['type']       = 'folder';
597                     }
598 
599                     $this->fileList[] = $path;
600                 }
601             }
602             else
603             {
604                 $files = JFolder::files($sourceFolder);
605 
606                 foreach ($files as $file)
607                 {
608                     $path['src'] = $sourceFolder . '/' . $file;
609                     $path['dest'] = $targetFolder . '/' . $file;
610 
611                     $this->fileList[] = $path;
612                 }
613             }
614         }
615     }
616 
617     /**
618      * Refreshes the extension table cache
619      *
620      * @return  boolean result of operation, true if updated, false on failure
621      *
622      * @since   3.1
623      */
624     public function refreshManifestCache()
625     {
626         // Need to find to find where the XML file is since we don't store this normally
627         $manifestPath = JPATH_MANIFESTS . '/files/' . $this->parent->extension->element . '.xml';
628         $this->parent->manifest = $this->parent->isManifest($manifestPath);
629         $this->parent->setPath('manifest', $manifestPath);
630 
631         $manifest_details = JInstaller::parseXMLInstallFile($this->parent->getPath('manifest'));
632         $this->parent->extension->manifest_cache = json_encode($manifest_details);
633         $this->parent->extension->name = $manifest_details['name'];
634 
635         try
636         {
637             return $this->parent->extension->store();
638         }
639         catch (RuntimeException $e)
640         {
641             JLog::add(JText::_('JLIB_INSTALLER_ERROR_PACK_REFRESH_MANIFEST_CACHE'), JLog::WARNING, 'jerror');
642 
643             return false;
644         }
645     }
646 }
647 
648 /**
649  * Deprecated class placeholder. You should use JInstallerAdapterFile instead.
650  *
651  * @since       3.1
652  * @deprecated  4.0
653  * @codeCoverageIgnore
654  */
655 class JInstallerFile extends JInstallerAdapterFile
656 {
657 }
658 

Joomla! Framework TM API documentation generated by ApiGen 2.8.0
Joomla!® and Joomla! Framework™ are trademarks of Open Source Matters, Inc. in the United States and other countries.