You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
409 lines
12 KiB
409 lines
12 KiB
<?php
|
|
|
|
// This file is part of Moodle - http://moodle.org/
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/**
|
|
* Provides tool_installaddon_installer class.
|
|
*
|
|
* @package tool_installaddon
|
|
* @subpackage classes
|
|
* @copyright 2013 David Mudrak <david@moodle.com>
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
/**
|
|
* Implements main plugin features.
|
|
*
|
|
* @copyright 2013 David Mudrak <david@moodle.com>
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class tool_installaddon_installer {
|
|
|
|
/** @var tool_installaddon_installfromzip_form */
|
|
protected $installfromzipform = null;
|
|
|
|
/**
|
|
* Factory method returning an instance of this class.
|
|
*
|
|
* @return tool_installaddon_installer
|
|
*/
|
|
public static function instance() {
|
|
return new static();
|
|
}
|
|
|
|
/**
|
|
* Returns the URL to the main page of this admin tool
|
|
*
|
|
* @param array optional parameters
|
|
* @return moodle_url
|
|
*/
|
|
public function index_url(array $params = null) {
|
|
return new moodle_url('/admin/tool/installaddon/index.php', $params);
|
|
}
|
|
|
|
/**
|
|
* Returns URL to the repository that addons can be searched in and installed from
|
|
*
|
|
* @return moodle_url
|
|
*/
|
|
public function get_addons_repository_url() {
|
|
global $CFG;
|
|
|
|
if (!empty($CFG->config_php_settings['alternativeaddonsrepositoryurl'])) {
|
|
$url = $CFG->config_php_settings['alternativeaddonsrepositoryurl'];
|
|
} else {
|
|
$url = 'https://moodle.org/plugins/get.php';
|
|
}
|
|
|
|
if (!$this->should_send_site_info()) {
|
|
return new moodle_url($url);
|
|
}
|
|
|
|
// Append the basic information about our site.
|
|
$site = array(
|
|
'fullname' => $this->get_site_fullname(),
|
|
'url' => $this->get_site_url(),
|
|
'majorversion' => $this->get_site_major_version(),
|
|
);
|
|
|
|
$site = $this->encode_site_information($site);
|
|
|
|
return new moodle_url($url, array('site' => $site));
|
|
}
|
|
|
|
/**
|
|
* @return tool_installaddon_installfromzip_form
|
|
*/
|
|
public function get_installfromzip_form() {
|
|
if (!is_null($this->installfromzipform)) {
|
|
return $this->installfromzipform;
|
|
}
|
|
|
|
$action = $this->index_url();
|
|
$customdata = array('installer' => $this);
|
|
|
|
$this->installfromzipform = new tool_installaddon_installfromzip_form($action, $customdata);
|
|
|
|
return $this->installfromzipform;
|
|
}
|
|
|
|
/**
|
|
* Makes a unique writable storage for uploaded ZIP packages.
|
|
*
|
|
* We need the saved ZIP to survive across multiple requests so that it can
|
|
* be used by the plugin manager after the installation is confirmed. In
|
|
* other words, we cannot use make_request_directory() here.
|
|
*
|
|
* @return string full path to the directory
|
|
*/
|
|
public function make_installfromzip_storage() {
|
|
return make_unique_writable_directory(make_temp_directory('tool_installaddon'));
|
|
}
|
|
|
|
/**
|
|
* Returns localised list of available plugin types
|
|
*
|
|
* @return array (string)plugintype => (string)plugin name
|
|
*/
|
|
public function get_plugin_types_menu() {
|
|
global $CFG;
|
|
|
|
$pluginman = core_plugin_manager::instance();
|
|
|
|
$menu = array('' => get_string('choosedots'));
|
|
foreach (array_keys($pluginman->get_plugin_types()) as $plugintype) {
|
|
$menu[$plugintype] = $pluginman->plugintype_name($plugintype).' ('.$plugintype.')';
|
|
}
|
|
|
|
return $menu;
|
|
}
|
|
|
|
/**
|
|
* Hook method to handle the remote request to install an add-on
|
|
*
|
|
* This is used as a callback when the admin picks a plugin version in the
|
|
* Moodle Plugins directory and is redirected back to their site to install
|
|
* it.
|
|
*
|
|
* This hook is called early from admin/tool/installaddon/index.php page so that
|
|
* it has opportunity to take over the UI and display the first confirmation screen.
|
|
*
|
|
* @param tool_installaddon_renderer $output
|
|
* @param string|null $request
|
|
*/
|
|
public function handle_remote_request(tool_installaddon_renderer $output, $request) {
|
|
|
|
if (is_null($request)) {
|
|
return;
|
|
}
|
|
|
|
$data = $this->decode_remote_request($request);
|
|
|
|
if ($data === false) {
|
|
echo $output->remote_request_invalid_page($this->index_url());
|
|
exit();
|
|
}
|
|
|
|
list($plugintype, $pluginname) = core_component::normalize_component($data->component);
|
|
$pluginman = core_plugin_manager::instance();
|
|
|
|
$plugintypepath = $pluginman->get_plugintype_root($plugintype);
|
|
|
|
if (file_exists($plugintypepath.'/'.$pluginname)) {
|
|
echo $output->remote_request_alreadyinstalled_page($data, $this->index_url());
|
|
exit();
|
|
}
|
|
|
|
if (!$pluginman->is_plugintype_writable($plugintype)) {
|
|
$continueurl = $this->index_url(array('installaddonrequest' => $request));
|
|
echo $output->remote_request_permcheck_page($data, $plugintypepath, $continueurl, $this->index_url());
|
|
exit();
|
|
}
|
|
|
|
if (!$pluginman->is_remote_plugin_installable($data->component, $data->version, $reason)) {
|
|
$data->reason = $reason;
|
|
echo $output->remote_request_non_installable_page($data, $this->index_url());
|
|
exit();
|
|
}
|
|
|
|
$continueurl = $this->index_url(array(
|
|
'installremote' => $data->component,
|
|
'installremoteversion' => $data->version
|
|
));
|
|
|
|
echo $output->remote_request_confirm_page($data, $continueurl, $this->index_url());
|
|
exit();
|
|
}
|
|
|
|
/**
|
|
* Detect the given plugin's component name
|
|
*
|
|
* Only plugins that declare valid $plugin->component value in the version.php
|
|
* are supported.
|
|
*
|
|
* @param string $zipfilepath full path to the saved ZIP file
|
|
* @return string|bool declared component name or false if unable to detect
|
|
*/
|
|
public function detect_plugin_component($zipfilepath) {
|
|
|
|
$workdir = make_request_directory();
|
|
$versionphp = $this->extract_versionphp_file($zipfilepath, $workdir);
|
|
|
|
if (empty($versionphp)) {
|
|
return false;
|
|
}
|
|
|
|
return $this->detect_plugin_component_from_versionphp(file_get_contents($workdir.'/'.$versionphp));
|
|
}
|
|
|
|
//// End of external API ///////////////////////////////////////////////////
|
|
|
|
/**
|
|
* @see self::instance()
|
|
*/
|
|
protected function __construct() {
|
|
}
|
|
|
|
/**
|
|
* @return string this site full name
|
|
*/
|
|
protected function get_site_fullname() {
|
|
global $SITE;
|
|
|
|
return strip_tags($SITE->fullname);
|
|
}
|
|
|
|
/**
|
|
* @return string this site URL
|
|
*/
|
|
protected function get_site_url() {
|
|
global $CFG;
|
|
|
|
return $CFG->wwwroot;
|
|
}
|
|
|
|
/**
|
|
* @return string major version like 2.5, 2.6 etc.
|
|
*/
|
|
protected function get_site_major_version() {
|
|
return moodle_major_version();
|
|
}
|
|
|
|
/**
|
|
* Encodes the given array in a way that can be safely appended as HTTP GET param
|
|
*
|
|
* Be ware! The recipient may rely on the exact way how the site information is encoded.
|
|
* Do not change anything here unless you know what you are doing and understand all
|
|
* consequences! (Don't you love warnings like that, too? :-p)
|
|
*
|
|
* @param array $info
|
|
* @return string
|
|
*/
|
|
protected function encode_site_information(array $info) {
|
|
return base64_encode(json_encode($info));
|
|
}
|
|
|
|
/**
|
|
* Decide if the encoded site information should be sent to the add-ons repository site
|
|
*
|
|
* For now, we just return true. In the future, we may want to implement some
|
|
* privacy aware logic (based on site/user preferences for example).
|
|
*
|
|
* @return bool
|
|
*/
|
|
protected function should_send_site_info() {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Decode the request from the Moodle Plugins directory
|
|
*
|
|
* @param string $request submitted via 'installaddonrequest' HTTP parameter
|
|
* @return stdClass|bool false on error, object otherwise
|
|
*/
|
|
protected function decode_remote_request($request) {
|
|
|
|
$data = base64_decode($request, true);
|
|
|
|
if ($data === false) {
|
|
return false;
|
|
}
|
|
|
|
$data = json_decode($data);
|
|
|
|
if (is_null($data)) {
|
|
return false;
|
|
}
|
|
|
|
if (!isset($data->name) or !isset($data->component) or !isset($data->version)) {
|
|
return false;
|
|
}
|
|
|
|
$data->name = s(strip_tags($data->name));
|
|
|
|
if ($data->component !== clean_param($data->component, PARAM_COMPONENT)) {
|
|
return false;
|
|
}
|
|
|
|
list($plugintype, $pluginname) = core_component::normalize_component($data->component);
|
|
|
|
if ($plugintype === 'core') {
|
|
return false;
|
|
}
|
|
|
|
if ($data->component !== $plugintype.'_'.$pluginname) {
|
|
return false;
|
|
}
|
|
|
|
if (!core_component::is_valid_plugin_name($plugintype, $pluginname)) {
|
|
return false;
|
|
}
|
|
|
|
$plugintypes = core_component::get_plugin_types();
|
|
if (!isset($plugintypes[$plugintype])) {
|
|
return false;
|
|
}
|
|
|
|
// Keep this regex in sync with the one used by the download.moodle.org/api/x.y/pluginfo.php
|
|
if (!preg_match('/^[0-9]+$/', $data->version)) {
|
|
return false;
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* Extracts the version.php from the given plugin ZIP file into the target directory
|
|
*
|
|
* @param string $zipfilepath full path to the saved ZIP file
|
|
* @param string $targetdir full path to extract the file to
|
|
* @return string|bool path to the version.php within the $targetpath; false on error (e.g. not found)
|
|
*/
|
|
protected function extract_versionphp_file($zipfilepath, $targetdir) {
|
|
global $CFG;
|
|
require_once($CFG->libdir.'/filelib.php');
|
|
|
|
$fp = get_file_packer('application/zip');
|
|
$files = $fp->list_files($zipfilepath);
|
|
|
|
if (empty($files)) {
|
|
return false;
|
|
}
|
|
|
|
$rootdirname = null;
|
|
$found = null;
|
|
|
|
foreach ($files as $file) {
|
|
// Valid plugin ZIP package has just one root directory with all
|
|
// files in it.
|
|
$pathnameitems = explode('/', $file->pathname);
|
|
|
|
if (empty($pathnameitems)) {
|
|
return false;
|
|
}
|
|
|
|
// Set the expected name of the root directory in the first
|
|
// iteration of the loop.
|
|
if ($rootdirname === null) {
|
|
$rootdirname = $pathnameitems[0];
|
|
}
|
|
|
|
// Require the same root directory for all files in the ZIP
|
|
// package.
|
|
if ($rootdirname !== $pathnameitems[0]) {
|
|
return false;
|
|
}
|
|
|
|
// If we reached the valid version.php file, remember it.
|
|
if ($pathnameitems[1] === 'version.php' and !$file->is_directory and $file->size > 0) {
|
|
$found = $file->pathname;
|
|
}
|
|
}
|
|
|
|
if (empty($found)) {
|
|
return false;
|
|
}
|
|
|
|
$extracted = $fp->extract_to_pathname($zipfilepath, $targetdir, array($found));
|
|
|
|
if (empty($extracted)) {
|
|
return false;
|
|
}
|
|
|
|
// The following syntax uses function array dereferencing, added in PHP 5.4.0.
|
|
return array_keys($extracted)[0];
|
|
}
|
|
|
|
/**
|
|
* Return the plugin component declared in its version.php file
|
|
*
|
|
* @param string $code the contents of the version.php file
|
|
* @return string|bool declared plugin component or false if unable to detect
|
|
*/
|
|
protected function detect_plugin_component_from_versionphp($code) {
|
|
|
|
$result = preg_match_all('#^\s*\$plugin\->component\s*=\s*([\'"])(.+?_.+?)\1\s*;#m', $code, $matches);
|
|
|
|
// Return if and only if the single match was detected.
|
|
if ($result === 1 and !empty($matches[2][0])) {
|
|
return $matches[2][0];
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|