MDL-38509 Add ability to install add-ons from the remote repository
[moodle.git] / admin / tool / installaddon / classes / installer.php
1 <?php
3 // This file is part of Moodle - http://moodle.org/
4 //
5 // Moodle is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // Moodle is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * Provides tool_installaddon_installer related classes
20  *
21  * @package     tool_installaddon
22  * @subpackage  classes
23  * @copyright   2013 David Mudrak <david@moodle.com>
24  * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
25  */
27 defined('MOODLE_INTERNAL') || die();
29 /**
30  * Implements main plugin features.
31  *
32  * @copyright 2013 David Mudrak <david@moodle.com>
33  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
34  */
35 class tool_installaddon_installer {
37     /** @var tool_installaddon_installfromzip */
38     protected $installfromzipform = null;
40     /**
41      * Factory method returning an instance of this class.
42      *
43      * @return tool_installaddon_installer
44      */
45     public static function instance() {
46         return new static();
47     }
49     /**
50      * Returns the URL to the main page of this admin tool
51      *
52      * @param array optional parameters
53      * @return moodle_url
54      */
55     public function index_url(array $params = null) {
56         return new moodle_url('/admin/tool/installaddon/index.php', $params);
57     }
59     /**
60      * Returns URL to the repository that addons can be searched in and installed from
61      *
62      * @return moodle_url
63      */
64     public function get_addons_repository_url() {
65         global $CFG;
67         if (!empty($CFG->config_php_settings['alternativeaddonsrepositoryurl'])) {
68             $url = $CFG->config_php_settings['alternativeaddonsrepositoryurl'];
69         } else {
70             $url = 'https://moodle.org/plugins/get.php';
71         }
73         if (!$this->should_send_site_info()) {
74             return new moodle_url($url);
75         }
77         // Append the basic information about our site.
78         $site = array(
79             'fullname' => $this->get_site_fullname(),
80             'url' => $this->get_site_url(),
81             'majorversion' => $this->get_site_major_version(),
82         );
84         $site = $this->encode_site_information($site);
86         return new moodle_url($url, array('site' => $site));
87     }
89     /**
90      * @return tool_installaddon_installfromzip
91      */
92     public function get_installfromzip_form() {
93         global $CFG;
94         require_once(dirname(__FILE__).'/installfromzip_form.php');
96         if (!is_null($this->installfromzipform)) {
97             return $this->installfromzipform;
98         }
100         $action = $this->index_url();
101         $customdata = array('installer' => $this);
103         $this->installfromzipform = new tool_installaddon_installfromzip($action, $customdata);
105         return $this->installfromzipform;
106     }
108     /**
109      * Saves the ZIP file from the {@link tool_installaddon_installfromzip} form
110      *
111      * The file is saved into the given temporary location for inspection and eventual
112      * deployment. The form is expected to be submitted and validated.
113      *
114      * @param tool_installaddon_installfromzip $form
115      * @param string $targetdir full path to the directory where the ZIP should be stored to
116      * @return string filename of the saved file relative to the given target
117      */
118     public function save_installfromzip_file(tool_installaddon_installfromzip $form, $targetdir) {
120         $filename = clean_param($form->get_new_filename('zipfile'), PARAM_FILE);
121         $form->save_file('zipfile', $targetdir.'/'.$filename);
123         return $filename;
124     }
126     /**
127      * Extracts the saved file previously saved by {self::save_installfromzip_file()}
128      *
129      * The list of files found in the ZIP is returned via $zipcontentfiles parameter
130      * by reference. The format of that list is array of (string)filerelpath => (bool|string)
131      * where the array value is either true or a string describing the problematic file.
132      *
133      * @see zip_packer::extract_to_pathname()
134      * @param string $zipfilepath full path to the saved ZIP file
135      * @param string $targetdir full path to the directory to extract the ZIP file to
136      * @param string $rootdir explicitly rename the root directory of the ZIP into this non-empty value
137      * @param array list of extracted files as returned by {@link zip_packer::extract_to_pathname()}
138      */
139     public function extract_installfromzip_file($zipfilepath, $targetdir, $rootdir = '') {
140         global $CFG;
141         require_once($CFG->libdir.'/filelib.php');
143         $fp = get_file_packer('application/zip');
144         $files = $fp->extract_to_pathname($zipfilepath, $targetdir);
146         if ($files) {
147             if (!empty($rootdir)) {
148                 $files = $this->rename_extracted_rootdir($targetdir, $rootdir, $files);
149             }
150             return $files;
152         } else {
153             return array();
154         }
155     }
157     /**
158      * Returns localised list of available plugin types
159      *
160      * @return array (string)plugintype => (string)plugin name
161      */
162     public function get_plugin_types_menu() {
163         global $CFG;
164         require_once($CFG->libdir.'/pluginlib.php');
166         $pluginman = plugin_manager::instance();
168         $menu = array('' => get_string('choosedots'));
169         foreach (array_keys($pluginman->get_plugin_types()) as $plugintype) {
170             $menu[$plugintype] = $pluginman->plugintype_name($plugintype).' ('.$plugintype.')';
171         }
173         return $menu;
174     }
176     /**
177      * Returns the full path of the root of the given plugin type
178      *
179      * Null is returned if the plugin type is not known. False is returned if the plugin type
180      * root is expected but not found. Otherwise, string is returned.
181      *
182      * @param string $plugintype
183      * @return string|bool|null
184      */
185     public function get_plugintype_root($plugintype) {
187         $plugintypepath = null;
188         foreach (get_plugin_types() as $type => $fullpath) {
189             if ($type === $plugintype) {
190                 $plugintypepath = $fullpath;
191                 break;
192             }
193         }
194         if (is_null($plugintypepath)) {
195             return null;
196         }
198         if (!is_dir($plugintypepath)) {
199             return false;
200         }
202         return $plugintypepath;
203     }
205     /**
206      * Is it possible to create a new plugin directory for the given plugin type?
207      *
208      * @throws coding_exception for invalid plugin types or non-existing plugin type locations
209      * @param string $plugintype
210      * @return boolean
211      */
212     public function is_plugintype_writable($plugintype) {
214         $plugintypepath = $this->get_plugintype_root($plugintype);
216         if (is_null($plugintypepath)) {
217             throw new coding_exception('Unknown plugin type!');
218         }
220         if ($plugintypepath === false) {
221             throw new coding_exception('Plugin type location does not exist!');
222         }
224         return is_writable($plugintypepath);
225     }
227     /**
228      * Hook method to handle the remote request to install an add-on
229      *
230      * This is used as a callback when the admin picks a plugin version in the
231      * Moodle Plugins directory and is redirected back to their site to install
232      * it.
233      *
234      * This hook is called early from admin/tool/installaddon/index.php page so that
235      * it has opportunity to take over the UI.
236      *
237      * @param tool_installaddon_renderer $output
238      * @param string|null $request
239      * @param bool $confirmed
240      */
241     public function handle_remote_request(tool_installaddon_renderer $output, $request, $confirmed = false) {
242         global $CFG;
243         require_once(dirname(__FILE__).'/pluginfo_client.php');
245         if (is_null($request)) {
246             return;
247         }
249         $data = $this->decode_remote_request($request);
251         if ($data === false) {
252             echo $output->remote_request_invalid_page($this->index_url());
253             exit();
254         }
256         list($plugintype, $pluginname) = normalize_component($data->component);
258         $plugintypepath = $this->get_plugintype_root($plugintype);
260         if (file_exists($plugintypepath.'/'.$pluginname)) {
261             echo $output->remote_request_alreadyinstalled_page($data, $this->index_url());
262             exit();
263         }
265         if (!$this->is_plugintype_writable($plugintype)) {
266             $continueurl = $this->index_url(array('installaddonrequest' => $request));
267             echo $output->remote_request_permcheck_page($data, $plugintypepath, $continueurl, $this->index_url());
268             exit();
269         }
271         $continueurl = $this->index_url(array(
272             'installaddonrequest' => $request,
273             'confirm' => 1,
274             'sesskey' => sesskey()));
276         if (!$confirmed) {
277             echo $output->remote_request_confirm_page($data, $continueurl, $this->index_url());
278             exit();
279         }
281         // The admin has confirmed their intention to install the add-on.
282         require_sesskey();
284         // Fetch the plugin info. The essential information is the URL to download the ZIP
285         // and the MD5 hash of the ZIP, obtained via HTTPS.
286         $client = tool_installaddon_pluginfo_client::instance();
288         try {
289             $pluginfo = $client->get_pluginfo($data->component, $data->version);
291         } catch (tool_installaddon_pluginfo_exception $e) {
292             if (debugging()) {
293                 throw $e;
294             } else {
295                 echo $output->remote_request_pluginfo_exception($data, $e, $this->index_url());
296                 exit();
297             }
298         }
300         // Fetch the ZIP with the plugin version
301         $jobid = md5(rand().uniqid('', true));
302         $sourcedir = make_temp_directory('tool_installaddon/'.$jobid.'/source');
303         $zipfilename = 'downloaded.zip';
305         try {
306             $this->download_file($pluginfo->downloadurl, $sourcedir.'/'.$zipfilename);
308         } catch (tool_installaddon_installer_exception $e) {
309             if (debugging()) {
310                 throw $e;
311             } else {
312                 echo $output->installer_exception($e, $this->index_url());
313                 exit();
314             }
315         }
317         // Check the MD5 checksum
318         $md5expected = $pluginfo->downloadmd5;
319         $md5actual = md5_file($sourcedir.'/'.$zipfilename);
320         if ($md5expected !== $md5actual) {
321             $e = new tool_installaddon_installer_exception('err_zip_md5', array('expected' => $md5expected, 'actual' => $md5actual));
322             if (debugging()) {
323                 throw $e;
324             } else {
325                 echo $output->installer_exception($e, $this->index_url());
326                 exit();
327             }
328         }
330         // Redirect to the validation page.
331         $nexturl = new moodle_url('/admin/tool/installaddon/validate.php', array(
332             'sesskey' => sesskey(),
333             'jobid' => $jobid,
334             'zip' => $zipfilename,
335             'type' => $plugintype));
336         redirect($nexturl);
337     }
339     /**
340      * Download the given file into the given destination.
341      *
342      * This is basically a simplified version of {@link download_file_content()} from
343      * Moodle itself, tuned for fetching files from moodle.org servers. Same code is used
344      * in mdeploy.php for fetching available updates.
345      *
346      * @param string $source file url starting with http(s)://
347      * @param string $target store the downloaded content to this file (full path)
348      * @throws tool_installaddon_installer_exception
349      */
350     public function download_file($source, $target) {
351         global $CFG;
353         $newlines = array("\r", "\n");
354         $source = str_replace($newlines, '', $source);
355         if (!preg_match('|^https?://|i', $source)) {
356             throw new tool_installaddon_installer_exception('err_download_transport_protocol', $source);
357         }
358         if (!$ch = curl_init($source)) {
359             throw new tool_installaddon_installer_exception('err_curl_init', $source);
360         }
362         curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true); // verify the peer's certificate
363         curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2); // check the existence of a common name and also verify that it matches the hostname provided
364         curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); // return the transfer as a string
365         curl_setopt($ch, CURLOPT_HEADER, false); // don't include the header in the output
366         curl_setopt($ch, CURLOPT_TIMEOUT, 3600);
367         curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 20); // nah, moodle.org is never unavailable! :-p
368         curl_setopt($ch, CURLOPT_URL, $source);
370         $cacertfile = $CFG->dataroot.'/moodleorgca.crt';
371         if (is_readable($cacertfile)) {
372             // Do not use CA certs provided by the operating system. Instead,
373             // use this CA cert to verify the ZIP provider.
374             curl_setopt($ch, CURLOPT_CAINFO, $cacertfile);
375         }
377         if (!empty($CFG->proxyhost) and !is_proxybypass($source)) {
378             if (!empty($CFG->proxytype)) {
379                 if (strtoupper($CFG->proxytype) === 'SOCKS5') {
380                     curl_setopt($ch, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
381                 } else {
382                     curl_setopt($ch, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
383                     curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, false);
384                 }
385             }
387             if (empty($CFG->proxyport)) {
388                 curl_setopt($ch, CURLOPT_PROXY, $CFG->proxyhost);
389             } else {
390                 curl_setopt($ch, CURLOPT_PROXY, $CFG->proxyhost.':'.$CFG->proxyport);
391             }
393             if (!empty($CFG->proxyuser) and !empty($CFG->proxypassword)) {
394                 curl_setopt($ch, CURLOPT_PROXYUSERPWD, $CFG->proxyuser.':'.$CFG->proxypassword);
395                 curl_setopt($ch, CURLOPT_PROXYAUTH, CURLAUTH_BASIC | CURLAUTH_NTLM);
396             }
397         }
399         $targetfile = fopen($target, 'w');
401         if (!$targetfile) {
402             throw new tool_installaddon_installer_exception('err_download_write_file', $target);
403         }
405         curl_setopt($ch, CURLOPT_FILE, $targetfile);
407         $result = curl_exec($ch);
409         // try to detect encoding problems
410         if ((curl_errno($ch) == 23 or curl_errno($ch) == 61) and defined('CURLOPT_ENCODING')) {
411             curl_setopt($ch, CURLOPT_ENCODING, 'none');
412             $result = curl_exec($ch);
413         }
415         fclose($targetfile);
417         $curlerrno = curl_errno($ch);
418         $curlerror = curl_error($ch);
419         $curlinfo = curl_getinfo($ch);
421         if ($result === false or $curlerrno) {
422             throw new tool_installaddon_installer_exception('err_curl_exec', array('url' => $source, 'errorno' => $curlerrno, 'error' => $curlerror));
424         } else if (is_array($curlinfo) and (empty($curlinfo['http_code']) or $curlinfo['http_code'] != 200)) {
425             throw new tool_installaddon_installer_exception('err_curl_code', array('url' => $source, 'httpcode' => $curlinfo['http_code']));
426         }
427     }
429     //// End of external API ///////////////////////////////////////////////////
431     /**
432      * @see self::instance()
433      */
434     protected function __construct() {
435     }
437     /**
438      * @return string this site full name
439      */
440     protected function get_site_fullname() {
441         global $SITE;
443         return strip_tags($SITE->fullname);
444     }
446     /**
447      * @return string this site URL
448      */
449     protected function get_site_url() {
450         global $CFG;
452         return $CFG->wwwroot;
453     }
455     /**
456      * @return string major version like 2.5, 2.6 etc.
457      */
458     protected function get_site_major_version() {
459         return moodle_major_version();
460     }
462     /**
463      * Encodes the given array in a way that can be safely appended as HTTP GET param
464      *
465      * Be ware! The recipient may rely on the exact way how the site information is encoded.
466      * Do not change anything here unless you know what you are doing and understand all
467      * consequences! (Don't you love warnings like that, too? :-p)
468      *
469      * @param array $info
470      * @return string
471      */
472     protected function encode_site_information(array $info) {
473         return base64_encode(json_encode($info));
474     }
476     /**
477      * Decide if the encoded site information should be sent to the add-ons repository site
478      *
479      * For now, we just return true. In the future, we may want to implement some
480      * privacy aware logic (based on site/user preferences for example).
481      *
482      * @return bool
483      */
484     protected function should_send_site_info() {
485         return true;
486     }
488     /**
489      * Renames the root directory of the extracted ZIP package.
490      *
491      * This method does not validate the presence of the single root directory
492      * (the validator does it later). It just searches for the first directory
493      * under the given location and renames it.
494      *
495      * The method will not rename the root if the requested location already
496      * exists.
497      *
498      * @param string $dirname the location of the extracted ZIP package
499      * @param string $rootdir the requested name of the root directory
500      * @param array $files list of extracted files
501      * @return array eventually amended list of extracted files
502      */
503     protected function rename_extracted_rootdir($dirname, $rootdir, array $files) {
505         if (!is_dir($dirname)) {
506             debugging('Unable to rename rootdir of non-existing content', DEBUG_DEVELOPER);
507             return $files;
508         }
510         if (file_exists($dirname.'/'.$rootdir)) {
511             debugging('Unable to rename rootdir to already existing folder', DEBUG_DEVELOPER);
512             return $files;
513         }
515         $found = null; // The name of the first subdirectory under the $dirname.
516         foreach (scandir($dirname) as $item) {
517             if (substr($item, 0, 1) === '.') {
518                 continue;
519             }
520             if (is_dir($dirname.'/'.$item)) {
521                 $found = $item;
522                 break;
523             }
524         }
526         if (!is_null($found)) {
527             if (rename($dirname.'/'.$found, $dirname.'/'.$rootdir)) {
528                 $newfiles = array();
529                 foreach ($files as $filepath => $status) {
530                     $newpath = preg_replace('~^'.preg_quote($found.'/').'~', preg_quote($rootdir.'/'), $filepath);
531                     $newfiles[$newpath] = $status;
532                 }
533                 return $newfiles;
534             }
535         }
537         return $files;
538     }
540     /**
541      * Decode the request from the Moodle Plugins directory
542      *
543      * @param string $request submitted via 'installaddonrequest' HTTP parameter
544      * @return stdClass|bool false on error, object otherwise
545      */
546     protected function decode_remote_request($request) {
548         $data = base64_decode($request, true);
550         if ($data === false) {
551             return false;
552         }
554         $data = json_decode($data);
556         if (is_null($data)) {
557             return false;
558         }
560         if (!isset($data->name) or !isset($data->component) or !isset($data->version)) {
561             return false;
562         }
564         $data->name = s(strip_tags($data->name));
566         if ($data->component !== clean_param($data->component, PARAM_COMPONENT)) {
567             return false;
568         }
570         list($plugintype, $pluginname) = normalize_component($data->component);
572         if ($plugintype === 'core') {
573             return false;
574         }
576         if ($data->component !== $plugintype.'_'.$pluginname) {
577             return false;
578         }
580         // Keep this regex in sync with the one used by the download.moodle.org/api/x.y/pluginfo.php
581         if (!preg_match('/^[0-9]+$/', $data->version)) {
582             return false;
583         }
585         return $data;
586     }
590 /**
591  * General exception thrown by {@link tool_installaddon_installer} class
592  *
593  * @copyright 2013 David Mudrak <david@moodle.com>
594  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
595  */
596 class tool_installaddon_installer_exception extends moodle_exception {
598     /**
599      * @param string $errorcode exception description identifier
600      * @param mixed $debuginfo debugging data to display
601      */
602     public function __construct($errorcode, $a=null, $debuginfo=null) {
603         parent::__construct($errorcode, 'tool_installaddon', '', $a, print_r($debuginfo, true));
604     }