pfSense

<?php

 * pkg-utils.inc

 */

 *	Copyright (c)  2004-2015  Electric Sheep Fencing, LLC. All rights reserved.

 *	Copyright (c)  2005-2006 Colin Smith (ethethlay@gmail.com)

 *

 *	Redistribution and use in source and binary forms, with or without modification,

 *	are permitted provided that the following conditions are met:

 *

 *	1. Redistributions of source code must retain the above copyright notice,

 *		this list of conditions and the following disclaimer.

 *

 *	2. Redistributions in binary form must reproduce the above copyright

 *		notice, this list of conditions and the following disclaimer in

 *		the documentation and/or other materials provided with the

 *		distribution.

 *

 *	3. All advertising materials mentioning features or use of this software

 *		must display the following acknowledgment:

 *		"This product includes software developed by the pfSense Project

 *		 for use in the pfSense software distribution. (http://www.pfsense.org/).

 *

 *	4. The names "pfSense" and "pfSense Project" must not be used to

 *		 endorse or promote products derived from this software without

 *		 prior written permission. For written permission, please contact

 *		 coreteam@pfsense.org.

 *

 *	5. Products derived from this software may not be called "pfSense"

 *		nor may "pfSense" appear in their names without prior written

 *		permission of the Electric Sheep Fencing, LLC.

 *

 *	6. Redistributions of any form whatsoever must retain the following

 *		acknowledgment:

 *

 *	"This product includes software developed by the pfSense Project

 *	for use in the pfSense software distribution (http://www.pfsense.org/).

 *

 *	THIS SOFTWARE IS PROVIDED BY THE pfSense PROJECT ``AS IS'' AND ANY

 *	EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 *	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 *	PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE pfSense PROJECT OR

 *	ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 *	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 *	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 *	LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 *	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

 *	STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 *	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED

 *	OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 *	====================================================================

 *

	/* set up logging if needed */

	function pkg_debug($msg) {

		global $g, $debug, $fd_log;

		if (!$fd_log) {

		@fwrite($fd_log, $msg);

	}

}

function pkg_valid_name($pkgname) {

	global $g;

	$pattern = "/^{$g['pkg_prefix']}[a-zA-Z0-9\.\-_]+$/";

	return preg_match($pattern, $pkgname);

}

function pkg_remove_prefix(&$pkg_name) {

	global $g;

	if (substr($pkg_name, 0, strlen($g['pkg_prefix'])) == $g['pkg_prefix']) {

		$pkg_name = substr($pkg_name, strlen($g['pkg_prefix']));

	}

function pkg_update($force = false) {

	global $g;

	$pkg_env_vars = array(

		"FETCH_TIMEOUT" => 5,

		"FETCH_RETRY" => 2

		$http_proxy = $config['system']['proxyurl'];

		if (!empty($config['system']['proxyport'])) {

			$http_proxy .= ':' . $config['system']['proxyport'];

		}

		$pkg_env_vars['HTTP_PROXY'] = $http_proxy;

	}

	    isset($config['system']['use_mfs_tmpvar'])) {

		$pkg_env_vars['PKG_DBDIR'] = '/root/var/db/pkg';

		$pkg_env_vars['PKG_CACHEDIR'] = '/root/var/cache/pkg';

	}

		$pkg_env_vars[$key] = $value;

	}

}

		return false;

	}

		1 => array("pipe", "w"), /* stdout */

	if (!is_resource($process)) {

	}

	stream_set_blocking($pipes[1], 0);

	stream_set_blocking($pipes[2], 0);

	/* XXX: should be a tunnable? */

	$timeout = 300; // seconds

	$error_log = '';

	do {

		$write = array();

		$read = array($pipes[1], $pipes[2]);

		$except = array();

		$stream = stream_select($read, $write, $except, null, $timeout);

		if ($stream !== FALSE && $stream > 0) {

			foreach ($read as $pipe) {

				$content = stream_get_contents($pipe);

				if ($content == '') {

					continue;

				}

				if ($pipe === $pipes[1]) {

					if (!$mute) {

					flush();

				} else if ($pipe === $pipes[2]) {

					$error_log .= $content;

				}

			}

	} while ($status['running']);

	fclose($pipes[2]);

	proc_close($process);

	pkg_debug("pkg_call(): rc = {$rc}\n");

	if ($rc == 0) {

		return true;

	}

	pkg_debug("pkg_call(): error_log\n{$error_log}\n");

	if (!$mute) {

		    "ERROR!!! An error occurred on pkg execution (rc = %d) with parameters '%s':"),

		    $rc, $params) . "\n" . $error_log . "\n");

	if (empty($params)) {

		return -1;

	}

		1 => array("pipe", "w"), /* stdout */

	if (!is_resource($process)) {

	}

	$stdout = '';

	while (($l = fgets($pipes[1])) !== FALSE) {

		$stdout .= $l;

	}

	fclose($pipes[1]);

	$stderr = '';

	while (($l = fgets($pipes[2])) !== FALSE) {

		$stderr .= $l;

	}

	fclose($pipes[2]);

 * '=' - versions are the same

 * '>' - $v1 > $v2

 * '<' - $v1 < $v2

 * '?' - Error

 */

