| 1 | <?php
 | 
  
    | 2 | /**
 | 
  
    | 3 |  * $Id: addon.precheck.inc.php 928 2009-02-15 12:29:07Z doc $
 | 
  
    | 4 |  * Website Baker Add-On precheck functions
 | 
  
    | 5 |  *
 | 
  
    | 6 |  * This file contains the functions of the pretest performed upfront
 | 
  
    | 7 |  * of the Add-On installation process. The functions allows developers
 | 
  
    | 8 |  * to specify requirements for their Add-On.
 | 
  
    | 9 |  *
 | 
  
    | 10 |  * LICENSE: GNU Lesser General Public License 3.0
 | 
  
    | 11 |  * 
 | 
  
    | 12 |  * @author		Christian Sommer
 | 
  
    | 13 |  * @copyright	(c) 2009
 | 
  
    | 14 |  * @license		http://www.gnu.org/copyleft/lesser.html
 | 
  
    | 15 |  * @version		0.2.3
 | 
  
    | 16 |  * @platform	Website Baker 2.7
 | 
  
    | 17 |  *
 | 
  
    | 18 |  * Website Baker Project <http://www.websitebaker.org/>
 | 
  
    | 19 |  * Copyright (C) 2004-2009, Ryan Djurovich
 | 
  
    | 20 |  *
 | 
  
    | 21 |  * Website Baker is free software; you can redistribute it and/or modify
 | 
  
    | 22 |  * it under the terms of the GNU General Public License as published by
 | 
  
    | 23 |  * the Free Software Foundation; either version 2 of the License, or
 | 
  
    | 24 |  * (at your option) any later version.
 | 
  
    | 25 |  *
 | 
  
    | 26 |  * Website Baker is distributed in the hope that it will be useful,
 | 
  
    | 27 |  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 | 
  
    | 28 |  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 | 
  
    | 29 |  * GNU General Public License for more details.
 | 
  
    | 30 |  *
 | 
  
    | 31 |  * You should have received a copy of the GNU General Public License
 | 
  
    | 32 |  * along with Website Baker; if not, write to the Free Software
 | 
  
    | 33 |  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 | 
  
    | 34 | */
 | 
  
    | 35 | 
 | 
  
    | 36 | // prevent this file from being accessed directly
 | 
  
    | 37 | if (!defined('WB_PATH')) die(header('Location: ../index.php'));
 | 
  
    | 38 | 
 | 
  
    | 39 | function getVersion($version, $strip_suffix = true)
 | 
  
    | 40 | {
 | 
  
    | 41 | 	/**
 | 
  
    | 42 | 	 * This funtion creates a version string following the major.minor.revision convention
 | 
  
    | 43 | 	 * The minor and revision part of the version may not exceed 999 (three digits)
 | 
  
    | 44 | 	 * An optional suffix part can be added after revision (requires $strip_suffix = false)
 | 
  
    | 45 | 	 *
 | 
  
    | 46 | 	 * EXAMPLES: input --> output
 | 
  
    | 47 | 	 *	5 --> 5.000000; 5.0 --> 5.000000; 5.0.0 --> 5.000000
 | 
  
    | 48 | 	 * 	5.2 --> 5.002000; 5.20 --> 5.002000; 5.2.0 --> 5.002000
 | 
  
    | 49 | 	 * 	5.21 --> 5.002001; 5.2.1 --> 5.002001;
 | 
  
    | 50 | 	 * 	5.27.1 --> 5.027001; 5.2.71 --> 5.002071;
 | 
  
    | 51 | 	 * 	5.27.1 rc1 --> 5.027001_RC1 ($strip_suffix:= false)
 | 
  
    | 52 | 	 */
 | 
  
    | 53 | 	// replace comma by decimal point
 | 
  
    | 54 | 	$version = str_replace(',', '.', $version);
 | 
  
    | 55 | 
 | 
  
    | 56 | 	// convert version into major.minor.revision numbering system
 | 
  
    | 57 | 	@list($major, $minor, $revision) = explode('.', $version, 3);
 | 
  
    | 58 | 
 | 
  
    | 59 | 	// convert versioning style 5.21 into 5.2.1
 | 
  
    | 60 | 	if ($revision == '' && strlen(intval($minor)) == 2) {
 | 
  
    | 61 | 		$revision = substr($minor, -1);
 | 
  
    | 62 | 		$minor = substr($minor, 0, 1);
 | 
  
    | 63 | 	}
 | 
  
    | 64 | 	
 | 
  
    | 65 | 	// extract possible non numerical suffix from revision part (e.g. Alpha, Beta, RC1)
 | 
  
    | 66 | 	$suffix = strtoupper(trim(substr($revision, strlen(intval($revision)))));
 | 
  
    | 67 | 
 | 
  
    | 68 | 	// return standard version number (minor and revision numbers may not exceed 999)
 | 
  
    | 69 | 	return (int) $major . '.' . sprintf('%03d', (int) $minor) . sprintf('%03d', (int) $revision) . 
 | 
  
    | 70 | 		(($strip_suffix == false && $suffix != '') ? '_' . $suffix : '');
 | 
  
    | 71 | }
 | 
  
    | 72 | 
 | 
  
    | 73 | function versionCompare($version1, $version2, $operator = '>=')
 | 
  
    | 74 | {
 | 
  
    | 75 | 	/**
 | 
  
    | 76 | 	 * This funtion performs a comparison of two provided version strings
 | 
  
    | 77 | 	 * The versions are first converted into a string following the major.minor.revision 
 | 
  
    | 78 | 	 * convention and performs a version_compare afterwards.
 | 
  
    | 79 | 	 */
 | 
  
    | 80 | 	return version_compare(getVersion($version1), getVersion($version2), $operator);
 | 
  
    | 81 | }
 | 
  
    | 82 | 
 | 
  
    | 83 | function sortPreCheckArray($precheck_array)
 | 
  
    | 84 | {
 | 
  
    | 85 | 	/**
 | 
  
    | 86 | 	 * This funtion sorts the precheck array to a common format
 | 
  
    | 87 | 	 */
 | 
  
    | 88 | 	// define desired precheck order
 | 
  
    | 89 | 	$key_order = array('WB_VERSION', 'WB_ADDONS', 'PHP_VERSION', 'PHP_EXTENSIONS', 'PHP_SETTINGS', 'CUSTOM_CHECKS');
 | 
  
    | 90 | 
 | 
  
    | 91 | 	$temp_array = array();
 | 
  
    | 92 | 	foreach($key_order as $key) {
 | 
  
    | 93 | 		if (!isset($precheck_array[$key])) continue;
 | 
  
    | 94 | 		$temp_array[$key] = $precheck_array[$key];
 | 
  
    | 95 | 	}
 | 
  
    | 96 | 	return $temp_array;
 | 
  
    | 97 | }
 | 
  
    | 98 | 
 | 
  
    | 99 | function preCheckAddon($temp_addon_file)
 | 
  
    | 100 | {
 | 
  
    | 101 | 	/**
 | 
  
    | 102 | 	 * This funtion performs pretest upfront of the Add-On installation process.
 | 
  
    | 103 | 	 * The requirements can be specified via the array $PRECHECK which needs to
 | 
  
    | 104 | 	 * be defined in the optional Add-on file precheck.php.
 | 
  
    | 105 | 	 */
 | 
  
    | 106 | 	global $database, $admin, $TEXT, $HEADING, $MESSAGE;
 | 
  
    | 107 | 	
 | 
  
    | 108 | 	// path to the temporary Add-on folder
 | 
  
    | 109 | 	$temp_path = WB_PATH . '/temp/unzip';
 | 
  
    | 110 | 	
 | 
  
    | 111 | 	// check if file precheck.php exists for the Add-On uploaded via WB installation routine
 | 
  
    | 112 | 	if (!file_exists($temp_path . '/precheck.php')) return;
 | 
  
    | 113 | 	
 | 
  
    | 114 | 	// unset any previous declared PRECHECK array
 | 
  
    | 115 | 	unset($PRECHECK);
 | 
  
    | 116 | 
 | 
  
    | 117 | 	// include Add-On precheck.php file
 | 
  
    | 118 | 	include($temp_path . '/precheck.php');
 | 
  
    | 119 | 	
 | 
  
    | 120 | 	// check if there are any Add-On requirements to check for
 | 
  
    | 121 | 	if (!(isset($PRECHECK) && count($PRECHECK) > 0)) return;
 | 
  
    | 122 | 	
 | 
  
    | 123 | 	// sort precheck array
 | 
  
    | 124 | 	$PRECHECK = sortPreCheckArray($PRECHECK);
 | 
  
    | 125 | 	
 | 
  
    | 126 | 	$failed_checks = 0;
 | 
  
    | 127 | 	$msg = array();
 | 
  
    | 128 | 	// check if specified addon requirements are fullfilled
 | 
  
    | 129 | 	foreach ($PRECHECK as $key => $value) {
 | 
  
    | 130 | 		switch ($key) {
 | 
  
    | 131 | 			case 'WB_VERSION':
 | 
  
    | 132 | 				if (isset($value['VERSION'])) {
 | 
  
    | 133 | 					// obtain operator for string comparison if exist
 | 
  
    | 134 | 					$operator = (isset($value['OPERATOR']) &&  trim($value['OPERATOR']) != '') ? $value['OPERATOR'] : '>=';
 | 
  
    | 135 | 				
 | 
  
    | 136 | 					// compare versions and extract actual status
 | 
  
    | 137 | 					$status = versionCompare(WB_VERSION, $value['VERSION'], $operator);
 | 
  
    | 138 | 					$msg[] = array(
 | 
  
    | 139 | 						'check'		=> 'WB-' . $TEXT['VERSION'] .': ',
 | 
  
    | 140 | 						'required'	=> htmlentities($operator) . $value['VERSION'],
 | 
  
    | 141 | 						'actual'	=> WB_VERSION,
 | 
  
    | 142 | 						'status'	=> $status
 | 
  
    | 143 | 					);
 | 
  
    | 144 | 
 | 
  
    | 145 | 					// increase counter if required
 | 
  
    | 146 | 					if (!$status) $failed_checks++;
 | 
  
    | 147 | 				}
 | 
  
    | 148 | 				break;
 | 
  
    | 149 | 
 | 
  
    | 150 | 			case 'WB_ADDONS':
 | 
  
    | 151 | 				if (is_array($PRECHECK['WB_ADDONS'])) {
 | 
  
    | 152 | 					foreach($PRECHECK['WB_ADDONS'] as $addon => $values) {
 | 
  
    | 153 | 						if (is_array($values)) {
 | 
  
    | 154 | 							// extract module version and operator
 | 
  
    | 155 | 							$version = (isset($values['VERSION']) &&  trim($values['VERSION']) != '') ? $values['VERSION'] : '';
 | 
  
    | 156 | 							$operator = (isset($values['OPERATOR']) &&  trim($values['OPERATOR']) != '') ? $values['OPERATOR'] : '>=';
 | 
  
    | 157 | 						} else {
 | 
  
    | 158 | 							// no version and operator specified (only check if addon exists)
 | 
  
    | 159 | 							$addon = strip_tags($values);
 | 
  
    | 160 | 							$version = ''; $operator = '';
 | 
  
    | 161 | 						}
 | 
  
    | 162 | 					
 | 
  
    | 163 | 						// check if addon is listed in WB database
 | 
  
    | 164 | 						$table = TABLE_PREFIX . 'addons';
 | 
  
    | 165 | 						$sql = "SELECT * FROM `$table` WHERE `directory` = '" . addslashes($addon) . "'";
 | 
  
    | 166 | 						$results = $database->query($sql);
 | 
  
    | 167 | 					
 | 
  
    | 168 | 						$status = false; $addon_status = $TEXT['NOT_INSTALLED'];
 | 
  
    | 169 | 						if ($results && $row = $results->fetchRow()) {
 | 
  
    | 170 | 							$status = true; 
 | 
  
    | 171 | 							$addon_status = $TEXT['INSTALLED'];
 | 
  
    | 172 | 						
 | 
  
    | 173 | 							// compare version if required
 | 
  
    | 174 | 							if ($version != '') {
 | 
  
    | 175 | 								$status = versionCompare($row['version'], $version, $operator);
 | 
  
    | 176 | 								$addon_status = $row['version'];
 | 
  
    | 177 | 							}
 | 
  
    | 178 | 						}
 | 
  
    | 179 | 					
 | 
  
    | 180 | 						// provide addon status
 | 
  
    | 181 | 						$msg[] = array(
 | 
  
    | 182 | 							'check'		=> '  ' . $TEXT['ADDON'] . ': ' . htmlentities($addon),
 | 
  
    | 183 | 							'required'	=> ($version != '') ? $operator . ' ' . $version : $TEXT['INSTALLED'],
 | 
  
    | 184 | 							'actual'	=> $addon_status,
 | 
  
    | 185 | 							'status'	=> $status
 | 
  
    | 186 | 						);
 | 
  
    | 187 | 						
 | 
  
    | 188 | 						// increase counter if required
 | 
  
    | 189 | 						if (!$status) $failed_checks++;
 | 
  
    | 190 | 					}
 | 
  
    | 191 | 				}
 | 
  
    | 192 | 				break;
 | 
  
    | 193 | 
 | 
  
    | 194 | 			case 'PHP_VERSION':
 | 
  
    | 195 | 				if (isset($value['VERSION'])) {
 | 
  
    | 196 | 					// obtain operator for string comparison if exist
 | 
  
    | 197 | 					$operator = (isset($value['OPERATOR']) &&  trim($value['OPERATOR']) != '') ? $value['OPERATOR'] : '>=';
 | 
  
    | 198 | 				
 | 
  
    | 199 | 					// compare versions and extract actual status
 | 
  
    | 200 | 					$status = versionCompare(PHP_VERSION, $value['VERSION'], $operator);
 | 
  
    | 201 | 					$msg[] = array(
 | 
  
    | 202 | 						'check'		=> 'PHP-' . $TEXT['VERSION'] .': ',
 | 
  
    | 203 | 						'required'	=> htmlentities($operator) . ' ' . $value['VERSION'],
 | 
  
    | 204 | 						'actual'	=> PHP_VERSION,
 | 
  
    | 205 | 						'status'	=> $status
 | 
  
    | 206 | 					);
 | 
  
    | 207 | 
 | 
  
    | 208 | 					// increase counter if required
 | 
  
    | 209 | 					if (!$status) $failed_checks++;
 | 
  
    | 210 | 
 | 
  
    | 211 | 				}
 | 
  
    | 212 | 				break;
 | 
  
    | 213 | 
 | 
  
    | 214 | 			case 'PHP_EXTENSIONS':
 | 
  
    | 215 | 				if (is_array($PRECHECK['PHP_EXTENSIONS'])) {
 | 
  
    | 216 | 					foreach($PRECHECK['PHP_EXTENSIONS'] as $extension) {
 | 
  
    | 217 | 						$status = extension_loaded(strtolower($extension));
 | 
  
    | 218 | 						$msg[] = array(
 | 
  
    | 219 | 							'check'		=> '  ' . $TEXT['EXTENSION'] . ': ' . htmlentities($extension),
 | 
  
    | 220 | 							'required'	=> $TEXT['INSTALLED'],
 | 
  
    | 221 | 							'actual'	=> ($status) ? $TEXT['INSTALLED'] : $TEXT['NOT_INSTALLED'],
 | 
  
    | 222 | 							'status'	=> $status
 | 
  
    | 223 | 						);
 | 
  
    | 224 | 
 | 
  
    | 225 | 						// increase counter if required
 | 
  
    | 226 | 						if (!$status) $failed_checks++;
 | 
  
    | 227 | 					}
 | 
  
    | 228 | 				}
 | 
  
    | 229 | 				break;
 | 
  
    | 230 | 
 | 
  
    | 231 | 			case 'PHP_SETTINGS':
 | 
  
    | 232 | 				if (is_array($PRECHECK['PHP_SETTINGS'])) {
 | 
  
    | 233 | 					foreach($PRECHECK['PHP_SETTINGS'] as $setting => $value) {
 | 
  
    | 234 | 						$actual_setting = ($temp = ini_get($setting)) ? $temp : 0;
 | 
  
    | 235 | 						$status = ($actual_setting == $value);
 | 
  
    | 236 | 					
 | 
  
    | 237 | 						$msg[] = array(
 | 
  
    | 238 | 							'check'		=> '  '. ($setting),
 | 
  
    | 239 | 							'required'	=> $value,
 | 
  
    | 240 | 							'actual'	=> $actual_setting,
 | 
  
    | 241 | 							'status'	=> $status
 | 
  
    | 242 | 						);
 | 
  
    | 243 | 
 | 
  
    | 244 | 						// increase counter if required
 | 
  
    | 245 | 						if (!$status) $failed_checks++;
 | 
  
    | 246 | 					}
 | 
  
    | 247 | 				}
 | 
  
    | 248 | 				break;
 | 
  
    | 249 | 
 | 
  
    | 250 | 			case 'CUSTOM_CHECKS':
 | 
  
    | 251 | 				if (is_array($PRECHECK['CUSTOM_CHECKS'])) {
 | 
  
    | 252 | 					foreach($PRECHECK['CUSTOM_CHECKS'] as $key => $values) {
 | 
  
    | 253 | 						$msg[] = array(
 | 
  
    | 254 | 							'check'		=> $key,
 | 
  
    | 255 | 							'required'	=> $values['REQUIRED'],
 | 
  
    | 256 | 							'actual'	=> $values['ACTUAL'],
 | 
  
    | 257 | 							'status'	=> $values['STATUS']
 | 
  
    | 258 | 						);
 | 
  
    | 259 | 					}
 | 
  
    | 260 | 
 | 
  
    | 261 | 					// increase counter if required
 | 
  
    | 262 | 					if (!$status) $failed_checks++;
 | 
  
    | 263 | 				}
 | 
  
    | 264 | 				break;
 | 
  
    | 265 | 		}
 | 
  
    | 266 | 	}
 | 
  
    | 267 | 
 | 
  
    | 268 | 	// leave if all requirements are fullfilled
 | 
  
    | 269 | 	if ($failed_checks == 0) return;
 | 
  
    | 270 | 	
 | 
  
    | 271 | 	// output summary table with requirements not fullfilled
 | 
  
    | 272 | 	echo <<< EOT
 | 
  
    | 273 | 	<h2>{$HEADING['ADDON_PRECHECK_FAILED']}</h2>
 | 
  
    | 274 | 	<p>{$MESSAGE['ADDON']['PRECHECK_FAILED']}</p> 
 | 
  
    | 275 | 
 | 
  
    | 276 | 	<table width="700px" cellpadding="4" border="0" style="margin: 0.5em; border-collapse: collapse; border: 1px solid silver;">
 | 
  
    | 277 | 	<tr>
 | 
  
    | 278 | 		<th>{$TEXT['REQUIREMENT']}:</th>
 | 
  
    | 279 | 		<th>{$TEXT['REQUIRED']}:</th>
 | 
  
    | 280 | 		<th>{$TEXT['CURRENT']}:</th>
 | 
  
    | 281 | 	</tr>
 | 
  
    | 282 | EOT;
 | 
  
    | 283 | 
 | 
  
    | 284 | 	foreach($msg as $check) {
 | 
  
    | 285 | 		echo '<tr>';
 | 
  
    | 286 | 		$style = $check['status'] ? 'color: #46882B;' : 'color: #C00;';
 | 
  
    | 287 | 		foreach($check as $key => $value) {
 | 
  
    | 288 | 			if ($key == 'status') continue;
 | 
  
    | 289 | 			
 | 
  
    | 290 | 			echo '<td style="' . $style . '">' . $value . '</td>';
 | 
  
    | 291 | 		}
 | 
  
    | 292 | 		echo '</tr>';
 | 
  
    | 293 | 	}
 | 
  
    | 294 | 	echo '</table>';
 | 
  
    | 295 | 
 | 
  
    | 296 | 	// delete the temp unzip directory
 | 
  
    | 297 | 	rm_full_dir($temp_path);	
 | 
  
    | 298 | 
 | 
  
    | 299 | 	// delete the temporary zip file of the Add-on
 | 
  
    | 300 | 	if(file_exists($temp_addon_file)) { unlink($temp_addon_file); }	
 | 
  
    | 301 | 	
 | 
  
    | 302 | 	// output status message and die
 | 
  
    | 303 | 	$admin->print_error('');
 | 
  
    | 304 | }
 | 
  
    | 305 | 
 | 
  
    | 306 | ?>
 |