function pkg_version_compare($v1, $v2) {

	if (empty($v1) || empty($v2)) {

		return '?';

	}

	if ($rc != 0) {

		return '?';

	}

	return str_replace("\n", "", $stdout);

}

function is_pkg_installed($pkg_name) {

	global $g;

		return false;

	}

	pkg_remove_prefix($shortname);

	if ($force) {

		$pkg_force = "-f ";

	}

		pkg_call("clean -y");

function pkg_delete($pkg_name) {

	global $g;

	pkg_remove_prefix($shortname);

function is_package_installed($package_name) {

	return (get_package_id($package_name) != -1);

function get_package_id($package_name) {

		return -1;

	}

	foreach ($config['installedpackages']['package'] as $idx => $pkg) {

	}

function get_package_internal_name($package_data) {

	if (isset($package_data['internal_name']) && ($package_data['internal_name'] != "")) {

}

	$err = '';

	if (is_array($pkgs)) {

		$pkg_filter = $pkgs;

		$pkgs = 'all';

	}

		$pkgs = $g['pkg_prefix'];

	}

		require_once("util.inc");

	}

	/* Do not run remote operations if pkg has a lock */

	if (is_subsystem_dirty('pkg')) {

		$only_local = true;

		$lock = false;

	} else {

		$lock = true;

	}

	if ($only_local) {

		$extra_param = "-U ";

	}

		mark_subsystem_dirty('pkg');

	}

		clear_subsystem_dirty('pkg');

	}

		    "ERROR: Error trying to get packages list. Aborting...")

		    . "\n");

		update_status($err);

		$input_errors[] =  $err;

	}

	$result = array();

	$pkgs_info = explode("\n", $out);

	foreach ($pkgs_info as $pkg_info_json) {

		$pkg_info = json_decode($pkg_info_json, true);

		if (!isset($pkg_info['name'])) {

			continue;

		}

			continue;

		}

		pkg_remove_prefix($pkg_info['shortname']);

		/* XXX: Add it to globals.inc? */

		$pkg_info['changeloglink'] =

		    "https://github.com/pfsense/FreeBSD-ports/commits/devel/" .

		    $pkg_info['categories'][0] . '/' . $pkg_info['name'];

			$pkg_info['installed'] = true;

			if ($rc != 0) {

				    "ERROR: Error trying to get package version. Aborting...")

				    . "\n");

				update_status($err);

				$input_errors[] =  $err;

				return array();

			}

			$pkg_info['installed_version'] = str_replace("\n", "", $out);

			$pkg_info['broken'] = true;

		unset($pkg_info);

	usort($result, function($a, $b) {

		return(strcasecmp ($a['name'], $b['name']));

	});

 * If binary pkg is installed but post-install tasks were not

 * build phase, and at this point, cannot find a running system

 * to register itself in config.xml and also execute custom

 * install functions

 */

function register_all_installed_packages() {

	global $g, $config, $pkg_interface;

	$pkg_info = get_pkg_info('all', 'all', true);

	foreach ($pkg_info as $pkg) {

		if (!isset($pkg['installed'])) {

			continue;

		}

		pkg_remove_prefix($pkg['name']);

		if (is_package_installed($pkg['name'])) {

			continue;

		}

		update_status(sprintf(gettext(

		    "Running last steps of %s installation.") . "\n",

		    $pkg['name']));

		install_package_xml($pkg['name']);

	}

}

 * resync_all_package_configs() Force packages to setup their configuration and rc.d files.

 * This function may also print output to the terminal indicating progress.

 */

function resync_all_package_configs($show_message = false) {

		if (empty($package['name'])) {

		if ($show_message == true) {

		if (platform_booting() != true) {

		stop_service($internal_name);

		delete_package_xml($package_name);

function sync_package($package_name) {

	global $config, $builder_package_install;

	// If this code is being called by pfspkg_installer

	if (($pkg_id = get_package_id($package_name)) == -1) {

		return; // This package doesn't really exist - exit the function.

	$package =& $config['installedpackages']['package'][$pkg_id];

	if (!empty($pkg_config['include_file'])) {

		$include_file = $pkg_config['include_file'];

			}

			if (file_exists($include_file)) {

				require_once($include_file);

			} else {

				return;

	if (!empty($pkg_config['custom_php_resync_config_command'])) {

function read_package_config($package_name) {

	global $g;

		return false;

	}

		return false;

	/* it always returns an array with 1 item */

	return $pkg_info['package'][0];

function read_package_configurationfile($package_name) {

	global $config, $g;

	$pkg_config = array();

	$id = get_package_id($package_name);

	if ($id < 0 || !isset($config['installedpackages']['package'][$id]['configurationfile'])) {

		return $pkg_config;

	}

	$pkg_configurationfile = $config['installedpackages']['package'][$id]['configurationfile'];

	if (empty($pkg_configurationfile) || !file_exists('/usr/local/pkg/' . $pkg_configurationfile)) {

		return $pkg_config;

	}

	$pkg_config = parse_xml_config_pkg('/usr/local/pkg/' . $pkg_configurationfile, "packagegui");

	return $pkg_config;

}

		return $pkg_config['after_install_info'];

}

	global $evaled;

	if (!$evaled) {

		$evaled = array();

	if (!in_array($evalmd5, $evaled)) {